Reflexão e identificadores de método/var são dois recursos poderosos em Java que permitem aos desenvolvedores acessar e manipular objetos em tempo de execução. No entanto, eles diferem na forma como acessam e manipulam objetos.

Vamos dar uma olhada em um exemplo de como usar reflexão para acessar um método em uma classe. Começaremos com uma classe simples chamada "MyClass" que possui uma variável de string privada e um método getter para essa variável. Para criar este objeto, podemos usar instanciação normal:

MyClass objectInstance = new MyClass("John Doe");

Para acessar o método usando reflexão, precisamos primeiro obter a classe da instância do nosso objeto usando o método getClass(). Então, podemos usar o método getDeclaredMethod() para encontrar o método que queremos acessar, neste caso, “getName”. Finalmente, precisamos invocar o método usando o método Invoke() e passar nossa instância do objeto. Aqui está o código para este processo:

Class> clazz = objectInstance.getClass();
Method method = clazz.getDeclaredMethod("getName");
String value = (String) method.invoke(objectInstance);
System.out.println(value); // prints "John Doe"

Por outro lado, os identificadores de método, encontrados na classe MethodHandles, fornecem uma maneira mais segura e otimizada de acessar métodos. Isso ocorre porque eles foram projetados especificamente para essa finalidade e são aprimorados para otimização de JVM.

Usar identificadores de método para acessar um método é semelhante a usar reflexão. Começamos obtendo a classe da nossa instância de objeto. Em seguida, usamos o método findVirtual() em MethodHandles para procurar o método que queremos acessar. A seguir, chamamos o método usando o método Invoke() e passamos nossa instância do objeto. Aqui está o código para este processo:

Class> clazz = objectInstance.getClass();
MethodHandle handle = MethodHandles.lookup().findVirtual(clazz, "getName", methodType(String.class));
String value = (String) handle.invoke(objectInstance);
System.out.println(value);  // Prints “John Doe”

No entanto, existem limitações quanto ao que os identificadores de método podem fazer. Eles não podem lidar com tarefas como instanciar classes, o que é possível com reflexão.

Para mostrar o poder dos identificadores de método, vamos dar uma olhada em como eles podem ser usados ​​para acessar diretamente um campo privado em uma classe. Digamos que nossa classe "MyClass" tenha uma variável de string privada chamada "nome". Poderíamos usar reflexão para acessá-lo, mas usar identificadores de método é uma alternativa mais segura.

Para acessar diretamente um campo privado usando reflexão, primeiro precisamos obter a classe de nossa instância de objeto. Em seguida, utilizamos o método getDeclaredField() para encontrar o campo que queremos acessar, neste caso, “nome”. No entanto, como este campo é privado, precisamos usar o método setAccessible() para definir sua acessibilidade como verdadeira. Finalmente, podemos usar o método get() para recuperar o valor do campo. Aqui está o código para este processo:

Class> clazz = objectInstance.getClass(); 
Field field = clazz.getDeclaredField("name"); 
field.setAccessible(true); 
String value = (String) field.get(objectInstance);
System.out.println(value); // prints “John Doe”

Usando identificadores de método, o processo é semelhante. Começamos obtendo a classe da nossa instância do objeto e depois usamos o método privateLookupIn() em MethodHandles para respeitar os modificadores de acesso do campo (já que é privado). A seguir, usamos o método findVarHandle() para encontrar o campo que queremos acessar. Finalmente, podemos usar o método get() para recuperar seu valor. Aqui está o código para este processo:

Class> clazz = objectInstance.getClass(); 
VarHandle handle = MethodHandles.privateLookupIn(clazz, MethodHandles.lookup()).findVarHandle(clazz, "name", String.class);
String value = (String) handle.get(objectInstance);
System.out.println(value); // prints “John Doe”

É recomendado instanciar estaticamente o identificador por motivos de desempenho, mas isso requer saber o nome da classe. Se você não sabe o nome da classe, não é possível usar esta abordagem.

Uma limitação dos identificadores de método é que eles não fornecem uma maneira de tratar exceções verificadas. Várias operações em identificadores de método e identificadores de var lançam exceções verificadas que devem ser capturadas e declaradas no código de produção.

Concluindo, identificadores de métodos e variáveis ​​fornecem uma gama focada de recursos no JDK para localizar metadados de classe e acessar métodos e campos fora das restrições normais do Java. Embora não cubram todas as capacidades de reflexão, oferecem alternativas mais seguras e otimizadas para essas tarefas.

Experimente a melhor maneira de estudar para a certificação Java com os planos de estudo do MyExamCloud e desfrute de testes práticos gratuitos.