JavaSE--反射-CSDN博客

本文介绍了Java中的反射机制，包括如何在运行时获取类的定义、包信息、注解、构造函数、属性和方法，以及其在处理封闭类和动态代理中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

什么是反射

反射(Reflect)是在运行状态中，对于任意一个类，都能知道这个类的属性和方法，对于任意一个对象，都能够调用它的任意一个属性和方法，这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

加载完类之后，在堆内存的方法区就产生了一个Class类型的对象，这个对象包含这个类的完整信息，可以通过这个对象查看到这个类的结构，这个对象就像一面镜子通过这个镜子看到类的结构，称之为反射。


import java.beans.JavaBean;
import java.util.Objects;

@JavaBean
public class Emp {
    private String code;
    private String name;
    private double salary;
    private int age;

    public static int num;

    public Emp(){};

    public Emp(String code, String name, double salary, int age) {
        this.code = code;
        this.name = name;
        this.salary = salary;
        this.age = age;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Emp emp = (Emp) o;
        return Double.compare(emp.salary, salary) == 0 && age == emp.age && Objects.equals(code, emp.code) && Objects.equals(name, emp.name);
    }

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

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getName() {
        return name;
    }

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

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public static void show(){
        System.out.println("");
    }


}

在使用一个封闭类时无法知晓这个类的结构，通过反射找到方法和属性

Java反射机制提供的功能

在运行时判断任意一个对象所属的类

在运行时构造任意一个类的对象

在运行时判断任意一个类所具有的成员变量和方在运行时获取泛型信息

在运行时调用任意一个对象的成员变量和方法

在运行时处理注解生成动态代理


import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

//对于一个类，可以通过反射，找到方法和属性
public class TestRef {
//类：包名，类名，方法(method)，属性(filed),注解，构造方法(constructor)
    //**通过反射3找到Emp类的定义
    public static void main(String[] args) {
        Class<Emp> empClass = Emp.class;
        System.out.println("------类型-------");
        System.out.println(empClass);
        System.out.println("------包-----");
        Package aPackage=empClass.getPackage();
        System.out.println(aPackage);
        System.out.println("-----注解-------");
        Annotation[] annotations= empClass.getAnnotations();
        for (int i = 0; i < annotations.length ; i++) {
            System.out.println(annotations[i]);
        }
        System.out.println("-------构造函数-------");
        Constructor<?>[] constructors= empClass.getConstructors();
        for (int i = 0; i < constructors.length ; i++) {
            System.out.println(constructors[i]);
        }
        System.out.println("-------属性------");
        Field[] fields= empClass.getFields();
        for (int i = 0; i < fields.length ; i++) {
            System.out.println(fields[i]);
        }
        System.out.println("-------方法------");
        Method[] methods=empClass.getMethods();
        for (int i = 0; i < methods.length ; i++) {
            System.out.println(methods[i]);
        }
    }

}