一、"Class"对象实例化的常见三种方式以及使用时机。

• 上篇博客学习的Java"反射"机制与Class类对象的实例化的方式。Java反射学习(1)(Java的“反射“机制、Class类对象的实例化方式)-CSDN博客
• 这篇博客首先将会针对三种实例化方式（全限定类名.forName()、类名.class、对象.getClass()）何种情况（何时）去使用它们？做出简单解释。

（1）源代码(编写)阶段——使用全限定类名.forName()。

• 一般使用该方式的次数最多！

---

• 通过全限定类名.forName()在该阶段获取Class对象（字节码文件对象）。

---

（2）加载阶段——使用类名.class。

• 一般使用情况更多的是作为参数进行传递。（如：同步代码块的"锁"对象）

---

• 将.class文件加载到内存中时。使用类名.class方式获取Class对象（字节码文件对象）。

---

（3）运行阶段——使用对象.getClass()。

• 一般已经创建了该类的对象，才使用该方式。

---

• 在内存中通过new xxx()的方式去创建该类的对象。
• 则使用对象.getClass()方式获得获取Class对象（字节码文件对象）。

二、Java中使用"反射"机制获取构造方法及内部的详细信息。

（1）反射机制获取构造方法的基本概念。

• 在Java中，可以使用反射机制获取类的构造方法及内部的详细信息（包括获取构造方法的修饰符、参数个数、参数类型、构造方法名以及进行赋值或创建新对象）。

---

（2）利用Java的对象机制进行封装。(Constructor类)

• 基于"Java万事万物皆对象"的机制。
• 使用.class（字节码文件）——字节码文件对象"Class"类对象获取对应类的信息。

---

• 构造方法——封装构造方法的类"Constructor"。

---

• 字段(成员变量)——封装成员变量的类"Field"。（后面博客讨论学习）
• 成员方法——封装成员方法的类"Method"。（后面博客讨论学习）

---

（3）操作构造方法的类"Constructor"相关的操作方法。

1、Class类中用于获取构造方法（返回Constructor类对象）的常用方法。

方法名称	方法功能基本描述
Constructor<?>[] getConstructors();	返回所有的公共构造方法对象的数组
Constructor<?>[] getDeclaredConstructors();	返回所有构造方法(获取所有权限的)对象的数组
Constructor<T> getConstructor(Class<?>... parameterTypes);	返回单个公共构造方法对象
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes);	返回单个构造方法(包括私有的)对象

2、Constructor类中用于创建对象的方法。

方法名称	方法功能基本描述
T newInstance(Object...initargs);	根据指定的构造方法创建对象。
setAccessible(boolean flag);	设置为true时，表示取消访问权限的检查。 (如对私有构造方法也能"强行"实例化) Object...initargs代表Object类型的可变参数。

3、Constructor类对象的重要操作方法。

方法声明	功能描述
getModifiers()	获取构造方法的修饰符。
getName()	获取构造方法的名称。
getParameterTypes()	获取构造方法中参数的类型。
toString()	返回此构造方法的信息。
newInstance(Object...initargs)	通过该构造方法的指定参数列表创建一个该类的对象。一般可能配合setAccessible()方法使用。 如果未设置参数，则表示默认采用无参的构造方法。 其中Object...initargs代表Object类型的可变参数。 可以学习博主之前的博客！Java之可变参数？？（Object... 数组变量名 ？？？）_java object...-CSDN博客 (上面的... parameterTypes也是可变参数类型)。

（3）具体的操作演示。

1、提供Student类。(4个构造方法)

• 两个成员属性：String name(姓名)、int age(年龄)。

---

• 访问权限为public的无参构造方法。
• 访问权限为public的参数为1(String name)的有参构造方法。
• 访问权限为protected的参数为1(int age)的有参构造方法。
• 访问权限为private的参数为2(String name,int age)的有参构造方法。

package com.fs.entity;

public class Student {
    //提供成员变量
    private String name;
    private int age;

    //无参构造（访问权限：public）
    public Student() {
    }

    //参数为1(name)的构造方法（访问权限：public）
    public Student(String name) {
         = name;
    }

    //参数为1(age)的构造方法（访问权限：protected）
    protected Student(int age) {
        this.age = age;
    }

    //参数为2的构造方法（访问权限：private）
    private Student(String name, int age) {
         = name;
        this.age = age;
    }

    //提供对于成员属性的getter、setter方法

    public String getName() {
        return name;
    }

    public void setName(String name) {
         = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //提供toString方法

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2、测试类中进行上述重要方法的测试操作。

<1>第一步。获取对应Student类的字节码文件对象。

• 因为类的所有信息都是存储在.class文件中！只有通过拿到对应类的字节码文件对象（Class）才能进行上面描述的方法的测试使用操作！

//1.通过Student类的全限定类名获取class字节码文件对象
        Class<?> clazz = Class.forName("com.fs.entity.Student");

<2>第二步。通过Class对象获取类中对应构造方法。

• 获取所有的公共构造方法。

package com.fs.test;
import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.通过Student类的全限定类名获取class字节码文件对象
        Class<?> clazz = Class.forName("com.fs.entity.Student");

        //获取所有的公共构造方法。
        Constructor<?>[] cons1 = clazz.getConstructors();
        for (Constructor<?> con : cons1) {
            //依次打印
            System.out.println(con);
        }
    }
}

---

• 获取所有的构造方法。（包括私有的、受保护的权限的构造方法）

package com.fs.test;
import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.通过Student类的全限定类名获取class字节码文件对象
        Class<?> clazz = Class.forName("com.fs.entity.Student");

        //获取所有的构造方法。（所有权限的构造方法都能获取到）
        Constructor<?>[] cons2 = clazz.getDeclaredConstructors();
        for (Constructor<?> con : cons2) {
            System.out.println(con);
        }

    }
}

