源码必备技能，反射

​ Class类的实例表示正在运行的Java应用程序中的类和接口，每个类只会产生一个Class对象，在类加载的时候自动创建
当用户想要获取任何一个Class类有三种方式：
​ 1、Object→getClass()
​ Class clazz = new Emp().getClass();
​ 2、任何数据类型都有一个静态的class属性
​ Class clazz = Emp.class;
​ 3、通过Class.forName()
​ Class clazz = Class.forName(“com.mashibing.entity.Emp”);
​ 4、如果是基本数据类型，可以通过TYPE的方式来获取Class对象

        //1、通过class.forname()来获取Class对象
//        Class clazz = Class.forName("com.mashibing.entity.Emp");
//        System.out.println(clazz.getPackage());
//        System.out.println(clazz.getName());
//        System.out.println(clazz.getSimpleName());
//        System.out.println(clazz.getCanonicalName());
        //2、通过类名.class来获取
//        Class clazz = Emp.class;
//        System.out.println(clazz.getPackage());
//        System.out.println(clazz.getName());
//        System.out.println(clazz.getSimpleName());
//        System.out.println(clazz.getCanonicalName());
        //3/通过对象的getClass来获取,不推荐使用
//        Class clazz = new Emp().getClass();
//        System.out.println(clazz.getPackage());
//        System.out.println(clazz.getName());
//        System.out.println(clazz.getSimpleName());
//        System.out.println(clazz.getCanonicalName());

        //4.如果是一个基本数据类型，那么可以通过TYPE的方式来获取Class对象
        Class type = Integer.TYPE;
        System.out.println(type.getName());
        System.out.println(type.getCanonicalName());

​ 1、第一种已经创建对象，就意味着已经产生了Class类
​ 2、第二种需要导入对应的包，依赖太强
​ 3、第三种常用，只需要传入一个类的完全限定名即可

​ Object newInstance()：用于操作对应的类
​ Field getFields()：获取成员变量，包括子类及父类，同时只能包含公共的方法
​ Field[] getField(String name):通过属性名来获取公共属性
​ Field getDeclaredFields()：此方法返回的是当前类的所有属性，不仅仅局限于公共访问修饰符，所有的访问修饰符都可以拿到
​ Field[] getDeclaredField(String name):通过属性名来获取所有属性
​ Field的属性：
​ getName()：返回属性名字
​ getType()：返回属性名字
​ Set（Object obj, Object value）：设置该属性的值
​ setAccessible(Boolean boolean):如果访问修饰符是私有的，设置属性是否允许被访问
​ int getModifiers()返回属性的类型，对应的int值
​ Method getMethod(String name, Class… parameterTypes)：根据名字和参数类型的class对象获取方法
​ Method[] getMethods():获取该对象的普通方法
​ Method getDeclaredMethod(String name, Class… parameterTypes):根据名字和参数类型的class对象获取方法
​ Method[] getDeclaredMethods()：获取所有方法的
​ Method的属性：
​ setAccessible(Boolean boolean):如果访问修饰符是私有的，设置属性是否允许被访问
​ invoke(Object obj, Object… args)；调用该方法，并传入参数与class对象的Object newInstance()：用于操作对应的类
​ Constructor[] getDeclaredConstructors()：获取普通的构造方法
​ Constructor getDeclaredConstructor(Class… parameterTypes)：获取所有的构造器，包括私有的和公有的
​ Constructor属性
​ setAccessible(Boolean boolean):如果访问修饰符是私有的，设置属性是否允许被访问
​ newInstance(Object … initargs)：传入要调用构造器的函数，并且执行方法

//获取成员变量,包括子类及父类，同时只能包含公共的方法

  Class clazz = Class.forName("com.mashibing.reflect.Student");
        
        ​        Field[] fields = clazz.getFields();
        ​        Field className = clazz.getField("className");
        ​        Object o4 = clazz.newInstance();
        ​        className.setAccessible(false);
        ​        className.set(o4,"张三");
        ​        System.out.println(((Student)o4).className);
        ​        for (Field field : fields) {
            System.out.println(field);
            System.out.println(field.getName());
            System.out.println(field.getType());
            System.out.println(field.getModifiers());
            System.out.println("--------");
        ​        }
        ​        System.out.println("==============");
        ​        //此方法返回的是当前类的所有属性，不仅仅局限于公共访问修饰符，所有的访问修饰符都可以拿到
        ​        Field[] declaredFields = clazz.getDeclaredFields();
        ​        declaredFields[1].setAccessible(true);
        ​        Object o1 = clazz.newInstance();
        ​        declaredFields[1].set(o1,"上海");
        ​        System.out.println(((Student)o1).getAddress());

    for (Field field : declaredFields) {
        System.out.println(field);
        System.out.println(field.getName());
        System.out.println(field.getType());
        System.out.println(field.getModifiers());
        System.out.println("--------");
    }

    System.out.println("LLLLLLLLLLLLLLLLLLLLLLLLLLLLL");
    //反射在一定程度上破坏了封装行，需要合理使用
    Field addres = clazz.getDeclaredField("address");
    System.out.println(addres.getName());
    System.out.println(addres.getType());
    System.out.println(addres.getModifiers());
    //设置该属性是否能被访问，ture表示能被访问，破坏了封装性
    addres.setAccessible(true);
    Object o = clazz.newInstance();
    addres.set(o,"北京");
    System.out.println(((Student)o).getAddress());

    System.out.println("方法====================");
    //获取该对象的普通方法，包含的方法范围是当前对象及父类对象的所有公共方法
    Method[] methods = clazz.getMethods();
    for (Method method : methods) {
        System.out.println(method);
        System.out.println(method.getName());
        System.out.println(method.getModifiers());
    }
    System.out.println("+++++++++++++++++++++");
    //获取当前类中所有的方法，无论什么访问修饰符
    Method[] declaredMethod = clazz.getDeclaredMethods();
    for (Method method : declaredMethod) {
        System.out.println(method.getName());
        System.out.println(method.getReturnType());
    }
    Method add = clazz.getDeclaredMethod("add", int.class, int.class);
    Object o2 = clazz.newInstance();
    add.setAccessible(true);
    add.invoke(o2,123,123);


    System.out.println("++++++++++++++++++++++");
    //获取对象的所有构造方法,只能获取公有的构造方法
    Constructor[] constructors = clazz.getConstructors();
    for (Constructor constructor : constructors) {
        System.out.println(constructor.getName());
    }
    //获取所有的构造方法，无论是私有或者是公有
    Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
    for (Constructor declaredConstructor : declaredConstructors) {
        System.out.println(declaredConstructor.getName());
    }
    //如何调用私有的构造方法
    Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class, int.class, String.class);
    declaredConstructor.setAccessible(true);
    Student o3 = (Student)declaredConstructor.newInstance("msb", 44, "java");
    System.out.println(o3);

​