Java反射机制及其常用方法

最近的面试中也常被问到反射以及反射的延伸应用,故此篇用来回顾反射的机制以及常用方法

反射机制的概念

反射机制指在程序运行过程中，对任意一个类都能获取其所有属性和方法，并且对任意一个对象都能调用其任意一个方法。这种动态获取类和对象的信息，以及动态调用对象的方法的功能被称为Java语言的反射机制。

反射的应用

Java中的对象有两种类型:编译时类型和运行时类型。编译时类型指在声明对象时所采用的类型，运行时类型指为对象赋值时所采用的类型。
在如下代码中，person 对象的编译时类型为Person, 运行时类型为Student,因此无法在编译时获取在Student类中定义的方法:
Person persion = new Student();
因此，程序在编译期间无法预知该对象和类的真实信息，只能通过运行时信息来发现该对象和类的真实信息，而其真实信息(对象的属性和方法)通常通过反射机制来获取，这便是Java语言中反射机制的核心功能。

Java的反射API

Java的反射API主要用于在运行过程中动态生成类、接口或对象等信息，其常用API如下。

• Class类: 用于获取类的属性、方法等信息。
• Field类: 表示类的成员变量，用于获取和设置类中的属性值。
• Method类:表示类的方法，用于获取方法的描述信息或者执行某个方法。
• Constructor类: 表示类的构造方法。

反射的步骤

1. 获取想要操作的类的Class对象，该Class对象是反射的核心，通过它可以调用类的任意方法。
2. 调用Class对象所对应的类中定义的方法，这是反射的使用阶段。
3. 使用反射API来获取并调用类的属性和方法等信息。

具体示例

实体类

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

    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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;  //判断调用对象和传入对象是否是同个字节码文件.class
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

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

    public void eat(int num){
        System.out.println("今天吃了"+num+"次饭");
    }
}

1.获取Class对象

public class De01_Reflect {
    public static void main(String args[]) throws ClassNotFoundException {
        // 获取Class对象
        Class clazz = Class.forName("bean.Person");
        Class clazz2 = Person.class;

        Person p = new Person();
        Class clazz3 = p.getClass();
        System.out.println(clazz == clazz2);    //true
        System.out.println(clazz2 == clazz3);   //true
    }
}

2.反射创建实例对象

注: Class类的newInstance()方法是使用该类无参的构造函数创建对象, 如果一个类没有无参的构造函数, 就不能这样创建了,可以使用Class类的getConstructor(String.class,int.class)方法获取一个指定的构造函数然后再调用Constructor类的newInstance(“张三”,20)方法创建对象
*/

public class De03_Constructor {
 
    public static void main(String args[]) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        // 获取Class对象
        Class clazz = Class.forName("bean.Person");
        // 1.直接newInstance()创建实例
        Person pp = (Person) clazz.newInstance();
        System.out.println(pp);
        // 2.根据构造方法创建实例
        Constructor c = clazz.getConstructor(String.class,int.class);   //获取有参构造
        Person p = (Person) c.newInstance("张三",24);         //通过有参构造创建对象
        System.out.println(p);

    }
}

3.暴力反射去除私有权限

注:Class.getField(String)方法可以获取类中的指定字段(可见的),如果是私有的可以用getDeclaedField(“name”)方法获取,通过set(obj, “李四”)方法可以设置指定对象上该字段的值, 如果是私有的需要先调用setAccessible(true)设置访问权限,用获取的指定的字段调用get(obj)可以获取指定对象中该字段的值

public class De04_Field暴力反射 {
    public static void main(String args[]) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        Class clazz = Class.forName("bean.Person");
        Constructor c = clazz.getConstructor(String.class, int.class);   //获取有参构造
        Person p = (Person) c.newInstance("张三", 24);         //通过有参构造创建对象

        // 获取公共权限的字段
//        Field f = clazz.getField("name");
//        f.set(p,"李四");
        // 暴力反射获取私有权限字段
        Field f = clazz.getDeclaredField("name");
        f.setAccessible(true);      //去除private权限
        f.set(p, "李四");
        System.out.println(p);
    }
}

4.Method

注: Class.getMethod(String, Class…) 和 Class.getDeclaredMethod(String, Class…)方法可以获取类中的指定方法,使用invoke(Object, Object…)进行调用

• 无参 Class.getMethod(“eat”) invoke(obj)
• 有参 Class.getMethod(“eat”,int.class) invoke(obj,10)

public class De05_Method {
  
    public static void main(String args[]) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class clazz = Class.forName("bean.Person");
        Constructor c = clazz.getConstructor(String.class, int.class);   //获取有参构造
        Person p = (Person) c.newInstance("张三", 24);         //通过有参构造创建对象

//        Method method = clazz.getMethod("eat");     //获取eat方法(无参)
//        method.invoke(p);
        Method method = clazz.getMethod("eat", int.class);     //获取eat方法(带参数)
        method.invoke(p, 8);
    }
}

5.反射越过泛型检查

注:泛型只在编译期间有效,运行期会被擦除

public class De06_反射越过泛型检查 {
    public static void main(String args[]) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(111);
        list.add(222);

        Class clazz = Class.forName("java.util.ArrayList"); //获取字节码对象
        Method method = clazz.getMethod("add",Object.class);
        method.invoke(list,"abc");      //擦除泛型,存入String
        System.out.println(list);   //[111, 222, abc]
    }
}

6.通过配置文件加载类

1. 写一个Properties格式的配置文件，配置类的完整名称。
2. 写一个程序，读取这个Properties配置文件，获得类的完整名称并加载这个类，用反射的方式运行run方法

De08.properties文件内容

reflect.De08_DemoClass

// 要通过文件加载的类
public class De08_DemoClass {
    public void run() {
        System.out.println("welcome!");
    }
}

public class De08_配置类的完整名称 {
    public static void main(String args[]) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException {
    
        BufferedReader br = new BufferedReader(new FileReader("De08.properties"));
        Class clazz = Class.forName(br.readLine());

        De08_DemoClass demoClass = (De08_DemoClass) clazz.newInstance();    //通过字节码创建对象
        demoClass.run();
    }
}

GitHub:反射示例Demo