Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Handles de métodos em Java: pesquisa, associação e invocação

Pesquisa um método de instância pela sua assinatura, associa o recetor a um novo handle e compara uma chamada exata com outra que permite adaptar tipos compatíveis.

Versão: Java SE 21

Sintaxe

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.

No Java SE 21, os handles de métodos fazem parte de java.lang.invoke. MethodHandles.lookup() cria um Lookup com as permissões de acesso da classe que faz a chamada. MethodType.methodType(String.class, int.class) descreve um retorno String e um parâmetro int, sem incluir o recetor. MethodHandles.Lookup.findVirtual procura um método de instância pela classe ou interface, nome e tipo do método. Se não houver correspondência, lança NoSuchMethodException; se o acesso for negado ou o método for estático, lança IllegalAccessException. Não partilhes um Lookup privilegiado com código não fiável.

O handle resultante tem um parâmetro inicial para o recetor. O seu tipo é normalmente a classe ou a interface pedida, mas as regras de acesso protected podem restringi-lo. Nos métodos não privados, o tipo do recetor em tempo de execução determina a implementação chamada. bindTo não chama o método: cria um novo handle de aridade fixa que fornece uma referência como primeiro argumento. O handle original não muda. Se não houver um primeiro parâmetro de tipo referência, bindTo lança IllegalArgumentException; se a referência não puder ser convertida nesse tipo, lança ClassCastException.

invokeExact e invoke têm assinaturas polimórficas: os tipos estáticos dos argumentos determinam os tipos dos parâmetros no local da chamada. O literal null passado sem cast tem o tipo nulo, que o compilador regista como java.lang.Void no descritor do local da chamada. Por isso, o argumento de invokeExact(null) não corresponde exatamente a um parâmetro String; (String) null dá ao argumento o tipo estático String. Um cast explícito aplicado à chamada fixa o tipo de retorno; sem cast, é Object numa expressão ou void quando a chamada é uma instrução autónoma. invokeExact exige que esse tipo completo seja igual a handle.type(). Não faz conversões e lança WrongMethodTypeException se não houver correspondência.

Se a correspondência for exata, invoke comporta-se como invokeExact; caso contrário, tenta adaptar a chamada segundo as regras de asType. Uma adaptação não suportada lança WrongMethodTypeException. Um cast permitido ainda pode falhar em execução com ClassCastException, e o unboxing de null provoca NullPointerException. Ambos os métodos de invocação declaram throws Throwable e podem propagar exceções do método de destino.

Exemplos

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);
    }
}

Resultado

ava
va
va

A pesquisa seleciona `substring(int)`, não `substring(int, int)`. O primeiro `invokeExact` recebe um `String` e um `int`; o segundo recebe apenas um `int`, pois `bindTo` fixou o recetor em `"Java"`. Ambos os casts especificam um retorno `String`. O último `invoke` alarga `byte` para `int`, pelo que escreve `va`, tal como a segunda chamada.

Lições relacionadas

  • Java · Lição 56 · Avançado · Versão: 2

Fontes