Java反射机制创建对象

[java] view plain copy

 

1. package lxf;  
2.   
3. import java.lang.reflect.Constructor;  
4. import java.lang.reflect.Field;  
5. import java.lang.reflect.Method;  
6.   
7. class Person {  
8.     private String name;  
9.     private int age;  
10.   
11.     public Person(String name, int age) {  
12.         this.name = name;  
13.         this.age = age;  
14.     }  
15.   
16.     public Person() {  
17.         // TODO Auto-generated constructor stub  
18.     }  
19.   
20.     public String getName() {  
21.         return name;  
22.     }  
23.   
24.     public void setName(String name) {  
25.         this.name = name;  
26.     }  
27.   
28.     public int getAge() {  
29.         return age;  
30.     }  
31.   
32.     public void setAge(int age) {  
33.         this.age = age;  
34.     }  
35.   
36. }  
37.   
38. /** 
39.  * 使用反射机制来创建对象 
40.  *  
41.  * @author lxf 
42.  * @time 2014-4-8下午05:08:41 
43.  *  
44.  */  
45. public class CreateObject {  
46.   
47.     /** 
48.      * Java的反射机制是指：反射就是把Java类中的各种成分映射成相应相应的Java类， 然后就可以获取这个类的所有信息 
49.      *  
50.      * @throws Exception 
51.      */  
52.     public static void createObj1() throws Exception {  
53.         // 返回与带有给定字符串名的类或接口相关联的 Class 对象。  
54.         // Class classType = Person.class;  
55.         Class classType = Class.forName("lxf.Person");  
56.         Object obj = classType.newInstance();  
57.         System.out.println("使用反射反射机制创建出来的对象是否是Person类的对象："  
58.                 + (obj instanceof Person));  
59.     }  
60.   
61.     /** 
62.      * 创建带有构造参数的对象的时候我们需要使用另外一种方式即： 1.先获取操作类的Class对象即字节码文件 
63.      * 2.使用Class对象的getConstructor 
64.      * (parameterTypes)方法获取该对象的构造方法的对象，注意括号中可以带不等的可变参数, 
65.      * 3.使用构造方法对象的newInstance(initargs)方法就可以实例化一个对象 4.注意，使用这些方法都不可以访问被 
66.      * private修饰的方法，需要设置某些访问权限setAccessable()方法 
67.      *  
68.      * @throws Exception 
69.      */  
70.     public static void createObj2() throws Exception {  
71.         @SuppressWarnings("rawtypes")  
72.         Class classType = Person.class;  
73.   
74.         @SuppressWarnings("unchecked")  
75.         Constructor<Person> con = classType.getConstructor(String.class,  
76.                 int.class);  
77.         Object obj = con.newInstance("lxf", 23);  
78.         System.out.println("使用constructor对象的newInstance方法创建对象的信息："  
79.                 + ((Person) obj).getName());  
80.     }  
81.   
82.     /** 
83.      * 操作方法包括（private方法） 步骤： 1.首先获取要操作类的Class对象 
84.      * 2.然后通过Class对象的getMethod方法获取要操作的方法的Method对象（两个参数，第一个参数是方法名，第二个参数是参数类型） 
85.      * 3.调用Method的方法的invoke方法（两个参数，第一个参数是该方法属于的类对象，具体参数） 
86.      * 4.当方法被private修饰的时候，首先需要调用getDeclaredMethod()方法获取要操作的被private修饰的类。 
87.      * 在这里要注意这个getDeclaredMethod方法，它既可以用作获取普通方法的对象也可以用来操作private修饰的方法， 
88.      * 但是操作private修饰的方法的时候，必须使用这个方法，其它方法不可以。普通方法还可以使用getMethod方法， 
89.      * 且属性操作也是如此。另外，还需要设置访问权限setAccessable(true)才可以 
90.      *  
91.      * @throws Exception 
92.      */  
93.     public static void methodDo() throws Exception {  
94.         Person p = new Person();  
95.         Class classType = Person.class;  
96.         Method method = classType.getMethod("setName", String.class);  
97.         method.invoke(p, "ckl");  
98.         System.out.println("使用反射操作SetName方法后，Person对象的name值是：" + p.getName());  
99.   
100.         Method method2 = classType.getDeclaredMethod("test");  
101.         method2.setAccessible(true);  
102.         method2.invoke(p);  
103.     }  
104.   
105.     /** 
106.      * 操作字段 
107.      *  
108.      * @throws Exception 
109.      */  
110.     public static void FieldDo() throws Exception {  
111.         Person p = new Person();  
112.         Class classType = Person.class;  
113.         Field field = classType.getDeclaredField("name");  
114.         Field field2 = classType.getDeclaredField("age");  
115.         field.setAccessible(true);  
116.         field2.setAccessible(true);  
117.         field.set(p, "lxf");  
118.         field2.set(p, 23);  
119.         System.out.println("使用反射机制操作被private修饰的对象字段后得到的属性值是：" + p.getName());  
120.         System.out.println("使用反射机制操作被private修饰的对象字段后得到的属性值是：" + p.getAge());  
121.     }  
122.   
123.     public static void main(String[] args) throws Exception {  
124.         new CreateObject().FieldDo();  
125.     }  
126.   
127. }  

根据以上代码：.使用反射机制创建对象的步骤如下：
1、先声明你要创建的对象的类全称；使用Class类的静态方法forName(String.className)加载这个类的字节码（注意，加载字节码不等于实例化对象） ，返回 一个Class对象，这个对象代表的是一个字节码文件。

2、调用这个类对象（字节码）的方法newInstance()方法（注意：这里的这个newInstance方法默认调用默认的构造方法即调用无参的构造方法， 一旦构造方法有参数时，此方法行不通，需要使用构造方法的对象的相关方法来 实例化）实例化类Person，返回的是Object类型
3、强制转换成Person类型即你所需类型
而获得Class对象的方法还有：
Class c = Class.forName("Java.lang.String");这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句：Class c = int.class; 或者 Class c = Integer.TYPE;它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。
到此反射基本操作就结束了，详细方法可参看API。