反射

反射是框架设计的灵魂

1. 定义

• JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法
• 对于任意一个对象，都能够调用它的任意一个方法和属性
• 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制
• 要想解剖一个类,必须先要获取到该类的字节码文件对象
• 而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象

例子

import java.lang.reflect.Method;
public class Demo1_refiect {
    public static void main(String[] args) throws Exception {
        Demo1_person person = new Demo1_person();
        person.setName("小刘");
        person.setAge(18);
        System.out.println(person);
        
        // 1.通过反射的方式，创建Demo1_person类的对象，并调用对象的setName方法，参数是小刘
        Class<?> cls1 = Class.forName("com.day22.Demo1_person");
        Object obj = cls1.newInstance();
        // 动态获取这个类的所有方法
        Method[] methods = cls1.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        Method method = cls1.getMethod("setName", String.class);
        System.out.println("单个获取："+method);
        // invoke(Object obj, Object...args)
        // 对带有指定参数的指定对象调用由此Method对象表示的底层方法
        method.invoke(obj, "小龚");
        System.out.println(obj);
    }
}
public class Demo1_person {
    public String sex;
    private String name;
    private int 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 "Demo1_person [name=" + name + ", age=" + age + "]";
    }
}

Class对象

Class对象用于描述一个正在运行的类或接口。如果类或接口被加载进内存了，内存中肯定会有该类的Class对象。

• 如何获取类的Class对象
  方式一：通过类的class属性来获得

Class cls = Person.class;

方式二：通过类的对象的getClass()方法来获得

Person p = new Person();
Class cls = p.getClass();

方式三：通过Class的静态方法forName(完整类名)来获得

Class<?> cls = Class.forName("com.xxx.Person");

例子

public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 获取对象的三种方式
        // 方式一：通过类的class属性来获得
        Class<?> cls1 = Demo1_person.class;
        System.out.println(cls1);
        // 方式二：通过类的对象的getClass()方法获得
        Demo1_person p = new Demo1_person();
        Class<?> cls2 = p.getClass();
        System.out.println(cls2);
        // 方式三：通过forName方式获得
        Class<?> cls3 = Class.forName("com.day22.Demo1_person");
        System.out.println(cls3);
    }
}

• 如何使用Class对象来创建类的对象
  使用newInstance()方法来创建对象（Class类的newInstance()方法是使用该类无参的构造函数创建对象）
  例子

Object object =  cls3.newInstance();
System.out.println(object); // Demo1_person [name=null, age=0]

Constructor构造器

• 获得一个类的Constructor对象

方法	描述
getConstructors()	获得类中所有的构造器
getConstructor(Class...parameterTypes)	获得类中指定的构造器

例子

import java.lang.reflect.Constructor;

public class Demo5_constructor {

    public static void main(String[] args) throws Exception {
        
        Class<?> cls = Class.forName("com.day22.Demo3_teacher");
        // 获取Demo3_teacher类中所有的构造方法
        Constructor<?>[] constructors = cls.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }
        // 获取指定的构造方法
        Constructor<?> constructor = cls.getConstructor(String.class, int.class);
    }
}

• 通过Constructor创建对象
  newInstance(Object...args)

// 单参数的 newInstance(Object ... initargs)  Object ... initargs===可变参数
Object obj = constructor.newInstance("小刘", 22);
System.out.println(obj);
// 打印输出
Demo3_teacher [teacherName=小刘, teacherAge=22]

Field: 通过反射来操作一个类的属性

• 获得Filed对象

方法	描述
getField(String fieldName)	获得指定字段的Field对象
getFields()	获得所有字段（父类公共的，子类公共的）的Field对象数组
getDeclaredField(String fieldName)	获得指定字段的Field对象（只有子类的，不包含父类的，包含私有的）的Field对象
getDeclaredFields()	获得所有字段（只有子类的，不包含父类的，包含私有的）的Field对象数组

例子

