68.3 反射获取构造器对象

有了这个构造器对象，我们就可以在代码中灵活的创建对象了

getDeclaredConstructor() 拿到存在的构造器：

获取了构造器，现在创建对象

package com.itheima.d3_reflect_constructor;
import org.junit.Test;
import java.lang.reflect.Constructor;
/**
    目标：反射_获取Constructor构造器对象.
    反射的第一步是先得到Class类对象。（Class文件）
    反射中Class类型获取构造器提供了很多的API:
         1. Constructor getConstructor(Class... parameterTypes)
            根据参数匹配获取某个构造器，只能拿public修饰的构造器，几乎不用！
         2. Constructor getDeclaredConstructor(Class... parameterTypes)
            根据参数匹配获取某个构造器，只要申明就可以定位，不关心权限修饰符，建议使用！
         3. Constructor[] getConstructors()
            获取所有的构造器，只能拿public修饰的构造器。几乎不用！！太弱了！
         4. Constructor[] getDeclaredConstructors()
            获取所有申明的构造器，只要你写我就能拿到，无所谓权限。建议使用！！
    小结：
        获取类的全部构造器对象： Constructor[] getDeclaredConstructors()
            -- 获取所有申明的构造器，只要你写我就能拿到，无所谓权限。建议使用！！
        获取类的某个构造器对象：Constructor getDeclaredConstructor(Class... parameterTypes)
            -- 根据参数匹配获取某个构造器，只要申明就可以定位，不关心权限修饰符，建议使用！
 */
public class TestStudent01 {
    // 1. getConstructors:
    // 获取全部的构造器：只能获取public修饰的构造器。
    // Constructor[] getConstructors()
    @Test
    public void getConstructors() { // 定义一个测试方法
        // a. 第一步： 获取类对象
        Class c = Student.class;
        // b. 提取类中的全部的构造器对象  // 返回的是一个构造器类型的数组
        Constructor[] constructors = c.getConstructors(); //
        // c. 遍历构造器  // 将构造器数组，遍历.for
        for (Constructor constructor : constructors) {   // 一个参数是0  一个参数的数量为2
            System.out.println(constructor.getName() + "====>" + constructor.getParameterCount());
        }
    }
    // 2. getDeclaredConstructors();
    // 获取所有的构造器，只要你敢写，这里就能拿到，无所谓权限是否可及（可以拿到private的）
    @Test
    public void getDeclaredConstructors() { // 定义一个测试方法
        // a. 第一步： 获取类对象
        Class c = Student.class;
        // b. 提取类中的全部的构造器对象  // 返回的是一个构造器类型的数组
        Constructor[] constructors = c.getDeclaredConstructors(); //
        // c. 遍历构造器  // 将构造器数组，遍历.for
        for (Constructor constructor : constructors) {   //一个参数是0   参数的数量为2
            System.out.println(constructor.getName() + "====>" + constructor.getParameterCount());
        }
    }
    /**
     *   getConstructor （Class .. parameterTypes）
     *   获取某个构造器： 只能拿public修饰的某个构造器
     */
    @Test
    public void getConstructor() throws NoSuchMethodException { // 定义一个测试方法
        // a. 第一步： 获取类对象
        Class c = Student.class;
        // b. 定位单个构造器对象（按照参数定位无参数构造器）
        Constructor constructor = c.getConstructor(); // 只能拿public的构造器，这里没有写参数，所以拿到的是无参构造器
        System.out.println(constructor.getName() + "====>" + constructor.getParameterCount());
    }
    // 4.getConstructor(Class... parameterTypes)
    // 获取某个构造器：只要你敢写，这里就能拿到，无所谓权限是否可及。
    @Test
    public void getDeclaredConstructor() throws Exception {
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.定位单个构造器对象 (按照参数定位无参数构造器)
        Constructor cons = c.getDeclaredConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());
        // c.定位某个有参构造器                      // 这里匹配的是String类型的类型
        Constructor cons1 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());
    }
}

package com.itheima.d3_reflect_constructor;
import org.junit.Test;
import java.lang.reflect.Constructor;
/**
    目标: 反射_获取Constructor构造器然后通过这个构造器初始化对象。
    反射获取Class中的构造器对象Constructor作用：
            也是初始化并得到类的一个对象返回。
    Constructor的API:
         1. T newInstance(Object... initargs)
                创建对象，注入构造器需要的数据。
         2. void setAccessible(true)
                修改访问权限，true代表暴力攻破权限，false表示保留不可访问权限(暴力反射)
    小结：
        可以通过定位类的构造器对象。
        如果构造器对象没有访问权限可以通过：void setAccessible(true)打开权限
        构造器可以通过T newInstance(Object... initargs)调用自己，传入参数！
 */
public class TestStudent02 {
    // 1.调用构造器得到一个类的对象返回。
    @Test
    public void getDeclaredConstructor() throws Exception {
        // a.第一步：获取类对象
        Class c = Student.class;
        // b.定位单个构造器对象 (按照参数定位无参数构造器)
        Constructor cons = c.getDeclaredConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());
        // 如果遇到了私有的构造器，可以暴力反射 （只能暴力一次，下次就不行了，破坏了封装性)
        cons.setAccessible(true); // 权限被打开
        Student s = (Student) cons.newInstance();   // cons是构造器类型的对象（这里获取的是无参构造器对象），现在根据这个指定的构造器创建Student类型的对象
        System.out.println(s);  // 输出   无参数构造器执行！Student{name='null', age=0}（执行了构造器里面的内容）
        System.out.println("-------------------");
        // c.定位某个有参构造器
        Constructor cons1 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(cons1.getName() + "===>" + cons1.getParameterCount());
        Student s1 = (Student) cons1.newInstance("孙悟空", 1000); // 将Student有参构造器，创建Student对象，给予参数
        System.out.println(s1);  //有参数构造器执行！
//        Student{name='孙悟空', age=1000}
    }
}

package com.itheima.d3_reflect_constructor;
public class Student {
    private String name;
    private int age;
    private Student(){
        System.out.println("无参数构造器执行！");
    }
    public Student(String name, int age) {
        System.out.println("有参数构造器执行！");
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}