Java Reflection API Tutorial mit Beispiel

Was ist Reflektion in Java?

Java Reflection ist der Prozess der Analyse und Änderung aller Fähigkeiten einer Klasse zur Laufzeit. Die Reflection-API in Java wird verwendet, um Klassen und ihre Member, die Felder, Methoden, Konstruktoren usw. enthalten, zur Laufzeit zu manipulieren.

Ein Vorteil der Reflexions-API in Java ist, dass sie auch private Mitglieder der Klasse manipulieren kann.

Das Paket java.lang.reflect stellt viele Klassen bereit, um Reflexion zu implementieren. java.Methods der Klasse java.lang.Class wird verwendet, um die vollständigen Metadaten einer bestimmten Klasse zu sammeln.

In diesem Tutorial lernen Sie-

Was ist Reflexion
Klasse im java.lang.reflect-Paket
Methoden, die in java.lang.Class verwendet werden
So erhalten Sie vollständige Informationen zu einem Kurs
Beispiel 1:Wie erhalte ich Metadaten einer Klasse
Beispiel 2:Wie erhalte ich Metadaten einer Variablen
Beispiel 3:Wie erhalte ich Metadaten der Methode
Beispiel 4:Wie man Metadaten von Konstruktoren erhält

Klasse im java.lang.reflect-Paket

Es folgt eine Liste verschiedener Java-Klassen in java.lang.package zur Implementierung von Reflection-

Feld :Diese Klasse wird verwendet, um deklarative Informationen wie Datentyp, Zugriffsmodifikator, Name und Wert einer Variablen zu sammeln.
Methode :Diese Klasse wird verwendet, um deklarative Informationen wie Zugriffsmodifizierer, Rückgabetyp, Name, Parametertypen und Ausnahmetyp einer Methode zu sammeln.
Konstruktor :Diese Klasse wird verwendet, um deklarative Informationen wie Zugriffsmodifikatoren, Namen und Parametertypen eines Konstruktors zu sammeln.
Modifikator :Diese Klasse wird verwendet, um Informationen über einen bestimmten Zugriffsmodifikator zu sammeln.

Methoden, die in java.lang.Class verwendet werden

Öffentliche Zeichenfolge getName () :Gibt den Namen der Klasse zurück.
öffentliche Klasse getSuperclass() :Gibt die Superklassenreferenz zurück
Public Class[] getInterfaces() :Gibt ein Array von Schnittstellen zurück, die von der angegebenen Klasse implementiert wurden
Öffentlich in getModifiers (): Gibt einen ganzzahligen Wert zurück, der die Modifikatoren der angegebenen Klasse darstellt, der als Parameter an „public static String toString (int i )“ übergeben werden muss Methode, die den Zugriffsbezeichner für die angegebene Klasse zurückgibt.

So erhalten Sie vollständige Informationen über einen Kurs

Um Informationen über Variablen, Methoden und Konstruktoren einer Klasse zu erhalten, müssen wir ein Objekt der Klasse 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;
		}
	}

Das folgende Beispiel zeigt verschiedene Wege, um ein Objekt der Klasse „Klasse“ zu erstellen:

Beispiel 1:Wie erhält man Metadaten der Klasse

Das folgende Beispiel zeigt, wie Metadaten abgerufen werden, wie z. B.:Klassenname, Superklassenname, implementierte Schnittstellen und Zugriffsmodifikatoren einer Klasse.

Wir erhalten die Metadaten der folgenden Klasse mit dem Namen Guru99Base.class:

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

Name der Klasse ist:Guru99Base
Die Zugriffsmodifikatoren sind:öffentlich und abstrakt
Es hat Schnittstellen implementiert:Serialisierbar und klonbar
Da es keine Klasse explizit erweitert hat, ist seine Superklasse:java.lang.Object

Unter der Klasse werden die Metadaten von Guru99Base.class abgerufen und gedruckt:

import java.lang.reflect.Modifier;
public class Guru99GetclassMetaData {

	public static void main (String [] args) throws ClassNotFoundException { 
	// Create Class object for Guru99Base.class 
	Class 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 in the form of Class array using getInterface() method
	class[] guru99InterfaceList = guru99classObj.getInterfaces();
	
	// Print the implemented interfaces using foreach loop 
	system.out.print("Implemented interfaces are : ");
	for (Class guru99class1 : quru99 InterfaceList)	{
		system.out.print guru99class1.getName() + " ");
	}
	system.out.println();
	
	//Get access modifiers using get Modifiers() method and toString() method of java.lang.reflect.Modifier class
	int guru99AccessModifier= guru99classObj.getModifiers(); 
	// Print the access modifiers
	System.Out.println("Access modifiers of the class are : " +Modifier.tostring(guru99AccessModifier));
	
	}
}

