深入理解java反射

一、什么是反射：
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基于反射机制的语言。最近，反射机制也被应用到了视窗系统、操作系统和文件系统中。

反射本身并不是一个新概念，尽管计算机科学赋予了反射概念新的含义。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。

二、什么是Java中的类反射：
Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性和方法。Java 的这一能力在实际应用中用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。
Reflection 是 Java 被视为动态（或准动态）语言的关键，允许程序于执行期 Reflection APIs 取得任何已知名称之 class 的內部信息，包括 package、type parameters、superclass、implemented interfaces、inner classes, outer class, fields、constructors、methods、modifiers，並可于执行期生成instances、变更 fields 內容或唤起 methods。

三、Java类反射中所必须的类：
Java的类反射所需要的类并不多，它们分别是：Field、Constructor、Method、Class、Object，下面我将对这些类做一个简单的说明。
Field类：提供有关类或接口的属性的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）属性或实例属性，简单的理解可以把它看成一个封装反射类的属性的类。
Constructor类：提供关于类的单个构造方法的信息以及对它的访问权限。这个类和Field类不同，Field类封装了反射类的属性，而Constructor类则封装了反射类的构造方法。
Method类：提供关于类或接口上单独某个方法的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。这个类不难理解，它是用来封装反射类方法的一个类。
Class类：类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
Object类：每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

四、Java的反射类能做什么：
       看完上面的这么多我想你已经不耐烦了，你以为我在浪费你的时间，那么好吧！下面我们就用一些简单的小例子来说明它。
       首先我们来看一下通过Java的反射机制我们能得到些什么。
       首先我们来写一个类：

 
      01 
       package com.juziku;  
     
      02 
        
      03 
       class A extends Object implements ActionListener {  
     
      04 
           private int a = 3;  
     
      05 
           public Integer b = new Integer(4);  
     
      06 
        
      07 
           public A() {  
     
      08 
           }  
     
      09 
        
      10 
           public A(int id, String name) {  
     
      11 
           }  
     
      12 
        
      13 
           public int abc(int id, String name) {  
     
      14 
               return 0;  
     
      15 
           }  
     
      16 
        
      17 
           public void actionPerformed(ActionEvent e) {  
     
      18 
           }  
     
      19 
      }

你可能被我这个类弄糊涂了，你看不出我要做什么，那就不要看这个类了，这个类是用来测试的，你知道知道它继承了Object类，有一个接口是ActionListener，两个属性int和Integer,两个构造方法和两个方法，这就足够了。
下面我们把A这个类作为一个反射类，来过去A类中的一些信息，首先我们先来过去一下反射类中的属性和属性值。

 
      01 
       package com.juziku;  
     
      02 
        
      03 
       import java.lang.reflect.*;  
     
      04 
        
      05 
       class B {  
     
      06 
           public static void main(String args[]) {  
     
      07 
               A r = new A();  
     
      08 
               Class temp = r.getClass();  
     
      09 
               try {  
     
      10 
                   System.out.println("反射类中所有公有的属性");  
     
      11 
                   Field[] fb = temp.getFields();  
     
      12 
                   for (int j = 0; j < fb.length; j++) {  
     
      13 
                       Class cl = fb[j].getType();  
     
      14 
                       System.out.println("fb:" + cl);  
     
      15 
                   }  
     
      16 
        
      17 
                   System.out.println("反射类中所有的属性");  
     
      18 
                   Field[] fa = temp.getDeclaredFields();  
     
      19 
                   for (int j = 0; j < fa.length; j++) {  
     
      20 
                       Class cl = fa[j].getType();  
     
      21 
                       System.out.println("fa:" + cl);  
     
      22 
                   }  
     
      23 
                   System.out.println("反射类中私有属性的值");  
     
      24 
                   Field f = temp.getDeclaredField("a");  
     
      25 
                   f.setAccessible(true);  
     
      26 
                   Integer i = (Integer) f.get(r);  
     
      27 
                   System.out.println(i);  
     
      28 
               } catch (Exception e) {  
     
      29 
                   e.printStackTrace();  
     
      30 
               }  
     
      31 
           }  
     
      32 
        
      33 
      }

