本文主要向大家介绍了JAVA语言的反射技术，Java中的反射是1.2引入的反射的基石：class类，Class类的各个实例对象分别对应各个类在内存中的字节码，例如Person类的字节码，ArrayList类的字节码，等等。希望对大家学习Java语言有所帮助。

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

Java类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例对象确定的，不同的实例对象有不同的属性值，Java程序中的各个Java类，他们是否属于同一类事物，是不是可以用一个类来描述这类事物呢？这个类的名字就是Class,要注意与小写的class关键字的区别，Class类描述了哪些方面的信息呢？类的名字，类的访问属性，类所属的包名，字段名称的列表，方法名称的列表，学习反射，首先要明白Class这个类，下面来看一下实例:

[java] view plain copy
1. public static void main(String[] args) throws Exception{  
2.         /**第一个例子了解Class类型的定义*/  
3.         String str1 = "abc";//字符串1  
4.         String str2 = "abcd";//字符串2  
5.         //三种方式获取Class类型  
6.         Class cls1 = str1.getClass();  
7.         Class cls2 = str2.getClass();  
8.         Class cls3 = String.class;  
9.         Class cls4 = Class.forName("java.lang.String");  
10.         System.out.println(cls1);//打印字符串1类型  
11.         System.out.println(cls2);//打印字符串2类型  
12.         System.out.println(cls3);  
13.         System.out.println(cls4);  
14.         System.out.println(cls1 == cls2);//字符串1和字符串2的类型是否相等  
15.         System.out.println(cls1 == cls3);  
16.           
17.         //总之只要在源程序中出现的类型，都有各自的Class实例对象  
18.         System.out.println(cls1.isPrimitive());//是不是原始类型(同样也有类似的方法判断是不是枚举，数组等类型)  
19.         System.out.println(int.class.isPrimitive());  
20.         System.out.println(int.class == Integer.class);//int类型和Integer类型是不一样的，一个是基本类型，一个是对象类型  
21.         System.out.println(int.class == Integer.TYPE);//8中数据基本类型都对应与其对象类型中的TYPE字段  
22.         System.out.println(int[].class.isPrimitive());//数组类型不是原始类型，数组是一个对象类型即int[]是一个Object  
23.     }

运行结果:

对应输出的结果可以看出，三种获取String类型的方法得到的结果都是java.lang.String,同时还有就是str1字符串1和str2字符串2的类型也是一样的，即使类容不一样，这个就和上面说的一致了，同样的类型对应在内存中的字节码是一样的，即JVM只加载相同类型的字节码到内存只有一次，内存中同样的类型的字节码也是只有一份，所以即使对象的内容不一样，但是类型一样，字节码是一样的，这个不要和对象不一样的概念混淆了，

[java] view plain copy

1. System.out.println(str1==str2)  

这段代码输出的肯定是false，因为str1和str2是两个不同的对象，由此可以看出，类型是一样的Class对象是相等的，当然也可以用Class对象来判断两个对象是不是同一种类型

下面来看一下基本类型和对象类型的却别：

int是基本类型，Integer是对象类型，这个类型是不一样的，所以Class对象也是不一样的，同时Class对象中也提供了一些判断方法，比如判断是不是基本类型，枚举类型，数组类型等信息，还有一点要注意的就是基本类型数组是一个对象类型，所以下面的代码是没有错的:

[java] view plain copy

1. Object obj = {1，2，3}  

在来看一下8种数据类型对应的对象中的字段TYPE，先来看一下文档：

文档中说了，Java中的8中基本数据类型的字节码对应的就是其对象类型中的TYPE字段(这里还有一个Void类型)，再看一下Integer中的TYPE字段的定义:

[java] view plain copy
1. /** 
2.      * The {@code Class} instance representing the primitive type 
3.      * {@code int}. 
4.      * 
5.      * @since   JDK1.1 
6.      */  
7.     public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

就是获取int类型的字节码

下面来看一下Class中的Constructor类（类的构造方法）

Class中的Constructor类是对象的构造方法反射出来对应的对象类型，具体看一下代码：