den Namen der Klasse mit der getName-Methode ausgeben
Drucken Sie den Namen der Superklasse mit der Methode getSuperClass().getName()
Namen der implementierten Schnittstellen ausgeben
Drucken Sie die von der Klasse verwendeten Zugriffsmodifikatoren

Beispiel 2:So erhalten Sie Metadaten einer Variablen

Die folgenden Beispiele zeigen, wie Metadaten der Variablen abgerufen werden:

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:

Erstellen Sie das Klassenobjekt der obigen Klasse, d. h. Guru99VariableMetaData.class, wie folgt:

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

Erhalten Sie die Metadaten in Form eines Feldarrays mit getFields() oder getDeclaredFields() Methoden wie folgt:

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

getFields() Die Methode gibt Metadaten der öffentlichen Variable aus der angegebenen Klasse sowie aus ihrer Superklasse zurück.

getDeclaredFields() -Methode gibt nur Metadaten aller Variablen aus der angegebenen Klasse zurück.

Ermitteln Sie den Namen der Variablen mit der Methode „public String getName()“.
Ermitteln Sie den Datentyp der Variablen mit der Methode „public Class getType()“.
Rufen Sie den Wert der Variablen mit der Methode „public xxx get (Field)“ ab.
Hier könnte xxx ein Byte oder weniger eines beliebigen Werttyps sein, den wir abrufen möchten.

Erhalten Sie die Zugriffsmodifikatoren der Variablen mit den Methoden getModifier() und Modifier.toString(int i).

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

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

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 Guru99VariableMetaData 
	Field[] guru99Field1= guru99ClassObjVar.getDeclaredFields();
	
	// Print name, datatypes, access modifiers and values of the varibales of the specified class 
	for(Field field : guru99Field1) { 
	System.out.println("Variable name : "+field.getName());
	System.out.println("Datatypes of the variable :"+field.getType());
	
	int guru99AccessModifiers = field.getModifiers();
	System.out.printlln("Access Modifiers of the variable : "+Modifier.toString(guru99AccessModifiers));
	System.out.println("Value of the variable : "+field.get(guru99ClassVar));
	System.out.println();
	system.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *") ;
	}
	}
}

Klassenobjekt für Guru99VariableMetaData.class erstellt
Alle Metadaten der Variablen in einem Field-Array erhalten
Alle Variablennamen in der Klasse Guru99VariableMetaData.class ausgegeben
Alle Datentypen der Variablen in der Klasse Guru99VariableMetaData.class ausgegeben
Alle Zugriffsmodifikatoren der Variablen in der Klasse Guru99VariableMetaData.class ausgegeben
Gedruckte Werte aller Variablen in Gedruckt alle Datentypen der Variablen in der Klasse Guru99VariableMetaData.class

Beispiel 3:Wie erhält man Metadaten der Methode

Das folgende Beispiel zeigt, wie Metadaten einer Methode abgerufen werden:

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 Reflextion  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:

Erstellen Sie das Klassenobjekt der obigen Klasse, d. h. Guru99MethodMetaData.class wie folgt:

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

Erhalten Sie Methodeninformationen in einem Methodenarray mit den Methoden getMethods() und getDeclaredMethods() wie unten:
```
Method[]  guru99 Method 1= guru99ClassObjVar .get Methods();
Method []  guru99 Method 2= guru99ClassObjVar .getDeclared Method s();
```
getMethods() method gibt Metadaten der öffentlichen Methoden der angegebenen Klasse sowie ihrer Superklasse zurück.

getDeclaredMethods() method gibt nur Metadaten aller Methoden aus der angegebenen Klasse zurück.
Ermitteln Sie den Namen der Methode mit getName() Methode.
Ermitteln Sie den Rückgabetyp der Methode mit getReturnType() Methode.
Zugriffsmodifikatoren der Methoden mit getModifiers() abrufen und Modifiers.toString(int i) Methoden.
Methodenparametertypen mit getParameterTypes() abrufen Methode, die ein Klassenarray zurückgibt.
Erhalten Sie eine ausgelöste Ausnahme mit getExceptionTypes() Methode, die ein Klassenarray zurückgibt.

