JAVA类反射学习资料

转载自：http://www.iteye.com/topic/1114312

1、获取指定类的构造器相关信息

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. }      

 

 

 

2、通过反射创新类的新对象 

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. }     

 

 

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. }     

 

4、获取指定类的方法相关信息

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. }     

 

5、通过反射改变字段的值

Java代码  

1. import java.lang.reflect.*;     
2. /**   
3. *通过反射改变字段的值   
4. */     
5. class ModifyField      
6. {     
7.  //声明一个字段     
8.  public double d;     
9.  public static void main(String[] args) throws Exception     
10.  {     
11.   //得到类的类对象     
12.   Class c=Class.forName("ModifyField");     
13.   //根据字段名得到字段对象     
14.   Field f=c.getField("d");     
15.   //创建类的实例     
16.   ModifyField mf=new ModifyField();     
17.   //打印修改前字段的值     
18.   System.out.println("修改 "+f.getName()+" 前的值为："+mf.d);     
19.   //修改d的值为12.34     
20.   f.setDouble(mf,12.34);     
21.   //打印修改后的值     
22.   System.out.println("修改 "+f.getName()+" 后的值为："+mf.d);     
23.     
24.  }     
25. }     

 

 

6、通过反射执行类的方法

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. }     

 

7、通过反射来操作数组 

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. }     

 

 

8、通过反射创建和使用更复杂的数组

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. }