Java Reflexion (Reflection)

In diesem Tutorial werden wir Reflection lernen, die eine Eigenschaft der Java-Programmierung ist und uns ermöglicht, Klassen, Methoden und mehr zu überprüfen und zu ändern.

In Java ermöglicht Reflection das Überprüfen und Verändern von Klassen, Interfaces, Konstruktoren, Methoden und Feldern zur Laufzeit.

Java Klasse namens Class

Bevor wir Java Reflection lernen, müssen wir eine Java-Klasse namens Class verstehen.

In Java gibt es eine Klasse namens Class, die alle Informationen über Objekte und Klassen im Laufzeitkontext speichert.

Class-Objekte beschreiben die Eigenschaften einer spezifischen Klasse. Dieses Objekt wird zur Reflection verwendet.

Erstellen Sie ein Objekt der Klasse Class mit dem Namen

Wir können Class-Objekte erstellen, indem wir:

• Verwenden Sie die Methode forName()

forName() akzeptiert einen String-Parameter (den Namen der Klasse) und gibt ein Class-Objekt zurück. Das zurückgegebene Objekt referenziert die von der Zeichenkette angegebene Klasse. Zum Beispiel,

Class Dog { }
Class c1　= Class.forName("Dog");

• Verwenden Sie die Methode getClass()

　Die Methode getClass() verwendet ein Objekt einer spezifischen Klasse, um neue Objekte der Klasse Class zu erstellen. Zum Beispiel,

Dog d1　= new Dog()
Class c1　= d1.getClass();

• Verwenden Sie .class

Wir können auch verwenden.classErweiterungsnamen, um Class-Objekte zu erstellen. Zum Beispiel,

Class c1　= Dog.class;

Nachdem ein Class-Objekt erstellt wurde, können wir diese Objekte zur Reflection verwenden.

Interface abrufen

Wir können die Methode getInterfaces() der Klasse Class verwenden, um Informationen über die von der Klasse implementierten Interfaces zu sammeln. Diese Methode gibt ein Interface-Array zurück.

Beispiel: Interface abrufen

import java.lang.Class;
import java.lang.reflect.*;
interface Animal {
　　　public void display();
}
interface Mammal {
　　　public void makeSound();
}
class Dog implements Animal, Mammal {
　　　public void display() {
　　　　　　System.out.println("Ich bin ein Hund.");
　　　}
　　　public void makeSound() {
　　　　　　System.out.println("Bark bark");
　　　}
}
class ReflectionDemo {
　　public static void main(String[] args) {
　　　　　　try {
　　　　　　　　　　//创建一个Dog类的对象
　　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　//使用getClass()创建Class对象
　　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　
　　　　　　　　　　//Suche nach den von Dog implementierten Interfaces
　　　　　　　　　　Class[] objInterface = obj.getInterfaces();
　　　　　　　　　　for(Class c : objInterface) {
　　　　　　　　　　　　　　//Drucke den Interface-Namen
　　　　　　　　　　　　　　System.out.println("Interface Name: ")　+　c.getName());
　　　　　　　　　　}
　　　　　　}
　　　　　　catch(Exception　e)　{
　　　　　　　　　　e.printStackTrace();
　　　　　　}
　　　}
}

Ausgaberesultat

Interface Name: Animal
Interface Name: Mammal

获取超类和访问修饰符

类Class的方法getSuperclass()可用于获取有关特定类的超类的信息。

而且，Class提供了一种getModifier()方法，该方法以整数形式返回class的修饰符。

示例：获取超类和访问修饰符

import java.lang.Class;
import java.lang.reflect.*;
interface Animal {
　　　public void display();
}
public class Dog implements Animal {
　　　public void display() {
　　　　　　　System.out.println("Ich bin ein Hund.");
　　　}
}
class ReflectionDemo {
　　　public static void main(String[] args) {
　　　　　　　try {
　　　　　　　　　　　//创建一个Dog类的对象
　　　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　　//使用getClass()创建Class对象
　　　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　　　　//以整数形式获取Dog的访问修饰符
　　　　　　　　　　　int modifier = obj.getModifiers();
　　　　　　　　　　　System.out.println("Modifikator:　"　+　Modifier.toString(modifier));
　　　　　　　　　　　//找到Dog的超类
　　　　　　　　　　　Class superClass = obj.getSuperclass();
　　　　　　　　　　　System.out.println("Superclass: ")　+　superClass.getName());
　　　　　　　}
　　　　　　　catch(Exception　e)　{
　　　　　　　　　　　e.printStackTrace();
　　　　　　　}
　　　}
}

