Java反射学习

    反射是Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说"自审"，并能直接操作程序的内部属性。例如，使用它能获得 Java 类中各成员的名称并显示出来。

Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。

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

反射除了显示类的自身信息外，它还可以创建对象和执行方法等

(1)找出类的方法
　　找出一个类中定义了些什么方法，这是一个非常有价值也非常基础的 reflection 用法,示例代码如下：

 

Java代码

1. import java.lang.reflect.*;   
2. /**  
3. *获取指定类的方法相关信息  
4. */  
5. class InformationTest    
6. {   
7.  public static void main(String[] args) throws Exception   
8.  {   
9.   //得到String类对象   
10.   Class cls=Class.forName("java.lang.String");   
11.   //得到所有的方法，包括从父类继承过来的方法   
12.   Method []methList=cls.getMethods();   
13.   //下面是得到的是String类本身声明的方法   
14.   //Method []methList=cls.getDeclaredMethods();   
15.   //遍历所有的方法   
16.   for(Method m:methList){   
17.    //方法名   
18.    System.out.println("方法名="+m.getName());   
19.    //方法声明所在的类   
20.    System.out.println("声明的类="+m.getDeclaringClass());   
21.    //获取所有参数类型的集体   
22.    Class []paramTypes=m.getParameterTypes();   
23.    //遍历参数类型   
24.    for(int i=0;i<paramTypes.length;i++){   
25.     System.out.println("参数 "+i+" = "+paramTypes[i]);   
26.    }   
27.    //获取所有异常的类型   
28.    Class []excepTypes=m.getExceptionTypes();   
29.    //遍历异常类型   
30.    for(int j=0;j<excepTypes.length;j++){   
31.     System.out.println("异常 "+j+" = "+excepTypes[j]);   
32.    }   
33.    //方法的返回类型   
34.    System.out.println("返回类型 ="+m.getReturnType());   
35.    //结束一层循环标志   
36.    System.out.println("---------");   
37.   }   
38.  }   
39. }  

