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