通过反射获取构造函数,创建实例。
反射通俗理解
(根据字符串)解析出一个类的各个组成部分(构造函数,字段,方法)。
主要用来做框架
以下是一个简单的测试类
首先是一个测试实体,在此为一个Person类。类里面有五个构造函数。里面的构造有两种类型的:
1、公开的
2、私有的
其中每种类型又包含无参数的,和有参数的(一个或多个)
然后是一个测试类,主要测试了上面所说的几种类型组合的构造函数的获取,以及创建对象并输出测试代码。测试是用Junit来测试的。
**** 反射创建对象时,有两种方式。
关于第一种方式,获取私有构造函数需要getDeclaredConstructor()来获取,创建实例前,通过setAccessible(true)强制设置为可在类外执行。
关于第二种方式,通过类创建则必须要保证类中要一个无参数的构建函数。
1、获取到构造函数,通过构造函数创建实例(对象)
2、加载类之后,直接通过类创建实例
Person.java:
1 package cn.rt.gwq;
2
3 import java.util.List;
4
5 public class Person {
6
7 public String value = "public value";
8
9 /**
10 *无参数构造函数
11 */
12 public Person() {
13 System.out.println("no params constructor");
14 }
15
16 /**
17 * 一个参数的构造函数
18 * @param name
19 */
20 public Person(String name) {
21 System.out.println("string name constructor");
22 value = "change the value : "+name;
23 }
24
25 /**
26 * 一个参数的构造函数
27 * @param age
28 */
29 public Person(int age) {
30 System.out.println("int age constructor");
31 value = "change the value : "+age;
32 }
33
34 /**
35 * 多个参数的构造函数
36 * @param usm
37 * @param pwd
38 */
39 public Person(String usm,String pwd) {
40 System.out.println("String usm,String pwd constructor");
41 value = "change the value : "+usm +":"+pwd;
42 }
43
44 /**
45 * 私有的构造函数
46 * @param list
47 */
48 private Person(List list) {
49 System.out.println("List constructor");
50 value = "change the value : "+list.toArray().toString();
51 }
52
53 }
Person.java
Demo.java:reflect
1 package cn.rt.gwq;
2
3 import java.lang.reflect.Constructor;
4 import java.util.ArrayList;
5 import java.util.List;
6
7 import org.junit.Test;
8
9 public class Demo {
10
11 /**
12 * 获取无参数构造函数并创建对象
13 * @throws Exception
14 */
15 @Test
16 public void test1() throws Exception{
17
18 //加载类
19 Class clazz1 = Class.forName("cn.rt.gwq.Person");
20 //获取构造函数
21 Constructor c = clazz1.getConstructor(null);
22 //根据构造函数创建对象
23 Person p = (Person)c.newInstance(null);
24 //验证
25 System.out.println(p.value);
26
27 return;
28
29 }
30
31 /**
32 * 获取有参数的构造函数并创建对象
33 * @throws Exception
34 */
35 @Test
36 public void test2() throws Exception {
37
38 Class clazz2 = Class.forName("cn.rt.gwq.Person");
39 Constructor c = clazz2.getConstructor(String.class);
40 Person p = (Person) c.newInstance("bob");
41 System.out.println(p.value);
42
43 return;
44 }
45
46 /***
47 * 获取多个参数的构造函数并创建对象
48 * @throws Exception
49 */
50 @Test
51 public void test3() throws Exception{
52
53 Class clazz3 = Class.forName("cn.rt.gwq.Person");
54 Constructor c = clazz3.getConstructor(String.class,String.class);
55 Person p = (Person) c.newInstance("username","password");
56 System.out.println(p.value);
57
58 return ;
59 }
60
61 /**
62 * 获取私有的构造函数并且创建对象
63 * @throws Exception
64 */
65 @Test
66 public void test4() throws Exception{
67
68 //加载类
69 Class clazz3 = Class.forName("cn.rt.gwq.Person");
70 //获取构造函数
71 //Constructor c = clazz3.getConstructor(List.class);
72 //需要用带Declared的方法来读取私有方法
73 Constructor c = clazz3.getDeclaredConstructor(List.class);
74 //强制可读0
75 c.setAccessible(true);
76 //参数
77 List list = new ArrayList<>();
78 list.add(1);list.add(2);
79 //创建对象
80 Person p = (Person) c.newInstance(list);
81 //验证
82 System.out.println(p.value);
83
84 return;
85
86 }
87
88 /***
89 * 不通过构造函数,直接通过类来创建对象
90 * 前提:必须有一个无参数的构造函数
91 * @throws Exception
92 */
93 @Test
94 public void test5() throws Exception {
95
96 Class clazz = Class.forName("cn.rt.gwq.Person");
97 Person p = (Person) clazz.newInstance();
98 System.out.println(p.value);
99
100 }
101
102
103 }
Demo.java