复习了一下反射，写了一个小例子。

*Reflection使用流程如下：
*1. 要想使用反射，首先要获得待处理类或者对象的Class对象，Class的构造方法是Private的，所以Class对象是不可构造的。
*2. 获取某个类或者摸个对象所对应的Class对象有三种方式。a) Class的静态方法，Class.forName("xx") b)使用类的.class语法： String.class ;c)对象的getClass()方法。
*3. 可以使用classType.newInstance()方法来实例化此class对应类的对象。但是此方式只能实例化没有参数 的构造方法的对象。如果要是想要实例化带参数的构造方法，则需要get其Constructor
*4. 可以得到相应的Method 对象 来invoke Method 或者 Field对象 使用Set或get来得到相应的变量值 。
 

 ?[Copy to clipboard]Download zuiniuwang.java

 

 
  1. /**  
  2.  * ReflectionTest.java  
  3.  * reflection  
  4.  *  
  5.  * Function： TODO  
  6.  *  
  7.  *   ver     date           author  
  8.  * ──────────────────────────────────  
  9.  *           2011-5-31      Leon  
  10.  *  
  11.  * Copyright (c) 2011, TNT All Rights Reserved.  
  12. */  
  13.    
  14. package reflection;  
  15. /**  
  16.  * ClassName:ReflectionTest  
  17.  * Function: TODO ADD FUNCTION  
  18.  * Reason:   TODO ADD REASON  
  19.  *  
  20.  * @author   Leon  
  21.  * @version  
  22.  * @since    Ver 1.1  
  23.  * @Date     2011-5-31  
  24.  */  
  25.    
  26. import java.lang.reflect.Array;  
  27. import java.lang.reflect.Constructor;  
  28. import java.lang.reflect.Field;  
  29. import java.lang.reflect.Method;  
  30.    
  31. public class ReflectionTest {  
  32.    
  33.     private static  Class<?>  classType;  
  34.     public int add(int parameter1, int parameter2) {  
  35.         return parameter1 + parameter2;  
  36.    
  37.     }  
  38.     private String echo(String message) {  
  39.         return message;  
  40.     }  
  41.     /**  
  42.      *Reflection使用流程：  
  43.      *1. 要想使用反射，首先要获得待处理类或者对象的Class对象。  
  44.      *2. 获取某个类或者摸个对象所对应的Class对象有三种方式。a) Class的静态方法，Class.forName("xx")  
  45.      *   b)使用类的.class语法： String.class ;c)对象的getClass()方法。  
  46.      *3. 可以使用classType.newInstance()方法来实例化此class对应类的对象。但是此方式只能实例化没有参数  
  47.      *   的构造方法的对象。如果要是想要实例化带参数的构造方法，则需要get其Constructor  
  48.      *4. 可以得到相应的Method 对象 来invoke Method 或者 Field对象 使用Set或get来得到相应的变量值 。  
  49.      *  
  50.      *  
  51.      *  
  52.      * @param args  
  53.      * @throws Exception  
  54.      *void  
  55.      * @exception  
  56.      * @since  1.0.0  
  57.      */  
  58.     public static void main(String... args) throws Exception{  
  59.         /**  
  60.          * 通过反射创建对象（带参数和不带参数）及 遍历其方法 和 成员变量  
  61.          */  
  62.    
  63.         //生成类所对应的class对象  三种方法 1.forName 2.XXX.class 3.object.getClass.  
  64.         classType = Class.forName("reflection.ReflectionTest");  
  65.         //得到这个类的Method对象数组包括"私有方法"  
  66.         Method[] methods = classType.getDeclaredMethods();  
  67.    
  68.         for(Method method : methods){  
  69.             System.out.println( "method" +  method);  
  70.         }  
  71. //      Class<?> classType =  ReflectionTest.class;  
  72.         //生成类对应的对象  
  73.         ReflectionTest reflectionTest = (ReflectionTest) classType.newInstance();  
  74.         //获得方法的对象 第一个参数为方法名，第二个参数为该方法的参数，因为仅仅是方法名不能确定是哪个方法  
  75.         Method addMethod  =  classType.getMethod("add", new Class[]{int.class , int.class});  
  76.         //调用方法，以第一个参数是 类的对象，第二个是实际的参数，返回为基本类型的包装类  
  77.         Object result =addMethod.invoke(reflectionTest, new Object[]{1,2});  
  78.         System.out.println("Result  is :"  +result);  
  79.    
  80.         //通过Constructor来生成对象（不带参数）  
  81.         classType = Customer.class ;  
  82.    
  83.         Constructor<?>[]  constructors =classType.getConstructors();  
  84.    
  85.         for(Constructor x : constructors){  
  86.             System.out.println(x);  
  87.         }  
  88.    
  89.         Constructor  cons = classType.getConstructor(new Class[]{});  
  90.         Customer  customer = (Customer) cons.newInstance(new Object[]{});  
  91.         customer.setAge(1);  
  92.         customer.setName("李四");  
  93.    
  94.         //以上几行代码等价于  
  95.         Customer  customer2 = (Customer) classType.newInstance();  
  96.    
  97.         //获得public成员变量，如果要获得所有成员变量需要  classType.getDeclaredFields();  
  98.         Field[] fields = classType.getFields();  
  99.         for(Field field : fields){  
  100.             // 获取属性的名字  
  101.             String name = field.getName();  
  102.             System.out.println("field :" +  name );  
  103.    
  104.             // 获取对应的Method 属性名首字母变大写+ get 和 set  
  105.             String  firstLetter =  name.substring(0,1).toUpperCase(); //sub取左不取右  
  106.             String  getMethodName = "get"+firstLetter + name.substring(1);  
  107.             String  setMethodName = "set"+firstLetter + name.substring(1);  
  108.             //get的参数都为空  
  109.             Method  getMethod = classType.getMethod(getMethodName, new Class[]{});  
  110.             Method  setMethod = classType.getMethod(setMethodName, new Class[]{field.getType()});  
  111.             //把customer1的对象通过Method方法给customer2对象  
  112.             Object  value = getMethod.invoke(customer, new Object[]{});  
  113.              //得到的对象类型和赋值的类型是相同的  
  114.             setMethod.invoke(customer2,new Object[]{value});  
  115.    
  116.         }  
  117.         System.out.println("customer2 + name: " +  customer2.getName());  
  118.    
  119.         //带参数的的构造方法  
  120.         cons = classType.getConstructor(new Class[]{String.class , int.class});  
  121.         Customer customerZhangSan=(Customer) cons.newInstance(new Object[]{"张三" , 22});  
  122.         System.out.println(customerZhangSan.getName());  
  123.    
  124.         /**  
  125.          *  对数组的访问  
  126.          */  
  127.         //java.lang.reflect.Array 类提供了动态创建和访问数组元素的各种静态方法,全部都是静态方法。  
  128.         Class<?>  classType = String.class;  
  129.         //生成一个字符串数组  
  130.         Object array =  Array.newInstance(classType, 10);  
  131.         //设置第5个元素为&ldquo;hello&rdquo;  
  132.         Array.set(array, 5, "hello");  
  133.         String str =(String)  Array.get(array, 5);  
  134.         System.out.println("1维数组的第5个元素的值为"+ str);  
  135.    
  136.         //创建一个多维数组，第2--n的可变参数是 数组的维度，也可以用一个数组来赋值new int[]{5,5,5}  
  137.         //Integer.TYPE 和 Integer.class 都返回class对象，但是TYPE返回的是原生类型，所以int数组用TYPE  
  138.         //第一个个参数是component Type（只有数组才有，否则Class.getComponentType为空），如2为数组它的component Type就是一维数组  
  139.         Object array2 =  Array.newInstance(Integer.TYPE, 5,5,5);//长宽高都是5  
  140.         //得到高为3的2维数组  
  141.         Object arrayObj = Array.get(array2, 3);  
  142.         //的到宽为5的1维数组  
  143.         arrayObj = Array.get(arrayObj, 2);  
  144.         //给1维数组的index为3的元素设置值为100  
  145.         Array.setInt(arrayObj, 3, 100);  
  146.         //强制类型转化  
  147.         int[][][] arrayCast = (int[][][])array2 ;  
  148.         System.out.println("三维数组的值为:"+arrayCast[3][2][3]);  
  149.    
  150.         /**  
  151.          * 对私有成员的访问  
  152.          */  
  153.         //反射可以实现对私有方法的调用  
  154.         Class<!--?-->  customerClass  = Customer.class ;  
  155.         //通过getMethod只能得到public方法，要得到private方法必须 调用getDeclaredMethod  
  156.         Method  privateTest =customerClass.getDeclaredMethod("privateTestMethod", String.class);  
  157.         //必须调用这个，因为从而忽略Java的访问控制检查  
  158.         privateTest.setAccessible(true);  
  159.          //第一个参数是调用哪个对象  
  160.         String strPrivate = (String)privateTest.invoke( new Customer(), "张桑");  
  161.         System.out.println("访问私有成员方法"+ strPrivate);  
  162.    
  163.         Customer testCustomer =new Customer();  
  164.         Field  fieldPrivateTest =  customerClass.getDeclaredField("str");  
  165.         fieldPrivateTest.setAccessible(true);  
  166.         fieldPrivateTest.set(testCustomer, "zhangK");  
  167.         System.out.println("私有成员变量str是："+  fieldPrivateTest.get(testCustomer));  
  168.         //通过Method来得到  
  169.         Method  testMethod = customerClass.getDeclaredMethod("getStr", null); //不能用getMethod不然不能访问私有变量  
  170.         testMethod.setAccessible(true);  
  171.         String stringTest=(String)testMethod.invoke(testCustomer, null);  
  172.         System.out.println("访问私有成员变量 "+ stringTest);  
  173.     }  
  174.    
  175.     private static class Customer {  
  176.    
  177.         public Customer() {  
  178.             super();  
  179.         }  
  180.    
  181.         public Customer(String name, int age) {  
  182.             super();  
  183.             this.name = name;  
  184.             this.age = age;  
  185.         }  
  186.    
  187.         private String name ;   
  188.    
  189.         private int age ;   
  190.    
  191.         public String getName() {  
  192.             return name;  
  193.         }  
  194.    
  195.         public void setName(String name) {  
  196.             this.name = name;  
  197.         }  
  198.    
  199.         public int getAge() {  
  200.             return age;  
  201.         }  
  202.    
  203.         public void setAge(int age) {  
  204.             this.age = age;  
  205.         }     
  206.    
  207.         private String  str= "wangwu";  
  208.         private String  privateTestMethod(String  name){  
  209.             return "hello " + name ;  
  210.         }  
  211.    
  212.         private String  getStr(){  
  213.             return  str ;  
  214.         }  
  215.     }  
  216.    
  217. }