反射：Class类、反射概念、类中各成员的反射、反射的应用、数组的反射

1  反射的基础Class类

      Person类代表人，它的实例对象就是张三，李四这样一个个具体的人。

      在Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。

 

      Class类代表Java类，它的各个实例对象又分别对应什么呢？
      对应各个类在内存中的字节码。例如，Person类的字节码，ArrayList类的字节码等等。

 

      一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型就是Class。

      Class类描述了哪些方面的信息呢：类的名字，类的访问属性，类所属于的包名，字段名称的列表、方法名称的列表，等等。

      学习反射，首先就要明白Class这个类。

 

如何得到各个字节码对应的实例对象（Class类型）：
      1，类名.class，例如，System.class。
      2，对象.getClass()，例如，new Date().getClass()。
      3，Class.forName("类名")，例如，Class.forName("java.util.Date");。

九个预定义Class实例对象（八大基本类型+void）：

      Byte.TYPE，Integer.TYPE，Short.TYPE，Long.TYPE，Float.TYPE，Double.TYPE，Character.TYPE，Boolean.TYPE，Void.TYPE。（返回对应的基本数据类型的字节码Class对象）

      这些对象通过基本数据类型调用，被public static final修饰。

      这些对象仅能通过下列声明为public static final的变量访问。

 

注意：

      1、Int.class == Integer.TYPE。

      2、数组类型的Class实例对象Class.isArray()为true。

总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[]，void…

 

示例：

[java]  view plain  copy

1. public class ReflectDemo{  
2.     public static void main(String[] args) throws Exception {  
3.         String str = "abc";  
4.           
5.         //三种获取字节码对象的方式：  
6.         Class clazz1 = String.class;  
7.         Class clazz2 = str.getClass();  
8.         Class clazz3 = Class.forName("java.lang.String" );  
9.           
10.         System. out.println(clazz1 == clazz2);//true  
11.         System. out.println(clazz2 == clazz3);//true  
12.           
13.         System. out.println(clazz1.isPrimitive());//false  
14.         System. out.println(int.class.isPrimitive()); //true  
15.           
16.         //这里注意，基本类型int和包装类Integer的Class对象(字节码)不同。  
17.         System. out.println(int.class == Integer.class);//false  
18.           
19.         //Integer.TYPE，表示基本类型int的Class对象。  
20.         System. out.println(int.class == Integer.TYPE);//true  
21.           
22.         System. out.println(int[].class.isPrimitive());//false  
23.         System. out.println(int[].class.isArray());//true  
24.     }  
25. }  

2  反射的概念

      反射就是把Java类中的各种成分映射成相应的java类。

      例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示。就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。

      表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。

     一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象。

3  构造方法的反射Constructor类

Constructor类代表某个类中的一个构造方法。

Constructor对象代表一个构造方法，Constructor对象上会有的方法有：得到方法名字，得到所属于的类，产生实例对象。

 

得到某个类所有的构造方法：
      例子：Constructor[] constructors= Class.forName("java.lang.String").getConstructors();

得到某一个构造方法：
        例子：Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);  //获得方法时要用到类型

注意：

      一个类有多个构造方法，根据getConstructors() 中参数的个数和类型，区分清楚想得到其中的哪个方法

      例如，Class.getMethod(name,Class... args)中的args参数就代表所要获取的那个方法的各个参数的类型的列表。

重点：getConstructors() 中参数类型用什么方式表示？用Class实例对象。

重点：getConstructors()只能获得被public修饰的构造函数。没有public修饰的可以通过getDeclaredConstructor()获得。

 

创建实例对象：

      通常方式：String str = new String(new StringBuffer("abc"));

      反射方式： String str = (String)constructor.newInstance(new StringBuffer("abc"));

                           //调用获得的方法时要用到上面相同类型的实例对象

Class.newInstance()方法：
      例子：String obj = (String)Class.forName("java.lang.String").newInstance(); //该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。

 

代码示例：

[java]  view plain  copy

1. public class ContructroReflect {  
2.     public static void main(String[] args) throws Exception {  
3.           
4.         //根据参数列表中传递的Class对象，获取相应的构造函数。  
5.         Constructor constructor = String.class.getConstructor(StringBuffer.class);  
6.           
7.         //使用此Constructor对象表示的构造方法来创建该构造方法的声明类的新实例，  
8.         //并用指定的初始化参数初始化该实例。  
9.         String str = (String)constructor.newInstance( new StringBuffer("abc" ));  
10.           
11.         System. out.println(str.charAt(2));  
12.         //结果：c  
13.     }  
14. }  

