Java Reflection (mit Beispielen)

In diesem Tutorial lernen wir Reflexion, eine Funktion in der Java-Programmierung, mit der wir Klassen, Methoden usw. überprüfen und ändern können.

In Java können wir mithilfe von Reflection Klassen, Schnittstellen, Konstruktoren, Methoden und Felder zur Laufzeit untersuchen und bearbeiten.

In Java gibt es eine Klasse mit dem Namen Class, die alle Informationen zu Objekten und Klassen zur Laufzeit speichert. Das Objekt der Klasse kann verwendet werden, um eine Reflexion durchzuführen.

Reflexion von Java-Klassen

Um eine Java-Klasse wiederzugeben, müssen wir zuerst ein Objekt der Klasse erstellen.

Mithilfe des Objekts können wir verschiedene Methoden aufrufen, um Informationen zu Methoden, Feldern und Konstruktoren abzurufen, die in einer Klasse vorhanden sind.

Es gibt drei Möglichkeiten, Objekte der Klasse zu erstellen:

1. Verwenden der forName () -Methode

 class Dog (… ) // create object of Class // to reflect the Dog class Class a = Class.forName("Dog");

Hier verwendet die forName()Methode den Namen der zu reflektierenden Klasse als Argument.

2. Verwenden der Methode getClass ()

 // create an object of Dog class Dog d1 = new Dog(); // create an object of Class // to reflect Dog Class b = d1.getClass();

Hier verwenden wir das Objekt der Dog-Klasse, um ein Objekt der Klasse zu erstellen.

3. Verwenden der .class-Erweiterung

 // create an object of Class // to reflect the Dog class Class c = Dog.class;

Jetzt wissen wir, wie wir Objekte der Class. Mit diesem Objekt können wir zur Laufzeit Informationen über die entsprechende Klasse abrufen.

Beispiel: Java Class Reflection

 import java.lang.Class; import java.lang.reflect.*; class Animal ( ) // put this class in different Dog.java file public class Dog extends Animal ( public void display() ( System.out.println("I am a dog."); ) ) // put this in Main.java file class Main ( public static void main(String() args) ( try ( // create an object of Dog Dog d1 = new Dog(); // create an object of Class // using getClass() Class obj = d1.getClass(); // get name of the class String name = obj.getName(); System.out.println("Name: " + name); // get the access modifier of the class int modifier = obj.getModifiers(); // convert the access modifier to string String mod = Modifier.toString(modifier); System.out.println("Modifier: " + mod); // get the superclass of Dog Class superClass = obj.getSuperclass(); System.out.println("Superclass: " + superClass.getName()); ) catch (Exception e) ( e.printStackTrace(); ) ) )

Ausgabe

 Name: Hund Modifikator: public Superklasse: Tier

Im obigen Beispiel haben wir eine Oberklasse erstellt: Tier und eine Unterklasse: Hund. Hier versuchen wir die Klasse Hund zu inspizieren.

Beachten Sie die Aussage,

 Class obj = d1.getClass();

Hier erstellen wir mit der getClass()Methode ein Objektobjekt der Klasse . Mit dem Objekt rufen wir verschiedene Methoden der Klasse auf.

  • obj.getName () - gibt den Namen der Klasse zurück
  • obj.getModifiers () - gibt den Zugriffsmodifikator der Klasse zurück
  • obj.getSuperclass () - gibt die Superklasse der Klasse zurück

Weitere Informationen Classfinden Sie unter Java Class (offizielle Java-Dokumentation).

Hinweis : Wir verwenden die ModifierKlasse, um den Ganzzahl-Zugriffsmodifikator in eine Zeichenfolge zu konvertieren.

Reflektierende Felder, Methoden und Konstruktoren

Das Paket java.lang.reflectenthält Klassen, mit denen Klassenmitglieder bearbeitet werden können. Beispielsweise,

  • Methodenklasse - Enthält Informationen zu Methoden in einer Klasse
  • Feldklasse - Enthält Informationen zu Feldern in einer Klasse
  • Konstruktorklasse - Enthält Informationen zu Konstruktoren in einer Klasse

1. Reflexion von Java-Methoden

