Reflexionsmechanismus in Java

Der Reflexionsmechanismus von Java ist eine der Eigenschaften von Java. Der Reflexionsmechanismus ist die Grundlage für die Erstellung der Framework-Technologie. Durch die Verwendung von Reflexion kann das Programm flexibler gemacht und eine harte Codierung des Programms im Code vermieden werden. Im Vergleich zu vielen Anfängern, die nur mit den Grundlagen von Java vertraut sind, ist Reflexion immer noch ein sehr vages und schwieriges Konzept. Lassen Sie uns über einige Anwendungen der Reflexion sprechen.

Der Java-Reflexionsmechanismus bezieht sich auf die Funktion des dynamischen Abrufens von Informationen und des dynamischen Aufrufs von Objektmethoden im laufenden Zustand. Die Java-Reflektion verfügt über drei dynamische Eigenschaften: 1. Generieren von Objektinstanzen zur Laufzeit, 2. Aufrufen und Ausgeben während der Laufzeit, 3. Ändern von Attributen zur Laufzeit.

Was ist also das Prinzip der Reflexion? Dann müssen wir uns zunächst den Ausführungsprozess des Java-Programms ansehen. Wenn das Java-Programm ausgeführt werden soll, muss die Java-Klasse von der Java Virtual Machine geladen werden. Beim Ausführen eines Programms werden die benötigten Klassen bereits beim Kompilieren geladen. Ich muss es hier erwähnen. Ich glaube, dass viele Leute keine klare Vorstellung davon haben, was Kompilierungszeit ist und was Laufzeit ist, wenn der Compiler Ihnen hilft, den Code in Code zu übersetzen, den das Gerät erkennen kann Beispielsweise führt der Compiler während der Kompilierung einige einfache Arbeiten durch, z. B. die Überprüfung, ob Ihre Syntax fehlerhaft ist, ob beim Schreiben von Schlüsselwörtern oder Namen Fehler vorliegen und ob Klassen geladen werden müssen , aber was macht es zur Laufzeit? Laufzeit ist, wenn Ihr Programm in den Speicher geladen wird. Die Laufzeitprüfung besteht darin, Operationen und Beurteilungen in Ihrem Speicher durchzuführen:

 int[] nums = new int[3];
        nums[4] = 12;

Offensichtlich Der obige Code verursacht einen Array-Index außerhalb der Grenzen, aber das Programm meldet beim Kompilieren keinen Fehler, sondern beim Ausführen einen ArrayIndexOutOfBoundsException-Fehler. Dies ist der Unterschied zwischen Kompilierung und Laufzeit.

Der Java-Reflexionsmechanismus bestimmt nicht, welche Klasse beim Kompilieren geladen wird. Er wird geladen und verwendet, wenn das Programm ausgeführt wird. Schauen wir uns den Ausführungsprozess der Reflexion an:

Der Java-Reflexionsmechanismus kann die Grundstruktur der Klasse kennen. Diese Fähigkeit, die Struktur der Java-Klasse zu erkennen, wird zur „Selbstprüfung“, wie wenn wir zum Schreiben Software wie Eclipse verwenden Code Die automatische Eingabeaufforderungsfunktion verwendet das Prinzip der Java-Reflexion. Welche Funktionen können wir also durch Javas Reflexion erreichen? 1. Bestimmen Sie zur Laufzeit die Klasse, zu der ein Objekt gehört. 2. Konstruieren Sie zur Laufzeit ein Objekt einer beliebigen Klasse. 3. Bestimmen Sie zur Laufzeit die Eigenschaften und Methoden einer beliebigen Klasse. 4. Rufen Sie zur Laufzeit eine Methode eines beliebigen Objekts auf. Zu den häufig verwendeten Klassen in der Java-Reflexion gehört die Class-Klasse: die Kernklasse der Reflektion. Über die Class-Klasse können Sie die Attribute, Methoden usw. der Klasse abrufen. Abgelegte Klasse: Stellt die Attribute der Klasse dar und kann die Werte der Attribute in der Klasse abrufen und festlegen. Methodenklasse: Stellt die Methode der Klasse dar, mit der Informationen über die Methoden in der Klasse abgerufen oder Methoden ausgeführt werden können. Konstruktorklasse: Stellt die Konstruktormethode der Klasse dar.

Okay, wir haben einige grundlegende Informationen zur Java-Reflexion gelernt. Jetzt werden wir Code verwenden, um jede Reflexionsfunktion einzeln zu implementieren:

Die erste ist auch die einfachste, First of Alles in allem müssen wir die Class-Klasse verwenden und sie zuerst instanziieren, aber die Class-Klasse hat keinen Konstruktor. Wie instanziieren wir sie? Es gibt drei Möglichkeiten, eine Class-Klasse zu erstellen:

