反射 动态加载类，获取构造函数、方法、成员

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;

public class DynamicClass {

    private String name;
    private String sex;

    public static void main(String[] args) throws ClassNotFoundException {
        /*
         * 万事万物皆对象
         * 所有的类都是Class类的对象，所有的方法都是Method类的对象，所有的
         * 每个类都存在class的静态成员参数
         * 表示类的唯一标识   类类型
         */
        System.out.println("DynamicClass .class : " + DynamicClass.class);
        /*
         * 每个类的对象，都具有一个getClass方法  用来获取类类型
         * 类类型是Class类的对象
         */
        System.out.println("DynamicClass .getClass : " + new DynamicClass().getClass());
        /*
         * 一个类的类类型是唯一的，也是一个定值。相同的类的类类型是相等的。
         */
        System.out.println(DynamicClass.class == new DynamicClass().getClass());

        /*
         * 通过Class.forName方法获取的类类型
         */
        Class dynamicClass = Class.forName("com.haut.zm.test.DynamicClass");

        System.out.println("Class forName : " + dynamicClass);

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

        /*
         * 获取类自己所有的方法，不包含继承方法
         */
        Method[] methods = dynamicClass.getDeclaredMethods();
        /*
         * lambda也是method方法的一个对象
         */
        Arrays.stream(methods).forEach(method -> {
            System.out.println("++++++++++++");
            System.out.println(method.getName());
            /*
             * 方法返回类型  如果没有返回值是void的，说明void也是Class类的类类型
             */
            System.out.println("returnType : " + method.getAnnotatedReturnType().getType());
            Class[] parameterTypes = method.getParameterTypes();
            for(Class parameterType : parameterTypes) {
                System.out.print("parameterType : " + parameterType.getName() + "\t");
                System.out.println();
            }
            System.out.println();
        });

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

        /*
         * 获取所有的成员变量信息
         */
        Field[] fields = dynamicClass.getDeclaredFields();
        System.out.println("field : ");
        for(Field field : fields) {
            System.out.print(field.getName() + " : " + field.getType() + "\t");
        }

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

        /*
         * 构造方法，及参数类型
         */
        Constructor[] declaredConstructors = dynamicClass.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor.getName());
            for (Class parameterType : declaredConstructor.getParameterTypes()) {
                System.out.println(parameterType.getName());
            }
        }

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

        /*
         * 动态加载类
         */
        try {
            Class c = Class.forName("com.haut.zm.test.Word");
            OfficeAble officeAble = (OfficeAble) c.newInstance();
            officeAble.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private DynamicClass(){}

    public DynamicClass(String name) {
        this.name = name;
    }

    public DynamicClass(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }

    private void print(String print) {
        System.out.println("print : " + print);
    }

    private void print(String print, int type, String name) {
        System.out.println(name + print + type);
        System.out.println(int.class);
    }
}

interface OfficeAble{
    void start();
}

class Word implements OfficeAble{

    @Override
    public void start() {
        System.out.println("word start...");
    }
}

class Excel implements OfficeAble{

    @Override
    public void start() {
        System.out.println("excel start...");
    }
}