Java Reflection API-Tutorial mit Beispiel

Was ist Reflexion in Java?

Java Reflection ist der Prozess der Analyse und Modifizierung aller Fähigkeiten einer Klasse zur Laufzeit. Die Reflection-API in Java Wird verwendet, um eine Klasse und ihre Elemente, einschließlich Felder, Methoden, Konstruktoren usw., zur Laufzeit zu manipulieren.

Ein Vorteil der Reflection API in Java Das Problem ist, dass es auch die privaten Mitglieder der Klasse manipulieren kann.

Das Paket java.lang.reflect stellt zahlreiche Klassen zur Implementierung von Reflection bereit. Die Methoden der Klasse java.lang.Class dienen dazu, die vollständigen Metadaten einer bestimmten Klasse zu erfassen.

Klasse im java.lang.reflect-Paket

Es folgt eine Liste von verschiedene Java Unterricht im java.lang.reflect-Paket zur Implementierung von Reflection:

• Feld: Diese Klasse dient dazu, deklarative Informationen wie Datentyp, Zugriffsmodifizierer, Name und Wert einer Variablen zu erfassen.
• Anleitung: Diese Klasse dient dazu, deklarative Informationen wie Zugriffsmodifizierer, Rückgabetyp, Name, Parametertypen und Ausnahmetyp einer Methode zu erfassen.
• Bauherr: Diese Klasse dient dazu, deklarative Informationen wie den Zugriffsmodifizierer, den Namen und die Parametertypen eines Konstruktors zu erfassen.
• Modifikator: Diese Klasse dient dazu, Informationen über einen bestimmten Zugriffsmodifikator zu sammeln.

In java.lang.Class verwendete Methoden

• public String getName(): Gibt den Namen der Klasse zurück.
• public Class getSuperclass(): Gibt die Referenz auf die Oberklasse zurück.
• public Class[] getInterfaces(): Gibt ein Array von Schnittstellen zurück, die von der angegebenen Klasse implementiert werden.
• public int getModifiers(): Gibt einen ganzzahligen Wert zurück, der die Modifikatoren der angegebenen Klasse darstellt und als Parameter an die Methode „public static String toString(int i)“ übergeben werden muss, welche den Zugriffsspezifizierer für die gegebene Klasse zurückgibt.

So erhalten Sie vollständige Informationen zu einer Klasse

Um Informationen zu erhalten VariablenUm die Methoden und Konstruktoren einer Klasse zu verwenden, müssen wir ein Objekt dieser Klasse erstellen. Das folgende Beispiel zeigt verschiedene Möglichkeiten, ein Objekt der Klasse „Class“ zu erstellen:

public class Guru99ClassObjectCreation {
    public static void main(String[] args) throws ClassNotFoundException {
        // 1 - By using Class.forName() method
        Class c1 = Class.forName("Guru99ClassObjectCreation");
        // 2 - By using getClass() method
        Guru99ClassObjectCreation guru99Obj = new Guru99ClassObjectCreation();
        Class c2 = guru99Obj.getClass();
        // 3 - By using .class
        Class c3 = Guru99ClassObjectCreation.class;
    }
}

Beispiel 1: Wie man Metadaten einer Klasse erhält

Das folgende Beispiel zeigt, wie man Metadaten wie den Klassennamen, den Namen der Oberklasse, implementierte Schnittstellen und Zugriffsmodifizierer einer Klasse erhält.

Wir werden die Metadaten der unten stehenden Klasse abrufen, die heißt Guru99Base.class:

import java.io.Serializable;
public abstract class Guru99Base implements Serializable, Cloneable {
}

1. Der Name der Klasse lautet: Guru99Base
2. Die Zugriffsmodifikatoren sind: öffentlich und abs.tract
3. Es verfügt über implementierte Schnittstellen: Serialisierbar und Klonbar
4. Da es keine Klasse explizit erweitert hat, ist seine Oberklasse: java.lang.Object