Die MethodKlasse bietet verschiedene Methoden, mit denen Informationen zu den in einer Klasse vorhandenen Methoden abgerufen werden können. Beispielsweise,

 import java.lang.Class; import java.lang.reflect.*; class Dog ( // methods of the class public void display() ( System.out.println("I am a dog."); ) private void makeSound() ( System.out.println("Bark Bark"); ) ) class Main ( public static void main(String() args) ( try ( // create an object of Dog Dog d1 = new Dog(); // create an object of Class // using getClass() Class obj = d1.getClass(); // using object of Class to // get all the declared methods of Dog Method() methods = obj.getDeclaredMethods(); // create an object of the Method class for (Method m : methods) ( // get names of methods System.out.println("Method Name: " + m.getName()); // get the access modifier of methods int modifier = m.getModifiers(); System.out.println("Modifier: " + Modifier.toString(modifier)); // get the return types of method System.out.println("Return Types: " + m.getReturnType()); System.out.println(" "); ) ) catch (Exception e) ( e.printStackTrace(); ) ) )

Ausgabe

 Methodenname: display Modifikator: public Rückgabetypen: void Methodenname: makeSound Modifikator: private Rückgabetypen: void

Im obigen Beispiel versuchen wir, Informationen über die in der Dog-Klasse vorhandenen Methoden zu erhalten. Wie bereits erwähnt, haben wir zuerst ein Objekt erstellt Class, das die getClass()Methode verwendet.

Beachten Sie den Ausdruck,

 Method() methods = obj.getDeclaredMethod();

Hier gibt das getDeclaredMethod()alle in der Klasse vorhandenen Methoden zurück.

Außerdem haben wir ein Objekt m der MethodKlasse erstellt. Hier,

  • m.getName () - gibt den Namen einer Methode zurück
  • m.getModifiers () - Gibt den Zugriffsmodifikator von Methoden in ganzzahliger Form zurück
  • m.getReturnType () - gibt den Rückgabetyp der Methoden zurück

Die MethodKlasse bietet auch verschiedene andere Methoden, mit denen Methoden zur Laufzeit überprüft werden können. Weitere Informationen finden Sie in der Java-Methodenklasse (offizielle Java-Dokumentation).

2. Reflexion von Java-Feldern

Wie Methoden können wir auch verschiedene Felder einer Klasse mithilfe der Methoden der FieldKlasse untersuchen und ändern . Beispielsweise,

 import java.lang.Class; import java.lang.reflect.*; class Dog ( public String type; ) class Main ( public static void main(String() args) ( try ( // create an object of Dog Dog d1 = new Dog(); // create an object of Class // using getClass() Class obj = d1.getClass(); // access and set the type field Field field1 = obj.getField("type"); field1.set(d1, "labrador"); // get the value of the field type String typeValue = (String) field1.get(d1); System.out.println("Value: " + typeValue); // get the access modifier of the field type int mod = field1.getModifiers(); // convert the modifier to String form String modifier1 = Modifier.toString(mod); System.out.println("Modifier: " + modifier1); System.out.println(" "); ) catch (Exception e) ( e.printStackTrace(); ) ) )

Ausgabe

 Wert: labrador Modifikator: public

Im obigen Beispiel haben wir eine Klasse namens Dog erstellt. Es enthält ein öffentliches Feld mit dem Namen type. Beachten Sie die Aussage,

 Field field1 = obj.getField("type");

Here, we are accessing the public field of the Dog class and assigning it to the object field1 of the Field class.

We then used various methods of the Field class:

  • field1.set() - sets the value of the field
  • field1.get() - returns the value of field
  • field1.getModifiers() - returns the value of the field in integer form

Similarly, we can also access and modify private fields as well. However, the reflection of private field is little bit different than the public field. For example,

 import java.lang.Class; import java.lang.reflect.*; class Dog ( private String color; ) class Main ( public static void main(String() args) ( try ( // create an object of Dog Dog d1 = new Dog(); // create an object of Class // using getClass() Class obj = d1.getClass(); // access the private field color Field field1 = obj.getDeclaredField("color"); // allow modification of the private field field1.setAccessible(true); // set the value of color field1.set(d1, "brown"); // get the value of field color String colorValue = (String) field1.get(d1); System.out.println("Value: " + colorValue); // get the access modifier of color int mod2 = field1.getModifiers(); // convert the access modifier to string String modifier2 = Modifier.toString(mod2); System.out.println("Modifier: " + modifier2); ) catch (Exception e) ( e.printStackTrace(); ) ) )

Output

 Value: brown Modifier: private

In the above example, we have created a class named Dog. The class contains a private field named color. Notice the statement.

 Field field1 = obj.getDeclaredField("color"); field1.setAccessible(true);

Here, we are accessing color and assigning it to the object field1 of the Field class. We then used field1 to modify the accessibility of color and allows us to make changes to it.

We then used field1 to perform various operations on the private field color.

To learn more about the different methods of Field, visit Java Field Class (official Java documentation).

3. Reflection of Java Constructor

We can also inspect different constructors of a class using various methods provided by the Constructor class. For example,

 import java.lang.Class; import java.lang.reflect.*; class Dog ( // public constructor without parameter public Dog() ( ) // private constructor with a single parameter private Dog(int age) ( ) ) class Main ( public static void main(String() args) ( try ( // create an object of Dog Dog d1 = new Dog(); // create an object of Class // using getClass() Class obj = d1.getClass(); // get all constructors of Dog Constructor() constructors = obj.getDeclaredConstructors(); for (Constructor c : constructors) ( // get the name of constructors System.out.println("Constructor Name: " + c.getName()); // get the access modifier of constructors // convert it into string form int modifier = c.getModifiers(); String mod = Modifier.toString(modifier); System.out.println("Modifier: " + mod); // get the number of parameters in constructors System.out.println("Parameters: " + c.getParameterCount()); System.out.println(""); ) ) catch (Exception e) ( e.printStackTrace(); ) ) )

Output

 Constructor Name: Dog Modifier: public Parameters: 0 Constructor Name: Dog Modifier: private Parameters: 1

In the above example, we have created a class named Dog. The class includes two constructors.

We are using reflection to find the information about the constructors of the class. Notice the statement,

 Constructor() constructors = obj.getDeclaredConstructor();

Hier greifen wir auf alle in Dog vorhandenen Konstruktoren zu und weisen sie einem Array-Konstruktor des ConstructorTyps zu.

Wir haben dann Objekt c verwendet, um verschiedene Informationen über den Konstruktor zu erhalten.

  • c.getName () - gibt den Namen des Konstruktors zurück
  • c.getModifiers () - Gibt die Zugriffsmodifikatoren des Konstruktors in ganzzahliger Form zurück
  • c.getParameterCount () - Gibt die Anzahl der in jedem Konstruktor vorhandenen Parameter zurück

Weitere Informationen zu den Methoden der ConstructorKlasse finden Sie unter Konstruktorklasse

Interessante Beiträge...