java反射技术

转载：http://blog.csdn.net/qinwu19910928/article/details/9101365?locationNum=6&fps=1

今天给大家介绍下Java反射技术

反射是什么，用最简单的语句来介绍反射就是加载类并解剖类的各个组成部分，稍有java基础的人都知道，java类在内存中是以字节码的形式存在的，而java中有一个Class类表示的正是某个类的字节码对象。大家查阅javaAPI可以发现这个类有个静态方法forName，它可以接收一个字符串作为类名，返回值正是此类名所表示的类的字节码对象，至此我们完成了反射技术中的第一步：加载类，也就是说我们成功的把一个我们指定的类加载到内存并且得到它的字节码对象。

那么在java中，到底有几种加载类得到类的字节码对象的方法呢，上面我们介绍的通过Class类的静态方法forName方法是一种，那还有没有其他的方法呢，下面我们就用代码的方式把加载类的几种方法给大家一一呈现：

[java]  view plain  copy

 print ?

1. package com.reflection;  
2.   
3. public class ReflectionDemo {  
4.   
5.     /** 
6.      * @param args 
7.      */  
8.     public static void main(String[] args) throws Exception {  
9.   
10.         //第1种：调用Class类的静态方法foName加载并返回某个类的字节码对象  
11.         Class personClass1 = Class.forName("com.reflection.Person");  
12.           
13.         //第2种：调用Person对象的getClass方法也可以返回该类的字节码对象  
14.         Class personClass2 = new Person().getClass();  
15.   
16.         //第3种：直接使用Person.class也可以将Person类加载到内存并返回Person类的字节码对象  
17.         Class personClass3 = Person.class;  
18.           
19.   
20.     }  
21.   
22. }  

加载类只是反射技术的第一步，其实反射技术的核心是在第二步，那就是解剖类的各个组成部分，大家想一想，java类有几个组成部分呢，无非就是构造函数、字段和方法，所以，所谓的解剖类的各个组成部分，无非就是解剖出类的构造函数、字段或者是方法。下面我们就一一介绍怎样解剖出的类的这三个部分。

解剖类的构造方法

构造方法在java类中是一种特殊的方法，它的作用只有一个，就是用来创造对象，同样，反射机制解剖构造方法的作用也是为了用它创造对象，我们翻阅一下javaAPI的Class类的方法列表，不难发现他就有一个getConstructor方法，它接收一系列可变参数（关于java可变参数，不熟悉的读者可以先去掌握这部分知识），返回的是一个Constructor对象，里面封装的是一个构造函数,而Constructor对象有一个方法newInstance，同样接收一系类可变参数，返回值是Object类型，此Object类型即是我们反利用解剖出的构造方法创建的新对象。getConstructor只能解剖类的public类型的构造函数，对于private类型的构造函数，需要用到Class类的另外一个函数getDeclaredConstructor，接收的参数和返回值和getConstructor一样，接下来，我们就用代码演示下怎么解剖类的各种构造函数。

被反射的类Person，为了演示解剖各种构造函数，我们给Person添加三个构造函数：

[java]  view plain  copy

 print ?

1. package com.reflection;  
2.   
3. public class Person {  
4.   
5.     public Person() {  
6.         System.out.println("name");  
7.     }  
8.   
9.     public Person(String name) {  
10.         System.out.println(name);  
11.     }  
12.   
13.     private Person(String name, int age) {  
14.         System.out.println(name + age);  
15.     }  
16.   
17. }  

测试类:演示了如何解剖出类的各种构造函数

[java]  view plain  copy

 print ?