---

• 获取单个构造函数（不填写参数：默认获取无参构造方法）

package com.fs.test;
import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.通过Student类的全限定类名获取class字节码文件对象
        Class<?> clazz = Class.forName("com.fs.entity.Student");

        //获取单个构造函数（不填写参数：默认获取无参构造方法）
        Constructor<?> con = clazz.getConstructor();
        System.out.println(con);

    }
}

---

• 获取单个参数的单个构造函数。
• （注意方法的参数类型要与提供的构造方法中的参数类型要以一致！）
• 参数类型传递的是对应的字节码文件（如String类型——>传String.class）即可。还记得Class类对象实例化的第二种常见方式（类名.class）就是通常用于传参！

package com.fs.test;
import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.通过Student类的全限定类名获取class字节码文件对象
        Class<?> clazz = Class.forName("com.fs.entity.Student");

        //获取单个参数(String name)的单个构造函数。
        Constructor<?> con1 = clazz.getConstructor(String.class);
        System.out.println(con1);
        //获取单个参数(int age)的单个构造函数。
        //注意访问权限不是public。需要使用getDeclaredConstructor
        Constructor<?> con2 = clazz.getDeclaredConstructor(int.class);
        System.out.println(con2);
    }
}

---

• 获取两个参数的单个构造函数。
• 和上面的写法大差不大。

package com.fs.test;
import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.通过Student类的全限定类名获取class字节码文件对象
        Class<?> clazz = Class.forName("com.fs.entity.Student");
        
        //获取两个参数的单个构造函数。
        Constructor<?> con = clazz.getDeclaredConstructor(String.class, int.class);
        System.out.println(con);
    }
}

---

<3>第三步。通过获取的构造方法获取其对应的详细信息。

• 在"反射"机制的面前一切都是"赤裸裸"的。
• 我们可以通过构造方法获取其访问权限、方法名称、所有的形式参数类型与参数个数。更重要的是通过获取到的构造方法去实例化对应的对象。

---

• 获取构造方法对应的访问权限修饰符。（返回的数字进行体现的）
• private（私有）：返回的int值为2。public（公共）：返回的int值为1。
• 这些值的规律可以通过API帮助文档查询。搜索“常量字段值”即可。

---

package com.fs.test;
import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.通过Student类的全限定类名获取class字节码文件对象
        Class<?> clazz = Class.forName("com.fs.entity.Student");
        
        //获取单个无参构造方法
        Constructor<?> con0 = clazz.getConstructor();
        System.out.println(con0);
        //获取构造方法对应的访问权限修饰符
        int modifiers = con0.getModifiers();
        System.out.println(modifiers);

        System.out.println("====================");

        //获取两个参数的单个构造函数。
        Constructor<?> con = clazz.getDeclaredConstructor(String.class, int.class);
        System.out.println(con);
        //获取构造方法对应的访问权限修饰符
        int modifiers2 = con.getModifiers();
        System.out.println(modifiers2);

    }
}

---

• 获取这个访问权限修饰符的应用场景，对应idea底层就是获取你自定义的类中提供的构造方法对应的访问修饰符权限。
• 如果是私有的，你在new对象的时候它也不会进行提示！

---

• 获取指定构造方法的对应参数的个数与类型。

package com.fs.test;
import com.fs.entity.Student;

import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.通过Student类的全限定类名获取class字节码文件对象
        Class<?> clazz = Class.forName("com.fs.entity.Student");

        //获取两个参数的单个构造函数。
        Constructor<?> con = clazz.getDeclaredConstructor(String.class, int.class);
        System.out.println(con);

        //获取对应参数个数与参数类型
        int parameterCount = con.getParameterCount();
        System.out.println("该构造方法的参数个数："+parameterCount);
        Class<?>[] parameterTypes = con.getParameterTypes();
        for (Class<?> parameterType : parameterTypes) {
            System.out.println("该构造方法的参数类型："+parameterType);
        }


    }
}

---

• 直接获取指定构造方法的每一个参数。
• idea在底层获取到我们对应构造方法的参数类型，就可以以图形化方式展示出来！

package com.fs.test;
import com.fs.entity.Student;

import java.lang.reflect.Constructor;
import java.lang.reflect.Parameter;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //1.通过Student类的全限定类名获取class字节码文件对象
        Class<?> clazz = Class.forName("com.fs.entity.Student");

        //获取两个参数的单个构造函数。
        Constructor<?> con = clazz.getDeclaredConstructor(String.class, int.class);
        System.out.println(con);

        //直接指定构造方法的每个参数
        Parameter[] parameters = con.getParameters();
        for (Parameter parameter : parameters) {
            System.out.println(parameter);
        }



    }
}

---

• 使用指定的构造方法完成创建对象。（包括可以暂时使用private权限的构造方法创建对象）
• 注意：需要给对应构造方法的参数进行依次赋值（参数类型需要匹配）。

---

• 暴力反射！使用方法临时取消访问权限的校验。

package com.fs.test;
import com.fs.entity.Student;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Parameter;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //1.通过Student类的全限定类名获取class字节码文件对象
        Class<?> clazz = Class.forName("com.fs.entity.Student");

        //获取两个参数的单个构造函数。
        Constructor<?> con = clazz.getDeclaredConstructor(String.class, int.class);
        System.out.println(con);

        //表示临时取消权限的校验
        con.setAccessible(true);
        //创建对象
         Object objStudent = con.newInstance("张三", 18);
         Student stu = (Student) objStudent;
        System.out.println("姓名："+stu.getName()+"年龄："+stu.getAge());


    }
}