java反射

一   什么是 Java反射机制  有什么用

         （1）： JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

      （2）：Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。

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

                             在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

实例说明：

         (1) class 类的使用：获取类的属性、方法、构造方法、类的相关信息

[java] view plain copy

1. import java.lang.reflect.Constructor;  
2. import java.lang.reflect.Field;  
3. import java.lang.reflect.Method;  
4. /** 
5.  *  
6.  * @author lijian 
7.  *class 类的使用：获取类的属性、方法、构造方法、类的相关信息 
8.  */  
9. public class TestClass_1 {  
10.   
11.     public static void main(String[] args) throws ClassNotFoundException {  
12.        //forName(String className)返回与带有给定字符串名的类或接口相关联的 Class 对象。  
13.         Class clazz = Class.forName("java.lang.String");  
14.        //getDeclaredFields();返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段，包括公共、保护、默认（包）访问和私有字段，但不包括继承的字段。  
15.         Field[] field = clazz.getDeclaredFields();  
16.         System.out.println("---------------------显示类的属性----------------------------");  
17.         for (Field f : field) {  
18.             //getName()返回此 Field 对象表示的字段的名称  
19.             //getType()返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。  
20.             System.out.println(f.getName() + "        " + f.getType());  
21.         }  
22.         System.out.println("---------------------显示类的方法-----------------------------");  
23.         //getDeclaredMethods() 返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。  
24.         Method[] method = clazz.getDeclaredMethods();  
25.         for (Method m : method) {  
26.             System.out.println(m.getName());  
27.         }  
28.         System.out.println("---------------------显示类的构造方法-----------------------------");  
29.         //getDeclaredConstructors() 返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。  
30.        Constructor[] constructors = clazz.getDeclaredConstructors();  
31.        for(Constructor c:constructors)  
32.        {  
33.            System.out.println(c);  
34.        }  
35.       System.out.println("----------------------获取类的相关的信息----------------------------------------------");  
36.       System.out.println("类所在的包为："+ clazz.getPackage().getName());  
37.       System.out.println("类名："+ clazz.getName());  
38.       System.out.println("父类的名称："+ clazz.getSuperclass().getName());  
39.         
40.     }  
41. }  

    以下示例中会使用到User.java类，其代码如下：

[java] view plain copy

 

