Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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.

Fonti