Java Tutorial sull'API Reflection con esempio
⚡ Riepilogo intelligente
Java L'API Reflection analizza e modifica le funzionalità di una classe in fase di esecuzione, inclusi campi, metodi e costruttori. Questa risorsa illustra il pacchetto java.lang.reflect, i metodi principali di java.lang.Class e presenta quattro esempi che leggono i metadati di una classe, una variabile, un metodo e un costruttore.

In cosa consiste la Riflessione Java?
Java La reflection è il processo di analisi e modifica di tutte le capacità di una classe in fase di esecuzione. L'API Reflection in Java Viene utilizzato per manipolare una classe e i suoi membri, che includono campi, metodi, costruttori, ecc., in fase di esecuzione.
Un vantaggio dell'API Reflection in Java La sua caratteristica principale è che può manipolare anche i membri privati della classe.
Il pacchetto java.lang.reflect fornisce numerose classi per implementare la reflection. I metodi della classe java.lang.Class vengono utilizzati per raccogliere i metadati completi di una particolare classe.
Classe nel pacchetto java.lang.reflect
Di seguito è riportato un elenco di vario Java classi nel pacchetto java.lang.reflect per implementare la reflection:
- Settore: Questa classe viene utilizzata per raccogliere informazioni dichiarative come il tipo di dati, il modificatore di accesso, il nome e il valore di una variabile.
- Metodo: Questa classe viene utilizzata per raccogliere informazioni dichiarative come il modificatore di accesso, il tipo di ritorno, il nome, i tipi di parametro e il tipo di eccezione di un metodo.
- Costruttore: Questa classe viene utilizzata per raccogliere informazioni dichiarative come il modificatore di accesso, il nome e i tipi di parametro di un costruttore.
- Modificare: Questa classe viene utilizzata per raccogliere informazioni su uno specifico modificatore di accesso.
Metodi utilizzati in java.lang.Class
- public String getName(): Restituisce il nome della classe.
- public Class getSuperclass(): Restituisce il riferimento alla superclasse.
- public Class[] getInterfaces(): Restituisce un array di interfacce implementate dalla classe specificata.
- int getModifiers(): pubblico Restituisce un valore intero che rappresenta i modificatori della classe specificata, che deve essere passato come parametro al metodo "public static String toString(int i)" che restituisce lo specificatore di accesso per la classe data.
Come ottenere informazioni complete su una classe
Per ottenere informazioni su variabiliPer creare un oggetto di una classe, dobbiamo prima definire i metodi e i costruttori. L'esempio seguente mostra diversi modi per creare un oggetto della classe "Class":
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; } }
Esempio 1: Come ottenere i metadati di una classe
L'esempio seguente mostra come ottenere metadati quali il nome della classe, il nome della superclasse, le interfacce implementate e i modificatori di accesso di una classe.
Otterremo i metadati della classe seguente denominata Guru99Base.class:
import java.io.Serializable; public abstract class Guru99Base implements Serializable, Cloneable { }
- Il nome della classe è: Guru99 Base
- I suoi modificatori di accesso sono: pubblico e assolutotract
- Ha implementato interfacce: serializzabile e clonabile
- Poiché non ha esteso esplicitamente alcuna classe, la sua superclasse è: java.lang.Object
La classe seguente otterrà i metadati di Guru99Base.class e stampalo:
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)); } }
- Stampa il nome della classe utilizzando il metodo getName().
- Stampa il nome della superclasse utilizzando il metodo getSuperclass().getName().
- Stampa i nomi delle interfacce implementate.
- Stampa i modificatori di accesso utilizzati dalla classe.
Esempio 2: Come ottenere i metadati di una variabile
L'esempio seguente mostra come ottenere i metadati di una variabile.
Qui stiamo creando una classe chiamata Guru99VariableMetaData.class con alcune variabili:
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"; }
Passaggi per ottenere i metadati sulle variabili nella classe precedente:
- Crea l'oggetto classe della classe sopra indicata, ovvero: Guru99VariableMetaData.class, come di seguito:
Guru99VariableMetaData guru99ClassVar = new Guru99VariableMetaData(); Class guru99ClassObjVar = guru99ClassVar.getClass();
- Ottieni i metadati sotto forma di un array di campi utilizzando il getFields() or getDeclaredFields() metodi come di seguito:
Field[] guru99Field1 = guru99ClassObjVar.getFields(); Field[] guru99Field2 = guru99ClassObjVar.getDeclaredFields();
Migliori getFields() Il metodo restituisce i metadati delle variabili pubbliche della classe specificata, nonché della sua superclasse.
Migliori getDeclaredFields() Il metodo restituisce i metadati di tutte le variabili appartenenti esclusivamente alla classe specificata.
- Ottieni il nome delle variabili utilizzando il metodo “public String getName()”.
- Ottieni il tipo di dati delle variabili utilizzando il metodo “public Class getType()”.
- Ottieni il valore della variabile utilizzando il metodo "public xxx get(Field)". Qui, xxx può essere un byte, uno short o qualsiasi altro tipo di valore che vogliamo recuperare.
- Ottieni i modificatori di accesso delle variabili utilizzando i metodi getModifiers() e Modifier.toString(int i).
Qui stiamo scrivendo una classe per ottenere i metadati delle variabili presenti nella classe 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(); } } }
- Creato un oggetto di classe per Guru99VariableMetaData.class.
- Ho ottenuto tutti i metadati delle variabili in un array di campi.
- Stampati tutti i nomi delle variabili nella classe Guru99VariableMetaData.class.
- Sono stati stampati tutti i tipi di dati delle variabili della classe.
- Sono stati stampati tutti i modificatori di accesso delle variabili della classe.
- Sono stati stampati i valori di tutte le variabili della classe.
Esempio 3: Come ottenere i metadati di un metodo
L'esempio seguente mostra come ottenere i metadati di un metodo.
Qui stiamo creando una classe chiamata Guru99MethodMetaData.class con alcuni metodi:
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"); } }
Procedura per ottenere i metadati relativi ai metodi della classe sopra descritta:
- Crea l'oggetto classe della classe sopra indicata, ovvero: Guru99MethodMetaData.class, come di seguito:
Guru99MethodMetaData guru99ClassVar = new Guru99MethodMetaData(); Class guru99ClassObjVar = guru99ClassVar.getClass();
- Ottieni le informazioni sui metodi in un array Method utilizzando i metodi getMethods() e getDeclaredMethods() come mostrato di seguito:
Method[] guru99Method1 = guru99ClassObjVar.getMethods(); Method[] guru99Method2 = guru99ClassObjVar.getDeclaredMethods();
Migliori getMetodi() Il metodo restituisce i metadati dei metodi pubblici della classe specificata e della sua superclasse. getDeclaredMethods() Il metodo restituisce i metadati di tutti i metodi della sola classe specificata.
- Ottieni il nome del metodo utilizzando il getName () metodo.
- Ottieni il tipo di ritorno del metodo utilizzando il getReturnType() metodo.
- Ottieni i modificatori di accesso dei metodi utilizzando il getModifiers() and Modificatore.toStringa(int i) metodi.
- Ottieni i tipi di parametri del metodo utilizzando getParameterTypes() metodo che restituisce un array di Class.
- Ottieni le eccezioni generate utilizzando il getExceptionTypes() metodo che restituisce un array di Class.
Qui stiamo scrivendo una classe per ottenere i metadati dei metodi presenti nella classe 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(); } } }
- Creato un oggetto di classe per Guru99MethodMetaData.class.
- Ho ottenuto tutti i metadati di tutti i metodi in un array Method.
- Vengono stampati tutti i nomi dei metodi presenti nella classe.
- Vengono stampati i tipi di ritorno dei metodi della classe.
- Sono stati stampati tutti i modificatori di accesso dei metodi della classe.
- Vengono stampati i tipi di parametri dei metodi.
- Vengono stampate le eccezioni generate dai metodi.
Esempio 4: Come ottenere i metadati dei costruttori
L'esempio seguente mostra come ottenere i metadati dei costruttori.
Qui stiamo creando una classe chiamata Guru99Classe costruttore con costruttori diversi:
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 { } }
Qui stiamo scrivendo una classe per ottenere i metadati dei costruttori presenti nella classe Guru99Costruttore.classe:
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(); } } }
- Creato un oggetto di classe per Guru99Costruttore.classe.
- Ho ottenuto tutti i metadati di tutti i costruttori in un array di costruttori.
- Stampati tutti i nomi dei costruttori presenti nella classe.
- Sono stati stampati tutti i modificatori di accesso dei costruttori della classe.
- Vengono stampati i tipi di parametri dei costruttori.
- Vengono stampate le eccezioni generate dai costruttori.
















