Java反射机制 详解 基本功能

一般而言，开发者社群说到动态语言，大致认同的一个定义是：“程序运行时，运行改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，perl,phthon,ruby是动态语言，C++,JAVA,C#不是动态语言。

 

在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？ 答案是肯定的，这种动态获取类的信息以及动态调用对象的方法的功能来自于Java语言的反射(Reflection)机制。

Java反射机制主要提供了以下功能：

在运行时判断任意一个对象所属的类。

在运行时构造任意一个类的对象.

在运行时判断任意一个类所具有的成员变量和方法。

在运行时调用任意一个对象的方法。

reflection是Java被视为动态(或准动态)语言的一个关键性质，这个机制运行程序在运行时透过reflection apis取得任意一个已知名称的class的

内部信息，包括其modifiers(诸如public,static等等)，superclass(例如Object)，实现之Interface(例如serializable),也包括fields和methods的所有信息，并可于运行时改变fields内容或调用methods。

 

在JDK中，主要由以下类来实现Java反射机制，这些类都位于Java.lang.reflect包中

Class类：代表一个类

Field类： 代表类的成员变量(成员变量也称为类的属性)。

Method类： 代表类的方法。

Constructor类： 代表类都构造方法。

Array类： 提供了动态创建数组，以及访问数组的元素的静态方法

例程DumpMethods类演示了ReflectionAPI的基本作用，它读取命令行参数指定的类名，然后打印这个类所具有的方法信息。

public static void main(String args[]){

    Class<?> classType=Class.forName(args[0]);

    Method methods[]=classType.getDeclaredMethods();

    for(int i=0; i<method.length;i++)

    {

         System.out.println(methods[i].toString());

         }

}

 

例程ReflectTester类进一步演示了ReflectionAPI的基本使用方法。  ReflectTester类有一个copy(Object object)方法，这个方法能够创建一个和参数object同样类型的对象，然后把object对象中的所有属性拷贝到新建的对象中，并将它返回

 

这个例子只能复制简单的JavaBean，假定JavaBean的每个属性都有public类型的getXXX()和setXXX()方法

getClass() 返回一个对象的运行时Class     每个对象在运行时都对应一个Class 获得信息

getConstructor()返回构造方法   然后调用构造方法的newInstance方法

newInstance()返回当前的构造方法产生的类的实例。

Filed field=classTye.getDeclaredFields();  获得对象的属性

 

1.获得对象的类型：

Class classType=object.getClass();

System.out.println("Class:"+classType.getName());

 

在Java.lang.Object类中定义了getClass()方法，因此对于任意一个Java对象，都可以通过此方法获得对象的类型。 Class类是Reflection API中的一个核心类，它有以下方法。

getName():  获得类的完整名字

getFields():获得类的public类型的属性

getDeclaredFields();  获得类的所有属性

getMethods():获得类的public类型的方法

getDeclaredMethods():获得类的所有方法

 

getMethod(String name,Class[] parameterTypes):获得类的特定方法，name参数指定方法的名字，parameterTypes参数指定方法的参数类型

 

getConstructors():获得类的public类型的构造方法。

getConstructor(Class[]parameterTyes):获得类的特定构造方法，parameterTypes参数指定构造方法的参数类型。

new Instance():通过类的不带参数的构造方法创建这个类的一个对象。

2.通过默认构造方法创建一个新对象：

Object objectCopy=classType.getConstructor(new Class[]{}).newInstance(new Object[]{});

以上代码先调用Class类的getConstructor()方法获得一个Constructor对象，它代表默认的构造方法，然后调用Constructor对象的newInstance()方法构造一个实例。

获得每个属性相应的getXXX()和setXXX()方法(字符串拼接)，然后执行这些方法，把原来对象的属性拷贝到新的对象中。

 

add()方法的两个参数为int类型，获得表示add()方法的Method对象的代码如下：

Method addMethod=classType.getMethod("add",new Class[]{int.class,int.class});

Method类的invoke(Object obj,Object args[])方法接收的参数必须为对象，如果参数为基本类型，并需转换为相应的包装类型的对象.

invoke()方法的返回值总是对象，如果实际被调用的方法的返回类型是基本类型数据，那么invoke()方法会把它转换为相应的包装类型的对象，在将其返回。

classType.newInstance()只能调用默认构造方法来产生对象。

 

Class newInstance()                     Constructor.newInstance(),还有一个带参数的

Method addMethod=classType.getMethod("add",new Class[]{int.class,int.class});      //一定要传包装类型

Object result=addMethod.invoke(invokeTester,new Object[]{new Integer(100),new Integer(200)});

在本例中，尽管InvokeTester类的add()方法的两个参数以及返回值都是int类型，调用add Method对象的invoke()方法时，只能传递Integer类型的参数，并且invoke()方法的返回类型也是Integer类型，Integer类型是Int基本类型的包装类：