1. package com.reflection;  
2.   
3. import java.lang.reflect.Constructor;  
4.   
5. import org.junit.Test;  
6.   
7. public class ReflectionDemo {  
8.     @Test  
9.     public void Test1() throws Exception {  
10.         Class PersonClass = Class.forName("com.reflection.Person");  
11.         //解剖出那个无参的构造函数，所以传入的参数为null  
12.         Constructor constructor = PersonClass.getConstructor(null);  
13.         //使用构造函数创建对象，因为是无参构造函数，所以传入参数为null  
14.         Person person = (Person)constructor.newInstance(null);  
15.   
16.     }  
17.   
18.     @Test  
19.     public void Test2() throws Exception {  
20.         Class PersonClass = Class.forName("com.reflection.Person");  
21.         //解剖出那个接收一个String参数的构造函数，我们使用String.class来指定参数类型为String  
22.         Constructor constructor = PersonClass.getConstructor(String.class);  
23.         //创建对象时需要传入一个String类型的参数  
24.         Person person = (Person)constructor.newInstance("person name");  
25.   
26.     }  
27.       
28.     @Test  
29.     public void Test3() throws Exception {  
30.         Class PersonClass = Class.forName("com.reflection.Person");  
31.         //解剖那个接收两个参数的private类型的构造函数，使用getDeclaredConstructor方法，同样传入的参数为String.class,int.class  
32.         Constructor constructor = PersonClass.getDeclaredConstructor(String.class,int.class);  
33.         //这句很重要，对于私有的构造方法，我们要调用Constructor的setAccessible将它的访问权限设为true，这样才可以在类的外面调用它  
34.         constructor.setAccessible(true);  
35.         //同样创建对象时需要传入一个String一个int类型的变量  
36.         Person person = (Person)constructor.newInstance("person name",23);  
37.   
38.     }  
39. }  

解剖类的方法

掌握了怎么反射类的构造方法，再来反射类的方法就很简单了，其实都差不多，下面就直接上代码了

首先给Person类加几个各种各样的方法

[java]  view plain  copy

 print ?

1. package com.reflection;  
2.   
3. public class Person {  
4.   
5.     public Person() {  
6.         System.out.println("person");  
7.     }  
8.   
9.     public Person(String name) {  
10.         System.out.println(name);  
11.     }  
12.   
13.     private Person(String name, int age) {  
14.         System.out.println(name + age);  
15.     }  
16.   
17.     public void grow() {  
18.         System.out.println("growing......");  
19.     }  
20.   
21.     public void grow(String name) {  
22.         System.out.println(name + "is growing......");  
23.     }  
24.   
25.     public int howOld() {  
26.         return 23;  
27.     }  
28.   
29.     private void sex() {  
30.         System.out.println("I am a boy");  
31.     }  
32.   
33.     public static void sport() {  
34.         System.out.println("I like run");  
35.     }  
36. }  

测试类：反射Person类中各种各样的方法

[java]  view plain  copy

 print ?

1. package com.reflection;  
2.   
3. import java.lang.reflect.Constructor;  
4. import java.lang.reflect.Method;  
5. import org.junit.Test;  
6.   
7.   
8.   
9. public class ReflectionDemo1 {  
10.       
11.     Person person = new Person();  
12.       
13.     @Test  
14.     public void Test1() throws Exception {  
15.         Class PersonClass = Class.forName("com.reflection.Person");  
16.         //第一个参数为要反射的方法的名字，第二个参数为可变参数，接收的为该方法要接收的参数类型  
17.         Method method = PersonClass.getMethod("grow", null);  
18.         //调用Method类的invoke方法来执行该方法，执行的时候需要接收一个对象来做为方法执行的主体，第二个可变参数才是方法要传入的一系列参数  
19.         method.invoke(person, null);  
20.     }  
21.   
22.     @Test  
23.     public void Test2() throws Exception {  
24.         Class PersonClass = Class.forName("com.reflection.Person");  
25.         Method method = PersonClass.getMethod("grow", String.class);  
26.         method.invoke(person, "xiaohei");  
27.   
28.     }  
29.       
30.     @Test  
31.     public void Test3() throws Exception {  
32.         Class PersonClass = Class.forName("com.reflection.Person");  
33.         Method method = PersonClass.getMethod("howOld", null);  
34.         //用一个Integer来接收方法的返回值，然后转成int类型  
35.         int age = (Integer)method.invoke(person, null);  
36.         System.out.println(age);  
37.   
38.     }  
39.   
40.     @Test  
41.     public void Test4() throws Exception {  
42.         Class PersonClass = Class.forName("com.reflection.Person");  
43.         Method method = PersonClass.getDeclaredMethod("sex", null);  
44.         method.setAccessible(true);  
45.         method.invoke(person, null);  
46.   
47.     }  
48.   
49.     @Test  
50.     public void Test5() throws Exception {  
51.         Class PersonClass = Class.forName("com.reflection.Person");  
52.         Method method = PersonClass.getDeclaredMethod("sport", null);  
53.         method.setAccessible(true);  
54.         //反射的静态方法，不必指定执行主体，所以第一个参数可为null，当然指定也可  
55.         method.invoke(null, null);  
56.   
57.     }  
58. }  

