Java-Reflexion
Java-Reflexion
In diesem Tutorial lernen wir Reflektion kennen, eine Funktion in der Java-Programmierung, die es uns ermöglicht, Klassen, Methoden usw. zu untersuchen und zu ändern.
In Java ermöglicht uns die Reflektion, Klassen, Schnittstellen, Konstruktoren, Methoden und Felder zur Laufzeit zu untersuchen und zu manipulieren.
In Java gibt es eine Klasse namens Class das alle Informationen über Objekte und Klassen zur Laufzeit enthält. Das Objekt von Class kann verwendet werden, um Reflexionen durchzuführen.
Reflektion von Java-Klassen
Um eine Java-Klasse widerzuspiegeln, müssen wir zuerst ein Objekt von Class erstellen .
Und mit dem Objekt können wir verschiedene Methoden aufrufen, um Informationen über Methoden, Felder und Konstruktoren zu erhalten, die in einer Klasse vorhanden sind.
Es gibt drei Möglichkeiten, Objekte der Klasse zu erstellen:
1. Verwendung der forName()-Methode
class Dog {...}
// create object of Class
// to reflect the Dog class
Class a = Class.forName("Dog");
Hier die forName() Die Methode nimmt den Namen der Klasse, die wiedergegeben werden soll, als Argument.
2. Verwendung der getClass()-Methode
// 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 Dog class, um ein Objekt von Class zu erstellen .
3. Verwendung der Erweiterung .class
// create an object of Class
// to reflect the Dog class
Class c = Dog.class;
Jetzt wissen wir, wie wir Objekte der Class erstellen können . Wir können dieses Objekt verwenden, um zur Laufzeit Informationen über die entsprechende Klasse zu erhalten.
Beispiel:Java-Klassenreflexion
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: Dog Modifier: public Superclass: Animal
Im obigen Beispiel haben wir eine Superklasse erstellt:Animal und eine Unterklasse:Dog . Hier versuchen wir, die Klasse Dog zu inspizieren .
Beachten Sie die Anweisung,
Class obj = d1.getClass();
Hier erstellen wir ein Objekt obj von Klasse mit getClass() Methode. Mit dem Objekt rufen wir verschiedene Methoden von Class auf .
- obj.getName() - gibt den Namen der Klasse zurück
- obj.getModifiers() - gibt den Zugriffsmodifikator der Klasse zurück
- obj.getSuperclass() - gibt die Oberklasse der Klasse zurück
Um mehr über Class zu erfahren , besuchen Sie die Java-Klasse (offizielle Java-Dokumentation).
Hinweis :Wir verwenden den Modifier Klasse, um den Integer-Zugriffsmodifikator in einen String umzuwandeln.
Reflexionsfelder, Methoden und Konstruktoren
Das Paket java.lang.reflect stellt Klassen bereit, die zum Manipulieren von Klassenmitgliedern verwendet werden können. Zum Beispiel
- Methodenklasse - liefert Informationen über Methoden in einer Klasse
- Feldklasse - liefert Informationen über Felder in einer Klasse
- Konstruktorklasse - liefert Informationen über Konstruktoren in einer Klasse
1. Reflexion von Java-Methoden
Die Method Die Klasse stellt verschiedene Methoden bereit, mit denen Informationen über die in einer Klasse vorhandenen Methoden abgerufen werden können. Zum Beispiel
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
Method Name: display Modifier: public Return Types: void Method Name: makeSound Modifier: private Return Types: void
Im obigen Beispiel versuchen wir, Informationen über die in Dog vorhandenen Methoden zu erhalten Klasse. Wie bereits erwähnt, haben wir zunächst ein Objekt obj erstellt von Class mit dem getClass() Methode.
Beachten Sie den Ausdruck,
Method[] methods = obj.getDeclaredMethod();
Hier die getDeclaredMethod() gibt alle innerhalb der Klasse vorhandenen Methoden zurück.
Außerdem haben wir ein Objekt m erstellt des Method Klasse. 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 von Methoden zurück
Die Method Die Klasse stellt auch verschiedene andere Methoden bereit, die zum Untersuchen von Methoden zur Laufzeit verwendet werden können. Um mehr zu erfahren, besuchen Sie die Klasse Java Method (offizielle Java-Dokumentation).
2. Reflexion von Java-Feldern
Wie Methoden können wir auch verschiedene Felder einer Klasse mit den Methoden des Field untersuchen und ändern Klasse. Zum Beispiel
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
Value: labrador Modifier: public
Im obigen Beispiel haben wir eine Klasse namens Dog erstellt . Es enthält ein öffentliches Feld namens type . Beachten Sie die Anweisung,
Field field1 = obj.getField("type"); Hier greifen wir auf das öffentliche Feld des Dog zu Klasse und dem Objekt field1 zuweisen des Feldes Klasse.
Wir haben dann verschiedene Methoden des Field verwendet Klasse:
- field1.set() - setzt den Wert des Feldes
- field1.get() - gibt den Wert des Feldes zurück
- field1.getModifiers() - gibt den Wert des Feldes als Ganzzahl zurück
Ebenso können wir auch auf private Felder zugreifen und diese ändern. Die Reflexion des privaten Bereichs unterscheidet sich jedoch geringfügig von der des öffentlichen Bereichs. Zum Beispiel
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();
}
}
} Ausgabe
Value: brown Modifier: private
Im obigen Beispiel haben wir eine Klasse namens Dog erstellt . Die Klasse enthält ein privates Feld namens color . Beachten Sie die Aussage.
Field field1 = obj.getDeclaredField("color");
field1.setAccessible(true);
Hier greifen wir auf color zu und dem Objekt field1 zuweisen des Field Klasse. Wir haben dann field1 verwendet um die Zugänglichkeit von color zu ändern und erlaubt uns, Änderungen daran vorzunehmen.
Anschließend haben wir field1 verwendet, um verschiedene Operationen mit dem privaten Feld color auszuführen.
Um mehr über die verschiedenen Methoden von Field zu erfahren , besuchen Sie Java Field Class (offizielle Java-Dokumentation).
3. Reflexion des Java-Konstruktors
Wir können auch verschiedene Konstruktoren einer Klasse untersuchen, indem wir verschiedene Methoden verwenden, die von Constructor bereitgestellt werden Klasse. Zum Beispiel
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();
}
}
} Ausgabe
Constructor Name: Dog Modifier: public Parameters: 0 Constructor Name: Dog Modifier: private Parameters: 1
Im obigen Beispiel haben wir eine Klasse namens Dog erstellt . Die Klasse enthält zwei Konstruktoren.
Wir verwenden Reflektion, um die Informationen über die Konstruktoren der Klasse zu finden. Beachten Sie die Anweisung,
Constructor[] constructors = obj.getDeclaredConstructor();
Hier greifen wir auf alle Konstruktoren zu, die in Dog vorhanden sind und sie einem Array Konstruktoren zuweisen des Constructor Typ.
Wir haben dann das 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
Um mehr über die Methoden des Constructor zu erfahren besuchen Sie die Constructor-Klasse
Java