这里，我主要想给大家介绍如何用反射机制执行某个类的构造方法。
首先，写一个普通的类：

package com.mec.about_reflection;

public class Person {
    private String name;
    private int age;

    public Person() {
        System.out.println("无参构造器！");
    }

    public Person(String name) {
        System.out.println("name:" + name);
    }


    @SuppressWarnings("unused")
    private void privateMethod(){
        System.out.println("这是一个私有的方法！");

    }

    public Person(String name, int age) {
        System.out.println("有参构造器！");
        this.setName(name);
        this.setAge(age);
    }

    public void setName(String name , int age){  
        System.out.println("name: " + name);  
        System.out.println("age:"+ age);  

    } 

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "name：" + name + ", age：" + age;
    }
}

大家可以看出这就是一个普通的Java类。
接下来，我们在main函数中获取并执行它的构造方法。

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import com.mec.about_reflection.Person;
public class TestMethod {
    public static void main(String[] args) {
        //利用反射机制得到这个（Person）这个类
        Class class1 = null;
        class1 = Person.class;

        try {
            //1.获取它的无参构造方法，这个比较简单newInstance()方法就是给这个类创建了一个新的对象，自然执行了它的构造方法，
            Object object = class1.newInstance();//此句会调用它的但参构造方法，且伴随着“;”完而执行完毕无参构造方法
            //底下这句话会显示这个类的toString（）方法（已经过验证）
            System.out.println("调用它的无参构造方法！：" + object);
            //调用它的有参构造方法
            System.out.println("调用它的有参构造方法！");
            //获取这个类
            Class class2 = Class.forName("com.mec.about_reflection.Person");
            System.out.println("执行单参构造方法！");
            //2.获取并执行它的单参构造方法
            Class[] clazzType = new Class[]{Class.forName("java.lang.String")};
            Constructor constructor1 = class2.getConstructor(clazzType);
            System.out.println("单参constructor1:" + constructor1);
            Object object2 = constructor1.newInstance("远远");//此时已经执行了它的但参构造方法
            //这一行会输出是默认调用了这个类的toString()方法
            System.out.println("object2:" + object2);
            //3.获取并执行这个类的双参构造方法
            //将Person这个类的有参构造方法的参数类型用Class数组的方式存放，{Class.forName("java.lang.String"),int.class}这句话是为了得到类型，在这里具体指Person中有参构造方法中的参数类型，
            Class[] classParaType = new Class[]{Class.forName("java.lang.String"),int.class};
            //获取这个类的构造方法并将存放这个构造方法参数的数组传进去，用Constructor类创的实例接收它
            Constructor constructor = class2.getConstructor(classParaType);
            System.out.println("双参constructor:" + constructor);
            //创建一个对象，并将自己要传递的实参传进去
            Object result = constructor.newInstance("芳芳",108);//这里伴随着“;”它的双参构造方法已经执行完毕
            //这一行会输出是默认调用了这个类的toString()方法
            System.out.println("result:" + result);
            } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

执行结果如下：

无参构造器！
调用它的无参构造方法！：name：null, age：0
调用它的有参构造方法！
执行单参构造方法！
单参constructor1:public com.mec.about_reflection.Person(java.lang.String)
name:远远
object2:name：null, age：0
双参constructor:public com.mec.about_reflection.Person(java.lang.String,int)
有参构造器！
result:name：芳芳, age：108

大家可能对于带参构造方法的参数存放问题有疑问，我刚刚试了单参构造方法的获取，它也只能用数组的形式表示，这一点对于菜鸟级别的我也有难度，再接再厉以后学明白了我会解释的！