image.png
    反射：将类的各个组成部分封装为其他对象，这就是反射机制
    好处：

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

    获取Class对象的方式

    1. Class.forName（”全类名”）：将字节码文件加载进内存，返回Class对象

    多用于配置文件，将类名定义在配置文件中。读取文件，加载类

    1. 类名.Class：通过类名的属性Class获取

    多用于参数的传递

    1. 对象.getclass():getclass（）方法在Object类中定义着

    多用于对象的获取字节码的方式

    Class对象功能
    获取功能
    1.获取成员变量们
    Field[ ] getFields( ) ：获取所有public修饰的成员变量
    Field getField(String name) ：获取指定名称的public修饰的成员变量

    Field[ ] getDeclaredFields( ) ：获取所有的成员变量，不考虑修饰符
    Field getDeclaredField(String name)
    2.获取构造方法们
    Constructor<?>[ ] getConstructors( )
    Constructor getConstructor(类<?>… parmeterTypes)**

    Constructor getDeclaredConstructor(类<?>… parameterTypes)
    Constructor<?>[ ] getDeclaredConstructors( )
    3.获取成员方法们
    Method[ ] getMethods( )
    Method getMethod(String name,类<?>… parameterTypers)

    Method[ ] getDeclaredMethods( )
    Method getDeclaredMethod(String name,类<?>… parameterTypers)
    4**.**获取类名
    String getName( )
    **
    Field：成员变量
    操作
    1.设置值
    void set（Object obj，Object value）
    2.获取值
    get（Object obj）
    3.忽略访问权限修饰符的安全检查
    setAccessible（true）：暴力反射
    Person类：

    1. package HeiMa.Reflect;/*
    3.     @create 2020--12--24--20:53
    4. */
    6. public class Person {
    7.     private String name;
    8.     private int age;
    10.     public String a;
    11.     protected String b;
    12.     String c;
    13.     private String d;
    15.     public Person() {
    16.     }
    18.     public Person(String name, int age, String a, String b, String c, String d) {
    19.         this.name = name;
    20.         this.age = age;
    21.         this.a = a;
    22.         this.b = b;
    23.         this.c = c;
    24.         this.d = d;
    25.     }
    27.     public String getName() {
    28.         return name;
    29.     }
    31.     public void setName(String name) {
    32.         this.name = name;
    33.     }
    35.     public int getAge() {
    36.         return age;
    37.     }
    39.     public void setAge(int age) {
    40.         this.age = age;
    41.     }
    43.     public String getA() {
    44.         return a;
    45.     }
    47.     public void setA(String a) {
    48.         this.a = a;
    49.     }
    51.     public String getB() {
    52.         return b;
    53.     }
    55.     public void setB(String b) {
    56.         this.b = b;
    57.     }
    59.     public String getC() {
    60.         return c;
    61.     }
    63.     public void setC(String c) {
    64.         this.c = c;
    65.     }
    67.     public String getD() {
    68.         return d;
    69.     }
    71.     public void setD(String d) {
    72.         this.d = d;
    73.     }
    75.     @Override
    76.     public String toString() {
    77.         return "Person{" +
    78.                 "name='" + name + '\'' +
    79.                 ", age=" + age +
    80.                 ", a='" + a + '\'' +
    81.                 ", b='" + b + '\'' +
    82.                 ", c='" + c + '\'' +
    83.                 ", d='" + d + '\'' +
    84.                 '}';
    85.     }
    86.     public void eat() {
    87.         System.out.println("eat...");
    88.     }
    90.     public void eat(String food) {
    91.         System.out.println("eat..."+ food);
    92.     }
    93. }

    获取成员变量：

    1. package HeiMa.Reflect;/*
    3.     @create 2020--12--24--20:55
    4. */
    6. import java.lang.reflect.Field;
    8. public class ReflectDemo {
    9.     public static void main(String[] args) throws Exception {
    10.         //获取person的class对象
    11.         Class personClass = Person.class;
    13.         // Field[] getFields()获取所有public修饰的成员变量
    14.         Field[] fields = personClass.getFields();
    15.         for (Field field : fields) {
    16.             System.out.println(field);
    17.         }
    19.         System.out.println("------------------");
    20.         Field a = personClass.getField("a");
    22.         //获取成员变量a的值
    23.         Person person = new Person();
    24.         Object o = a.get(person);
    25.         System.out.println(o);
    27.         a.set(person, "张三");
    28.         System.out.println(person);
    30.         System.out.println("===================");
    31.         Field[] declaredFields = personClass.getDeclaredFields();
    32.         for (Field declaredField : declaredFields) {
    33.             System.out.println(declaredField);
    34.         }
    36.         //field getDeclaredField（String name）
    37.         Field d = personClass.getDeclaredField("d");
    38.         //忽略访问权限修饰符的安全检查
    39.         d.setAccessible(true);//暴力反射
    40.         Object o1 = d.get(person);
    41.         System.out.println(o1);
    42.     }
    43. }

    Constructor：构造方法
    创建对象：
    T newInstance（Object……initargs）

    如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance

    获取构造方法：

    1. package HeiMa.Reflect;/*
    3.     @create 2020--12--24--20:55
    4. */
    6. import java.lang.reflect.Constructor;
    7. import java.lang.reflect.Field;
    9. public class ReflectDemo2 {
    10.     public static void main(String[] args) throws Exception {
    11.         //获取person的class对象
    12.         Class personClass = Person.class;
    14.         Constructor constructor = personClass.getConstructor(String.class, int.class,String.class,String.class,String.class,String.class);
    15.         System.out.println(constructor);
    16.         //创建对象
    17.         Object person = constructor.newInstance("张三", 28,"a","b","c","d");
    18.         System.out.println(person);
    20.         System.out.println("---------------------");
    22.         Constructor constructor1 = personClass.getConstructor();
    23.         System.out.println(constructor1);
    25.         //创建对象
    26.         Object o = constructor1.newInstance();
    27.         System.out.println(o);
    29.         Object o1 = personClass.newInstance();
    30.         System.out.println(o1);
    32.     }
    33. }

    Method：方法对象
    执行方法
    Object invoke（Object obj，Object…… args）

    获取方法名称：
    String getName：获取方法名

    获取方法对象及方法名：

    1. package HeiMa.Reflect;/*
    3.     @create 2020--12--24--20:55
    4. */
    6. import java.lang.reflect.Constructor;
    7. import java.lang.reflect.Method;
    9. public class ReflectDemo3 {
    10.     public static void main(String[] args) throws Exception {
    11.         //获取person的class对象
    12.         Class personClass = Person.class;
    14.         //获取指定名称的方法
    15.         Method eat = personClass.getMethod("eat");
    16.         Person p = new Person();
    17.         //执行方法
    18.         eat.invoke(p);
    20.         Method eat1 = personClass.getMethod("eat", String.class);
    21.         //执行方法
    22.         eat1.invoke(p, "饭");
    24.         System.out.println("-----------");
    26.         //获取所有public修饰的方法
    27.         Method[] methods = personClass.getMethods();
    28.         for (Method method : methods) {
    29.             System.out.println(method);
    30.             System.out.println(method.getName());
    31.         }
    33.         //获取类名
    34.         String name = personClass.getName();
    35.         System.out.println(name);
    36.     }
    37. }

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

    Java反射机制是Java中底层的一个功能，就是通过这个机制可以进行对象的灵活的调用和处理
    在后期学习中会用到反射的相关的内容，但是都是底层的理解，比如：文件的加载，spring框架底层……

    目前我们讲反射是讲解反射的使用

    Java中提供了一个api - Class用于反射机制的一个类
    是在Java.lang包下的，不需要导包

    当前案例演示利用反射的机制获取对象的属性

    1. package Test25_Demo.TestDemo2;/*
    3.     @create 2020--12--18--10:14
    4. */
    6. import org.junit.Test;
    8. public class ReflectDemo {
    9.     //新建对象的获取直接使用反射获取 - 不适用new
    11.     //单元测试
    12.     @Test
    13.     public void test1() {
    14.         //已知明确的类型，获取Class对象
    15.         Class clazz = Student.class;
    16.         System.out.println(clazz);//class Test25_Demo.TestDemo2.Student
    17.     }
    19.     @Test
    20.     public void test2() {
    21.         //已知对象获取class对象
    22.         Student s = new Student();
    23.         Class clazz = s.getClass();//getClass()是顶级父类Object中的方法
    24.         System.out.println(clazz);//class Test25_Demo.TestDemo2.Student
    25.     }
    27.     @Test
    28.     public void test3() throws ClassNotFoundException {
    29.         //完全限定名（包名.类名)，获取Class对象 - 比较常用 - 安全
    30.         String className = "Test25_Demo.TestDemo2.Student";
    31.         //forName()返回这个地址值所对应的类
    32.         Class<?> aClass = Class.forName(className);
    33.         System.out.println(aClass);//class Test25_Demo.TestDemo2.Student
    34.     }
    36.     //测试结果：通过不同的反射获取的对象是同一个
    37.     @Test
    38.     public void test4() throws ClassNotFoundException {
    39.         Class clazz1 = Student.class;
    40.         Student s1 = new Student();
    41.         Class clazz2 = s1.getClass();
    42.         String className = "Test25_Demo.TestDemo2.Student";
    43.         Class<?> aClass = Class.forName(className);
    45.         //比较
    46.         System.out.println(clazz1 == clazz2);//true
    47.         System.out.println(clazz2 == aClass);//true
    48.         System.out.println(clazz1 == aClass);//true
    49.     }
    50. }
    1. package Test25_Demo.TestDemo2;/*
    3.     @create 2020--12--18--10:14
    4. */
    6. import org.junit.Test;
    8. import java.lang.reflect.Constructor;
    9. import java.lang.reflect.InvocationTargetException;
    11. /**
    12.  * 通过Java反射机制构建对象的测试 - 这些操作平时只要我们创建对象，内存中就偷偷的帮我们做了
    13.  * 步骤：
    14.  * 1.创建该类的Class对象
    15.  * 2.利用Class对象去创建类对象
    16.  * 3.利用Class对象中的newInstance方法创建对象，类中有公共的无参构造方法
    17.  * 4.最后获取Class类中的构造函数对象，通过构造函数创建实例对象
    18.  */
    19. public class ReflectDemo2 {
    20.     @Test
    21.     public void test01() throws IllegalAccessException, InstantiationException {
    22.         //类中有无参构造方法
    23.         Class clazz = Student.class;
    24.         Object obj = clazz.newInstance();//默认调用的是无参的 - 创建实例
    25.         System.out.println(clazz);//class Test25_Demo.TestDemo2.Student
    26.         System.out.println(obj);//Student{id=0, name='null'} - 当前的Object进行了向下转型给了反射获取到的类Student
    28.     }
    30.     @Test
    31.     public void test02() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    32.         //获取Class类中的构造函数对象
    33.         Class clazz = Student.class;
    34.         //获取到构造函数 - 有参
    35.         Constructor constructor = clazz.getConstructor(int.class, String.class);
    36.         //通过构造函数为属性赋值
    37.         Object tom = constructor.newInstance(20, "Tom");//Student{id=20, name='Tom'}
    38.         System.out.println(tom);
    39.     }
    41.     //演示普通的方式实例化对象做不到的事情
    42.     @Test
    43.     public void test03() {
    44.         Student s = new Student();
    45.         s.setId(1);
    46.         //s.setName();//不能进行name的赋值，因为方法是私有的
    47.         System.out.println(s);//Student{id=1, name='null'}
    48.     }
    49. }