Java反射机制基础

反射：框架设计的灵魂

（1）反射机制：将类的各个组成部分——>封装为其它对象。

• Class类对象：将字节码文件通过类加载器加载到内存中，将其中的成员变量封装为field对象，将构造方法封装为Constructor对象，将成员方法封装为Method对象（方法都放在method[]中），这些统一为Class类对象（Class class;）。
  ——本质：获取Class对象后，反向获取Person对象的各种信息。

好处：
1.可以在程序的运行过程中去操作这些对象
2.可以解耦（通过降低程序的耦合性，来提高程序的可扩展性）

反射的用途：
1、在运行时获得类的各种内容，进行反编译：.class–>.java，对于Java这种先编译再运行的语言，能够让我们很方便的创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代码的链接，更加容易实现面向对象。

2、通过反射机制访问java对象的属性，方法，构造方法等

3、当我们在使用IDE,比如Ecplise时，当我们输入一个对象或者类，并想调用他的属性和方法时，一按点号，编译器就会自动列出他的属性或者方法，这里就是用到反射。

4、反射最重要的用途就是开发各种通用框架。比如很多框架（Spring）都是配置化的（比如通过XML文件配置Bean），为了保证框架的通用性，他们可能需要根据配置文件加载不同的类或者对象，调用不同的方法，这个时候就必须使用到反射了，运行时动态加载需要的加载的对象。

（2）获取Class对象的方式

对于不同的阶段，采用不同的方式：

• 方式一、源代码阶段：可通过Class.forName(“全类名(包名.类名)”)：将字节码文件加载进内存，返回class对象；
  ——多用于配置文件中，将类名定义在配置文件中，读取文件，加载类。

• 方式二、Class类对象阶段：如果已经将字节码文件加载进内存，class类对象已经有了，通过类名.class获取
  ——多用于参数的传递

• 方式三、Runtime运行时阶段：已经创建了实例对象，可以通过对象.getClass() 来获取（getClass()方法是在Object类中定义的）
  ——多用于对象获取字节码的方式

先写一个Person类：

package com.atguigu.test;

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

    public String a;
    protected String b;
    String c;
    private String d;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
}

获取对象：

package com.atguigu.test;

public class ReflectDemo1 {
    public static void main(String[] args) throws Exception {
        //1.Class.forName("全类名")
        Class cls1 = Class.forName("com.atguigu.test.Person");
        System.out.println(cls1);
        //2.类名.class
        Class<Person> cls2 = Person.class;
        System.out.println(cls2);
        //3.对象.getClass()
        Person p = new Person();
        Class cls3 = p.getClass();
        System.out.println(cls3);
        //对比三个对象
        System.out.println(cls1 == cls2);//true
        System.out.println(cls1 == cls3);//true
    }
}

——也由此可知：三种方式所创建的三个对象都一致。

结论：同一个字节码文件（.class文件）在一次程序运行过程中，只会被加载一次，之后无论通过哪种方式去获取Class对象，都会是同一个对象。
（每一个字节码文件对应的class类对象不同）

（3）Class对象的功能

• 获取功能
  ① 获取成员变量们：Field[ ] getFields()；
  ② 获取构造方法们：
  ③ 获取成员方法们
  ④ 获取类名：String getName()；

① 获取成员变量们

Field：成员变量
1.设置值：void set(Object obj,Object value);
2.获取值：get(Object obj)
3.忽略访问权限修饰符的安全检查（为了访问private成员）——d.setAccessible(true)：暴力反射

验证①：
（1）getFields()和getField()——获取成员变量

package com.atguigu.test;

import java.lang.reflect.Field;

public class ReflectDemo2 {
    //Field对象的方法
    public static void main(String[] args) throws Exception {
        Class personClass = Person.class;//获取class对象，第二种方式
        //Field[] getFields()获取所有public修饰的成员变量

        //（1）获取成员变量们：Field[] getFields()；
        Field[] fields = personClass.getFields();//成员变量们
        for(Field field : fields){
            System.out.println(field);
        }

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

        //（2）获取特定的成员变量
        Field a = personClass.getField("a");//获取成员变量a，a是在Person中定义的public成员变量
        Person p = new Person();
        Object value = a.get(p);//获取成员变量a的对象
        System.out.println(value);//未设置值，为null
        //设置a的值
        a.set(p,"张三");
        System.out.println(p);
    }
}

运行结果：

（2）验证①：获取所有成员变量：getDeclaredFields()，包括public、private和proteced

		//（3）获取所有成员变量
        Field[] declaredFields = personClass.getDeclaredFields();
        for(Field declaredField : declaredFields){
            System.out.println(declaredField);
        }
        //（4）获取特定的成员变量
        Field d = personClass.getDeclaredField("d");
        //忽略访问权限修饰符的安全检查（为了访问private成员）
        d.setAccessible(true);//暴力反射
        Object value2 = d.get(p);
        System.out.println(value2);
        //获取私有成员d的信息
        d.set(p,"张三");
        System.out.println(p);

【注意】：private String d被获取到了！所以反射机制甚至可以获取私有的成员变量信息！

getFields与getDeclaredFields的区别：

• getField()是获取当前类public声明的属性，包括集成而来的public修饰的属性；

• getDeclaredFields()获取的是当前类声明的所有属性，包括private ，protect，public 修饰的类，但是不包括集成自父类的属性

② 获取构造方法们

Constructor构造方法： （构造器用于创建对象）
创建对象：

• T newInstance(Object obj,Object value)
• 如果使用空参构造方法创建对象，操作可以简化：class对象的newInstance方法

package com.atguigu.test;
import java.lang.reflect.Constructor;

public class ReflectDemo2 {
    //Field对象的方法
    public static void main(String[] args) throws Exception {
        Class personClass = Person.class;//获取class对象，第二种方式
        //获取构造方法
        //Constructor<T> getConstructor(类<?>... parameterTypes)
        
        System.out.println("------获取带参构造-----");
        //(1)使用带参构造器创建对象
        Constructor constructor1 = personClass.getConstructor(String.class,int.class);
        System.out.println(constructor1);
        //创建对象
        Object person = constructor1.newInstance("张三",23);
        System.out.println(person);

        System.out.println("------获取无参构造-----");
        //（2）使用无参构造器创建对象
        //如果使用空参构造方法创建对象，操作可以简化：class对象的newInstance方法
        Object o = personClass.newInstance();
        System.out.println(o);
    }
}

——Spring动态代理要用到：newInstance()方法

③ 获取成员方法们

• Method[ ] getMethods();——获取成员方法（括号内根据有参无参可传参）
• Method[ ] getDeclaredMethods();——获取所有成员方法
  Method[ ] getMethods() = personClass.getMethods();
  String name = method.getName()；

验证略。。。

获取类名
String className = personClass.getName()：