这里用到了两个方法，getFields()、getDeclaredFields()，它们分别是用来获取反射类中所有公有属性和反射类中所有的属性的方法。另外还有getField(String)和getDeclaredField(String)方法都是用来过去反射类中指定的属性的方法，要注意的是getField方法只能取到反射类中公有的属性，而getDeclaredField方法都能取到。
这里还用到了Field 类的setAccessible方法，它是用来设置是否有权限访问反射类中的私有属性的，只有设置为true时才可以访问，默认为false。另外Field类还有set(Object AttributeName,Object value)方法，可以改变指定属性的值。

下面我们来看一下如何获取反射类中的构造方法

 
      01 
       package com.juziku;  
     
      02 
        
      03 
       import java.lang.reflect.*;  
     
      04 
        
      05 
       public class SampleConstructor {  
     
      06 
           public static void main(String[] args) {  
     
      07 
               A r = new A();  
     
      08 
               printConstructors(r);  
     
      09 
           }  
     
      10 
        
      11 
           public static void printConstructors(A r) {  
     
      12 
               Class c = r.getClass();  
     
      13 
               // 获取指定类的类名  
     
      14 
               String className = c.getName();  
     
      15 
               try {  
     
      16 
                   // 获取指定类的构造方法  
     
      17 
                   Constructor[] theConstructors = c.getConstructors();  
     
      18 
                   for (int i = 0; i < theConstructors.length; i++) {  
     
      19 
                       // 获取指定构造方法的参数的集合  
     
      20 
                       Class[] parameterTypes = theConstructors[i].getParameterTypes();  
     
      21 
        
      22 
                       System.out.print(className + "(");  
     
      23 
        
      24 
                       for (int j = 0; j < parameterTypes.length; j++)  
     
      25 
                           System.out.print(parameterTypes[j].getName() + " ");  
     
      26 
        
      27 
                       System.out.println(")");  
     
      28 
        
      29 
                   }  
     
      30 
               } catch (Exception e) {  
     
      31 
                   e.printStackTrace();  
     
      32 
               }  
     
      33 
           }  
     
      34 
      }

这个例子很简单,只是用getConstructors()方法获取了反射类的构造方法的集合，并用Constructor类的getParameterTypes()获取该构造方法的参数。

下面我们再来获取一下反射类的父类（超类）和接口

 
      01 
       package com.juziku;  
     
      02 
        
      03 
       import java.io.*;  
     
      04 
       import java.lang.reflect.*;  
     
      05 
        
      06 
       public class SampleInterface {  
     
      07 
           public static void main(String[] args) throws Exception {  
     
      08 
               A raf = new A();  
     
      09 
               printInterfaceNames(raf);  
     
      10 
           }  
     
      11 
        
      12 
           public static void printInterfaceNames(Object o) {  
     
      13 
               Class c = o.getClass();  
     
      14 
               // 获取反射类的接口  
     
      15 
               Class[] theInterfaces = c.getInterfaces();  
     
      16 
               for (int i = 0; i < theInterfaces.length; i++)  
     
      17 
                   System.out.println(theInterfaces[i].getName());  
     
      18 
               // 获取反射类的父类（超类）  
     
      19 
               Class theSuperclass = c.getSuperclass();  
     
      20 
               System.out.println(theSuperclass.getName());  
     
      21 
           }  
     
      22 
      }

这个例子也很简单，只是用Class类的getInterfaces()方法获取反射类的所有接口，由于接口可以有多个，所以它返回一个Class数组。用getSuperclass()方法来获取反射类的父类（超类），由于一个类只能继承自一个类，所以它返回一个Class对象。