4  成员变量的反射（暴力反射）

Field类代表某个类中的一个成员变量。

问题：

得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？

类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？

所以字段field X 代表的是X的定义，而不是具体的X变量。

 

getField()：获取公有字段的Class实例。

getDeclaredField()：获取私有字段的Class实例。

fieldX.setAccessible( true)：可以使对象rp中的私有成员变量X，可以从外部被访问，即fieldX.get( rp)，这称为暴力反射。

 

代码示例：

[java]  view plain  copy

1. import java.lang.reflect.Constructor;  
2. import java.lang.reflect.Field;  
3.   
4. class ReflectPoint {  
5.     private int x;  
6.     public int y ;  
7.       
8.     public ReflectPoint(int x, int y) {  
9.          super();  
10.          this.x = x;  
11.          this.y = y;  
12.     }  
13. }  
14.   
15. public class FieldReflect{  
16.     public static void main(String[] args) throws Exception {  
17.         ReflectPoint rp = new ReflectPoint(3, 5);  
18.           
19.         Field fieldY = rp.getClass().getField( "y");//获取字段Y的Class实例  
20.         /*  fieldY值是多少？是5？错！ 
21.             fieldY不是对象身上的变量，而是类上的定义， 
22.             要用它去取某个对象上对应的值。 */  
23.           
24.         System. out.println(fieldY.get(rp));//用fieldY对象获取rp上相应的值  
25.         //结果：5  
26.           
27.         Field fieldX = rp.getClass().getDeclaredField("x");//获取私有字段  
28.           
29.         fieldX.setAccessible(true); //使private类型的成员变量也可以被获取值，称为暴力反射  
30.           
31.         System. out.println(fieldX.get(rp));//暴力反射后，私有的成员变量也可以被取值  
32.           
33.         /*  getField方法只能获取公有字段的Class实例。 
34.             getDeclaredField方法可以获取私有字段的Class实例。 
35.              
36.             然后通过setAccessible(true)方法使私有的成员变量也可以被访问到。  
37.             这称为暴力反射（private修饰的成员变量只能在本类内访问）。*/  
38.     }  
39. }  

暴力反射：

通过调用字段fieldX的setAccessible( true) 方法，可以使对象rp中的私有成员变量X，可以从外部被访问，即fieldX.get( rp)，这称为暴力反射。

5  成员方法的反射

Method类代表某个类中的一个成员方法。

得到类中的某一个方法：
      例子：Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);
调用方法：
      通常方式：char x = str.charAt(1));
      反射方式：char x = charAt.invoke(str, 1));  //调用charAt实例代表的方法，调用者是str字符串，传递参数1。

注意：

      如果传递给Method对象的invoke()方法的第一个参数为null，说明该Method对象对应的是一个静态方法！

jdk1.4和jdk1.5的invoke方法的区别：

      Jdk1.4：public Object invoke(Object obj,Object[] args)
      Jdk1.5：public Object invoke(Object obj,Object... args)  //可变参数

代码示例：

[java]  view plain  copy

1. import java.lang.reflect.Method;  
2. public class MethodReflect{  
3.     public static void main(String[] args) throws Exception {  
4.         String str = "abc";  
5.           
6.         //获取charAt(int)方法的Class实例。  
7.         Method methodCharAt = String.class.getMethod("charAt", int.class );  
8.           
9.         // invoke(str, 1)：调用str中的当前方法，参数是1.  
10.         System. out.println(methodCharAt.invoke(str, 1));//结果：b  
11.         System. out.println(methodCharAt.invoke(str, new Object[]{2}));//结果：c  
12.     }  
13. }  

6  用反射方式执行某个类中的main方法

写一个程序A，该程序能根据用户提供的类名B，去执行B类中的main方法。

通过给A的main方法设置传入的参数，来指定B类的类名。

 

命令行下给main方法传递参数：B类的类名(包括包路径)在java运行命令之后。

Eclipse中给main方法传递参数：右击Run As-->点击Run Configurations-->点击Arguments选项卡。

 

问题：

      启动Java程序的main方法的参数是一个字符串数组，

      即public static void main(String[] args)，

      通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？

      按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac按jdk1.4的语法进行处理，即把数组拆开成若干个单独的参数。

      所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,new String[]{“xxx”})；javac只把它当作jdk1.4的语法进行理解，即把数组拆开成若干个单独的参数，而不把它当作jdk1.5的语法解释(整个数组是一个参数)，因此会出现参数类型不对的问题。

 

