Java反射之剖析构造函数

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

 

以下是一个简单的测试类

首先是一个测试实体,在此为一个Person类。类里面有五个构造函数。里面的构造有两种类型的：

　　1、公开的

　　2、私有的

其中每种类型又包含无参数的，和有参数的（一个或多个）

然后是一个测试类，主要测试了上面所说的几种类型组合的构造函数的获取，以及创建对象并输出测试代码。测试是用Junit来测试的。

 

**** 反射创建对象时，有两种方式。

　　关于第一种方式，获取私有构造函数需要getDeclaredConstructor()来获取，创建实例前，通过setAccessible(true)强制设置为可在类外执行。

　　关于第二种方式，通过类创建则必须要保证类中要一个无参数的构建函数。

　　   1、获取到构造函数，通过构造函数创建实例（对象）

　　   2、加载类之后，直接通过类创建实例

 

Person.java:

package cn.rt.gwq;

import java.util.List;

public class Person {
    
    public String value = "public  value";
    
    /**
     *无参数构造函数
     */
    public Person() {
        System.out.println("no params constructor");
    }
    
    /**
     * 一个参数的构造函数
     * @param name
     */
    public Person(String name) {
        System.out.println("string name constructor");
        value = "change the value : "+name;
    }
    
    /**
     * 一个参数的构造函数
     * @param age
     */
    public Person(int age) {
        System.out.println("int age constructor");
        value = "change the value : "+age;
    }
    
    /**
     * 多个参数的构造函数
     * @param usm
     * @param pwd
     */
    public Person(String usm,String pwd) {
        System.out.println("String usm,String pwd constructor");
        value = "change the value : "+usm +":"+pwd;
    }
    
    /**
     * 私有的构造函数
     * @param list
     */
    private Person(List list) {
        System.out.println("List constructor");
        value = "change the value : "+list.toArray().toString();
    }

}

 

Demo.java:reflect

package cn.rt.gwq;

import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

public class Demo {
    
    /**
     * 获取无参数构造函数并创建对象
     * @throws Exception
     */
    @Test
    public void test1() throws Exception{
        
        //加载类
        Class clazz1 = Class.forName("cn.rt.gwq.Person");
        //获取构造函数
        Constructor c = clazz1.getConstructor(null);
        //根据构造函数创建对象
        Person p = (Person)c.newInstance(null);
        //验证
        System.out.println(p.value);
        
        return;
        
    }
    
    /**
     * 获取有参数的构造函数并创建对象
     * @throws Exception
     */
    @Test
    public void test2() throws Exception {
         
        Class clazz2 = Class.forName("cn.rt.gwq.Person");
        Constructor c = clazz2.getConstructor(String.class);
        Person p = (Person) c.newInstance("bob");
        System.out.println(p.value);
        
        return;
    }
    
    /***
     * 获取多个参数的构造函数并创建对象
     * @throws Exception
     */
    @Test
    public void test3() throws Exception{
        
        Class clazz3 = Class.forName("cn.rt.gwq.Person");
        Constructor c = clazz3.getConstructor(String.class,String.class);
        Person p = (Person) c.newInstance("username","password");
        System.out.println(p.value);
        
        return ;
    }
    
    /**
     * 获取私有的构造函数并且创建对象
     * @throws Exception
     */
    @Test
    public void test4() throws Exception{
        
        //加载类
        Class clazz3 = Class.forName("cn.rt.gwq.Person");
        //获取构造函数
        //Constructor c = clazz3.getConstructor(List.class);
        //需要用带Declared的方法来读取私有方法
        Constructor c = clazz3.getDeclaredConstructor(List.class);
        //强制可读0
        c.setAccessible(true);
        //参数
        List list = new ArrayList<>();
        list.add(1);list.add(2);
        //创建对象
        Person p = (Person) c.newInstance(list);
        //验证
        System.out.println(p.value);
        
        return;
                
    }
    
    /***
     * 不通过构造函数，直接通过类来创建对象
     * 前提：必须有一个无参数的构造函数
     * @throws Exception
     */
    @Test
    public void test5() throws Exception {
        
        Class clazz = Class.forName("cn.rt.gwq.Person");
        Person p = (Person) clazz.newInstance();
        System.out.println(p.value);
        
    }
    

}