Java反射初步

一.概念

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

　　Class类的构造方法是private，由JVM创建。Class 没有公共构造方法。

　　反射是java语言的一个特性，它允程序在运行时（注意不是编译的时候）来进行自我检查并且对内部的成员进行操作。例如它允许一个java的类获取他所有的成员变量和方法并且显示出来。Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。 （来自Sun）

　　JavaBean 是 reflection 的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过 reflection 动态的载入并取得 Java 组件(类) 的属性。

　　反射是从1.2就有的，后面的三大框架都会用到反射机制,涉及到类"Class",无法直接new CLass()，其对象是内存里的一份字节码（Java中，字节码是CPU构架（JVM）的具有可移植性的机器语言。）.　　

　　Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。　

1 Person p1 = new Person();2 //下面的这三种方式都可以得到字节码3 CLass c1 = Date.class();4 p1.getClass(); 5 //若存在则加载，否则新建,往往使用第三种,类的名字在写源程序时不需要知道，到运行时再传递过来6 Class.forName("java.lang.String");

　　CLass.forName()字节码已经加载到java虚拟机中，去得到字节码；java虚拟机中还没有生成字节码 用类加载器进行加载，加载的字节码缓冲到虚拟机中。　

　　考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。

 1 import java.lang.reflect.*;   2  3 public class DumpMethods {   4    public static void main(String args[]) {   5       try {   6            Class c = Class.forName("java.util.Stack");   7  8            Method m[] = c.getDeclaredMethods();   9              10            for (int i = 0; i < m.length; i++)  11                System.out.println(m[i].toString());  12       }  13       catch (Throwable e){  14             System.err.println(e);  15       }  16    }  17 }

1 public synchronized java.lang.Object java.util.Stack.pop() 2 public java.lang.Object java.util.Stack.push(java.lang.Object) 3 public boolean java.util.Stack.empty() 4 public synchronized java.lang.Object java.util.Stack.peek() 5 public synchronized int java.util.Stack.search(java.lang.Object)

　　这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

　　以下示例使用 Class 对象来显示对象的类名：

1 void printClassName(Object obj) {2          System.out.println("The class of " + obj +3                             " is " + obj.getClass().getName());4      }

　　还可以使用一个类字面值（JLS Section 15.8.2）来获取指定类型（或 void）的 Class 对象。例如：

1 System.out.println("The name of class Foo is: "+Foo.class.getName());

 　　在没有对象实例的时候，主要有两种办法。

//获得类类型的两种方式        Class cls1 = Role.class;        Class cls2 = Class.forName("yui.Role");

　　注意第二种方式中，forName中的参数一定是完整的类名（包名+类名），并且这个方法需要捕获异常。现在得到cls1就可以创建一个Role类的实例了，利用Class的newInstance方法相当于调用类的默认的构造器。

1 Object o = cls1.newInstance(); 2 //创建一个实例        3 //Object o1 = new Role();   //与上面的方法等价

 

二.常用方法　　

