Java反射之剖析构造函数

Posted 2020-07-10

反射通俗理解
　　（根据字符串）解析出一个类的各个组成部分（构造函数，字段，方法）。
　　主要用来做框架

 

以下是一个简单的测试类

首先是一个测试实体,在此为一个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