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 }

  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 }