　　1.isPrimitive(判断是否是基本类型的字节码)

 1 public class TestReflect { 2     public static void main(String[] args) { 3         // TODO Auto-generated method stub 4         String str = "abc"; 5         Class cls1 = str.getClass(); 6         Class cls2 = String.class; 7         Class cls3 = null;//必须要加上null 8         try { 9             cls3 = Class.forName("java.lang.String");10         } catch (ClassNotFoundException e) {11             // TODO Auto-generated catch block12             e.printStackTrace();13         }14         System.out.println(cls1==cls2);15         System.out.println(cls1==cls3);16         17         System.out.println(cls1.isPrimitive());18         System.out.println(int.class.isPrimitive());//判定指定的 Class 对象是否表示一个基本类型。19         System.out.println(int.class == Integer.class);20         System.out.println(int.class == Integer.TYPE);21         System.out.println(int[].class.isPrimitive());22         System.out.println(int[].class.isArray());23     }24 }25 /*26  * true27 true28 false29 true30 false31 true32 false33 true34 35  */36 */

　　2.getConstructor和getConstructors()

　　java中构造方法没有先后顺序，通过类型和参数个数区分。　

1 public class TestReflect {2     public static void main(String[] args) throws SecurityException, NoSuchMethodException {3         // TODO Auto-generated method stub4         String str = "abc";5         6         System.out.println(String.class.getConstructor(StringBuffer.class));7     }8 }

　　3.Filed类代表某一类中的一个成员变量。

 1 import java.lang.reflect.Field; 2 public class TestReflect { 3     public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception { 4         ReflectPointer rp1 = new ReflectPointer(3,4); 5         Field fieldx = rp1.getClass().getField("x");//必须是x或者y 6         System.out.println(fieldx.get(rp1)); 7          8         /* 9          * private的成员变量必须使用getDeclaredField，并setAccessible(true),否则看得到拿不到10          */11         Field fieldy = rp1.getClass().getDeclaredField("y");12         fieldy.setAccessible(true);//暴力反射13         System.out.println(fieldy.get(rp1));14         15     }16 }17 18 class ReflectPointer {19     20     public int x = 0;21     private int y = 0;22     23     public ReflectPointer(int x,int y) {//alt + shift +s相当于右键source24         super();25         // TODO Auto-generated constructor stub26         this.x = x;27         this.y = y;28     }29 }

　　4.

三.典型例题

　　1.将所有String类型的成员变量里的b改成a。

 1 import java.lang.reflect.Field; 2 public class TestReflect { 3     public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception { 4         ReflectPointer rp1 = new ReflectPointer(3,4); 5         changeBtoA(rp1); 6         System.out.println(rp1); 7          8     } 9     10     private static void changeBtoA(Object obj) throws RuntimeException, Exception {11         Field[] fields = obj.getClass().getFields();12         13         for(Field field : fields) {14             //if(field.getType().equals(String.class))15             //由于字节码只有一份,用equals语义不准确16             if(field.getType()==String.class) {17                 String oldValue = (String)field.get(obj);18                 String newValue = oldValue.replace('b', 'a');19                 field.set(obj,newValue);20             }21         }22     }23 }24 25 class ReflectPointer {26     27     private int x = 0;28     public int y = 0;29     public String str1 = "ball";30     public String str2 = "basketball";31     public String str3 = "itcat";32     33     public ReflectPointer(int x,int y) {//alt + shift +s相当于右键source34         super();35         // TODO Auto-generated constructor stub36         this.x = x;37         this.y = y;38     }39 40     @Override41     public String toString() {42         return "ReflectPointer [str1=" + str1 + ", str2=" + str2 + ", str3="43                 + str3 + "]";44     }45 }

　　2.写一个程序根据用户提供的类名，调用该类的里的main方法。

　　为什么要用反射的方式呢？

 1 import java.lang.reflect.Field; 2 import java.lang.reflect.Method; 3  4 public class TestReflect { 5     public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception { 6         String str = args[0]; 7         /* 8          * 这样会数组角标越界，因为压根没有这个字符数组 9          * 需要右键在run as-configurations-arguments里输入b.Inter（完整类名）10          * 11          */12         Method m = Class.forName(str).getMethod("main",String[].class);13         //下面这两种方式都可以,main方法需要一个参数14         15         m.invoke(null, new Object[]{new String[]{"111","222","333"}});16         m.invoke(null, (Object)new String[]{"111","222","333"});//这个可以说明，数组也是Object17         /*18          * m.invoke(null, new String[]{"111","222","333"})19          * 上面的不可以,因为java会自动拆包20          */21     }22 }23 24 class Inter {25     public static void main(String[] args) {26         for(Object obj : args) {27             System.out.println(obj);28         }29     }30 }

　　3.模拟 instanceof 操作符

 1 class S {   2 }    3  4 public class IsInstance {   5    public static void main(String args[]) {   6       try {   7            Class cls = Class.forName("S");   8            boolean b1 = cls.isInstance(new Integer(37));   9            System.out.println(b1);  10            boolean b2 = cls.isInstance(new S());  11            System.out.println(b2);  12       }  13       catch (Throwable e) {  14            System.err.println(e);  15       }  16    }  17 }

　　在这个例子中创建了一个S 类的 Class 对象，然后检查一些对象是否是S的实例。Integer(37) 不是，但 new S()是。

四.Method类

　　代表类（不是对象）中的某一方法。

 1 import java.lang.reflect.Field; 2 import java.lang.reflect.Method; 3 /* 4  * 人在黑板上画圆，涉及三个对象,画圆需要圆心和半径，但是是私有的，画圆的方法 5  * 分配给人不合适。 6  *  7  * 司机踩刹车，司机只是给列车发出指令，刹车的动作还需要列车去完成。 8  *  9  * 面试经常考面向对象的设计，比如人关门，人只是去推门。10  * 11  * 这就是专家模式：谁拥有数据，谁就是专家,方法就分配给谁12  */13 public class TestReflect {14     public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception {15         String str = "shfsfs";16         //包开头是com表示是sun内部用的，java打头的才是用户的17         Method mtCharAt = String.class.getMethod("charAt", int.class);18         Object ch = mtCharAt.invoke(str,1);//若第一个参数是null，则肯定是静态方法19         System.out.println(ch);20         21         System.out.println(mtCharAt.invoke(str, new Object[]{2}));//1.4语法22         23     }24     25 }

 

五.数组的反射

　　Array工具类用于完成数组的反射操作。

　　同类型同纬度有相同的字节码。

　　int.class和Integer.class不是同一份字节码，Integer.TYPE，TYPE代表包装类对应的基本类的字节码    int.class==Integer.TYPE

 1 import java.util.Arrays; 2  3 /* 4  * 从这个例子看出即便字节码相同但是对象也不一定相同,根本不是一回事 5  *  6  */ 7 public class TestReflect { 8     public static void main(String[] args) throws SecurityException, NoSuchMethodException, NoSuchFieldException, IllegalArgumentException, Exception { 9         int[] a = new int[3];10         int[] b = new int[]{4,5,5};//直接赋值后不可以指定长度，否则ＣＥ11         int[][] c = new int[3][2];12         String[] d = new String[]{"jjj","kkkk"};13         System.out.println(a==b);//false14         System.out.println(a.getClass()==b.getClass());//true15         //System.out.println(a.getClass()==d.getClass());    //比较字节码a和cd也没法比16         System.out.println(a.getClass());//输出class [I17         System.out.println(a.getClass().getName());//输出[I,中括号表示数组，I表示整数18         19         System.out.println(a.getClass().getSuperclass());//输出class java.lang.Object20         System.out.println(d.getClass().getSuperclass());//输出class java.lang.Object21         22         //由于父类都是Object,下面都是可以的23         Object obj1 = a;//不可是Object[]24         Object obj2 = b;25         Object[] obj3 = c;//基本类型的一位数组只可以当做Object，非得还可以当做Object[]26         Object obj4 = d;27         28         //注意asList处理int[]和String[]的区别29         System.out.println(Arrays.asList(b));//1.4没有可变参数，使用的是数组,[[I@1bc4459]30         System.out.println(Arrays.asList(d));//[jjj, kkkk]31         32     }33 }

六.结束语
　　以上就是反射机制的简单的使用，显然学过spring的朋友一定明白了，为什么可以通过配置文件就可以让我们获得指定的方法和变量，在我们创建对象的时候都是通过传进string实现的，就好像你需要什么，我们去为你生产，还有我们一直在用Object,这就说明java语言的动态特性，依赖性大大的降低了。