Was ist Java-Reflektion? Detaillierte Einführung in den Java-Reflexionsmechanismus

Der Inhalt dieses Artikels befasst sich mit der Frage, was Java-Reflexion ist. Die detaillierte Einführung in den Java-Reflexionsmechanismus hat einen gewissen Referenzwert. Ich hoffe, dass sie für Sie hilfreich ist.

1. Konzept

Java-Reflektion (Reflection) bedeutet, dass das Java-Programm, wenn es ausgeführt wird, eine Klasse laden kann, deren Name nur bekannt ist, die vollständige Konstruktionsmethode der Klasse erhalten kann und Instanziieren Sie das Objekt, indem Sie Werte für Objekteigenschaften festlegen oder Objektmethoden aufrufen. Diese Funktion zum dynamischen Abrufen von Klasseninformationen und zum dynamischen Aufrufen von Objektmethoden zur Laufzeit wird als Java-Reflexionsmechanismus bezeichnet.

2. Class-Klasse

Die Class-Klasse erbt von der Object-Klasse und ist der Eingang zum Java-Reflexionsmechanismus. Sie kapselt die Laufzeitinformationen einer Klasse oder Schnittstelle und kann durch Aufrufen abgerufen werden die Methode der Class-Klasse. Wie ist diese Klassenklasse zu verstehen? Wenn eine gewöhnliche Klasse eine Sammlung aller Objektmethoden und -attribute ist, kann diese Klassenklasse als Sammlung aller gewöhnlichen Klassen verstanden werden.

Im Folgenden sind mehrere Methoden zum Abrufen der Klassenklasse aufgeführt:

public class TestClass {
    public static void main(String[] args) throws ClassNotFoundException {
        // 1、 Class.forName();
        Class<?> aClass0 = Class.forName("java.lang.Object");
        // 2、类名.Class
        Class<Integer> aClass1 = Integer.class;
        // 3、包装类.TYPE —— 返回基本类型的 Class 引用，基本类型在虚拟机运行时就已经加载了它的Class
        Class<Integer> aClass2 = Integer.TYPE;
        // 4、对象名.getClass()
        String str = "Hello, World";
        Class<? extends String> aClass3 = str.getClass();
        // 5、Class类.getSuperClass() —— 获得父类的 Class 对象
        Class<?> aClass4 = aClass3.getSuperclass();

        System.out.println(aClass0.getName());
        System.out.println(aClass1.getName());
        System.out.println(aClass2.getName());
        System.out.println(aClass3.getName());
        System.out.println(aClass4.getName());
    }
}

3. Abrufen von Klasseninformationen

Um den Reflexionsmechanismus von Java zu testen, habe ich ein Paar erstellt Übergeordnete und untergeordnete Klassen. Es umfasst vier Kapselungsattribute, um die Erfassung mehrerer Arten von Informationen so weit wie möglich zu testen:

Vehicle.java

vpublic class Vehicle {
    private String color;
    protected Integer seat;
    int year;
    public Date createdOn;
    private String getColor() {
        return color;
    }
    protected Integer getSeat() {
        return seat;
    }
    int getYear() {
        return year;
    }
    public Date getCreatedOn() {
        return createdOn;
    }
}

Car.java

public class Car extends Vehicle {
    private String brand;
    protected Integer a;
    int b;
    public Date updatedOn;
    public Car(){}
    private Car(String brand, Integer a, int b, Date updatedOn) {
        this.brand = brand;
        this.a = a;
        this.b = b;
        this.updatedOn = updatedOn;
    }
    private String getBrand() {
        return brand;
    }
    protected Integer getA() {
        return a;
    }
    int getB() {
        return b;
    }
    public Date getUpdatedOn() {
        return updatedOn;
    }
}

1. Methoden abrufen

Klasse ruft Methoden hauptsächlich auf die folgenden zwei Arten ab:

Methode[] getMethods() gibt alle zugänglichen öffentlichen Methoden der Klasse zurück oder Schnittstelle (einschließlich geerbter öffentlicher Methoden).

Method[] getDeclaredMethods() Gibt alle Methoden dieser Klasse oder Schnittstelle zurück (ausgenommen geerbte Methoden).

