Infine una coppia di metodi che non hanno direttamente a che vedere con la reflection: si tratta di metodi che permettono di ottenere una file la cui posizione viene specificata, attraverso una stringa, in relazione alla posizione nel filesystem del presente oggetto class e alla sua posizione nella gerarchia dei package. Per fare un esempio, la stringa “/image/dog.gif” denota un‘immagine gif presente nella cartella image che si trova nella package root della presente classe. Questi metodi sono utili per recuperare immagini, file di configurazione o altre risorse utili in fase di esecuzione:

URL getResource(String name) InputStream getResourceAsStream(String name) 

Si passa ora ad analizzare le classi, presenti nel package java.lang.reflect, che completano il panorama degli strumenti per la reflection.

Field

Il primo metodo che verrà  illustrato permette di conoscere, a partire da un oggetto Field, la classe in cui è stato dichiarato:

Class getDeclaringClass() 

Un gruppo di metodi permette di conoscere il nome del campo, il suo tipo, i suoi modificatori e l‘eventuale tipo generico:

String getName() Class getType() int getModifiers() Type getGenericType() 

A partire da Java 1.5, un campo può rappresentare anche la costante di una enum:

boolean isEnumConstant() 

Una serie di metodi get() e set() permettono di ispezionare il contenuto del presente oggetto Field o di modificarlo. E‘ disponibile un metodo per ogni circostanza, sia per trattare Object che per tipi primitivi:

Object get(Object obj) boolean getBoolean(Object obj) byte getByte(Object obj) char getChar(Object obj) double getDouble(Object obj) float getFloat(Object obj) int getInt(Object obj) long getLong(Object obj) short getShort(Object obj) void set(Object obj, Object value) void setBoolean(Object obj, boolean z) void setByte(Object obj, byte b) void setChar(Object obj, char c) void setDouble(Object obj, double d) void setFloat(Object obj, float f) void setInt(Object obj, int i) void setLong(Object obj, long l) void setShort(Object obj, short s) 

Seguono i consueti metodi che permettono di ispezionare le eventuali annotazioni:

Infine una coppia di metodi permette di ottenere una rappresentazione sotto forma di stringa, con o senza la dichiarazione di tipi parametrici:

String toGenericString() String toString() 

Classe Constructor

La classe Constructor è una classe parametrica al cui tipo T corrisponde a quello della classe di appartenenza. Anche questa classe dispone di un metodo che permette di ottenere la classe a cui il costruttore appartiene:

Class getDeclaringClass() 

Segue la descrizione dei metodi che permettono l‘ispezione del presente oggetto, in modo da conoscerne il nome, i modificatori, il tipo dei parametri (semplici o generici), le eventuali eccezioni generate (semplici o parametriche) e i tipi parametrici dichiarati dal presente oggetto Constructor:

String getName() int getModifiers() Class[] getParameterTypes() Type[] getGenericParameterTypes() Class[] getExceptionTypes() Type[] getGenericExceptionTypes() TypeVariable>[] getTypeParameters() 

In tutti i casi in cui i precedenti metodi restituiscono un array, questo avrà  lunghezza 0 se l‘elemento richiesto non è presente. Un apposito metodo permette di sapere se il presente costruttore accetta o meno un numero variabile di argomenti:

boolean isVarArgs() 

Una serie di metodi permette di gestire le eventuali annotazioni. Rispetto ai metodi già  visti su Field, si noti il metodo getParameterAnnotations(), che restituisce un array di array che contiene le eventuali annotazioni dei parametri formali, in ordine di dichiarazione:

Il metodo newInstance() permette di creare un oggetto di tipo T a partire dal presente oggetto Constructor con i parametri adeguati:

T newInstance(Object... initargs) 

L‘ultimo metodo segnalato permette di avere una rappresentazione in formato stringa del costruttore rappresentato dal presente oggetto, comprensivo di eventuali tipi parametrici:

String toGenericString() 

Classe Method

I metodi della classe Method sono in gran parte comuni a quelli della classe Constructor, con l‘unica differenza che un metodo prevede anche un tipo di ritorno, ragion per cui la classe Method contiene un apposito metodo getReturnType():

Class getDeclaringClass() Class getReturnType() Type getGenericReturnType() String getName() int getModifiers() Class[] getParameterTypes() Type[] getGenericParameterTypes() Class[] getExceptionTypes() Type[] getGenericExceptionTypes() TypeVariable[] getTypeParameters() boolean isVarArgs() 

Nel caso il presente oggetto Method rappresenti il metodo di un tipo di annotazione, è disponibile un apposito metodo per ispezionare l‘eventuale valore di default:

Object getDefaultValue() 

Seguono i metodi per ispezionare le eventuali annotazioni, corrispondenti in tutto e per tutto a quelli della classe Constructor:

Il metodo toGenericString() permette di ottenere una rappresentazione in formato stringa del metodo sottostante:

String toGenericString() 

Infine un metodo invoke() permette di invocare il presente metodo su un oggetto specificato da un apposito parametro con gli argomenti opportuni:

Object invoke(Object obj, Object... args) 

Classe Array

La classe Array comprende solamente metodi statici, che permettono di operare su oggetti Class di tipo array. Il primo metodo che verrà  illustrato permette di conoscere la lunghezza di un array:

static int getLength(Object array) 

Seguono una coppia di metodi che permettono di creare un array a partire da un parametro di tipo Class che ne denota il tipo e da un intero lenght che ne specifica la lunghezza. La seconda versione del metodo newInstance() permette di creare array di array, specificando l‘insieme delle lunghezze attraverso un array di interi:

static Object newInstance(Class componentType, int length) static Object newInstance(Class componentType, int[] dimensions) 

Infine una serie di metodi get() e set() permettono di leggere o di impostare il valore di un elemento di un array, specificandone il valore e l‘indice:

static Object get(Object array, int index) static boolean getBoolean(Object array, int index) static byte getByte(Object array, int index) static char getChar(Object array, int index) static double getDouble(Object array, int index) static float getFloat(Object array, int index) static int getInt(Object array, int index) static long getLong(Object array, int index) static short getShort(Object array, int index) static void set(Object array, int index, Object value) static void setBoolean(Object array, int index, boolean z) static void setByte(Object array, int index, byte b) static void setChar(Object array, int index, char c) static void setDouble(Object array, int index, double d) static void setFloat(Object array, int index, float f) static void setInt(Object array, int index, int i) static void setLong(Object array, int index, long l) static void setShort(Object array, int index, short s) 

Interfaccia Annotation

L‘interfaccia Annotation viene implementata dalle classi che rappresentano uno specifico tipo di annotazione. L‘unico metodo definito da questa interfaccia è il seguente:

Class annotationType() 

Questo metodo restituisce l‘oggetto Class che rappresenta l‘annotazione vera e propria, che può avere i propri modificatori, le proprie annotazioni e i propri metodi, che a loro volta possono avere un valore di default.

Classe Package

Il package è denotato da un nome, che segue la dot notation caratteristica di Java (ad esempio java.io o javax.swing);

String getName() 

I seguenti metodi permettono di accedere ad una serie di informazioni di carattere commerciale legate al venditore del package, al titolo dell‘implementazione, e alla versione:

String getImplementationVendor() String getImplementationTitle() String getImplementationVersion() 

Qualora il package si rifaccia ad una specifica, è possibile recuperare le informazioni corrispondenti al venditore della specifica, al titolo e alla versione:

String getSpecificationVendor() String getSpecificationTitle() String getSpecificationVersion() 

Qualora il presente package sia l‘implementazione di una particolare specifica, si può verificare l‘eventuale compatibilità  con una versione di riferimento specificata dal parametro:

boolean isCompatibleWith(String desired) 

Seguono i consueti metodi per l‘ispezione delle eventuali annotazioni:

Quindi il caratteristico metodo toString():

String toString() 

Infine una coppia di metodi statici che permettono di recuperare un package a partire da un nome o l‘elenco di tutti i packages accessibili al ClassLoader:

static Package getPackage(String name) static Package[] getPackages() 

Type

L‘introduzione dei tipi parametrici in Java 5 ha richiesto la definizione di un‘apposita interfaccia Type, peraltro vuota, e di quattro sue sottoclassi con delle forti interazioni reciproche, come si vede in figura 3:

Il diagramma delle classi di Type è molto complesso, e riflette la complessità  della metarappresentazione dei tipi parametrici.

GenericArrayType

Il linguaggio Java 5 permette di definire array di tipo parametrico. Un apposito metodo permette di conoscere il tipo generico dell‘array stesso:

Type getGenericComponentType() 

ParametryzedType

L‘interfaccia ParametryzedType contiene tutti i metodi necessari ad ispezionare un tipo parametrico. Il primo di questi permette di conoscere il tipo reale dei tipi parametrici dichiarati:

Type[] getActualTypeArguments() 

A questo proposito è bene ricordare che il tipo parametrico reale è noto solamente a runtime, un fattore che giustifica l‘importanza del metodo precedente. Il metodo seguente restituisce il tipo che racchiude il presente tipo, permettendo in questo modo di ispezionare i tipi parametrici nidificati:

Type getOwnerType() 

L‘ultimo dei metodi di questa interfaccia permette di conoscere l‘oggetto Type che rappresenta la classe o l‘interfaccia che ha dichiarato il presente tipo:

Type getRawType() 

A questo proposito si ricorda che la classe Class implementa a sua volta l‘interfaccia Type.

TypeVariable

L‘interfaccia TypeVariable è un‘interfaccia parametrica il cui tipo parametrico formale D rappresenta un oggetto di tipo GenericDeclaration, che verrà  illustrato in seguito. Il primo metodo di questa interfaccia restituisce un array di oggetti Type che denota i limiti superiori dell‘oggetto Type corrente:

Type[] getBounds() 

Il prossimo metodo restituisce il nome di questo tipo parametrico, così come appare nel codice sorgente:

String getName() 

Infine un metodo che restituisce un oggetto GenericDeclaration che rappresenta la dichiarazione generica del presente oggetto TypeVariable:

D getGenericDeclaration() 

L‘interfaccia GenericDeclaration contiene un solo metodo:

TypeVariable[] getTypeParameters()

Questo metodo permette di ottenere un array di TypeVariable che rappresentano le dichiarazioni di tipi parametrici dichiarati dal presente oggetto GenericDeclaration in ordine di dichiarazione.

WildcardType

L‘interfaccia WildcardType denota il carattere jolly ‘?‘ e le sue applicazioni all‘interno delle dichiarazioni di tipi parametrici (ad esempio , o ) per specificare limiti superiori o limiti inferiori:

Type[] getLowerBounds() Type[] getUpperBounds() 

Conclusioni

Siamo finalmente giunti al termine di questa lunga carrellata sulle classi che forniscono l‘infrastruttura per la reflection. Il prossimo mese sarà  possibile vedere un utilizzo pratico di tali classi per ispezionare oggetti a runtime.