public static void main(String[] args) { //第一种方法，通过对象.getClass()方法 User user = new User();
        Class<? extends User> cs = user.getClass();
        System.out.println(cs); //第二种方法，通过类名.class Class<User> cs1 = User.class;
        System.out.println(cs1); //第三种方法，通过Class本身的forName()方法，注意forName()方法会抛出一样，并且里面的参数需要完整的包名和类名 Class<?> cs2 = null; try {
            cs2 = Class.forName("cn.fanfu.demo.User");
        } catch (ClassNotFoundException e) { // TODO Auto-generated catch block  e.printStackTrace();
        }
        System.out.println(cs2);
    }

Die Die dritte Methode forName() kann eine Klasse instanziieren, wenn die Klasse unsicher ist, was flexibler ist.

Die zweite besteht darin, eine neue Instanz des Class-Klassenobjekts durch die parametrisierte Konstruktion der Class-Klasse zu erstellen:

public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchMethodException, IllegalArgumentException, 
InstantiationException, IllegalAccessException, InvocationTargetException { 
//在这里为了更直观的展示，直接使用String类 Class<?> cs =Class.forName("java.lang.String"); char[] ch = {&#39;大&#39;,&#39;家&#39;,&#39;好&#39;,&#39;！&#39;,&#39;！&#39;}; 
//调用Class类的有参构造函数，函数里的值为类.class Constructor<?> cst = cs.getConstructor(char[].class);
       String name = (String) cst.newInstance(ch);
       System.out.println(name); //因为这里的异常会使代码没有直观的显示，所以我直接抛给虚拟机 }

Die dritte besteht darin, die Struktur, Schnittstelle, Methoden usw. der Klasse zu erhalten. Attribute usw. Reihenelemente:

public static void main(String[] args) throws ClassNotFoundException,
            SecurityException, NoSuchMethodException, IllegalArgumentException,
            InstantiationException, IllegalAccessException,
            InvocationTargetException { //先创建好两个对象 Class<?> cs = Class.forName("cn.fanfu.demo.User");
        Constructor<?>[] con = null; //通过getConstructors()方法返回一个Constructor[]数组，数组里存储的是该类的各个构造 con = cs.getConstructors(); for (Constructor<?> item : con) {
            System.out.println(item);
        } //通过getInterfaces()方法返回一个Class<?>[]数组，数组里存储的是该类的各个接口 Class<?>[] inter = cs.getInterfaces(); for (Class<?> item : inter) {
            System.out.println(item);
        } //通过getSuperclass()方法返回一个Class<?> Class<?> parent = cs.getSuperclass(); //java中只支持单继承，所以只有一个父类  System.out.println(parent); //通过getMethods()方法返回一个Method[]数组，数组里存储的是该类的各个方法 Method[] method = cs.getMethods(); for (Method item : method) {
            System.out.println(item);
        } //通过getDeclaredFields()方法返回一个Field[]数组，数组里存储的是该类的各个属性 Field[] fiel = cs.getDeclaredFields(); for (Field item : fiel) {
            System.out.println(item);
        } //getDeclaredFields()方法可以获取全部属性，getFields()方法只能获取到公有属性 Field[] fiel1 = cs.getFields(); for (Field item : fiel1) {
            System.out.println(item);
        }
    }

Das vierte besteht darin, den Wert eines Klassenattributs abzurufen oder zu ändern:

public static void main(String[] args) throws ClassNotFoundException,
            SecurityException, NoSuchMethodException, IllegalArgumentException,
            InstantiationException, IllegalAccessException,
            InvocationTargetException, NoSuchFieldException { //创建User对象 User us = new User();
        us.setAge(12);
        us.setName("张三");
        Class<?> cs = us.getClass(); //获取私有属性的值 Field fl = cs.getDeclaredField("name"); //要先设置允许访问 fl.setAccessible(true); //通过get方法指定对象获取值 String name = (String) fl.get(us);
        System.out.println(name); //通过set方法指定对象并修改值 fl.set(us, "李四");
        String name2 = (String) fl.get(us);
        System.out.println(name2);        
    }

Das fünfte besteht darin, eine Methode durch Reflexion aufzurufen:

public static void main(String[] args) throws ClassNotFoundException,
            SecurityException, NoSuchMethodException, IllegalArgumentException,
            InstantiationException, IllegalAccessException,
            InvocationTargetException, NoSuchFieldException { //创建User对象 User us = new User();
        us.setAge(12);
        us.setName("张三");
        Class<?> cs = us.getClass(); //通过getMethod()方法获取类中方法，该方法有两个参数，一个指定方法名，一个指定方法中参数的类型 Method mm = cs.getMethod("say"); //通过invoke()方法调用方法，该方法有两个参数，一个指定对象，另一个传递参数  mm.invoke(us);
    }