解决该问题的方法：

方法一：mainMethod.invoke(null, new Object[]{new String[]{"xxx"}});  //多加一个数组。

方法二：mainMethod.invoke(null, (Object)new String[]{"xxx"});  //(Object) 是告诉编译器，传递的是一个对象不是一个数组，就不会把数组拆开成若干个单独的参数了。

 

代码示例：

[java]  view plain  copy

1. package mypkg;  
2. import java.lang.reflect.Method;  
3.   
4. public class MainReflect{  
5.     public static void main(String[] args) throws Exception {  
6.         String startingClassName = args[0];  
7.           
8.         Method mainMethod = Class.forName(startingClassName).getMethod("main",String[].class);  
9.           
10.       //mainMethod.invoke(null, new Object[]{new String[]{"111","222","333"}}); //方法一  
11.         mainMethod.invoke(null, (Object)new String[]{"111","222","333"}); //方法二  
12.     }  
13. }  
14.   
15. class TestArguments{  
16.     public static void main(String[] args) {  
17.         for(String arg : args){  
18.             System. out.println(arg);  
19.         }  
20.     }  
21. }  

命令行下编译、运行结果：

7  数组的反射

7.1 数组的反射特点

具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象(此处比较与值无关)。

代表数组的Class实例对象的getSuperClass()方法，返回的父类为Object类对应的Class。

 

基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；

非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

 

代码及注释：

[java]  view plain  copy

1. public class ArrayReflect {  
2.     public static void main(String[] args) throws Exception {  
3.         int [] a1 = new int[3];  
4.         int [] a2 = new int[4];  
5.         int [][] a3 = new int[2][3];  
6.         String[] a4 = new String[3];  
7.   
8.         System.out.println(a1.getClass() == a2.getClass());//结果：true  
9.         System.out.println(a1.getClass() == a4.getClass());//结果：false  
10.         System.out.println(a1.getClass() == a3.getClass());//结果：false  
11.           
12.           
13.         System. out .println(a1.getClass().getName());//结果：[I  
14.         /* Class类的getName方法返回值中[表示数组的深度， 
15.         [表示一维数组，[[表示二维数组。剩下的内容则表示数组类型，例如I表示int类型. */  
16.           
17.         System. out .println(a1.getClass().getSuperclass().getName());//结果：java.lang.Object  
18.         System. out .println(a4.getClass().getSuperclass().getName());//结果：java.lang.Object  
19.           
20.           
21.         Object aObj1 = a1; //int[]数组是Object，int不是Object。  
22.         Object aObj2 = a4;  
23.           
24.         //Object[] aObj3 = a1; //a1是int类型的数组，int不是Object，因此编译就会报错  
25.           
26.         //a3是数组的数组，元素也是一维数组，父类是Object，因此不会报错  
27.         Object[] aObj4 = a3;  
28.           
29.         //a4是String的数组，String父类是Object，因此不会报错  
30.         Object[] aObj5 = a4;  
31.     }  
32. }  

7.2  Arrays类的asList()方法处理int[]和String[]时的差异

JDK1.4中为 Arrays.asList(Object[] a);

JDK1.5中为 Arrays.asList(T... a);

所以 as.List( new int[]{1,2,3}) 中，数组元素的类型是int，而int不是Object，所以不能打印出数组内容。

代码及注释：

[java]  view plain  copy

1. import java.util.Arrays;  
2.   
3. public class ArrayReflect2 {  
4.     public static void main(String[] args) throws Exception {  
5.         int [] a5 = new int[]{1,2,3};  
6.         String[] a6 = new String[]{"a" ,"b" ,"c" };  
7.           
8.         //直接使用System.out.println无法打印出数组的内容  
9.         System. out .println(a5); //结果：[I@18a992f  
10.         System. out .println(a6); //结果：[Ljava.lang.String;@4f1d0d  
11.          
12.         //通过Arrays.asList方法打印出数组的内容  
13.         System. out .println(Arrays.asList(a5));  
14.         /* 结果：[[I@18a992f] 
15.         原因是因为JDK1.4中为Arrays.asList(Object[] a)，JDK1.5中为Arrays.asList(T... a)。 
16.         a5是int[]类型，元素类型int不是Object，JDK1.4中的asList方法处理不了，JDK1.5可以处理。 
17.         但是JDK1.5将 int数组整体作为一个参数进行处理。 
18.         因此最终结果就是将 int[]进行了封装，结果类型也就成了[[I。 */  
19.           
20.         System. out .println(Arrays.asList(a6));  
21.         //结果：[a, b, c]  
22.     }  
23. }  