Ausgaberesultat

Modifikator:　public
Superclass: Animal

反射字段，方法和构造函数

该软件包java.lang.reflect提供了可用于操作类成员的类。例如，

• 方法类 - 提供有关类中方法的信息

• 字段类 - 提供有关类中字段的信息

• 构造函数类　 - 提供有关类中构造函数的信息

Java 反射与字段

　我们可以使用Field类提供的各种方法检查和修改类的不同字段。

• getFields() - 返回该类及其超类的所有公共字段

• getDeclaredFields()　 - 返回类的所有字段

• getModifier() - 以整数形式返回字段的修饰符

• set(classObject,value) - 使用指定的值设置字段的值

• get(classObject) - 获取字段的值

• setAccessible(boolean) - Privaten Felder zugänglich machen

注意：如果我们知道字段名称，则可以使用

• getField("fieldName") - 从类返回名称为fieldName的公共字段。

• getDeclaredField("fieldName") - 从类返回名称为fieldName的字段。
  

示例：访问公共字段

import java.lang.Class;
import java.lang.reflect.*;
class Dog {
　　public String type;
}
class ReflectionDemo {
　　public static void main(String[] args) {
　　　　　try{
　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　//创建Class对象
　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　//Öffentliche Felder der Klasse Dog manipulieren
　　　　　　　　　Field field1　= obj.getField("type");
　　　　　　　　//Wert des Felds setzen
　　　　　　　　　field1.set(d1, "labrador");
　　　　　　　　//Wert des Felds in einen String umwandeln und erhalten
　　　　　　　　　String typeValue = (String)field1.get(d1);
　　　　　　　　　System.out.println("Typ: ");　+　typeValue);
　　　　　　　　　//Zugriffsmodifikator des Typs erhalten
　　　　　　　　　int mod1　= field1.getModifiers();
　　　　　　　　　String modifier1　= Modifier.toString(mod1);
　　　　　　　　　System.out.println("Modifikator:　"　+　Modifikator1);
　　　　　　　　　System.out.println(" ");
　　　　　}
　　　　　catch(Exception　e)　{
　　　　　　　　　e.printStackTrace();
　　　　　}
　　}
}

Ausgaberesultat

Typ: labrador
Modifikator:　public

Beispiel: Zugriff auf privates Feld

import java.lang.Class;
import java.lang.reflect.*;
class Dog {
　private String color;
}
class ReflectionDemo {
public static void main(String[] args) {
　　　try {
　　　　　　Dog d1　= new Dog();
　　　　　　//Erstellen Sie ein Class-Objekt der Klasse
　　　　　　Class obj = d1.getClass();
　　　　　　//Privaten Felder zugreifen
　　　　　　Field field2　= obj.getDeclaredField("color");
　　　　　
　　　　　　//Privaten Felder zugänglich machen
　　　　　　field2.setAccessible(true);
　　　　　　//Farbewert setzen
　　　　　　field2.set(d1, "brown");
　　　　　　//　Wert des Typs in String umwandeln und erhalten
　　　　　　String colorValue = (String)field2.get(d1);
　　　　　　System.out.println("Farbe: ");　+　colorValue);
　　　　　　//Zugriffsmodifikator von "color" erhalten
　　　　　　int mod2　= field2.getModifiers();
　　　　　　String modifier2　= Modifier.toString(mod2);
　　　　　　System.out.println("Modifikator: ");　+　Modifikator2);
　　　}
　　　catch(Exception　e)　{
　　　　　　e.printStackTrace();
　　　}
　}
}

Ausgaberesultat

Farbe: brown
Modifikator: private

Java Reflection und Methoden

Wie bei Feldern können wir verschiedene Methoden der Klasse Method verwenden, um verschiedene Methoden der Klasse zu überprüfen.

• getMethods() - Rückgabe aller öffentlichen Methoden der Klasse und ihrer Superklasse

• getDeclaredMethod() - Rückgabe aller Methoden der Klasse

• getName() - Rückgabe des Namens der Methode

• getModifiers() - Gibt den Zugriffsmodifikator der Methode in Form einer Zahl zurück

• getReturnType() - Rückgabe des Rückgabetyps der Methode

Beispiel: Methodenreflexion