Die folgende Klasse ruft die Metadaten ab. Guru99Base.class und drucke es aus:

import java.lang.reflect.Modifier;
public class Guru99GetclassMetaData {
    public static void main(String[] args) throws ClassNotFoundException {
        // Create Class object for Guru99Base.class
        Class<Guru99Base> guru99ClassObj = Guru99Base.class;

        // Print name of the class
        System.out.println("Name of the class is : " + guru99ClassObj.getName());

        // Print super class name
        System.out.println("Name of the super class is : " + guru99ClassObj.getSuperclass().getName());

        // Get the list of implemented interfaces using getInterfaces() method
        Class[] guru99InterfaceList = guru99ClassObj.getInterfaces();

        // Print the implemented interfaces using a for-each loop
        System.out.print("Implemented interfaces are : ");
        for (Class guru99class1 : guru99InterfaceList) {
            System.out.print(guru99class1.getName() + " ");
        }
        System.out.println();

        // Get access modifiers using getModifiers() and Modifier.toString()
        int guru99AccessModifier = guru99ClassObj.getModifiers();
        System.out.println("Access modifiers of the class are : " + Modifier.toString(guru99AccessModifier));
    }
}

1. Den Namen der Klasse mit der Methode getName() ausgeben.
2. Den Namen der Oberklasse mit der Methode getSuperclass().getName() ausgeben.
3. Gib die Namen der implementierten Schnittstellen aus.
4. Gib die von der Klasse verwendeten Zugriffsmodifizierer aus.

Beispiel 2: Wie man Metadaten einer Variablen erhält

Das folgende Beispiel zeigt, wie man die Metadaten einer Variablen erhält.

Hier erstellen wir eine Klasse namens Guru99VariableMetaData.class mit einigen Variablen:

package guru;
public class Guru99VariableMetaData {
    public static int guru99IntVar1 = 1111;
    static int guru99IntVar2 = 2222;
    static String guru99StringVar1 = "guru99.com";
    static String guru99StringVar2 = "Learning Reflection API";
}

Schritte zum Abrufen der Metadaten zu den Variablen in der obigen Klasse:

1. Erstellen Sie das Klassenobjekt der oben genannten Klasse, d.h. Guru99VariableMetaData.class, wie unten dargestellt:

   Guru99VariableMetaData guru99ClassVar = new Guru99VariableMetaData();
   Class guru99ClassObjVar = guru99ClassVar.getClass();

2. Die Metadaten werden mithilfe des folgenden Befehls in Form eines Feld-Arrays abgerufen: getFields() or getDeclaredFields() Methoden wie folgt:

   Field[] guru99Field1 = guru99ClassObjVar.getFields();
   Field[] guru99Field2 = guru99ClassObjVar.getDeclaredFields();

Das getFields() Die Methode gibt die Metadaten der öffentlichen Variablen sowohl der angegebenen Klasse als auch ihrer Oberklasse zurück.

Das getDeclaredFields() Die Methode gibt nur die Metadaten aller Variablen der angegebenen Klasse zurück.

3. Ermitteln Sie die Namen der Variablen mit der Methode „public String getName()“.
4. Den Datentyp der Variablen ermitteln Sie mit der Methode „public Class getType()“.
5. Den Wert der Variablen erhalten Sie mit der Methode „public xxx get(Field)“. Hierbei kann xxx ein Byte, ein Short oder ein beliebiger anderer Datentyp sein, den wir abrufen möchten.
6. Die Zugriffsmodifizierer der Variablen können mit den Methoden getModifiers() und Modifier.toString(int i) ermittelt werden.

Hier schreiben wir eine Klasse, um die Metadaten der in der Klasse vorhandenen Variablen zu erhalten. Guru99VariableMetaData.class:

package guru;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Guru99VariableMetaDataTest {
    public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException {
        // Create Class object for Guru99VariableMetaData.class
        Guru99VariableMetaData guru99ClassVar = new Guru99VariableMetaData();
        Class guru99ClassObjVar = guru99ClassVar.getClass();

        // Get the metadata of all the fields of the class
        Field[] guru99Field1 = guru99ClassObjVar.getDeclaredFields();

        // Print name, data types, access modifiers and values of the variables
        for (Field field : guru99Field1) {
            System.out.println("Variable name : " + field.getName());
            System.out.println("Datatype of the variable : " + field.getType());

            int guru99AccessModifiers = field.getModifiers();
            System.out.println("Access Modifiers of the variable : " + Modifier.toString(guru99AccessModifiers));
            System.out.println("Value of the variable : " + field.get(guru99ClassVar));
            System.out.println();
        }
    }
}

1. Es wurde ein Klassenobjekt erstellt für Guru99VariableMetaData.class.
2. Alle Metadaten der Variablen wurden in einem Feld-Array gespeichert.
3. Alle Variablennamen der Klasse wurden ausgegeben. Guru99VariableMetaData.class.
4. Alle Datentypen der Variablen in der Klasse wurden ausgegeben.
5. Alle Zugriffsmodifizierer der Variablen in der Klasse wurden ausgegeben.
6. Die Werte aller Variablen in der Klasse wurden ausgegeben.

Beispiel 3: Wie man Metadaten einer Methode erhält

Das folgende Beispiel zeigt, wie man die Metadaten einer Methode erhält.

Hier erstellen wir eine Klasse namens Guru99MethodMetaData.class mit einigen Methoden:

package guru;
import java.sql.SQLException;
public class Guru99MethodMetaData {

    public void guru99Add(int firstElement, int secondElement, String result)
    throws ClassNotFoundException, ClassCastException {
        System.out.println("Demo method for Reflection API");
    }
    public String guru99Search(String searchString)
    throws ArithmeticException, InterruptedException {
        System.out.println("Demo method for Reflection API");
        return null;
    }
    public void guru99Delete(String deleteString)
    throws SQLException {
        System.out.println("Demo method for Reflection API");
    }
}

Schritte zum Abrufen der Metadaten zu den Methoden in der obigen Klasse:

1. Erstellen Sie das Klassenobjekt der oben genannten Klasse, d.h. Guru99MethodMetaData.class, wie unten dargestellt:

   Guru99MethodMetaData guru99ClassVar = new Guru99MethodMetaData();
   Class guru99ClassObjVar = guru99ClassVar.getClass();

2. Informationen zu Methoden in einem Methoden-Array erhalten Sie mithilfe der Methoden getMethods() und getDeclaredMethods() wie folgt:

   Method[] guru99Method1 = guru99ClassObjVar.getMethods();
   Method[] guru99Method2 = guru99ClassObjVar.getDeclaredMethods();

   Das getMethods() Die Methode gibt die Metadaten der öffentlichen Methoden der angegebenen Klasse sowie ihrer Oberklasse zurück. getDeclaredMethods() Die Methode gibt nur die Metadaten aller Methoden der angegebenen Klasse zurück.

3. Ermitteln Sie den Namen der Methode mithilfe der getName () Methode.
4. Ermitteln Sie den Rückgabetyp der Methode mithilfe von getReturnType() Methode.
5. Ermitteln Sie die Zugriffsmodifizierer der Methoden mithilfe der getModifiers() und Modifier.toString(int i) Methoden.
6. Ermitteln Sie die Methodenparametertypen mithilfe der getParameterTypes() Methode, die ein Klassen-Array zurückgibt.
7. Ausgelöste Ausnahmen mithilfe der getExceptionTypes() Methode, die ein Klassen-Array zurückgibt.

Hier schreiben wir eine Klasse, um die Metadaten der in der Klasse vorhandenen Methoden abzurufen. Guru99MethodMetaData.class:

package guru;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Guru99MethodMetaDataTest {

    public static void main(String[] args) {
        // Create Class object for Guru99MethodMetaData.class
        Class guru99ClassObj = Guru99MethodMetaData.class;

        // Get the metadata of all the methods using getDeclaredMethods()
        Method[] guru99Methods = guru99ClassObj.getDeclaredMethods();

        for (Method method : guru99Methods) {
            System.out.println("Name of the method : " + method.getName());
            System.out.println("Return type of the method : " + method.getReturnType());

            int guru99ModifierList = method.getModifiers();
            System.out.println("Method access modifiers : " + Modifier.toString(guru99ModifierList));

            Class[] guru99ParamList = method.getParameterTypes();
            System.out.print("Method parameter types : ");
            for (Class class1 : guru99ParamList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();

            Class[] guru99ExceptionList = method.getExceptionTypes();
            System.out.print("Exception thrown by method : ");
            for (Class class1 : guru99ExceptionList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();
        }
    }
}

1. Es wurde ein Klassenobjekt erstellt für Guru99MethodMetaData.class.
2. Ich habe alle Metadaten aller Methoden in einem Methoden-Array gespeichert.
3. Alle in der Klasse vorhandenen Methodennamen wurden ausgegeben.
4. Die Rückgabetypen der Methoden in der Klasse wurden ausgegeben.
5. Alle Zugriffsmodifizierer der Methoden in der Klasse wurden ausgegeben.
6. Die Parametertypen der Methoden wurden ausgegeben.
7. Die von den Methoden ausgelösten Ausnahmen wurden ausgegeben.

Beispiel 4: Wie man Metadaten von Konstruktoren erhält

Das folgende Beispiel zeigt, wie man die Metadaten von Konstruktoren erhält.

Hier erstellen wir eine Klasse namens Guru99Constructor.class mit verschiedenen Konstruktoren:

package guru;

import java.rmi.RemoteException;
import java.sql.SQLException;

public class Guru99Constructor {

    public Guru99Constructor(int no) throws ClassCastException, ArithmeticException { }
    public Guru99Constructor(int no, String name) throws RemoteException, SQLException { }
    public Guru99Constructor(int no, String name, String address) throws InterruptedException { }
}

Hier schreiben wir eine Klasse, um die Metadaten der in der Klasse vorhandenen Konstruktoren zu erhalten. Guru99Constructor.class:

package guru;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
public class Guru99ConstructorMetaDataTest {

    public static void main(String[] args) {
        // Create Class object for Guru99Constructor.class
        Class guru99Class = Guru99Constructor.class;

        // Get all the constructor information in the Constructor array
        Constructor[] guru99ConstructorList = guru99Class.getConstructors();

        for (Constructor constructor : guru99ConstructorList) {
            System.out.println("Constructor name : " + constructor.getName());

            int guru99Modifiers = constructor.getModifiers();
            System.out.println("Constructor modifier : " + Modifier.toString(guru99Modifiers));

            Class[] guru99ParamList = constructor.getParameterTypes();
            System.out.print("Constructor parameter types : ");
            for (Class class1 : guru99ParamList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();

            Class[] guru99ExceptionList = constructor.getExceptionTypes();
            System.out.print("Exception thrown by constructors : ");
            for (Class class1 : guru99ExceptionList) {
                System.out.print(class1.getName() + " ");
            }
            System.out.println();
        }
    }
}

1. Es wurde ein Klassenobjekt erstellt für Guru99Constructor.class.
2. Ich habe alle Metadaten aller Konstruktoren in einem Konstruktor-Array gespeichert.
3. Alle in der Klasse vorhandenen Konstruktoren wurden ausgegeben.
4. Alle Zugriffsmodifizierer der Konstruktoren in der Klasse wurden ausgegeben.
5. Die Parametertypen der Konstruktoren wurden ausgegeben.
6. Die von den Konstruktoren ausgelösten Ausnahmen wurden ausgegeben.

Häufig gestellte Fragen