JAVA反射机制基础概念

　　反射机制:所谓的反射机制就是java语言在运行时拥有一项自观的能力。经过这种能力能够完全的了解自身的状况为下一步的动做作准备。下面具体介绍一下java的反射机制。这里你将颠覆原来对java的理解。 Java的反射机制的实现要借助于4个类：class，Constructor，Field，Method；其中class表明的时类对 象，Constructor－类的构造器对象，Field－类的属性对象，Method－类的方法对象。经过这四个对象咱们能够粗略的看到一个类的各个组 成部分。 Class：程序运行时，java运行时系统会对全部的对象进行运行时类型的处理。这项信息记录了每一个对象所属的类，虚拟机一般使用运行时类型信息选择正 确的方法来执行（摘自：白皮书）。可是这些信息咱们怎么获得啊，就要借助于class类对象了啊。在Object类中定义了getClass()方法。我 们能够经过这个方法得到指定对象的类对象。而后咱们经过分析这个对象就能够获得咱们要的信息了。 好比：ArrayList arrayList; Class clazz = arrayList.getClass(); 而后我来处理这个对象clazz。 固然了Class类具备不少的方法，这里重点将和Constructor，Field，Method类有关系的方法。 Reflection 是 Java 程序开发语言的特征之一，它容许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操做程序的内部属性。Java 的这一能力在实际应用中也许用得不是不少，可是我的认为要想对java有个更加深刻的了解仍是应该掌握的。

1. 一个简单的例子

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

import java.lang.reflect.*;

public class DumpMethods {
   public static void main(String args[]) {
      try {
           Class c = Class.forName("java.util.Stack");

           Method m[] = c.getDeclaredMethods();

           for (int i = 0; i < m.length; i++)
               System.out.println(m[i].toString());
      }
      catch (Throwable e){
            System.err.println(e);
      }
   }
}

它的结果输出为：

public synchronized java.lang.Object java.util.Stack.pop()
public java.lang.Object java.util.Stack.push(java.lang.Object)
public boolean java.util.Stack.empty()
public synchronized java.lang.Object java.util.Stack.peek()
public synchronized int java.util.Stack.search(java.lang.Object)

这样就列出了java.util.Stack 类的各方法名以及它们的限制符和返回类型。

这个程序使用 Class.forName 载入指定的类，而后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。

2.开始使用 Reflection

用于 reflection 的类，如 Method，能够在 java.lang.relfect 包中找到。使用这些类的时候必需要遵循三个步骤：第一步是得到你想操做的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。

下面就是得到一个 Class 对象的方法之一：

Class c = Class.forName("java.lang.String");

这条语句获得一个 String 类的类对象。还有另外一种方法，以下面的语句：

Class c = int.class; 或者 Class c = Integer.TYPE;

它们可得到基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。

第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的全部方法的列表。

一旦取得这个信息，就能够进行第三步了——使用 reflection API 来操做这些信息，以下面这段代码：

Class c = Class.forName("java.lang.String");

Method m[] = c.getDeclaredMethods();

System.out.println(m[0].toString());

它将以文本方式打印出 String 中定义的第一个方法的原型。

在下面的例子中，这三个步骤将为使用 reflection 处理特殊应用程序提供例证。

模拟 instanceof 操做符

获得类信息以后，一般下一个步骤就是解决关于 Class 对象的一些基本的问题。例如，Class.isInstance 方法能够用于模拟 instanceof 操做符：

class S {
}

public class IsInstance {
   public static void main(String args[]) {
      try {
           Class cls = Class.forName("S");
           boolean b1 = cls.isInstance(new Integer(37));
           System.out.println(b1);
           boolean b2 = cls.isInstance(new S());
           System.out.println(b2);
      }
      catch (Throwable e) {
           System.err.println(e);
      }
   }
}

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

3.找出类的方法

找出一个类中定义了些什么方法，这是一个很是有价值也很是基础的 reflection 用法。下面的代码就实现了这一用法：

import java.lang.reflect.*;

public class Method1 {
   private int f1(Object p, int x) throws NullPointerException {

   if (p == null)
      throw new NullPointerException();
   return x;
}

   public static void main(String args[]) {
       try {
           Class cls = Class.forName("Method1");
           Method methlist[] = cls.getDeclaredMethods();

           for (int i = 0; i < methlist.length; i++) {
               Method m = methlist[i];
               System.out.println("name = " + m.getName());
               System.out.println("decl class = " + m.getDeclaringClass());
               Class pvec[] = m.getParameterTypes();

               for (int j = 0; j < pvec.length; j++)
                   System.out.println("param #" + j + " " + pvec[j]);

               Class evec[] = m.getExceptionTypes();

               for (int j = 0; j < evec.length; j++)
                   System.out.println("exc #" + j + " " + evec[j]);

               System.out.println("return type = " + m.getReturnType());
               System.out.println("-----");
           }
       }
       catch (Throwable e) {
           System.err.println(e);
       }
   }
}

这个程序首先取得 method1 类的描述，而后调用 getDeclaredMethods 来获取一系列的 Method 对象，它们分别描述了定义在类中的每个方法，包括 public 方法、protected 方法、package 方法和 private 方法等。若是你在程序中使用 getMethods 来代替 getDeclaredMethods，你还能得到继承来的各个方法的信息。

取得了 Method 对象列表以后，要显示这些方法的参数类型、异常类型和返回值类型等就不难了。这些类型是基本类型仍是类类型，均可以由描述类的对象按顺序给出。

输出的结果以下：

name = f1
decl class = class method1
param #0 class java.lang.Object
param #1 int
exc #0 class java.lang.NullPointerException
return type = int
-----
name = main
decl class = class method1
param #0 class [Ljava.lang.String;
return type = void

