Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Handle di metodo in Java: ricerca, associazione e invocazione

Cerca un metodo di istanza tramite la sua firma, associa il ricevitore a un nuovo handle e confronta una chiamata esatta con una che adatta i tipi compatibili.

Versione: Java SE 21

Sintassi

Java SE 21 · java.lang.invoke
MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodType signature = MethodType.methodType(String.class, int.class);
MethodHandle target = lookup.findVirtual(String.class, "substring", signature); // (String, int) -> String
MethodHandle bound = target.bindTo("Java");                                    // (int) -> String
String unboundResult = (String) target.invokeExact("Java", 1);
String boundResult = (String) bound.invokeExact(2);
String adaptedResult = (String) bound.invoke((byte) 2);
// The invocations declare throws Throwable.

In Java SE 21 gli handle di metodo fanno parte di java.lang.invoke. MethodHandles.lookup() crea un Lookup con i diritti di accesso della classe chiamante. MethodType.methodType(String.class, int.class) descrive un risultato String e un parametro int, senza il ricevitore. MethodHandles.Lookup.findVirtual cerca un metodo di istanza per classe o interfaccia, nome e tipo di metodo. Se non trova una corrispondenza, lancia NoSuchMethodException; se l’accesso è negato o il metodo è statico, lancia IllegalAccessException. Non condividere un Lookup privilegiato con codice non attendibile.

L’handle ottenuto aggiunge all’inizio un parametro per il ricevitore, il cui tipo è di norma la classe o l’interfaccia indicata, ma può essere ristretto dalle regole di accesso protected. Per i metodi non privati, il tipo del ricevitore a runtime determina quale implementazione viene eseguita. bindTo non chiama il metodo: crea un nuovo handle ad arità fissa che fornisce un riferimento come primo argomento. L’handle originale non cambia. Se manca un primo parametro di tipo riferimento, bindTo lancia IllegalArgumentException; se il riferimento non può essere convertito in quel tipo, lancia ClassCastException.

invokeExact e invoke sono polimorfici rispetto alla firma: i tipi statici degli argomenti determinano i tipi dei parametri nel punto di chiamata. Il letterale null passato senza cast ha il tipo nullo, che il compilatore registra come java.lang.Void nel descrittore del punto di chiamata. L’argomento di invokeExact(null) non corrisponde quindi esattamente a un parametro String; (String) null assegna all’argomento il tipo statico String. Un cast esplicito sulla chiamata imposta il tipo restituito; senza cast, è Object in un’espressione o void se la chiamata è un’istruzione autonoma. invokeExact richiede che l’intero tipo coincida con handle.type(). Non esegue conversioni e lancia WrongMethodTypeException in caso di mancata corrispondenza.

Con una corrispondenza esatta invoke si comporta come invokeExact; altrimenti tenta un adattamento secondo le regole di asType. Un adattamento non supportato lancia WrongMethodTypeException. Un cast consentito può comunque fallire a runtime con ClassCastException, mentre l’unboxing di null genera NullPointerException. Entrambi i metodi di invocazione dichiarano throws Throwable e possono propagare le eccezioni del metodo di destinazione.

Esempi

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;

public class MethodHandleDemo {
    public static void main(String[] args) throws Throwable {
        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodType signature = MethodType.methodType(String.class, int.class);
        MethodHandle substring = lookup.findVirtual(String.class, "substring", signature);

        String text = "Java";
        String unboundResult = (String) substring.invokeExact(text, 1);
        MethodHandle bound = substring.bindTo(text);
        String boundResult = (String) bound.invokeExact(2);

        byte index = 2;
        String adaptedResult = (String) bound.invoke(index);

        System.out.println(unboundResult);
        System.out.println(boundResult);
        System.out.println(adaptedResult);
    }
}

Risultato

ava
va
va

La ricerca seleziona `substring(int)`, non `substring(int, int)`. Il primo `invokeExact` passa uno `String` e un `int`; il secondo passa solo un `int` perché `bindTo` ha fissato il ricevitore a `"Java"`. Entrambi i cast specificano un risultato `String`. L’ultimo `invoke` converte `byte` in `int` per allargamento, quindi stampa `va` come la seconda chiamata.

Lezioni correlate

  • Java · Lezione 56 · Avanzato · Versione: 2

Fonti