Los identificadores de reflexión y método/var son dos características poderosas en Java que permiten a los desarrolladores acceder y manipular objetos en tiempo de ejecución. Sin embargo, difieren en la forma en que acceden y manejan los objetos.

Echemos un vistazo a un ejemplo de cómo usar la reflexión para acceder a un método en una clase. Comenzaremos con una clase simple llamada "MiClase" que tiene una variable de cadena privada y un método getter para esa variable. Para crear este objeto, podemos usar la creación de instancias normal:

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

Para acceder al método usando la reflexión, primero debemos obtener la clase de nuestra instancia de objeto usando el método getClass(). Luego, podemos usar el método getDeclaredMethod() para encontrar el método al que queremos acceder, en este caso, "getName". Finalmente, necesitamos invocar el método usando el método invoke() y pasar nuestra instancia de objeto. Aquí está el código para este proceso:

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

Por otro lado, los identificadores de métodos, que se encuentran en la clase MethodHandles, proporcionan una forma más segura y optimizada de acceder a los métodos. Esto se debe a que fueron diseñados específicamente para este propósito y están mejorados para la optimización de JVM.

Usar identificadores de métodos para acceder a un método es similar a usar la reflexión. Comenzamos obteniendo la clase de nuestra instancia de objeto. Luego, usamos el método findVirtual() en MethodHandles para buscar el método al que queremos acceder. A continuación, llamamos al método usando el método invoke() y pasamos nuestra instancia de objeto. Aquí está el código para este proceso:

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”

Sin embargo, existen limitaciones en cuanto a lo que pueden hacer los identificadores de métodos. No pueden manejar tareas como crear instancias de clases, lo cual es posible con la reflexión.

Para mostrar el poder de los identificadores de métodos, echemos un vistazo a cómo se pueden usar para acceder directamente a un campo privado en una clase. Digamos que nuestra clase "MyClass" tiene una variable de cadena privada llamada "nombre". Podríamos usar la reflexión para acceder a él, pero usar identificadores de métodos es una alternativa más segura.

Para acceder directamente a un campo privado usando la reflexión, primero necesitamos obtener la clase de nuestra instancia de objeto. Luego, usamos el método getDeclaredField() para encontrar el campo al que queremos acceder, en este caso, "nombre". Sin embargo, dado que este campo es privado, necesitamos usar el método setAccessible() para establecer su accesibilidad en verdadero. Finalmente, podemos usar el método get() para recuperar el valor del campo. Aquí está el código para este proceso:

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étodos, el proceso es similar. Comenzamos obteniendo la clase de nuestra instancia de objeto y luego usamos el método privateLookupIn() en MethodHandles para respetar los modificadores de acceso del campo (ya que es privado). A continuación, utilizamos el método findVarHandle() para encontrar el campo al que queremos acceder. Finalmente, podemos usar el método get() para recuperar su valor. Aquí está el código para este proceso:

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”

Se recomienda crear una instancia estática del identificador por razones de rendimiento, pero esto requiere conocer el nombre de la clase. Si no conoce el nombre de la clase, no es posible utilizar este método.

Una limitación de los identificadores de métodos es que no proporcionan una manera de manejar las excepciones marcadas. Varias operaciones en identificadores de métodos y identificadores var arrojan excepciones comprobadas que deben detectarse y declararse en el código de producción.

En conclusión, los identificadores de métodos y variables proporcionan una gama enfocada de capacidades en el JDK para encontrar metadatos de clases y acceder a métodos y campos fuera de las restricciones normales de Java. Si bien no cubren todas las capacidades de reflexión, ofrecen alternativas más seguras y optimizadas para estas tareas.

Experimente la mejor manera de estudiar para la certificación Java con los planes de estudio de MyExamCloud y disfrute de exámenes de práctica gratuitos.