下面我们来获取一下反射类的方法

 
      01 
       package com.juziku;  
     
      02 
        
      03 
       import java.lang.reflect.*;  
     
      04 
        
      05 
       public class SampleMethod {  
     
      06 
        
      07 
           public static void main(String[] args) {  
     
      08 
               A p = new A();  
     
      09 
               printMethods(p);  
     
      10 
           }  
     
      11 
        
      12 
           public static void printMethods(Object o) {  
     
      13 
               Class c = o.getClass();  
     
      14 
               String className = c.getName();  
     
      15 
               Method[] m = c.getMethods();  
     
      16 
               for (int i = 0; i < m.length; i++) {  
     
      17 
                   // 输出方法的返回类型  
     
      18 
                   System.out.print(m[i].getReturnType().getName());  
     
      19 
                   // 输出方法名  
     
      20 
                   System.out.print(" " + m[i].getName() + "(");  
     
      21 
                   // 获取方法的参数  
     
      22 
                   Class[] parameterTypes = m[i].getParameterTypes();  
     
      23 
                   for (int j = 0; j < parameterTypes.length; j++) {  
     
      24 
                       System.out.print(parameterTypes[j].getName());  
     
      25 
                       if (parameterTypes.length > j + 1) {  
     
      26 
                           System.out.print(",");  
     
      27 
                       }  
     
      28 
                   }  
     
      29 
        
      30 
                   System.out.println(")");  
     
      31 
               }  
     
      32 
        
      33 
           }  
     
      34 
        
      35 
      }

这个例子并不难，它只是获得了反射类的所有方法，包括继承自它父类的方法。然后获取方法的返回类型、方法名和方法参数。

接下来让我们回过头来想一想，我们获取了反射类的属性、构造方法、父类、接口和方法，可这些东西能帮我们做些什么呢！！
下面我写一个比较完整的小例子，来说明Java的反射类能做些什么吧！

 
      01 
       package com.juziku;  
     
      02 
        
      03 
       import java.lang.reflect.Constructor;  
     
      04 
       import java.lang.reflect.Method;  
     
      05 
        
      06 
       public class LoadMethod {  
     
      07 
           public Object Load(String cName, String MethodName, String[] type,  
     
      08 
                   String[] param) {  
     
      09 
               Object retobj = null;  
     
      10 
               try {  
     
      11 
                   // 加载指定的Java类  
     
      12 
                   Class cls = Class.forName(cName);  
     
      13 
        
      14 
                   // 获取指定对象的实例  
     
      15 
                   Constructor ct = cls.getConstructor(null);  
     
      16 
                   Object obj = ct.newInstance(null);  
     
      17 
        
      18 
                   // 构建方法参数的数据类型  
     
      19 
                   Class partypes[] = this.getMethodClass(type);  
     
      20 
        
      21 
                   // 在指定类中获取指定的方法  
     
      22 
                   Method meth = cls.getMethod(MethodName, partypes);  
     
      23 
        
      24 
                   // 构建方法的参数值  
     
      25 
                   Object arglist[] = this.getMethodObject(type, param);  
     
      26 
        
      27 
                   // 调用指定的方法并获取返回值为Object类型  
     
      28 
                   retobj = meth.invoke(obj, arglist);  
     
      29 
        
      30 
               } catch (Throwable e) {  
     
      31 
                   System.err.println(e);  
     
      32 
               }  
     
      33 
               return retobj;  
     
      34 
           }  
     
      35 
        
      36 
           // 获取参数类型Class[]的方法  
     
      37 
           public Class[] getMethodClass(String[] type) {  
     
      38 
               Class[] cs = new Class[type.length];  
     
      39 
               for (int i = 0; i < cs.length; i++) {  
     
      40 
                   if (!type[i].trim().equals("") || type[i] != null) {  
     
      41 
                       if (type[i].equals("int") || type[i].equals("Integer")) {  
     
      42 
                           cs[i] = Integer.TYPE;  
     
      43 
                       } else if (type[i].equals("float") || type[i].equals("Float")) {  
     
      44 
                           cs[i] = Float.TYPE;  
     
      45 
                       } else if (type[i].equals("double") || type[i].equals("Double")) {  
     
      46 
                           cs[i] = Double.TYPE;  
     
      47 
                       } else if (type[i].equals("boolean")  
     
      48 
                               || type[i].equals("Boolean")) {  
     
      49 
                           cs[i] = Boolean.TYPE;  
     
      50 
                       } else {  
     
      51 
                           cs[i] = String.class;  
     
      52 
                       }  
     
      53 
                   }  
     
      54 
               }  
     
      55 
               return cs;  
     
      56 
           }  
     
      57 
        
      58 
           // 获取参数Object[]的方法  
     
      59 
           public Object[] getMethodObject(String[] type, String[] param) {  
     
      60 
               Object[] obj = new Object[param.length];  
     
      61 
               for (int i = 0; i < obj.length; i++) {  
     
      62 
                   if (!param[i].trim().equals("") || param[i] != null) {  
     
      63 
                       if (type[i].equals("int") || type[i].equals("Integer")) {  
     
      64 
                           obj[i] = new Integer(param[i]);  
     
      65 
                       } else if (type[i].equals("float") || type[i].equals("Float")) {  
     
      66 
                           obj[i] = new Float(param[i]);  
     
      67 
                       } else if (type[i].equals("double") || type[i].equals("Double")) {  
     
      68 
                           obj[i] = new Double(param[i]);  
     
      69 
                       } else if (type[i].equals("boolean")  
     
      70 
                               || type[i].equals("Boolean")) {  
     
      71 
                           obj[i] = new Boolean(param[i]);  
     
      72 
                       } else {  
     
      73 
                           obj[i] = param[i];  
     
      74 
                       }  
     
      75 
                   }  
     
      76 
               }  
     
      77 
               return obj;  
     
      78 
           }  
     
      79 
      }