public class Demo3_teacher extends Demo1_person {
    public String teacherName;
    private int teacherAge;
}
import java.lang.reflect.Field;
public class Demo3_test {
    public static void main(String[] args) throws Exception {       
        Class<?> cls = Class.forName("com.day22.Demo3_teacher");
        // 获取指定字段的Field对象
        Field f =  cls.getField("teacherName");
        System.out.println(f);
        // 获得Teacher类中的所有字段（父类公共的，子类公共的）的Filed对象数组——属性
        // 假如Teacher父类中有一个Sex属性，getFields()也能获取
        Field[] fields = cls.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        // 获取指定字段的Field对象（有子类的，不包含父类的，包含私有的Field对象）
        Field df = cls.getDeclaredField("teacherAge");
        System.out.println(df);
        // 获得所有字段（只有子类的，不包含父类的，包含私有的）的Field对象数组——属性
        fields = cls.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
    }
}
// 打印输出
public java.lang.String com.day22.Demo3_teacher.teacherName
public java.lang.String com.day22.Demo3_teacher.teacherName
public java.lang.String com.day22.Demo1_person.sex
private int com.day22.Demo3_teacher.teacherAge
public java.lang.String com.day22.Demo3_teacher.teacherName
private int com.day22.Demo3_teacher.teacherAge

• 通过Field对象为属性赋值
  set([Object obj,Object value)
  将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
  例子

// 获得Teacher类中的名字属性 teacherName
Field ft = cls.getField("teacherName");
// 先创建对象
Object obj = cls.newInstance();
ft.set(obj, "小刘");
System.out.println(obj);

Method:操作类中的方法

• 获得Method对象

方法	描述
getMethods()	获取类中所有的公共方法，包括父类的公共方法
getMethod(String methodName, Class...parametersType)	获取类中指定的方法，公共的，包括父类的公共的方法
getDeclaredMethods()	获取本类的所有的方法，包括私有的
getDeclaredMethod(String methodName, Class... parametersType)	获取本类的指定的方法，可以是私有的

例子

import java.lang.reflect.Method;

public class Demo4_method_test {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Class<?> cls = Class.forName("com.day22.Demo3_teacher");
        // 获得类中所有的公共的，包括父类的公共方法
        Method[] methods = cls.getMethods();
        for (Method method2 : methods) {
            System.out.println(method2);
        }
        // 获得类中指定的公共的方法，包括父类的公共方法
        /**
         * @param name 指定的方法名字
         * @param parameterTypes 指定的方法名的参数类对象，可以写多个
         * */
        Method method3 = cls.getMethod("eat", String.class, Integer.class);
        System.out.println(method3);
        
        // 获取本类中的所有方法包括私有的方法
        Method[] dms = cls.getDeclaredMethods();
        for (Method method : dms) {
            System.out.println(method);
        }
        // 获得本类中指定的方法，可以是私有的
        /**
         * @param name 指定的方法名字
         * @param parameterTypes 指定的方法名的参数类对象，可以写多个，如果要查找的方法没有参数，不写
         * */
        Method method4 = cls.getDeclaredMethod("show");
        System.out.println(method4);
    }
}

• Method方法的调用
  使用invoke()方法进行调用

method.invoke(被调用方法的对象，实参列表)

例子

// Method方法的调用
        
        Class<?> clsm = Class.forName("com.day22.Demo3_teacher");
        // 获取指定的某个方法
        Method method5 = clsm.getMethod("eat", String.class, int.class);
        //先需要有Teacher对象
        Object obj = clsm.newInstance();
        // 方法的调用
        method5.invoke(obj, "小刘", 18 ); // 输出teacher public eat(String a, int b) function

反射案例

• 通过反射，越过泛型检查

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class Demo7_overriding_generics {
    // 通过反射越过泛型检查
    public static void main(String[] args) throws Exception {
        List<String> list = new ArrayList<>();
        list.add("小刘");
//      list.add(123);  // 编译错误
        Class<?> cls = Class.forName("java.util.ArrayList");
        Method method = cls.getMethod("add", Object.class);
        // 通过invoke方法，method可以调用list中的方法
        method.invoke(list, 123);
        System.out.println(list); // 打印输出[小刘, 123]
    }
}

我们使用泛型就是为了使运行时错误提前到了编译期，而使用反射，我们可以在运行时期将不相同的元素写入List集合，这就是通过反射越过泛型检查

• Properties类的使用
  Properties是描述一个属性集（键值对），它是一个Hashtable，可以通过Properties来读取外部文件存放的键值对。
  例子

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
public class Demo8_properties {
    public static void main(String[] args) throws IOException {
        // 1.创建Properties对象
        Properties properties = new Properties();
        // 2. 加载配置文件到properties中
        properties.load(new FileInputStream("src/com/day22/info.properties"));
        // 获取外部文件中的键值对
        System.out.println(properties.getProperty("name"));
    }
}