上节-->:
其实在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 java反射 反射 详解 java反射详解
java反射原理详解
Java 反射详解
java反射机制详解与应用
java反射详解,详细说明java反射内部机制,适合初学者。
java反射详解
(通过反射获取无参构造方法并使用) (通过反射获取带参构造方法并使用) (通过反射获取私有构造方法并使用) (通过反射获取成员变量并使用) (通过反射获取无参无返回值成员方法并使用) (通过反射获取带参带返回值成员...
class hello{ public static void main(String[] args) { Class<?> demo=null; try{ demo=Class.forName("Reflect.Person"); }catch (Exception e) { e.printStackTrace(); ... Person per=null;...
Java Reflection (JAVA反射)详解
比较详细讲述了java的反射机制,收获颇丰。希望大家能够共同学习,一起进步。
50页PPT详细讲解了反射与动态代理;强烈推荐。
java反射机制的详细描述
java反射 详解 入门到掌握 自己认为是很好的东东
Java 反射详解(包含私有方法属性的调用)
简单的来说,反射机制指的是程序在运行时能够获取自身的信息。在java中,只要给定类的名字,那么就可以通过反射机制来获得类的所有信息。
JAVA反射详解。 Reflection是Java 程序开发语言的特征之一,它允许运行中的 Java 程序对自身进行检查,或者说"自审",并能直接操作程序的内部属性。
详细讲解的JAVA的反射机制,JAVA反射的工作原理详细讲解的JAVA的反射机制,JAVA反射的工作原理详细讲解的JAVA的反射机制,JAVA反射的工作原理
JAVA基础--JAVA中的反射机制详解:本文档详细的介绍了Java的反射API的应用,希望能对各有所帮助