JAVA反射

动态语言

动态语言是指在程序运行过程当中可以改变其结构，可以引进新函数，已有的函数可以被删除等结构上的变化，比如 JavaScript，Python。从反射的角度来说，JAVA属于半动态语言

反射机制

在程序运行的过程当中，任意一个类都有可以知道这个类所有的属性和方法，任何一个对象都可以调用他的任何一个方法

反射的应用场景

java 的对象在运行时会出现两种类型：编译时类型和运行时类型

编译时类型是声明对象时决定的，运行时类型是实际给赋值给对象的类型决定的

比如：

Person person = new Student();
// Person为编译类型
// Student 为运行时类型

反射适用于在编译时无法知道该对象的类，只能靠运行时的信息发现该对象的类的信息。

比如该对象的编译类型时Object

JAVA的反射API

1. Class类：反射类，可以获取类的信息
2. Field 类：表示类的成员变量
3. Method类：表示类的方法
4. Constructor类：表示类的构造方法

反射的使用步骤

获取Class对象 -> 调用对象方法

Class对象是反射的核心，通过Class对象可以调用任意类的方法

获取Class对象的方法

一、调用某个类的getClass方法

Person person = new Person();
Class aClass = person.getClass();

二、 调用某个类的class属性获取该类的Class对象

Class aClass = Person.class;

三、 使用Class类中的forName()方法（最常用）

Class aClass = Class.forName("类的全路径名")

创建对象的方法

一 、 调用Class对象的newInstance()

要求该Class对象对应的类必须由空参构造器

二、 调用Constructor对象的new Instance()

应用实例

person类

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

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

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

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

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


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && money == person.money && Objects.equals(name, person.name);
    }

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

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

    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;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

测试类

public class test {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {

        // 获取Person类的class对象
        Class aClass = Class.forName("Test.Person");
        System.out.println(aClass);
		
        // 获取Person类所有的方法信息
        Method[] declaredMethods = aClass.getDeclaredMethods();
        for (Method m : declaredMethods) {
            System.out.println(m.toString());
        }
		// 获取Person类所有的成员变量信息
        Field[] declaredFields = aClass.getDeclaredFields();
        for (Field f : declaredFields) {
            System.out.println(f.toString());
        }
		// 获取Person类所有的构造方法信息
        Constructor[] declaredConstructors = aClass.getDeclaredConstructors();
        for (Constructor c : declaredConstructors) {
            System.out.println(c.toString());
        }

        // 使用newInstance创建对象
        Person person = (Person)aClass.newInstance();

        // 调用构造方法来创建对象
        // 获取构造方法
        Constructor declaredConstructors1 = aClass.getDeclaredConstructor(String.class, int.class, int.class);

        // 创建对象
        Person jx = (Person)declaredConstructors1.newInstance("jx", 19, 10000);
        System.out.println(jx);
    }
}