CKTIS / Java
java.lang.reflect.Method — esaminare e invocare un metodo
Un oggetto Method rappresenta un metodo accessibile tramite reflection. Consente di esaminarne il nome e le annotazioni e di invocarlo durante l’esecuzione. La soppressione dei controlli di accesso con setAccessible resta soggetta ai confini dei moduli.
Versione: Java SE 21; repository runtime, production runtime not attested
Sintassi
Method m = Type.class.getDeclaredMethod("methodName", ParameterType.class);
String name = m.getName();
boolean annotated = m.isAnnotationPresent(Marker.class);
m.setAccessible(true);
Object result = m.invoke(receiver, argument);java.lang.reflect.Method rappresenta un metodo di una classe o di un’interfaccia. Class.getDeclaredMethod cerca un metodo dichiarato da quel tipo, compresi quelli privati ma non quelli ereditati; Class.getMethod cerca metodi pubblici, inclusi quelli ereditati. I tipi dei parametri identificano l’overload: durante la ricerca int.class e Integer.class non sono intercambiabili.
Method.getName() restituisce solo il nome, non la firma. Method.isAnnotationPresent(Marker.class) verifica la presenza di un’annotazione di quel tipo; l’annotazione deve avere retention RetentionPolicy.RUNTIME. Le annotazioni dei metodi non vengono ereditate dai metodi che li sovrascrivono, neanche quando si usa @Inherited.
Method.setAccessible(true) sopprime, quando consentito, i controlli di accesso del linguaggio Java per questo oggetto reflection; non cambia la dichiarazione in public. Non supera i confini dei moduli: per accedere a un metodo privato in un altro modulo, il relativo package deve essere aperto al modulo chiamante. Il rifiuto può causare InaccessibleObjectException o SecurityException. trySetAccessible() consente di ottenere false al posto della prima eccezione.
Method.invoke(receiver, arguments) invoca il metodo; per un metodo statico il destinatario viene ignorato e può essere null. Il risultato è di tipo Object, i valori primitivi vengono convertiti nei rispettivi wrapper e void restituisce null. Argomenti non validi causano IllegalArgumentException, l’accesso negato causa IllegalAccessException e un’eccezione del metodo invocato viene racchiusa in InvocationTargetException.
L’esempio usa una classe distinta di livello superiore, Greeter, per mostrare l’accesso da Main a un metodo privato. Ambito: Java SE 21; l’ambiente di esecuzione del repository non è attestato, né lo è quello di produzione.
Esempi
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;
class Greeter {
@Retention(RetentionPolicy.RUNTIME)
@interface Marker {}
@Marker
private String greet(String name) {
return "Hello, " + name;
}
}
public class Main {
public static void main(String[] args) throws ReflectiveOperationException {
Method m = Greeter.class.getDeclaredMethod("greet", String.class);
System.out.println(m.getName());
System.out.println(m.isAnnotationPresent(Greeter.Marker.class));
m.setAccessible(true);
System.out.println(m.invoke(new Greeter(), "Ada"));
}
}Risultato
greet true Hello, Ada
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.