反射：

反射：框架设计的灵魂;

• 框架：半成品软件，可以在框架的基础上进行软件的开发，简化编译；
• 反射：将类的各个组成部分封装为其他的对象，这就是反射机制；

好处：
1：可以在操作运行过程中 ，操作这些对象；
2：可以解耦，提高程序的可扩展性；

获得Class 对象的方式

1：Class.forName(“全类名”) 将字节码文件加载到内存中，返回Class对象；
多用于配置文件，将类名配置在配置文件中。读取文件，加载类。

2：类名.class 通过类名的属性class 获取；
多用于参数的传递；

3：对象.getClass() getClass()方法在Object 类种定义着；
多用于对象获取字节码的方式；

package com.baidu.tVolatile;

public class PersonSTest {

    public static void main(String[] args) throws Exception {

        //Class.forName(“全类名”)
        Class<?> aClass = Class.forName("com.baidu.tVolatile.Person");
        System.out.println(aClass);

        //类名.class
        Class<Person> personClass = Person.class;
        System.out.println(personClass);

        //对象.getClass()
        Person person = new Person();
        System.out.println(person.getClass());
        }
     }

测试结果：

小结：
同一个字节码文件（*. class ）在程序一次运行中，只能被加载一次，无论通过哪一种方式获取的Class对象都是同一个。

pojo类；

package com.baidu.Reflection;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
    public int id;
    public String name;
    private String password;
    private String address;

    public void eat(){
        System.out.println("大学生在吃饭....");
    }


    public void eat(String food){
        System.out.println("大学生在吃饭...."+food);
    }

    public void sleep(){
        System.out.println("大学生在睡觉....");

    }

    private void game(){
        System.out.println("大学生在打游戏。。。");
    }

}

Class 对象获取；

1：获取成员变量们；

1：getField(String name) 返回一个 Field对象，它反映此表示的类或接口的指定公共成员字段 类对象。
2：getFields() 返回包含一个数组 Field对象反射由此表示的类或接口的所有可访问的公共字段 类对象。
3：getDeclaredFields() 返回的数组 Field对象反映此表示的类或接口声明的所有字段 类对象。
4：getDeclaredField(String name) 返回一个 Field对象，它反映此表示的类或接口的指定已声明字段 类对象。

1；getFields() ，，getField(String name)

2：getDeclaredFields()，，getDeclaredField(String name)

package com.baidu.Reflection;

import java.lang.reflect.Field;

public class Fieids {

    public static void main(String[] args) throws Exception {
        Class<Person> personClass = Person.class;

        //getFields 获得公共的成员变量
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("===================");
        //getField 获取指定的 公共的 成员变量
        System.out.println(personClass.getField("id"));

        System.out.println("====================");
        //getDeclaredFields 返回的数组 Field对象反映此表示的类或接口声明的所有字段 类对象(不管你是公共的，还是私有的)
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }

        System.out.println("====================");
        //getDeclaredField 返回一个 Field对象，它反映此表示的类或接口的指定已声明字段 类对象。
        Field password = personClass.getDeclaredField("password");
        System.out.println(password);
    }
}

测试结果

2：获取成员方法们；

package com.baidu.Reflection;

import java.lang.reflect.Method;

public class Methods {
    public static void main(String[] args) throws Exception {
        Class<Person> personClass = Person.class;

        //getMethods()
        //返回包含一个数组 方法对象反射由此表示的类或接口的所有公共方法 类对象，包括那些由类或接口和那些从超类和超接口继承的声明。
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

        System.out.println("======================");
        //getMethod(String name, 类<?>... parameterTypes)
        //返回一个 方法对象，它反映此表示的类或接口的指定公共成员方法 类对象。
        Method sleep = personClass.getMethod("sleep");
        System.out.println(sleep);

        System.out.println("======================");
        //getDeclaredFields()
        //返回的数组 Field对象反映此表示的类或接口声明的所有字段 类对象。
        Method[] declaredMethods = personClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }

        System.out.println("======================");
        System.out.println(personClass.getDeclaredMethod("game"));
    }
}

获取构造方法们

下面要使用私有的构造方法。
注意： 要想给私有的构造方法赋值的话，必须加上 setAccessible() 方法才能赋值；

    private Person(int id, String name,String password){
        this.id = id;
        this.name = name;
        this.password = password;
    }

package com.baidu.Reflection;

import java.lang.reflect.Constructor;

public class Constructors {
    public static void main(String[] args) throws Exception {
        Class<Person> personClass = Person.class;

        //getConstructors()
        //返回包含一个数组 Constructor对象反射由此表示的类的所有公共构造 类对象。
        Constructor<?>[] constructors = personClass.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }

        System.out.println("==================");
        //getConstructor(类<?>... parameterTypes)
        //返回一个 Constructor对象，该对象反映 Constructor对象表示的类的指定的公共 类函数。
        Constructor<Person> constructor = personClass.getConstructor(int.class, String.class);
        System.out.println(constructor); //获得了构造函数的操作，可以复制操作。

        //创建由此 类对象表示的类的新实例。
        Person person1 = constructor.newInstance(123, "张三");
        System.out.println(person1);

        System.out.println("==================");
        //getDeclaredConstructors()
        //返回一个反映 Constructor对象表示的类声明的所有 Constructor对象的数组 类 。
        Constructor<?>[] declaredConstructors = personClass.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }

        System.out.println("==================");
        Constructor<Person> declaredConstructor = personClass.getDeclaredConstructor(int.class, String.class, String.class);
        System.out.println(declaredConstructor);

        //注意： 如果你想给私有的方法设置之值的话，必须加上 setAccessible() 方法才能赋值；
        declaredConstructor.setAccessible(true); //暴力反射
        Person person2 = declaredConstructor.newInstance(12, "李四", "12232");
        System.out.println(person2);


    }
}