[java] view plain copy
1. public static void main(String[] args) throws Exception{  
2.         /**获取String对象指定的构造方法(通过方法的参数类型,传递参数的Class对象)*/  
3.         Constructor constructor = String.class.getConstructor(StringBuffer.class);//得到String对象的一个参数是StringBuffer的构造方法  
4.         String str = (String) constructor.newInstance(new StringBuffer("abc"));//生成对象String，当然要传递一个StringBuffer参数  
5.         System.out.println(str);//打印值  
6.         /**总结:这种方法是要传递参数类型和参数的值，getConstructor(...)方法的参数是一个可变参数，因为构造方法可能有多个参数*/  
7.           
8.         /**获取String默认的构造方法生成String对象*/  
9.         String str1 = String.class.newInstance();  
10.           
11.         /**获取String对象的所有构造方法,并将构造方法的参数类型打印出来*/  
12.         Constructor[] constructors = Class.forName("java.lang.String").getConstructors();  
13.         for(int i=0;i<constructors.length;i++){  
14.             Type[] type = constructors[i].getGenericParameterTypes();  
15.             for(int j=0;j<type.length;j++)  
16.                 System.out.print(type[j]+",");  
17.             System.out.println();  
18.         }  
19.     }

运行结果：

通过getConstructor(...)方法可以获取到String对象对应的参数类型的构造方法对象，因为一个对象可能有多个构造方法，所以getConstructor方法的参数是一个可变参数类型，可以同时传递多个类型，在生成String对象的时候，还需要传递参数值，这个和我们用常规方法产生String对象类似

同时也可以很方便的通过Class对象中的newInstance方法直接获取到String对象，这里是通过String对象的默认构造方法产生的对象，看一下newInstance的源代码：

[java] view plain copy
1. public T newInstance()  
2.         throws InstantiationException, IllegalAccessException  
3.     {  
4.         if (System.getSecurityManager() != null) {  
5.             checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());  
6.         }  
7.         return newInstance0();  
8.     }

在来看一下newInstance0方法的代码：

[java] view plain copy
1. private T newInstance0()  
2.        throws InstantiationException, IllegalAccessException  
3.    {  
4.        // NOTE: the following code may not be strictly correct under  
5.        // the current Java memory model.  
6.   
7.        // Constructor lookup  
8.        if (cachedConstructor == null) {  
9.            if (this == Class.class) {  
10.                throw new IllegalAccessException(  
11.                    "Can not call newInstance() on the Class for java.lang.Class"  
12.                );  
13.            }  
14.            try {  
15.                Class<?>[] empty = {};  
16.                final Constructor<T> c = getConstructor0(empty, Member.DECLARED);  
17.                // Disable accessibility checks on the constructor  
18.                // since we have to do the security check here anyway  
19.                // (the stack depth is wrong for the Constructor's  
20.                // security check to work)  
21.                java.security.AccessController.doPrivileged(  
22.                    new java.security.PrivilegedAction<Void>() {  
23.                        public Void run() {  
24.                                c.setAccessible(true);  
25.                                return null;  
26.                            }  
27.                        });  
28.                cachedConstructor = c;  
29.            } catch (NoSuchMethodException e) {  
30.                throw new InstantiationException(getName());  
31.            }  
32.        }  
33.        Constructor<T> tmpConstructor = cachedConstructor;  
34.        // Security check (same as in java.lang.reflect.Constructor)  
35.        int modifiers = tmpConstructor.getModifiers();  
36.        if (!Reflection.quickCheckMemberAccess(this, modifiers)) {  
37.            Class<?> caller = Reflection.getCallerClass(3);  
38.            if (newInstanceCallerCache != caller) {  
39.                Reflection.ensureMemberAccess(caller, this, null, modifiers);  
40.                newInstanceCallerCache = caller;  
41.            }  
42.        }  
43.        // Run constructor  
44.        try {  
45.            return tmpConstructor.newInstance((Object[])null);  
46.        } catch (InvocationTargetException e) {  
47.            Unsafe.getUnsafe().throwException(e.getTargetException());  
48.            // Not reached  
49.            return null;  
50.        }  
51.    }