import java.lang.Class;
import java.lang.reflect.*;
class Dog {
　　　public void display() {
　　　　　　System.out.println("Ich bin ein Hund.");
　　　}
　　　protected void eat() {
　　　　　　System.out.println("Ich esse Hundefutter.");
　　　}
　　　private void makeSound() {
　　　　　　System.out.println("Bark Bark");
　　　}
}
class ReflectionDemo {
　　　public static void main(String[] args) {
　　　　　　try {
　　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　//Erstellen Sie ein Class-Objekt
　　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　　　
　　　　　　　　　　//Verwenden Sie getDeclaredMethod() um alle Methoden zu erhalten
　　　　　　　　　　Method[] methods = obj.getDeclaredMethods();
　　　　　　　　　　//Gibt den Namen der Methode zurück
　　　　　　　　　　for(Method m : methods) {
　　　　　　　　　　　　　　　
　　　　　　　　　　　　　System.out.println("Methodenname: ");　+　m.getName());
　　　　　　　　　　　　　　
　　　　　　　　　　　　　//Gibt den Zugriffsmodifikator der Methode zurück
　　　　　　　　　　　　　int modifier = m.getModifiers();
　　　　　　　　　　　　　System.out.println("Modifikator:　"　+　Modifier.toString(modifier));
　　　　　　　　　　　　　　
　　　　　　　　　　　　　//Gibt den Rückgabetyp der Methode zurück
　　　　　　　　　　　　　System.out.println("Return Types: ");　+　m.getReturnType());
　　　　　　　　　　　　　System.out.println(" ");
　　　　　　　　　　}
　　　　　　　}
　　　　　　　catch(Exception　e)　{
　　　　　　　　　　　e.printStackTrace();
　　　　　　　}
　　　}
}

Ausgaberesultat

Methodenname: display
Modifikator:　public
Return type: void
Methodenname: eat
Modifikator: protected
Rückgabeart: void
Methodenname: makeSound
Modifikator:　private
Rückgabeart: void

Java Reflection und Konstruktoren

Wir können auch verschiedene Methoden der Constructor-Klasse verwenden, um verschiedene Konstruktoren der Klasse zu überprüfen.

• getConstructors() - Gibt alle öffentlichen Konstruktoren der Klasse sowie die Konstruktoren der Oberklasse der Klasse zurück

• getDeclaredConstructor() -Gibt alle Konstruktoren zurück

• getName() - Gibt den Namen des Konstruktors zurück

• getModifiers() - Gibt den Zugriffsmodifikator des Konstruktors als Integer zurück

• getParameterCount() - Gibt die Anzahl der Parameter des Konstruktors zurück

Beispiel: Konstruktor-Reflection

import java.lang.Class;
import java.lang.reflect.*;
class Dog {
　　　public Dog() {
　　　　　　
　　　}
　　　public Dog(int age) {
　　　　　　
　　　}
　　　private Dog(String sound, String type) {
　　　　　　
　　　}
}
class ReflectionDemo {
　　　public static void main(String[] args) {
　　　　　　try {
　　　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　　　　//Verwenden Sie getDeclaredConstructor() um alle Konstruktoren einer Klasse zu erhalten
　　　　　　　　　　　Constructor[]　constructors　=　obj.getDeclaredConstructors();
　　　　　　　　　　　for(Constructor　c　:　constructors)　{
　　　　　　　　　　　　　　　//Erhalten Sie den Namen des Konstruktors
　　　　　　　　　　　　　　　System.out.println("Konstruktorname:　"　+　c.getName());
　　　　　　　　　　　　　　　//Erhalten Sie den Zugriffsmodifikator des Konstruktors
　　　　　　　　　　　　　　　int　modifier　=　c.getModifiers();
　　　　　　　　　　　　　　　System.out.println("Modifikator:　"　+　Modifier.toString(modifier));
　　　　　　　　　　　　　　　//Erhalten Sie die Anzahl der Parameter im Konstruktor
　　　　　　　　　　　　　　　System.out.println("Anzahl der Parameter:　"　+　c.getParameterCount());
　　　　　　　　　　}
　　　　　　　}
　　　　　　　catch(Exception　e)　{
　　　　　　　　　　　e.printStackTrace();
　　　　　　　}
　　　　}
}

Ausgaberesultat

Konstruktorname:　Dog
Modifikator:　public
Anzahl der Parameter:　0
Konstruktorname:　Dog
Modifikator:　public
Anzahl der Parameter:　1
Konstruktorname:　Dog
Modifikator:　private
Anzahl der Parameter:　2