其实在方法的反射上，有一个方法的反射和其他方法是不大一样的，那就是main方法，到底有什么不一样，大家可以自己去网上查查，这里不赘述。

解剖类的字段

和反射方法差不多，只是Field类有自己独特的方法，直接上代码

给Person类加了几个字段

[java]  view plain  copy

 print ?

1. package com.reflection;  
2.   
3. public class Person {  
4.       
5.     public String name = "xiaohei";  
6.     private int age = 23;  
7.     private static String sex = "male";  
8.   
9.     public Person() {  
10.         System.out.println("person");  
11.     }  
12.   
13.     public Person(String name) {  
14.         System.out.println(name);  
15.     }  
16.   
17.     private Person(String name, int age) {  
18.         System.out.println(name + age);  
19.     }  
20.   
21.     public void grow() {  
22.         System.out.println("growing......");  
23.     }  
24.   
25.     public void grow(String name) {  
26.         System.out.println(name + "is growing......");  
27.     }  
28.   
29.     public int howOld() {  
30.         return 23;  
31.     }  
32.   
33.     private void sex() {  
34.         System.out.println("I am a boy");  
35.     }  
36.   
37.     public static void sport() {  
38.         System.out.println("I like run");  
39.     }  
40. }  

测试类：演示反射各种各样的字段

[java]  view plain  copy

 print ?

1. package com.reflection;  
2.   
3. import java.lang.reflect.Field;  
4. import org.junit.Test;  
5.   
6.   
7.   
8.   
9.   
10. public class ReflectionDemo2 {  
11.       
12.     Person person = new Person();  
13.       
14.     @Test  
15.     public void Test1() throws Exception {  
16.         Class PersonClass = Class.forName("com.reflection.Person");  
17.         Field field = PersonClass.getField("name");  
18.         //使用Field的get方法可得到该字段的值  
19.         String name = (String)field.get(person);  
20.         System.out.println(name);  
21.         //使用Field的set方法可设置该字段的值  
22.         field.set(person, "xiaobai");  
23.     }  
24.   
25.     @Test  
26.     public void Test2() throws Exception {  
27.         Class PersonClass = Class.forName("com.reflection.Person");  
28.         Field field = PersonClass.getDeclaredField("age");  
29.         //对于private类型的字段同样要设置它的访问权限为true才可访问  
30.         field.setAccessible(true);  
31.         int age = (Integer)field.get(person);  
32.         System.out.println(age);  
33.         field.set(person, 20);  
34.     }  
35.       
36.     @Test  
37.     public void Test3() throws Exception {  
38.         Class PersonClass = Class.forName("com.reflection.Person");  
39.         Field field = PersonClass.getDeclaredField("sex");  
40.         field.setAccessible(true);  
41.         //字段和方法不同，对于静态的字段，同样要设置get和set的对象主体  
42.         String sex = (String)field.get(person);  
43.         System.out.println(sex);  
44.         field.set(person, "female");  
45.     }  
46.   
47. }  

以上就是java反射技术的全部内容了，最后跟大家说一下，java反射技术只有在学习框架的时候有用，平实我们编程很少会用到反射技术，因为我们一般都是用new来加载类的，但是反射技术却是各种各样的框架都能用到的核心技术，因为框架都是通过读配置文件来决定加载哪些类的，所有如果想学透框架的核心原理，java反射技术是必须掌握的技术。

好了，不罗嗦了，希望以上内容能对大家的java学习有所帮助