4.获取构造器信息

获取类构造器的用法与上述获取方法的用法相似，如：

import java.lang.reflect.*;

public class Constructor1 {
   public Constructor1() {
   }

   protected Constructor1(int i, double d) {
   }

   public static void main(String args[]) {
      try {
           Class cls = Class.forName("Constructor1");
           Constructor ctorlist[] = cls.getDeclaredConstructors();

           for (int i = 0; i < ctorlist.length; i++) {
              Constructor ct = ctorlist[i];
              System.out.println("name = " + ct.getName());
              System.out.println("decl class = " + ct.getDeclaringClass());
              Class pvec[] = ct.getParameterTypes();

              for (int j = 0; j < pvec.length; j++)
                 System.out.println("param #" + j + " " + pvec[j]);

              Class evec[] = ct.getExceptionTypes();

              for (int j = 0; j < evec.length; j++)
                 System.out.println("exc #" + j + " " + evec[j]);

              System.out.println("-----");
           }
      }
      catch (Throwable e) {
           System.err.println(e);
      }
   }
}

这个例子中没能得到返回类型的相关信息，那是由于构造器没有返回类型。

这个程序运行的结果是：

name = Constructor1
decl class = class Constructor1
param #0 int
param #1 double
-----
name = Constructor1
decl class = class Constructor1
-----

5.获取类的字段(域)

找出一个类中定义了哪些数据字段也是可能的，下面的代码就在干这个事情：

import java.lang.reflect.*;

public class Field1 {
   private double d;
   public static final int i = 37;
   String s = "testing";

   public static void main(String args[]) {
      try {
           Class cls = Class.forName("Field1");
           Field fieldlist[] = cls.getDeclaredFields();

           for (int i = 0; i < fieldlist.length; i++) {
              Field fld = fieldlist[i];
              System.out.println("name = " + fld.getName());
              System.out.println("decl class = " + fld.getDeclaringClass());
              System.out.println("type = " + fld.getType());
              int mod = fld.getModifiers();
              System.out.println("modifiers = " + Modifier.toString(mod));
              System.out.println("-----");
           }
      }
      catch (Throwable e) {
           System.err.println(e);
      }
   }
}

这个例子和前面那个例子很是类似。例中使用了一个新东西 Modifier，它也是一个 reflection 类，用来描述字段成员的修饰语，如“private int”。这些修饰语自身由整数描述，并且使用 Modifier.toString 来返回以“官方”顺序排列的字符串描述 (如“static”在“final”以前)。这个程序的输出是：

name = d
decl class = class Field1
type = double
modifiers = private
-----
name = i
decl class = class Field1
type = int
modifiers = public static final
-----
name = s
decl class = class Field1
type = class java.lang.String
modifiers =
-----

和获取方法的状况一下，获取字段的时候也能够只取得在当前类中申明了的字段信息 (getDeclaredFields)，或者也能够取得父类中定义的字段 (getFields) 。

6.根据方法的名称来执行方法

文本到这里，所举的例子无一例外都与如何获取类的信息有关。咱们也能够用 reflection 来作一些其它的事情，好比执行一个指定了名称的方法。下面的示例演示了这一操做：

import java.lang.reflect.*;

public class Method2 {
   public int add(int a, int b) {
      return a + b;
   }

   public static void main(String args[]) {
      try {
           Class cls = Class.forName("Method2");

           Class partypes[] = new Class[2];
           partypes[0] = Integer.TYPE;
           partypes[1] = Integer.TYPE;

           Method meth = cls.getMethod("add", partypes);

           Method2 methobj = new Method2();
           Object arglist[] = new Object[2];
           arglist[0] = new Integer(37);
           arglist[1] = new Integer(47);

           Object retobj = meth.invoke(methobj, arglist);
           Integer retval = (Integer) retobj;
           System.out.println(retval.intValue());
      }
      catch (Throwable e) {
           System.err.println(e);
      }
   }
}

假如一个程序在执行的某处的时候才知道须要执行某个方法，这个方法的名称是在程序的运行过程当中指定的 (例如，JavaBean 开发环境中就会作这样的事)，那么上面的程序演示了如何作到。

上例中，getMethod用于查找一个具备两个整型参数且名为 add 的方法。找到该方法并建立了相应的Method 对象以后，在正确的对象实例中执行它。执行该方法的时候，须要提供一个参数列表，这在上例中是分别包装了整数 37 和 47 的两个 Integer 对象。执行方法的返回的一样是一个 Integer 对象，它封装了返回值 84。

7.建立新的对象

对于构造器，则不能像执行方法那样进行，由于执行一个构造器就意味着建立了一个新的对象 (准确的说，建立一个对象的过程包括分配内存和构造对象)。因此，与上例最类似的例子以下：

import java.lang.reflect.*;

public class Constructor2 {
   public Constructor2() {
   }

   public Constructor2(int a, int b) {
      System.out.println("a = " + a + " b = " + b);
   }

   public static void main(String args[]) {
      try {
           Class cls = Class.forName("Constructor2");
           Class partypes[] = new Class[2];
           partypes[0] = Integer.TYPE;
           partypes[1] = Integer.TYPE;

           Constructor ct = cls.getConstructor(partypes);
           Object arglist[] = new Object[2];
           arglist[0] = new Integer(37);
           arglist[1] = new Integer(47);
           Object retobj = ct.newInstance(arglist);
      }
      catch (Throwable e) {
           System.err.println(e);
      }
   }
}

根据指定的参数类型找到相应的构造函数并执行它，以建立一个新的对象实例。使用这种方法能够在程序运行时动态地建立对象，而不是在编译的时候建立对象，这一点很是有价值。