注意：Class类的getName方法返回值中[表示数组的深度，[表示一维数组，[[表示二维数组。剩下的内容则表示数组类型，例如I表示int类型。

 

7.3  Array类用于完成对数组的反射操作

反射中，Array类表示数组，位于java.lang.reflect 包中。

 

Array类对数组的反射操作：

[java]  view plain  copy

1. import java.lang.reflect.Array;  
2.   
3. public class ArrayReflect3 {  
4.     public static void main(String[] args) throws Exception {  
5.         String[] a1 = new String[]{"a","b","c"};  
6.         String a2 = "xyz";  
7.          
8.         printObject(a1);  
9.         printObject(a2);  
10.     }  
11.     
12.     public static void printObject(Object obj){  
13.         Class clazz = obj.getClass(); //获取Class实例对象  
14.           
15.         if(clazz.isArray()){ //如果是数组  
16.             int len = Array.getLength(obj); //获取数组长度  
17.             for(int i = 0; i < len; i++){  
18.                 System. out.println(Array.get(obj, i)); //打印 obj[i]  
19.             }  
20.         }else{  
21.            System. out.println(obj);  
22.         }  
23.    }  
24. }  

8  反射的作用：实现框架功能

框架：
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。

框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

 

框架要解决的核心问题：

我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？
因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。

 

下面的代码中实现一个简单的框架，使用时，我们只需更改配置文件中的值，配置文件config.properties存放在当前目录。

Config.properties文件中内容：

className1=java.util.HashSet

className2=java.util.ArrayList

 

代码及注释：

[java]  view plain  copy

1. package mypkg;  
2. import java.io.*;  
3. import java.util.*;  
4.   
5. public class FrameReflect{  
6.     public static void main(String[] args) throws Exception {  
7.         InputStream is = new FileInputStream("config.properties");  
8.         Properties props = new Properties();  
9.         props.load(is);  //加载配置文件中的内容到Properties集合(键值对)  
10.         is.close();  
11.           
12.         //config.properties配置文件中内容“className1=java.util.HashSet”  
13.         String className = (String)props.get("className1");  
14.         Collection collections = (Collection)Class.forName(className).newInstance();  
15.           
16.         ReflectPoint pt1 = new ReflectPoint(3, 3);  
17.         ReflectPoint pt2 = new ReflectPoint(5, 5);  
18.         ReflectPoint pt3 = new ReflectPoint(3, 3);  
19.           
20.         collections.add(pt1);  
21.         collections.add(pt2);  
22.         collections.add(pt3);  
23.         collections.add(pt1);  
24.           
25.         //pt1.y = 7;    
26.         //collections.remove(pt1); //哈希值改变，无法删除  
27.           
28.         System. out.println(collections.size()); //结果为2  
29.           
30.     /* 当集合为HashSet时，需要通过比较hashcode值以及equals方法是否返回true决定是否放入。 
31.     如果hashcode值相等并且equals方法返回true，那么就不会放入。因此，集合size为3。 
32.     如果想让size为2，也就是pt1与pt3作为同一个元素存入HashSet集合， 
33.     那就需要覆盖ReflectPoint类的hashCode方法以及equals方法。 */  
34.     }  
35. }  
36. /*  
37. 注意： 
38. 当一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了， 
39. 否则，对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了， 
40. 在这种情况下，即使在contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象， 
41. 也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象， 
42. 从而造成内存泄露。 
43.  */  
44. class ReflectPoint {  
45.     private int x ;  
46.     public int y ;  
47.       
48.     public ReflectPoint(int x, int y) {  
49.          super();  
50.          this.x = x;  
51.          this.y = y;  
52.     }  
53.     @Override  
54.     public int hashCode() {  
55.          final int prime = 31;  
56.          int result = 1;  
57.         result = prime * result + x;  
58.         result = prime * result + y;  
59.          return result;  
60.     }  
61.     @Override  
62.     public boolean equals(Object obj) {  
63.          if (this == obj)  
64.                return true ;  
65.          if (obj == null)  
66.                return false ;  
67.          if (getClass() != obj.getClass())  
68.                return false ;  
69.         ReflectPoint other = (ReflectPoint) obj;  
70.          if (x != other.x)  
71.                return false ;  
72.          if (y != other.y)  
73.                return false ;  
74.          return true ;  
75.     }  
76. }  

运行结果：