这是我在工作中写的一个实现Java在运行时加载指定的类，并调用指定方法的一个小例子。这里没有main方法，你可以自己写一个。
Load方法接收的五个参数分别是，Java的类名，方法名，参数的类型和参数的值。

结束语：
Java语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象，无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的方式与对象协作的库。Java reflection 非常有用，它使类和数据结构能按名称动态检索相关信息，并允许在运行着的程序中操作这些信息。Java 的这一特性非常强大，并且是其它一些常用语言，如 C、C++、Fortran 或者 Pascal 等都不具备的。

但反射有两个缺点。第一个是性能问题。用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。

反射的基石——Class类
Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。比如：众多的人可以用一个Person类来表示，而这个类就可以描述人的信息(姓名、年龄、性别等等)，而众多的Java类就可以用Class来表示。
Question：Person类代表人，它的实例对象可以是张三、李四，Class类代表Java类，它的各个实例对象有分别代表什么呢？
Answer: 对应各个类在内存中的字节码。一个类被类加载器加载到内存中，占用一份存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，即Class类型。

如何得到各个字节码对应的实例对象,有三种方法：
   1、类名.class,例如:System.class
   2、对象.getClass(),例如:new Data().getClass()
   3、Class.forName("类名"),例如:Class.forName("java.util.Date")

Class类的属性和方法请参见jdk

反射
反射就是把Java类中的各种成分映射成相应的java类。例如：一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示。表示java类的Class类显然要提供一系列的方法来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。

Contructor类
1、得到某个类的所有构造方法：
     Contructor[] contructors = lass.forName("类名").getContructors();
2、得到某个特定的构造方法：
     //获得方法时要用到类型
     Contructor contructors = Class.forName("类名").getContructor(参数类型.class,...);
3、创建实例对象
     通常方式:String str = new String(new StringBuffer("abc"));
     //调用获得的方法时要用到上面相同类型的实例
     反射方式:String str = (String)contructor.newInstance(new StringBuffer("abc"));
4、Class.forName();
     ·示例:String obj = (String)Class.forName("java.lang.String").newInstence();
     ·该方法内部先得到默认的构造方法，然后用该构造方法创建实例
     ·该方法的内部具体代码是怎样的呢？用到了缓存机制来保存默认构造方法的对象