代码有点长，我不需要全部看懂，只需要看其中的一部分即可：首先来看一下这段代码：

[java] view plain copy
1. if (cachedConstructor == null) {  
2.            if (this == Class.class) {  
3.                throw new IllegalAccessException(  
4.                    "Can not call newInstance() on the Class for java.lang.Class"  
5.                );  
6.            }

cacheConstructor定义是:

private volatile transient Constructor<T> cachedConstructor;

从名字上可以了解到是一个缓存的概念，由此我们可以猜测，这里用到了缓存机制，同时也说明了，反射是很耗资源的。

在来看一下代码：

[java] view plain copy
1. try {  
2.             return tmpConstructor.newInstance((Object[])null);  
3.         } catch (InvocationTargetException e) {  
4.             Unsafe.getUnsafe().throwException(e.getTargetException());  
5.             // Not reached  
6.             return null;  
7.         }

返回的时候用的是Constructor方法newInstance，同时传递的参数是null,因为默认的构造方法是无参的，从源代码中可以看出，Class中的newInstance方法实际上还是通过Constructor中的newInstance方法生成对象的。

上面还有就是打印出了String所有构造方法的参数类型，其中有一部分是空行的，这个就是String的无参的构造方法，什么也没有打印，打印出来的这些类型都是签名的。

下面在来看一下Field类，用来表示对象字段类型的

代码：

[java] view plain copy
1. public static void main(String[] args) throws Exception{  
2.     /**获取ReflectPoint类中的public的y字段(字段用名称来区分,方法用参数类型和个数和顺序来区分)*/  
3.     ReflectPoint point = new ReflectPoint(3,5);  
4.     Field fieldY = point.getClass().getField("y");  
5.     System.out.println("y字段的类型:"+fieldY.getGenericType());//获取字段的类型  
6.     System.out.println("y的值是:"+fieldY.get(point));//获取字段的值  
7.     /**获取ReflectPoint类中的private的x字段*/  
8.     Field fieldX = point.getClass().getDeclaredField("x");//没有用getField方法了，因为getField方法只能获取到public字段，getDeclaredField可以获取到所有的字段  
9.     fieldX.setAccessible(true);//因为x字段是private私有的，所以要暴力访问  
10.     System.out.println("x字段的类型:"+fieldX.getGenericType());  
11.     System.out.println("x的值是:"+fieldX.get(point));  
12.     /**将ReflectPoint对象中的String类型字段中的"j"字符换成"a"*/  
13.     Field[] fields = point.getClass().getDeclaredFields();  
14.     for(int i=0;i<fields.length;i++){  
15.         if(fields[i].getType() == String.class){  
16.             String oldValue = (String) fields[i].get(point);  
17.             String newValue = oldValue.replace("j", "a");  
18.             fields[i].set(point, newValue);  
19.         }  
20.     }  
21.     System.out.println(point);  
22. }

下面是ReflectPoint类：

[java] view plain copy
1. package com.reflect.demo;  
2.   
3. public class ReflectPoint {  
4.       
5.     private int x;//私有的  
6.     public int y;//公共的  
7.     public String str = "jiangwei";  
8.     public String str1 = "jiangzhi";  
9.       
10.     public ReflectPoint(){  
11.     }  
12.       
13.     public ReflectPoint(int x, int y) {  
14.         super();  
15.         this.x = x;  
16.         this.y = y;  
17.     }  
18.       
19.     public String getStr() {  
20.         return str;  
21.     }  
22.   
23.     public void setStr(String str) {  
24.         this.str = str;  
25.     }  
26.   
27.     public String getStr1() {  
28.         return str1;  
29.     }  
30.   
31.     public void setStr1(String str1) {  
32.         this.str1 = str1;  
33.     }  
34.   
35.     public int getX() {  
36.         return x;  
37.     }  
38.     public void setX(int x) {  
39.         this.x = x;  
40.     }  
41.     public int getY() {  
42.         return y;  
43.     }  
44.     public void setY(int y) {  
45.         this.y = y;  
46.     }  
47.       
48.     @Override  
49.     public String toString() {  
50.         return "ReflectPoint [x=" + x + ", y=" + y + ", str=" + str + ", str1="  
51.                 + str1 + "]";  
52.     }  
53.       
54.   
55. }

运行结果如下：

获取ReflectPoint对象中的所有字段，如果字段是String类型的，就将他的内容中的"j"字符换成"a"字符

这里要注意的是:在获取字段x的时候不能像获取其他的字段一样，因为x是private的，所以会出现以下问题：

没有找到字段x，所以这时候需要用getDeclaredField方法，这个方法是获取类中所有的字段，而getField方法是获取public的字段，但是这时候运行还是报错:

提示说不能访问ReflectPoint类中的私有变量，这时候需要再加一段代码：

fieldX.setAccessible(true);//因为x字段是private私有的，所以要暴力访问

这时候运行就没有问题了，所以如果类中的字段不是public的时候，在获取类的字段时候要注意，首先要能拿到这个字段用getDeclaredField方法，然后是能够操作这个字段还要加一段代码：fieldX.setAccessible(true)；这样就可以访问类中的所有字段了。

下面在来看一下Method类，是对应对象中方法

[java] view plain copy
1. public static void main(String[] args) throws Exception{  
2.         Method methodCharAt = String.class.getMethod("charAt", int.class);  
3.         System.out.println(methodCharAt.invoke("abc", 2));  
4.           
5.         Method[] methods = String.class.getDeclaredMethods();  
6.         for(int i=0;i<methods.length;i++){  
7.             System.out.println("方法名:"+methods[i].getName());  
8.         }  
9.     }

运行结果:

String类中有很多的方法，这里没有全部截图出来，这个作用很大的，我们就可以控制一个方法的执行流程，比如我想在String的charAt方法执行前干一件事，执行后干一件事，这个就是AOP概念了，后面的代理模式也要用到这个方法，所以说这个Method的作用很大的。

下面来看一下怎么反射带有数组参数的方法

看一下代码：

[java] view plain copy
1. public static void main(String[] args) throws Exception{  
2.         Method method = ReflectTest.class.getMethod("print", int[].class);  
3.         //invoke(Object obj,Object...args);  
4.         //JDK1.5:Object...  
5.         //JDK1.4:Object[]...  
6.         //先走1.4版本的,如果不符合就走1.5的版本,所以传递一个new Integer[]数组,因为Integer是Object,所以走JDK1.4版本的Object[] args  
7.         //这样对应的参数是args:1,2,3 args.length=3,但是方法print只有一个参数,所以会报异常  
8.         //如果将参数改成new int[]{1,2,3}的话,就不会了,因为int[]数组本身就是一个Object类型的,所以JDK1.4版本的走不通,所以走JDK1.5版本的  
9.         //JDK1.5版本中,编译器拿到int[](Object)直接传给args,这时候可变参数还是会转化成Object[]数组,但是这时候args.length=1,所以不会报错  
10.         method.invoke(null, new Integer[]{1,2,3});  
11.     }  
12.       
13. public static void print(int[] a){  
14.         for(int i=0;i<a.length;i++)  
15.             System.out.println(a[i]);  
16.     }

这个方法中就是通过反射带有数组类型的方法，然后用invoke方法执行，但是这里有个问题就是版本兼容的问题，我们知道可变参数是JDK1.5引入的，为了兼容向下版本，所以有可变参数的方法，首先会执行其对应的JDK低版本的方法，比如这里的invoke方法，invoke(Object obj,Object...args)这个是JDK1.5版本中定义的，在JDK1.4版本中的定义是invoke(Object obj,Object[] args)，可以查看源代码：

[java] view plain copy
1. public Object invoke(Object obj, Object... args)  
2.         throws IllegalAccessException, IllegalArgumentException,  
3.            InvocationTargetException  
4.     {  
5.         if (!override) {  
6.             if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {  
7.                 Class<?> caller = Reflection.getCallerClass(1);  
8.   
9.                 checkAccess(caller, clazz, obj, modifiers);  
10.             }  
11.         }  
12.         MethodAccessor ma = methodAccessor;             // read volatile  
13.         if (ma == null) {  
14.             ma = acquireMethodAccessor();  
15.         }  
16.         return ma.invoke(obj, args);  
17.     }

其中ma.invoke(Object,Object[] args)的，由此也说明了，可变参数和数组时相同的，互相传递参数是没有问题的。

言归正传，现在的问题是我给invoke(null,new Integer[]{1,2,3})传递这样的参数，执行报错(因为print是static,所以不依赖于对象类型，第一个参数为null)

提示参数个数不匹配，这个很郁闷呀，为什么不对呢？print方法接受的是一个int[]类型的数组，我传递一个Integer[]数组，为什么会提示参数的个数不正确呢？下面来解释一下原因：

刚才也说道了，为了版本的兼容问题，所以先走JDK1.4版本的

JDK1.5版本是:Object... args

JDK1.4版本是:Object[] args

而Integer是Object对象，所以new Integer[]相当于是new Object[]所以会走JDK1.4版本的，那么此时args.length=3了，但是print参数的个数是1,所以会报错了

我现在把new Integer[]改成new int[]，然后运行，尽然不报错了，这个又是为什么呢？

这个是因为Java中数组是一个Object，所以int[]是一个Object，但是Integer本身是一个Object，所以Integer[]是一个Object[]这个要注意，不要混淆，也就是说，Java中的基本类型的数据是一个Object,那么new int[]是一个Object，所以先走JDK1.4版本的Object[] args发现不匹配，所以在走JDK1.5版本的Object...args这个可以匹配的，可变参数args就传递一个Object(int[])，所以args.length=1这时候参数的个数匹配了，所以不报错了。

这里要注意两个问题：

一个是版本兼容的问题。

对于这个问题，我可以这样修改代码：

invoke(null,newObject[]{new Integer[]{1,2,3}});

invoke(null,(Object)new Integer[]{1,2,3});

这两种方式都可以，原理都是一样的，第一种方式是Object[] args直接走JDK1.4版本的,这时候args.length=1，所以不报错了，第二种方式是强制转化成Object，这样就表明了不走JDK1.4版本的Object[] args.而是走JDK1.5的Object... args的，这样args.length=1,解决方法的根据就是让args.length=1即可

这里还有另外的一种方式(这种方式和本文研究的问题是没有关系的，只是一种解决方案)：

[java] view plain copy
1. // 数组参数的调用方法    
2. Method arrayInputMethod = clazz.getMethod("print",Integer[].class);  
3. Object arrayObj = Array.newInstance(Integer.class, 3);//初始化大小为2，数组元素类型是Integer的数组    
4. Array.set(arrayObj, 0, 1);    
5. Array.set(arrayObj, 1, 2);  
[java] view plain copy
1. Array.set(arrayObj, 2, 3);    
2. arrayInputMethod.invoke(object, arrayObj);

这样也可以解决上面的问题，但是这个和此问题没有关系，只是做一下拓展.

还有一个问题就是Java中的基本类型数组是Object对象，下面在来看一下案例：

[java] view plain copy
1. public static void main(String[] args) throws Exception{  
2.         int[] intAry = {1,2,3};  
3.         String[] strAry = {"a","b","c"};  
4.         //将数组转化成list然后将内容打印出来  
5.         System.out.println(Arrays.asList(intAry));  
6.         System.out.println(Arrays.asList(strAry));  
7.     }

打印结果如下：

问题来了，为什么没有打印[1,2,3]呢，而String数组可以正常打印呢？，这个就是因为int[]是一个Object对象，看一下Arrays.asList方法的定义:

从文档中可以看到asList方法用到了可变参数，上面说到了，只要方法中的参数是可变参数类型的，要向下兼容，所以会有:

JDK1.5版本的asList（T...a)

JDK1.4版本的asList（T[] a)

这里的T是Object 所以int[]是一个Object，走JDK1.5版本的，所以只打印了一个数据就是int[]类型的对象的hashCode，而String数组走的是JDK1.4版本的，所以全部打印出来了，当然如果将int[]改成Integer[]也可以打印出来的。这个问题说明了，Java中的基本类型数组时一个Object.

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注编程语言JAVA频道