1. public class User {  
2.   
3.     private String name;  
4.     private int age;  
5.      
6.     public User(){}  
7.     public User(String name, int age) {  
8.     }  
9. 属性的setter 和getter 方法 省略······  

     (2)生成一个类的Class对象有一下四种方式

1. import entity.User;   
2. /** 
3.  *  
4.  * @author lijian  
5.  * 创建Class对象的4种方法 
6.  */  
7. public class TestClass_2 {  
8.   
9.     public static void main(String[] args) throws ClassNotFoundException {  
10.         User user = new User();  
11.         // 第一种：对象.Class  
12.         Class clazz = user.getClass();  
13.         // 使用包装器获取Class 对象  
14.         String str = "asdasd";  
15.         clazz = str.getClass();  
16.         // 第二种 ：类.class  
17.         clazz = User.class;  
18.         clazz = String.class;  
19.         clazz = Integer.class;  
20.   
21.         // 第三种：Class.forname();  
22.         clazz = Class.forName("java.lang.String");  
23.         clazz = Class.forName("java.lang.Long");  
24.          
25.         //第四种：包装类.type  
26.         clazz = Integer.TYPE;  
27.     }  
28. }  

(3)使用反射动态创建对象实例     有两种方式：

                      方法一：通过Class的newInstance()方法

                                       该方法要求该Class 对象的对应类有无参构造方法

                                        执行newInstance()实际上就是执行无参构造方法来创建该类的实例

                      方法二：通过Constructor的newInstance() 方法

                                         先使用Class对象获得指定的Constructor对象

                                          再调用Constructor对象的newInstance()方法来创建该Class对象对应类的对象

                                           通过该方法可以选择使用指定的构造方法来创建对象

下面就两种方法写个简单的实例:

1. import java.lang.reflect.Constructor;  
2. import entity.User;  
3.   
4. /** 
5.  *  
6.  * @author lijian 
7.  *  使用反射 动态创建对象  两种方式 
8.  */  
9. public class TestClass_3 {  
10.     public static void main(String[] args) throws Exception {  
11.         /** 
12.          * 方法1：通过Class的newInstance()方法 
13.          *          该方法要求该Class对象的对应类有无参构造方法 
14.          *              执行newInstance()实际上就是执行无参构造方法来创建该类的实例 
15.          */  
16.     //      Class  clazz = Class.forName("entity.User");  
17.     //  Object obj =  clazz.newInstance();  
18.           
19.         /** 
20.          * 方法2：通过Constructor的newInstance()方法 
21.          *             先使用Class对象获取指定的Constructor对象 
22.          *             再调用Constructor对象的newInstance()方法来创建该Class对象对应类的对象 
23.          *              通过该方法可选择使用指定构造方法来创建对象 
24.          */  
25.         Class clazz = Class.forName("entity.User");  
26.         //指定有参的构造方法  
27.         Constructor cons = clazz.getConstructor(new Class[] {int.class,String.class,String.class});  
28.         //使用有参数的构造方法实例对象  
29.                 Object obj = cons.newInstance(new Object[]{1,"scott","1234"});  
30.                 //转换为实际操作类  
31.                 User user = (User)obj;  
32.   
33.                 //也可以调用无参构造方法，比第一种方法复杂  
34.                 obj = clazz.getConstructor(new Class[]{}).newInstance(new Object[]{});  
35.                 user = (User)obj;  
36.                 //以下也可以调用无参构造方法  
37.                 obj = clazz.getConstructor().newInstance();  
38.                 //转换为实际操作类  
39.                  user = (User)obj;  
40.     }  
41.   
42. }  

（4）使用反射动态修改查询的属性值

              通过Class对象的getFields() 或者getField()方法可以获得该类所包括的全部Field属性或指定Filed属性。Field类提供了以下方法来方法访问属性：

 getXxx(Object   obj) ：获取obj对象该Field的属性值。此处的Xxx对应8个基本数据类型，如果该属性类型是引用类型则直接使用get(Objectobj)

        setXxx(Object obj,Xxx val) ：将obj对象的该Field赋值val。此处的Xxx对应8个基本数据类型，如果该属性类型是引用类型则直接使用set(Objectobj, Object val)

        setAccessible(Boolean flag)：若flag为true，则取消属性的访问权限控制，即使private属性也可以进行访问

1. import java.lang.reflect.Field;  
2.   
3.   
4. /** 
5.  *  
6.  * @author lijian 
7.  *    使用反射动态修改查询属性值 
8.  */  
9. public class TestClass_4 {  
10.   
11.     public static void main(String[] args) throws Exception {  
12.         Class clazz = Class.forName("entity.User");  
13.         Object obj = clazz.newInstance();//获得类的实例  
14.         //获得 User 类中的指定属性对应的Field对象（每个属性对应一个Field对象）  
15.         Field field = clazz.getDeclaredField("name");  
16.           
17.         //取消属性的访问权限控制，即使private 属性也可以进行访问  
18.         field.setAccessible(true);  
19.         //调用 getter 方法获取属性值  
20.         System.out.println(field.get(obj));  
21.         //调用setter 方法给属性赋值  
22.         field.set(obj, "scott");  
23.         //调用 getter 方法获取对应属性修改后的值  
24.         System.out.println(field.get(obj));  
25.     }  
26. }  

（5）使用反射动态执行方法

通过Class对象的getMethods()方法可以获得该类所包括的全部方法，返回值是Method[]

通过Class对象的getMethod() 方法可以获得该类所包括的执行方法，返回值是Method

每个Method对象对应一个方法，获得Method对象后，可以调用其invoke()来调用对应方法                                

Objectinvoke(Object obj , Object [] args):   obj代表当前方法所属的对象的名字，args代表当前方法的参数列表，返回值Object是当前方法的返回值，即执行当前方法的结果。

1. import java.lang.reflect.Method;  
2. import entity.User;  
3.   
4. /** 
5.  *  
6.  * @author lijian 
7.  *  使用反射动态执行方法 
8.  */  
9. public class TestClass_5 {  
10.   
11.     public static void main(String[] args) throws Exception{  
12.           
13.         Class clazz = User.class;  
14.         Object obj = clazz.newInstance();  
15.           
16.           
17.         //调用该对象的 setName方法  
18.         Method method = clazz.getMethod("setName", new Class[]{String.class});  
19.         Object result =method.invoke(obj, new Object[]{"scott"});       //  obj.setName("scott");  
20.         System.out.println("返回值为："+result);  
21.           
22.         //调用对象的getName()方法  
23.         Method method1 = clazz.getMethod("getName", new Class[]{});  
24.         Object obj1 = method1.invoke(obj, new Object[]{});  
25.         System.out.println("返回值为："+obj1);  
26.     }  
27. }  

    

（6）使用反射动态创建数组并存取元素

在java.lang.reflect包下提供了Array类，包括一系列static方法，通过这些方法可动态的创建数组、给元素赋值、取出元素值等

 Array提供的主要方法如下：

static ObjectnewInstance(Class<?> componentType, int[] dim) ：创建一个具有指定的组件类型和维度的新数组

static void setXxx(Objectarray, int index ，xxx val)：给数组对象array中第index个元素赋值val

static xxx getXxx(Objectarray, int index)：以 xxx形式返回指定数组对象array中第index个元素值

<1>动态创建一维数组，并给数组赋值：                   

 

1. import java.lang.reflect.Array;  
2.   
3. /** 
4.  *  
5.  * @author lijian 
6.  *  动态创建一维数组，并给数组赋值： 
7.  */  
8. public class TestClass_6 {  
9.   
10.     public static void main(String[] args) throws Exception  {     
11.           Class clazz = Class.forName("java.lang.Integer");  
12.           Object array = Array.newInstance(clazz, 10);//根据类的class 创建大小为10的数组  
13.           Array.set(array, 5, 10);//给数组的第5个元素赋值为10  
14.           Object el = Array.get(array, 5);//取出数组的第5个元素值显示  
15.           System.out.println(el);  
16.     }  
17.   
18. }  

   

<2>动态创建二维数组，并给数组赋值：

 

1. import java.lang.reflect.Array;  
2.   
3. /** 
4.  *  
5.  * @author lijian 
6.  *动态创建二维数组，并给数组赋值： 
7.  */  
8. public class TestClass_7 {  
9.   
10.     public static void main(String[] args) {  
11.         int dims[] = {10,15};  
12.         Object  array = Array.newInstance(int.class, dims);//创建一个10行15列二维数组，等价与：array[10][15]  
13.         Object  array1 = Array.get(array, 5);//获取二维数组中的第5行  
14.         Array.set(array1, 8, 300);     //给数组的第5行8列赋值300，等价与：array[5][8]=300  
15.         Object el = Array.get(array1, 8);//取出数组中第5行8列的值  
16.         System.out.println(el);  
17.     }  
18. }