- 浏览: 311065 次
- 性别:
- 来自: 上海
文章分类
最新评论
-
yan372397390:
请问这几行命令是在哪里输入的
Genymotion模拟器安装Genymotion-ARM-Translation变copy的解决办法 -
littlevine:
...
"WebDriverException: Cannot find firefox binary in PATH."的解决方法 -
jujis008:
楼主, 这selenium用的是jdk自带的log,所以在% ...
PhantomJSDriver怎么设置在console里不输出运行信息 -
qi_ling2005:
OnTheRoad_lee 写道 String[] phant ...
PhantomJSDriver怎么设置在console里不输出运行信息 -
OnTheRoad_lee:
String[] phantomArgs = new Str ...
PhantomJSDriver怎么设置在console里不输出运行信息
【案例】通过反射取得并修改数组的信息:
1
2
3
4
5
6
7
8
9
10
11
12
|
import java.lang.reflect.*;
class hello{
public static void main(String[] args) {
int [] temp={ 1 , 2 , 3 , 4 , 5 };
Class<?>demo=temp.getClass().getComponentType();
System.out.println( "数组类型: " +demo.getName());
System.out.println( "数组长度 " +Array.getLength(temp));
System.out.println( "数组的第一个元素: " +Array.get(temp, 0 ));
Array.set(temp, 0 , 100 );
System.out.println( "修改之后数组第一个元素为: " +Array.get(temp, 0 ));
}
} |
【运行结果】:
数组类型: int
数组长度 5
数组的第一个元素: 1
修改之后数组第一个元素为: 100
【案例】通过反射修改数组大小
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
class hello{
public static void main(String[] args) {
int [] temp={ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 };
int [] newTemp=( int [])arrayInc(temp, 15 );
print(newTemp);
System.out.println( "=====================" );
String[] atr={ "a" , "b" , "c" };
String[] str1=(String[])arrayInc(atr, 8 );
print(str1);
}
/**
* 修改数组大小
* */
public static Object arrayInc(Object obj, int len){
Class<?>arr=obj.getClass().getComponentType();
Object newArr=Array.newInstance(arr, len);
int co=Array.getLength(obj);
System.arraycopy(obj, 0 , newArr, 0 , co);
return newArr;
}
/**
* 打印
* */
public static void print(Object obj){
Class<?>c=obj.getClass();
if (!c.isArray()){
return ;
}
System.out.println( "数组长度为: " +Array.getLength(obj));
for ( int i = 0 ; i < Array.getLength(obj); i++) {
System.out.print(Array.get(obj, i)+ " " );
}
}
} |
【运行结果】:
数组长度为: 15
1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 =====================
数组长度为: 8
a b c null null null null null
动态代理
【案例】首先来看看如何获得类加载器:
1
2
3
4
5
6
7
8
9
|
class test{
} class hello{
public static void main(String[] args) {
test t= new test();
System.out.println( "类加载器 " +t.getClass().getClassLoader().getClass().getName());
}
} |
【程序输出】:
类加载器 sun.misc.Launcher$AppClassLoader
其实在java中有三种类类加载器。
1)Bootstrap ClassLoader 此加载器采用c++编写,一般开发中很少见。
2)Extension ClassLoader 用来进行扩展类的加载,一般对应的是jre\lib\ext目录中的类
3)AppClassLoader 加载classpath指定的类,是最常用的加载器。同时也是java中默认的加载器。
如果想要完成动态代理,首先需要定义一个InvocationHandler接口的子类,已完成代理的具体操作。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
package Reflect;
import java.lang.reflect.*;
//定义项目接口 interface Subject {
public String say(String name, int age);
} // 定义真实项目 class RealSubject implements Subject {
@Override
public String say(String name, int age) {
return name + " " + age;
}
} class MyInvocationHandler implements InvocationHandler {
private Object obj = null ;
public Object bind(Object obj) {
this .obj = obj;
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
.getClass().getInterfaces(), this );
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object temp = method.invoke( this .obj, args);
return temp;
}
} class hello {
public static void main(String[] args) {
MyInvocationHandler demo = new MyInvocationHandler();
Subject sub = (Subject) demo.bind( new RealSubject());
String info = sub.say( "Rollen" , 20 );
System.out.println(info);
}
} |
【运行结果】:
Rollen 20
类的生命周期
在一个类编译完成之后,下一步就需要开始使用类,如果要使用一个类,肯定离不开JVM。在程序执行中JVM通过装载,链接,初始化这3个步骤完成。
类的装载是通过类加载器完成的,加载器将.class文件的二进制文件装入JVM的方法区,并且在堆区创建描述这个类的java.lang.Class对象。用来封装数据。 但是同一个类只会被类装载器装载以前
链接就是把二进制数据组装为可以运行的状态。
链接分为校验,准备,解析这3个阶段
校验一般用来确认此二进制文件是否适合当前的JVM(版本),
准备就是为静态成员分配内存空间,。并设置默认值
解析指的是转换常量池中的代码作为直接引用的过程,直到所有的符号引用都可以被运行程序使用(建立完整的对应关系)
完成之后,类型也就完成了初始化,初始化之后类的对象就可以正常使用了,直到一个对象不再使用之后,将被垃圾回收。释放空间。
当没有任何引用指向Class对象时就会被卸载,结束类的生命周期
将反射用于工厂模式
先来看看,如果不用反射的时候,的工厂模式吧:
http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144851.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
/** * @author Rollen-Holt 设计模式之 工厂模式
*/
interface fruit{
public abstract void eat();
} class Apple implements fruit{
public void eat(){
System.out.println( "Apple" );
}
} class Orange implements fruit{
public void eat(){
System.out.println( "Orange" );
}
} // 构造工厂类 // 也就是说以后如果我们在添加其他的实例的时候只需要修改工厂类就行了 class Factory{
public static fruit getInstance(String fruitName){
fruit f= null ;
if ( "Apple" .equals(fruitName)){
f= new Apple();
}
if ( "Orange" .equals(fruitName)){
f= new Orange();
}
return f;
}
} class hello{
public static void main(String[] a){
fruit f=Factory.getInstance( "Orange" );
f.eat();
}
} |
这样,当我们在添加一个子类的时候,就需要修改工厂类了。如果我们添加太多的子类的时候,改的就会很多。
现在我们看看利用反射机制:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
package Reflect;
interface fruit{
public abstract void eat();
} class Apple implements fruit{
public void eat(){
System.out.println( "Apple" );
}
} class Orange implements fruit{
public void eat(){
System.out.println( "Orange" );
}
} class Factory{
public static fruit getInstance(String ClassName){
fruit f= null ;
try {
f=(fruit)Class.forName(ClassName).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return f;
}
} class hello{
public static void main(String[] a){
fruit f=Factory.getInstance( "Reflect.Apple" );
if (f!= null ){
f.eat();
}
}
} |
现在就算我们添加任意多个子类的时候,工厂类就不需要修改。
上面的爱吗虽然可以通过反射取得接口的实例,但是需要传入完整的包和类名。而且用户也无法知道一个接口有多少个可以使用的子类,所以我们通过属性文件的形式配置所需要的子类。
下面我们来看看: 结合属性文件的工厂模式
首先创建一个fruit.properties的资源文件,
内容为:
1
2
|
apple=Reflect.Apple orange=Reflect.Orange |
然后编写主类代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
package Reflect;
import java.io.*;
import java.util.*;
interface fruit{
public abstract void eat();
} class Apple implements fruit{
public void eat(){
System.out.println( "Apple" );
}
} class Orange implements fruit{
public void eat(){
System.out.println( "Orange" );
}
} //操作属性文件类 class init{
public static Properties getPro() throws FileNotFoundException, IOException{
Properties pro= new Properties();
File f= new File( "fruit.properties" );
if (f.exists()){
pro.load( new FileInputStream(f));
} else {
pro.setProperty( "apple" , "Reflect.Apple" );
pro.setProperty( "orange" , "Reflect.Orange" );
pro.store( new FileOutputStream(f), "FRUIT CLASS" );
}
return pro;
}
} class Factory{
public static fruit getInstance(String ClassName){
fruit f= null ;
try {
f=(fruit)Class.forName(ClassName).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return f;
}
} class hello{
public static void main(String[] a) throws FileNotFoundException, IOException{
Properties pro=init.getPro();
fruit f=Factory.getInstance(pro.getProperty( "apple" ));
if (f!= null ){
f.eat();
}
}
} |
【运行结果】:Apple
原文:http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html
发表评论
-
Java注解实例----一个简单的单元测试例子
2016-02-24 17:32 3733分享如何创建自定义的注解 @Test 和 @TestInfo ... -
java 注解反射实例
2016-02-18 16:43 1839Java注解反射实例 主要功能: 1. 得到一个类的所有 ... -
Gson TypeAdapter用法
2016-02-17 10:51 1941Gson TypeAdapter用法 实例:写一个Typ ... -
eclipse中使用git
2015-11-02 15:17 593http://blog.sina.com.cn/s/blog_ ... -
TestNg retry 相关问题讨论
2015-07-07 14:27 698http://www.csdn123.com/html/ex ... -
JavaMail通过Exchange发送邮件
2015-05-07 17:30 5014使用Exchange Server邮件服务器发送邮件的特殊之 ... -
Find Java classes implementing an interface
2014-09-22 16:30 840Find Java classes implementi ... -
从List中移除指定 List 中包含的其所有元素(可选操作)。
2013-07-24 13:05 3947从List中移除指定 List 中包含的其所有元素,这个当然 ... -
一个JAVA多线程的实例 (生产者和消费者)
2013-05-26 21:45 1144传送门: http://blog.163.com/dous ... -
JAVA 注解示例 详解
2012-07-03 15:13 1140JAVA 注解示例 详解 传送门 -
java反射详解转(一)
2012-06-11 10:35 1370本篇文章依旧采用小例子来说明,因为我始终觉的,案例 ... -
java 泛型学习
2012-03-14 17:19 1473今天看webdriver代码看到泛型,找到这篇文章补补 ht ... -
(转)获得程序当前路径System.getProperty("user.dir");
2012-02-29 14:47 1967java2核心技术 I 因为所有在java.i ...
相关推荐
### Java反射机制详解 #### 一、引言 Java反射机制是Java编程语言的一个核心特性,它允许程序在运行时动态地访问类的信息,并能够直接操作这些类的对象。这种能力对于许多开发框架(如Spring)来说至关重要,因为...
Java反射机制是Java编程语言中的一个重要特性,它允许程序在运行时检查和操作类、接口、对象等的内部信息。通过反射,我们可以动态地创建对象、访问和修改字段、调用方法,甚至执行私有方法和访问包内可见的元素。...
Java 反射机制是 Java 语言中的一个重要特性,它允许程序在运行时动态地获取类的信息(如类名、属性、方法等)并调用对象的方法,甚至修改对象的状态。这一机制极大地增强了 Java 程序的灵活性和可扩展性,尤其是在...
Java反射机制是Java语言的一种强大的特性,它允许程序在运行时动态地获取类的信息并操作类的对象。在Java中,反射主要涉及到`java.lang.Class`类、`java.lang.reflect`包中的类(如Constructor、Method、Field)以及...
(通过反射获取无参构造方法并使用) (通过反射获取带参构造方法并使用) (通过反射获取私有构造方法并使用) (通过反射获取成员变量并使用) (通过反射获取无参无返回值成员方法并使用) (通过反射获取带参带返回值成员...
### Java反射机制详解 #### 一、反射机制是什么 反射机制是Java编程语言的一个核心特性,它允许程序在运行时动态地获取类的信息,并且能够动态地创建对象和调用对象的方法。简单来说,反射机制使得Java程序可以...
Java反射机制是Java语言的一项强大功能,它允许程序在运行时动态地获取类的信息并操作类的对象。这一特性使得Java具有高度的灵活性和强大的扩展性,尤其是在开发框架和库时,反射机制起到了至关重要的作用。本文将...
### JAVA反射详解 Java反射是Java编程语言的一个强大特性,允许程序在运行时检查和操作类、接口、字段和方法等。本文章旨在深入解析Java反射机制,包括其原理、应用以及常见用法。 #### 了解Class对象 在Java中,...
"java反射机制详解" Java 反射机制是 Java 语言中的一种功能,它允许程序员在运行时检查和修改一个类的结构和行为。 Java 反射机制提供了一种获取类的信息、创建对象、调用方法和获取字段值的方式。 在 Java 中,...
Java反射是Java编程语言中的一个强大特性,它允许运行时的程序访问并操作类、接口、字段和方法等对象,即使这些对象在编译时并未被明确地引用。这一特性使得Java具有高度的动态性,使得代码能够在运行时检查类的信息...
反射机制是Java语言中一个非常重要的特性,它允许程序在运行时通过特定的API动态地访问对象的属性和方法。反射机制是Java编程的强大工具之一,但它也带来了安全性和性能问题,因此需要谨慎使用。在Java中,反射主要...
以下是对Java反射机制的详细解释: 1. 获取类信息: 要使用反射,首先需要获取类的`java.lang.Class`对象。这可以通过以下几种方式实现: - `Class<?> c = Class.forName("全限定类名");`:根据类的全限定名(包...
Java反射是Java语言的一个强大特性,它允许程序在运行时动态地获取类的信息(如类名、方法、字段等)并进行操作。反射在许多场景下都非常有用,例如在框架开发、插件系统、序列化、动态代理等方面。本文将通过三个...
Java反射是Java编程语言中的一个强大特性,它允许运行时检查类、接口、字段和方法的信息,甚至在程序运行过程中动态地创建对象和调用方法。这个特性使得Java具有高度的灵活性,尤其在处理元数据、插件系统、序列化、...
Java反射是Java编程语言中的一个强大工具,它允许程序在运行时检查并操作类、接口、字段和方法的信息。这使得开发者能够在不事先知道具体类名或方法名的情况下,动态地创建对象并调用方法。Java反射机制是Java动态性...
### JAVA反射机制详解 #### 一、JAVA反射机制概述 反射是Java编程语言的一个核心特性,它允许程序在运行时获取类的信息,并且可以动态地创建对象和调用方法。这种能力使得Java程序具备了高度的灵活性和扩展性。...