Field类
Filed类代表某个类中的成员变量
示例:

 
      01 
      RefletPoint.java 
     
      02 
       private int x;  
     
      03 
       public int y;  
     
      04 
        
      05 
       public ReflectPoint() {}  
     
      06 
        
      07 
       public ReflectPoint(int x,int y) {  
     
      08 
           this.x = x;  
     
      09 
           this.y = y;  
     
      10 
      } 
     
      11 
        
      12 
      FieldTest.java 
     
      13 
       ReflectPoint p1 = new ReflectPoint(2,8);  
     
      14 
       Field fy = Class.forName("com.juziku.ReflectPoint").getField("y");  
     
      15 
       System.out.println(fy.get(p1));   // 8  
     
      16 
        
      17 
       Field fx = Class.forName("com.juziku.ReflectPoint").getDeclaredField("x");  
     
      18 
       fx.setAccessible(true);  
     
      19 
       System.out.println(fx.get(p1));   // 2

Question: 得到的Field对象是对应于类上的成员变量？还是对应到对象上的成员变量？
      Anwser：是类上的成员变量。因为对象可以有多个，而类只有一个，所以fx.fy是得到的类上的那一份字节码。

Method类
   Method类代表某个类中一个成员方法
   ·得到类中的某个方法
        例子:Method charAt = Class.forName("java.lang.String").getMethod("charAt",int.class);
   ·调用方法:
        通常方式:str.charAt(1);
        反射方式:charAt.invoke(str,1);
   注意:如果传递给Method对象的invoke()方法的第一个参数是null,这说明该Method对象对应的是一个静态方法
   示例: 对接收数组参数的成员方法进行反射

 
      01 
       package com.juziku;  
     
      02 
        
      03 
       import java.lang.reflect.InvocationTargetException;  
     
      04 
       import java.lang.reflect.Method;  
     
      05 
        
      06 
       public class Test {  
     
      07 
        
      08 
           public static void main(String[] args) throws SecurityException,  
     
      09 
                   NoSuchMethodException, ClassNotFoundException,  
     
      10 
                   IllegalArgumentException, IllegalAccessException,  
     
      11 
                   InvocationTargetException {  
     
      12 
               String startingClassName = args[0];  
     
      13 
               Method mainMethod = Class.forName(startingClassName).getMethod("main",  
     
      14 
                       String[].class);  
     
      15 
               mainMethod.invoke(null, (Object) new String[] { "abc","def", "xyz" });  
     
      16 
           }  
     
      17 
        
      18 
      } 
     
      19 
        
      20 
       class Argumenmts {  
     
      21 
           public static void main(String[] args) {  
     
      22 
               for (String arg : args) {  
     
      23 
                   System.out.println(arg);  
     
      24 
               }  
     
      25 
           }  
     
      26 
      }

数组的反射
   ·具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象
   ·代表数组的Class实例对象的getSuperclass()方法返回的父类为Object类对应的Class
   ·基本类型的一维数组可以当做Ojbect类型使用，不能当做Object[]类型使用，而二维数组可以当做     Object类型使用，也可以当做Object[]类型使用
   示例:

 
      01 
       int[] a = new int[3];  
     
      02 
       int[] b = new int[4];  
     
      03 
       int[][] c = new int[3][4];  
     
      04 
       String[] s = new String[5];  
     
      05 
        
      06 
       System.out.println(a.getClass() == b.getClass());  // true  
     
      07 
       System.out.println(a.getClass() == c.getClass());  // false  
     
      08 
       System.out.println(c.getClass() == s.getClass());  // false  
     
      09 
      Array工具类用于完成对数组的反射操作 
     
      10 
        public static void printObject(Object obj) {  
     
      11 
               Class obyte = obj.getClass();  
     
      12 
               if (obyte.isArray()) {  
     
      13 
                      int len = Array.getLength(obj);  
     
      14 
                      for (int i = 0; i < len; i++) {  
     
      15 
                             System.out.println(Array.get(obj, i));  
     
      16 
                   }  
     
      17 
              } else {  
     
      18 
                     System.out.println(obj);  
     
      19 
             }  
     
      20 
         }

深入理解java反射

深入理解java反射

猜你喜欢