Hier schreiben wir eine Klasse, um die Metadaten der Methoden zu erhalten, die in der Klasse Guru99MethodMetaData.class vorhanden sind:

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 Guru99Method MetaData.class 
		class guru99ClassObj = Guru99MethodMetaData.class;

		// Get the metadata or information of all the methods of the class using getDeclaredMethods() 
		Method[] guru99Methods=guru99classObj.getDeclaredMethods();

		for(Method method : guru99Methods) { 
		// Print the method names
		System.out.println("Name of the method : "+method.getName());
		
		// Print return type of the methods 
		System.out.println("Return type of the method : "+method.getReturnType());
		
		//Get the access modifier list and print
		int guru99ModifierList = method.getModifiers(); 
		System.Out.printlin ("Method access modifiers : "+Modifier.toString(guru99ModifierList));
		
		// Get and print parameters of the methods 
		Class[] guru99ParamList= method.getParameterTypes(); 
		system.out.print ("Method parameter types : "); 
		for (Class class1 : guru99ParamList){ 
			System.out.println(class1.getName()+" ");
		}
        System.out.println();
		
		// Get and print exception thrown by the method 
		Class[] guru99ExceptionList = method. getExceptionTypes(); 
		system.out.print("Excpetion thrown by method :"); 
		for (Class class1 : guru99ExceptionList) {
			System.out.println (class1.getName() +" "):
		} 
		System.Out.println(); 
		system.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ");
		
		}
 
	}
}

Klassenobjekt für Guru99MethodMetaData.class erstellt
Alle Metadaten aller Methoden in einem Methodenarray erhalten
Alle in der Klasse Guru99MethodMetaData.class vorhandenen Methodennamen ausgegeben
Gedruckte Rückgabetypen der Methoden in der Klasse Guru99MethodMetaData.class
Alle Zugriffsmodifikatoren der Methoden in der Klasse Guru99MethodMetaData.class gedruckt
Ausgedruckte Parametertypen der Methoden in Guru99MethodMetaData.class
Gedruckte Ausnahmen werden von Methoden in Guru99MethodMetaData.class
ausgelöst

Beispiel 4:Wie erhält man Metadaten von Konstruktoren

Die folgenden Beispiele zeigen, wie Metadaten von Konstruktoren abgerufen werden:

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 Konstruktoren zu erhalten, die in der Klasse Guru99Constructor.class vorhanden sind:

package guru;
import java.lang.reflect.Constructor; 
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) {
			// Print all name of each constructor
			System.out.println("Constrcutor name : "+constructor.getName());
			
			//Get and print access modifiers of each constructor 
			int guru99Modifiers= constructor.getModifiers(); 
			System.Out.printlin ("Constrctor modifier : "+Modifier.toString(guru99Modifiers));
			
			// Get and print parameter types 
			Class[] guru99ParamList=constructor.getParameterTypes();
			System.out.print ("Constrctor parameter types :"); 
			for (Class class1 : guru99ParamList) { 
				System.out.println(class1.getName() +" ");
			}
			System. out.println();

			// Get and print exception thrown by constructors
			Class[] guru99ExceptionList=constructor.getFxceptionTypes();
			System.out.println("Exception thrown by constructors :"); 
			for (Class class1 : guru99ExceptionList) { 
				System.out.println(class1.getName() +" ");
			} 
			System.out.println();
			System.out.println("*******************************************");
		}
	}
}

Klassenobjekt für Guru99Constructor.class erstellt
Alle Metadaten aller Konstruktoren in einem Konstruktor-Array erhalten
Druckte alle Namen der Konstruktoren, die in der Klasse Guru99Constructor.class vorhanden sind
Alle Zugriffsmodifikatoren der Konstruktoren in der Klasse Guru99Constructor.class ausgegeben
Ausgedruckte Parametertypen der Konstruktoren in Guru99Constructor.class
Gedruckte Ausnahmen werden von Konstruktoren in Guru99Constructor.class geworfen

Zusammenfassung:

Reflektionsprogrammierung in Java hilft beim Abrufen und Ändern von Informationen über Klassen und Klassenmitglieder wie Variablen, Methoden und Konstruktoren.
Die Reflection-API in Java kann mithilfe von Klassen im Paket java.lang.reflect und Methoden der Klasse java.lang.Class implementiert werden.
Einige häufig verwendete Methoden der Klasse java.lang.Class sind getName (), getSuperclass (), getInterfaces (), getModifiers () usw.
Einige häufig verwendete Klassen im Paket java.lang.reflect sind Feld, Methode, Konstruktor, Modifikator usw.
Reflection API kann auf private Methoden und Variablen einer Klasse zugreifen, die eine Sicherheitsbedrohung darstellen könnten.
Die Reflection-API ist eine leistungsstarke Funktion, die von Java bereitgestellt wird, aber sie bringt einige Overheads mit sich, wie z. B. langsamere Leistung, Sicherheitslücken und Berechtigungsprobleme. Daher sollte die Reflection-API als letzter Ausweg zur Durchführung einer Operation behandelt werden.

Java BufferedReader:Lesen von Dateien in Java mit Beispiel Groovy Script Tutorial für Anfänger

Java