public class TestMethod {
    public static void main(String[] args) {
        Class<Car> carClass = Car.class;
        Method[] methods = carClass.getMethods();
        Method[] declaredMethods = carClass.getDeclaredMethods();

        for (Method method : methods) {
        //for (Method method : declaredMethods) {
            System.out.println("方法名：" + method.getName());
            System.out.println("该方法所在的类或接口：" + method.getDeclaringClass());
            System.out.println("该方法的参数列表：" + method.getParameterTypes());
            System.out.println("该方法的异常列表：" + method.getExceptionTypes());
            System.out.println("该方法的返回值类型：" + method.getReturnType());
        }
    }
}

2. Attribute abrufen

Klasse ruft Attribute hauptsächlich auf die folgenden zwei Arten ab:

Field[] getFields(): Speicher Alle zugänglich öffentliche Eigenschaften dieser Klasse oder Schnittstelle (einschließlich geerbter öffentlicher Eigenschaften).

Field[] getDeclaredFields(): Speichert alle Eigenschaften der Klasse oder Schnittstelle (ausgenommen geerbte Eigenschaften).

public class TestField {
    public static void main(String[] args) {
        Class<Car> carClass = Car.class;
        Field[] fields = carClass.getFields();
        Field[] declaredFields = carClass.getDeclaredFields();
        //for (Field field : fields) {
        for (Field field : declaredFields) {
            System.out.println("属性名称是：" + field.getName());
            System.out.println("该属性所在的类或接口是：" + field.getDeclaringClass());
            System.out.println("该属性的类型是：" + field.getType());
            // field.getModifiers() 以整数形式返回由此 Field 对象表示的属性的 Java 访问权限修饰符
            System.out.println("该属性的修饰符是：" + Modifier.toString(field.getModifiers()));
        }
    }
}

3. Erhalten Sie den Konstruktor

Die Class-Klasse erhält die Konstruktormethode hauptsächlich auf die folgenden zwei Arten:

Konstruktor[ ] getConstructors(): Gibt alle öffentlichen Konstruktoren der Klasse oder Schnittstelle zurück

Constructor[] getDeclaredConstructors(): Gibt alle Konstruktoren der Klasse oder Schnittstelle zurück

public class TestConstructor {
    public static void main(String[] args) throws NoSuchMethodException {
        Class<Car> carClass = Car.class;
        Constructor<?>[] constructors = carClass.getConstructors();
        Constructor<?>[] declaredConstructors = carClass.getDeclaredConstructors();
        Constructor<Car> carConstructor = carClass.getDeclaredConstructor(String.class, Integer.class, Integer.TYPE, Date.class);
        //for (Constructor constructor : declaredConstructors) {
        for (Constructor constructor : constructors) {
            System.out.println("该构造器的名称是：" + constructor.getName());
            System.out.println("该构造器所在的类或接口是：" + constructor.getDeclaringClass());
            //返回构造方法的参数类型
            constructor.getParameterTypes();
        }
    }
}

four , Dynamischer Aufruf

Bisher haben wir über die Methoden der Class-Klasse detaillierte Informationen zu den entsprechenden Klassenattributen, Methoden und Konstruktoren erhalten. Als nächstes werden wir diese Informationen verwenden, um Objekte dynamisch zu erstellen, Eigenschaften zu ändern und Methoden dynamisch aufzurufen.

public class Test {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class<Car> carClass = Car.class;
        // 1、实例化对象
        // 调用 Class 类的newInstance()；要求对应类必须有无参构造函数，相当于 Car car = new Car()
        Car car = carClass.newInstance();
        // 调用构造器的newInstance(Object ... initargs);
        Constructor<Car> declaredConstructor = carClass.getDeclaredConstructor(String.class, Integer.class, Integer.TYPE, Date.class);
        // 取消访问权限控制，即使是 private 权限也可以访问
        declaredConstructor.setAccessible(true);
        Car car1 = declaredConstructor.newInstance("brand", 21, 21, new Date());
        System.out.println(car1.getUpdatedOn());

        // 2、修改属性
        Field brand = carClass.getDeclaredField("brand");
        brand.setAccessible(true);
        System.out.println("取消访问权限控制后的值：" + brand.get(car1));
        brand.set(car1, "dnarb");
        System.out.println("修改属性后的值是：" + brand.get(car1));

        // 3、调用方法
        Method getBrand = carClass.getDeclaredMethod("getBrand");
        getBrand.setAccessible(true);
        System.out.println("调用反射方法得到的值是：" + getBrand.invoke(car1));
    }
}

Das obige ist der detaillierte Inhalt vonWas ist Java-Reflektion? Detaillierte Einführung in den Java-Reflexionsmechanismus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!