import java.lang.reflect.*;/***获取指定类的方法相关信息*/class InformationTest { public static void main(String[] args) throws Exception {  //得到String类对象  Class cls=Class.forName("java.lang.String");  //得到所有的方法，包括从父类继承过来的方法  Method []methList=cls.getMethods();  //下面是得到的是String类本身声明的方法  //Method []methList=cls.getDeclaredMethods();  //遍历所有的方法  for(Method m:methList){   //方法名   System.out.println("方法名="+m.getName());   //方法声明所在的类   System.out.println("声明的类="+m.getDeclaringClass());   //获取所有参数类型的集体   Class []paramTypes=m.getParameterTypes();   //遍历参数类型   for(int i=0;i<paramTypes.length;i++){    System.out.println("参数 "+i+" = "+paramTypes[i]);   }   //获取所有异常的类型   Class []excepTypes=m.getExceptionTypes();   //遍历异常类型   for(int j=0;j<excepTypes.length;j++){    System.out.println("异常 "+j+" = "+excepTypes[j]);   }   //方法的返回类型   System.out.println("返回类型 ="+m.getReturnType());   //结束一层循环标志   System.out.println("---------");  } }}

   (2) 获取构造器信息
　　获取类构造器的用法与上述获取方法的用法类似，示例代码如下：

  

Java代码

1.     import java.lang.reflect.*;   
2. import java.io.IOException;   
3. /**  
4. *获取指定类的构造器相关信息  
5. */  
6. public class ConstructorTest    
7. {   
8.  private int i;   
9.  private double j;   
10.  //默认的构造器   
11.  public ConstructorTest(){   
12.  }   
13.  //重载的构造器   
14.  public ConstructorTest(int i,double j)throws IOException{   
15.   this.i=i;   
16.   this.j=j;   
17.  }   
18.  public static void main(String[] args) throws Exception   
19.  {   
20.   //得到本类的类对象   
21.   Class cls=Class.forName("ConstructorTest");   
22.   //取得所有在本类声明的构造器   
23.   Constructor []cs=cls.getDeclaredConstructors();   
24.   //遍历   
25.   for(Constructor c:cs){   
26.    //构造器名称   
27.    System.out.println("构造器名="+c.getName());   
28.    //构造器声明所在的类   
29.    System.out.println("其声明的类="+c.getDeclaringClass());   
30.    //取得参数的类型集合   
31.    Class []ps=c.getParameterTypes();   
32.    //遍历参数类型   
33.    for(int i=0;i<ps.length;i++){   
34.     System.out.println("参数类型"+i+"="+ps[i]);   
35.    }   
36.    //取得异常的类型集合   
37.    Class []es=c.getExceptionTypes();   
38.    //遍历异常类型   
39.    for(int j=0;j<es.length;j++){   
40.     System.out.println("异常类型"+j+"="+es[j]);   
41.    }   
42.    //结束一层循环标志   
43.    System.out.println("-----------");   
44.   }   
45.  }   
46. }   

    import java.lang.reflect.*;import java.io.IOException;/***获取指定类的构造器相关信息*/public class ConstructorTest { private int i; private double j; //默认的构造器 public ConstructorTest(){ } //重载的构造器 public ConstructorTest(int i,double j)throws IOException{  this.i=i;  this.j=j; } public static void main(String[] args) throws Exception {  //得到本类的类对象  Class cls=Class.forName("ConstructorTest");  //取得所有在本类声明的构造器  Constructor []cs=cls.getDeclaredConstructors();  //遍历  for(Constructor c:cs){   //构造器名称   System.out.println("构造器名="+c.getName());   //构造器声明所在的类   System.out.println("其声明的类="+c.getDeclaringClass());   //取得参数的类型集合   Class []ps=c.getParameterTypes();   //遍历参数类型   for(int i=0;i<ps.length;i++){    System.out.println("参数类型"+i+"="+ps[i]);   }   //取得异常的类型集合   Class []es=c.getExceptionTypes();   //遍历异常类型   for(int j=0;j<es.length;j++){    System.out.println("异常类型"+j+"="+es[j]);   }   //结束一层循环标志   System.out.println("-----------");  } }} 

   

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

 

Java代码

1. import java.lang.reflect.*;   
2. /**  
3. *获取指定类的字段相关信息  
4. */  
5. class FieldTest    
6. {   
7.  //字段1   
8.  private double d;   
9.  //字段2   
10.  public static final int i=37;   
11.  //字段3   
12.  String str="fieldstest";   
13.  public static void main(String[] args) throws Exception   
14.  {   
15.   //获取本类的类对象   
16.   Class c=Class.forName("FieldTest");   
17.   //获取所有声明的的字段,getFields()包括继承来的字段   
18.   Field []fs=c.getDeclaredFields();   
19.   //遍历   
20.   for(int i=0;i<fs.length;i++){   
21.    Field f=fs[i];   
22.    //字段名   
23.    System.out.println("字段名"+(i+1)+"="+f.getName());   
24.    //字段声明所在的类   
25.    System.out.println("该字段所在的类为："+f.getDeclaringClass());   
26.    //字段的类型   
27.    System.out.println("字段"+(i+1)+"的类型："+f.getType());   
28.    //查看修饰符   
29.    int mod=f.getModifiers();   
30.    //为0就是默认的包类型   
31.    if(mod==0){   
32.                 System.out.println("该字段的修饰符为：默认包修饰符");   
33.    }else{   
34.     //否则就是相应的类型   
35.     System.out.println("该字段的修饰符为："+Modifier.toString(mod));   
36.    }   
37.    System.out.println("---结束第"+(i+1)+"循环---");   
38.   }   
39.  }   
40. }  

import java.lang.reflect.*;/***获取指定类的字段相关信息*/class FieldTest { //字段1 private double d; //字段2 public static final int i=37; //字段3 String str="fieldstest"; public static void main(String[] args) throws Exception {  //获取本类的类对象  Class c=Class.forName("FieldTest");  //获取所有声明的的字段,getFields()包括继承来的字段  Field []fs=c.getDeclaredFields();  //遍历  for(int i=0;i<fs.length;i++){   Field f=fs[i];   //字段名   System.out.println("字段名"+(i+1)+"="+f.getName());   //字段声明所在的类   System.out.println("该字段所在的类为："+f.getDeclaringClass());   //字段的类型   System.out.println("字段"+(i+1)+"的类型："+f.getType());   //查看修饰符   int mod=f.getModifiers();   //为0就是默认的包类型   if(mod==0){                System.out.println("该字段的修饰符为：默认包修饰符");   }else{    //否则就是相应的类型    System.out.println("该字段的修饰符为："+Modifier.toString(mod));   }   System.out.println("---结束第"+(i+1)+"循环---");  } }}

   

(4) 根据方法的名称来执行方法

我们也可以用 reflection 来做一些其它的事情，比如执行一个指定了名称的方法。下面的示例演示了这一操作：

 

Java代码

1. import java.lang.reflect.*;   
2. /**  
3. *通过反射执行类的方法  
4. */  
5. class PerformMethod    
6. {   
7.  //声明一个简单的方法，用于测试   
8.  public int add(int a,int b){   
9.   return a+b;   
10.  }   
11.  public static void main(String[] args)throws Exception   
12.  {   
13.   //获取本类的类对象   
14.   Class c=Class.forName("PerformMethod");   
15.   /**  
16.   *声明add方法参数类型的集合  
17.   *共有两个参数，都为Integer.TYPE  
18.   */  
19.   Class []paramTypes=new Class[2];   
20.   paramTypes[0]=Integer.TYPE;   
21.   paramTypes[1]=Integer.TYPE;   
22.   //根据方法名和参数类型集合得到方法   
23.   Method method=c.getMethod("add",paramTypes);   
24.   //声明类的实例   
25.   PerformMethod pm=new PerformMethod();   
26.   //传入参数的集合   
27.   Object []argList=new Object[2];   
28.   //传入37和43   
29.   argList[0]=new Integer(37);   
30.   argList[1]=new Integer(43);   
31.   //执行后的返回值   
32.   Object returnObj=method.invoke(pm,argList);   
33.   //类型转换下   
34.   Integer returnVal=(Integer)returnObj;   
35.   //打印结果   
36.   System.out.println("方法执行结果为："+returnVal.intValue());   
37.  }   
38. }  

import java.lang.reflect.*;/***通过反射执行类的方法*/class PerformMethod { //声明一个简单的方法，用于测试 public int add(int a,int b){  return a+b; } public static void main(String[] args)throws Exception {  //获取本类的类对象  Class c=Class.forName("PerformMethod");  /**  *声明add方法参数类型的集合  *共有两个参数，都为Integer.TYPE  */  Class []paramTypes=new Class[2];  paramTypes[0]=Integer.TYPE;  paramTypes[1]=Integer.TYPE;  //根据方法名和参数类型集合得到方法  Method method=c.getMethod("add",paramTypes);  //声明类的实例  PerformMethod pm=new PerformMethod();  //传入参数的集合  Object []argList=new Object[2];  //传入37和43  argList[0]=new Integer(37);  argList[1]=new Integer(43);  //执行后的返回值  Object returnObj=method.invoke(pm,argList);  //类型转换下  Integer returnVal=(Integer)returnObj;  //打印结果  System.out.println("方法执行结果为："+returnVal.intValue()); }}

  

(5) 创建新的对象

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

 

Java代码

1. import java.lang.reflect.*;   
2. /**  
3. *通过反射创新类的新对象  
4. */  
5. class CreateNewObj    
6. {   
7.  //显式默认的构造器   
8.  public CreateNewObj(){   
9.  }   
10.  //重载构造器   
11.  public CreateNewObj(int a,int b){   
12.   System.out.println("a= "+a+" b="+b);   
13.  }   
14.   
15.  public static void main(String[] args) throws Exception   
16.  {   
17.   //得到本类的类对象   
18.   Class c=Class.forName("CreateNewObj");   
19.   //声明构造器的参数类型集合   
20.   Class []paramTypes=new Class[2];   
21.   //都为int型   
22.   paramTypes[0]=Integer.TYPE;   
23.   paramTypes[1]=Integer.TYPE;   
24.         //根据参数类型决定得到哪个构造器   
25.   Constructor cs=c.getConstructor(paramTypes);   
26.   //声明要传入的参数集合   
27.   Object []argList=new Object[2];   
28.   //传入37和43   
29.   argList[0]=new Integer(37);   
30.   argList[1]=new Integer(43);   
31.   //根据符合上述参数类型的构造器来创建新的对象   
32.   Object rtnObj=cs.newInstance(argList);   
33.  }   
34. }  

import java.lang.reflect.*;/***通过反射创新类的新对象*/class CreateNewObj { //显式默认的构造器 public CreateNewObj(){ } //重载构造器 public CreateNewObj(int a,int b){  System.out.println("a= "+a+" b="+b); } public static void main(String[] args) throws Exception {  //得到本类的类对象  Class c=Class.forName("CreateNewObj");  //声明构造器的参数类型集合  Class []paramTypes=new Class[2];  //都为int型  paramTypes[0]=Integer.TYPE;  paramTypes[1]=Integer.TYPE;        //根据参数类型决定得到哪个构造器  Constructor cs=c.getConstructor(paramTypes);  //声明要传入的参数集合  Object []argList=new Object[2];  //传入37和43  argList[0]=new Integer(37);  argList[1]=new Integer(43);  //根据符合上述参数类型的构造器来创建新的对象  Object rtnObj=cs.newInstance(argList); }}

  

(6) 改变字段(域)的值

reflection 的还有一个用处就是改变对象数据字段的值。reflection 可以从正在运行的程序中根据名称找到对象的字段并改变它，下面的例子可以说明这一点：

 

Java代码

1. reflection 的还有一个用处就是改变对象数据字段的值。reflection 可以从正在运行的程序中根据名称找到对象的字段并改变它，下面的例子可以说明这一点：   
2.   
3. import java.lang.reflect.*;   
4. /**  
5. *通过反射改变字段的值  
6. */  
7. class ModifyField    
8. {   
9.  //声明一个字段   
10.  public double d;   
11.  public static void main(String[] args) throws Exception   
12.  {   
13.   //得到类的类对象   
14.   Class c=Class.forName("ModifyField");   
15.   //根据字段名得到字段对象   
16.   Field f=c.getField("d");   
17.   //创建类的实例   
18.   ModifyField mf=new ModifyField();   
19.   //打印修改前字段的值   
20.   System.out.println("修改 "+f.getName()+" 前的值为："+mf.d);   
21.   //修改d的值为12.34   
22.   f.setDouble(mf,12.34);   
23.   //打印修改后的值   
24.   System.out.println("修改 "+f.getName()+" 后的值为："+mf.d);   
25.   
26.  }   
27. }  

reflection 的还有一个用处就是改变对象数据字段的值。reflection 可以从正在运行的程序中根据名称找到对象的字段并改变它，下面的例子可以说明这一点：import java.lang.reflect.*;/***通过反射改变字段的值*/class ModifyField { //声明一个字段 public double d; public static void main(String[] args) throws Exception {  //得到类的类对象  Class c=Class.forName("ModifyField");  //根据字段名得到字段对象  Field f=c.getField("d");  //创建类的实例  ModifyField mf=new ModifyField();  //打印修改前字段的值  System.out.println("修改 "+f.getName()+" 前的值为："+mf.d);  //修改d的值为12.34  f.setDouble(mf,12.34);  //打印修改后的值  System.out.println("修改 "+f.getName()+" 后的值为："+mf.d); }}

   

(7)使用数组

reflection 的最后一种用法是创建的操作数组。数组在 Java 语言中是一种特殊的类类型，一个数组的引用可以赋给 Object 引用。观察下面的例子看看数组是怎么工作的：

  

Java代码

1. import java.lang.reflect.*;   
2. /**  
3. *通过反射来操作数组  
4. */  
5. class UserArray    
6. {   
7.  public static void main(String[] args) throws Exception   
8.  {   
9.   //得到String类的类对象   
10.   Class c=Class.forName("java.lang.String");   
11.   //通过Array类的反射创建一个含有10个元素的String类型的数组   
12.   Object arr=Array.newInstance(c,10);   
13.   //为数组第5个位置元素赋一个值   
14.   Array.set(arr,5,"第5个位置元素");   
15.   //取得第5个位置元素的值   
16.   String s=(String)Array.get(arr,5);   
17.   //打印这个元素的值   
18.   System.out.println("值为："+s);   
19.  }   
20. }   
21.   
22.    

import java.lang.reflect.*;/***通过反射来操作数组*/class UserArray { public static void main(String[] args) throws Exception {  //得到String类的类对象  Class c=Class.forName("java.lang.String");  //通过Array类的反射创建一个含有10个元素的String类型的数组  Object arr=Array.newInstance(c,10);  //为数组第5个位置元素赋一个值  Array.set(arr,5,"第5个位置元素");  //取得第5个位置元素的值  String s=(String)Array.get(arr,5);  //打印这个元素的值  System.out.println("值为："+s); }} 

  

看下更复杂的情况：

   

Java代码

1. import java.lang.reflect.*;   
2. /**  
3. *通过反射创建和使用更复杂的数组  
4. */  
5. class UserArrayComplex   
6. {   
7.  public static void main(String[] args) throws Exception   
8.  {   
9.   //声明数组的维数为5X10X15   
10.   int dims[]=new int []{5,10,15};   
11.   //创建该类型的数组，元素的类型为Integer   
12.   Object arr=Array.newInstance(Integer.TYPE,dims);   
13.   //得到第3个10X15的二维数组   
14.   Object arrObj=Array.get(arr,3);   
15.   //Class c=arrObj.getClass().getComponentType();   
16.   //System.out.println(c);   
17.   //得到第2维中的第2个15位长度的数组   
18.   arrObj=Array.get(arrObj,5);   
19.         //然后设置该数组里第10个元素的值为37   
20.   Array.set(arrObj,10,37);   
21.   //再将数组还原   
22.   int [][][]arrCast=(int [][][])arr;   
23.   //打印刚刚那个值   
24.   System.out.println(arrCast[3][5][10]);   
25.      
26.  }   
27. }