Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

MethodHandle: associazione degli argomenti e invocazioni tipizzate

Un MethodHandle è un riferimento tipizzato a un’operazione. Scopri come bindTo associa il primo argomento e in cosa invokeExact, rigoroso, differisce da invoke, che adatta i tipi, in Java SE 21.

Versione: Java SE 21; repository runtime, production runtime not attested

Sintassi

MethodHandle bound = handle.bindTo(receiver);
String exact = (String) bound.invokeExact(intArgument);
Object adapted = bound.invoke(integerArgument);

java.lang.invoke.MethodHandle rappresenta un’operazione, per esempio un metodo. Il suo tipo è descritto da MethodType. MethodHandles.lookup().findVirtual crea un handle per un metodo di istanza; il ricevitore diventa il primo argomento. L’accesso viene controllato quando si crea l’handle, quindi un handle per un metodo non pubblico deve essere protetto da codice non attendibile.

MethodHandle.bindTo(x) crea un nuovo handle associando x esclusivamente al primo parametro (posizione 0), che deve essere di tipo riferimento. Se il primo parametro è di tipo primitivo, bindTo lancia IllegalArgumentException anche se un parametro successivo è di tipo riferimento. L’associazione non invoca l’operazione né modifica l’handle originale. Nell’esempio, associare il ricevitore cambia il tipo da (String,int)String a (int)String.

MethodHandle.invokeExact richiede tipi identici per argomenti e risultato nel punto di chiamata; una discordanza causa WrongMethodTypeException. Per questo l’esempio usa (String) e un argomento int. MethodHandle.invoke consente l’adattamento secondo asType: qui, Integer viene convertito in int tramite unboxing e il risultato viene restituito come Object. Ciò non consente conversioni arbitrarie.

Entrambi i metodi di invocazione dichiarano throws Throwable. L’esempio trasferisce questo obbligo a main; il codice applicativo dovrebbe gestire o propagare gli errori con consapevolezza.

Esempi

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

public class Main {
    public static void main(String[] args) throws Throwable {
        MethodHandle substring = MethodHandles.lookup().findVirtual(
                String.class, "substring",
                MethodType.methodType(String.class, int.class));
        MethodHandle bound = substring.bindTo("Java");

        String exact = (String) bound.invokeExact(2);
        Integer index = Integer.valueOf(1);
        Object adapted = bound.invoke(index);

        System.out.println(exact);
        System.out.println(adapted);
    }
}

Risultato

va
ava

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