Object result=addMethod.invoke(invokeTest,new Object[]{new Integer(100),new Integer(200)});

System.out.println((Integer)result);        //result为integer类型

 

Array类： 提供了动态创建数组，以及访问数组的元素的静态方法

public static void main(String[]args){

    Class<?>classType=Class.forName("java.lang.String");

    Object array=Array.newInstance(classType,10);

    Array.set(array,5,"hello");

    String s=(String)Array.get(array,5);

    System.out.println(s);

}

 

getClass().class,  Integer.Type

众所周知 Java有个Object class,是所有Java classes的继承根源，其内声明了数个应该在所有Java class中被改写的methods: hashcode(),equals(),clone(),toString(),getClass()等。 其中getClass()返回一个Class object。

Class class十分特殊，它和一般classes一样继承自Object,其实体用以表示Java程序运行时的classes和interface。 也用来表示enum,array,primitive java types

(boolean, byte,char,short,int,long,float,double)以及关键词void。当一个class被加载，或当加载器(class loader)的defineClass()被JVM调用，JVM便自动产生一个Class object。如果您想借由“修改Java标准库源码”来观察Class object的实际生成实际(例如在Class的constructor内添加一个println())，不能够！因为Class并没有public constructor.

Class是reflection起源，针对任何你想探测的class,唯有先为它产生一个Class object，接下来才能经由后者唤起为数十个的Reflection APIs.

从object层次来说，==与equals时相同的，都是比较内存地址，也就是说，都是比较连个引用是够指向同一个对象，是则返回true,否则返回false。

 

Java允许我们从多种途径为一个class生成对应的Class object

Class object 诞生管道                  示例

运用getClass()

每个class都有此函数            String str="abc";  Class c1=str.getClass();

 

运用Class.getSuperclass()       Button b=new Button();    Class c2=b.getClass();    Class c2=c1.getSuperclass();

 

运用static method                    Class c1=Class.forName("java.lang.String");

Class.forName

最常被使用

 

.class语法                                Class  c1=String.class;

                            Class c5=int [].class;

 

primitive的TYPE语法                  Class c1=Boolean.Type;

                            Class c2=Byte.Type;

                            Class c3=Character.TYPE;

                            Class c4=Short.TYPE;

                            Class c5=Integer.TYPE;

                            Class c6=Long.TYPE;

                            Class c7=Float.TYPE;

                            Class c8=Double.TYPE;

                            Class c9=Void.TYPE;(Void也是一种类型)

 

欲生成对象实体，在reflection动态机制中有两种做法，一个针对“无自变量ctor”，一个针对“带参数ctor”。  如果欲调用的是“带参数的ctor”就比较麻烦些，

不再调用Class的newInstance()，而是调用Constructor的newInstance().首先准备一个Class[]作为ctor的参数类型(本例指定为一个double和一个int), 然后依次为自变量调用getConstructor(),获得一个专属ctor. 接下来在准备一个Object[]作为ctor实参值，调用上述专属ctor的newInstance()。

 

Class c=Class.forName("DynTest");

Object obj=null;

obj=c.newInstance();  //不带自变量

System.out.println(obj);

动态生成“Class object所对应之class”的对象实体，无自变量。

 

Class c=Class.forName("DynTest");

Class[] pTypes=new Class[]{double.class,int.class};

Constructor ctor=c.getConstructor(pTypes);

Object obj=null;

Object[] arg=new Object[]{3.14159,125};   //自变量

obj=ctor.newInstance(arg);

System.out.println(obj);

动态生成“Class object对应之class”的对象实体，自变量以Object[]表示。

 

运行时调用methods

这个动作和上述调用“带参数之ctor”相当类似，首先准备一个Class[]作为参数类型,然后依次为自变量调用getMethod(),获得特定的Method object。接下来准备一个Object[]放置自变量，然后调用上述所得之特定Method object的invoke()。 为什么获得Method object时不需要指定返回类型？

 

 public String func(String s,Hashtable ht)

   {
       System.out.println("func invoked");

       return s;

   }

public static void main(String args[])

{

         Class c=Class.forName("Bean");

         Class ptypes[]=new Class[2];

         ptypes[0]=Class.forName("java.lang.String");

         ptypes[1]=Class.forName("java.util.Hashtable");

         Method m=c.getMethod("func",ptypes);

         Bean obj=new Bean();

         Object arg[]=new Object[2];

         arg[0]=new String("hello world");

         arg[1]=null;

         Object r=m.invoke(obj,arg);

         String rval=(String)r;

         System.out.println(rval);

}

 

运行时变更fields内容

public class Test{

    public double d;

    public static void main(String args[])

    {

         Class c=Class.forName("Bean");

          Field f=c.getField("d");

          Bean obj=new Bean();

          System.out.println("d="+(Double)f.get(obj));

          f.set(obj,12.34);

          System.out.println("d="+obj.d);

}

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/lhfqq/archive/2010/01/31/5274706.aspx