Reflection es una API que se utiliza para examinar o modificar el comportamiento de métodos, clases e interfaces en tiempo de ejecución. Las clases requeridas para la reflexión se proporcionan en el paquete java.lang.reflect , que es esencial para comprender la reflexión. Así que estamos ilustrando el paquete con ayudas visuales para tener una mejor comprensión de la siguiente manera:
- La reflexión nos da información sobre la clase a la que pertenece un objeto y también los métodos de esa clase que se pueden ejecutar usando el objeto.
- A través de la reflexión, podemos invocar métodos en tiempo de ejecución independientemente del especificador de acceso utilizado con ellos.
La reflexión se puede usar para obtener información sobre la clase, los constructores y los métodos, como se muestra a continuación en formato tabular, como se muestra:
| Clase | El método getClass() se utiliza para obtener el nombre de la clase a la que pertenece un objeto. |
|---|---|
| Constructores | El método getConstructors() se utiliza para obtener los constructores públicos de la clase a la que pertenece un objeto. |
| Métodos | El método getMethods() se utiliza para obtener los métodos públicos de la clase a la que pertenece un objeto. |
Podemos invocar un método a través de la reflexión si conocemos su nombre y tipos de parámetros. Usamos dos métodos para este propósito como se describe a continuación antes de continuar de la siguiente manera:
- getDeclaredMethod()
- invocar()
Método 1: getDeclaredMethod(): Crea un objeto del método a invocar.
Sintaxis: La sintaxis para este método
Class.getDeclaredMethod(name, parametertype)
Parámetros:
- Nombre de un método cuyo objeto se va a crear.
- Una array de objetos de clase
Método 2: invoque(): Invoca un método de la clase en tiempo de ejecución usamos el siguiente método.
Sintaxis:
Method.invoke(Object, parameter)
Sugerencia: si el método de la clase no acepta ningún parámetro, se pasa nulo como argumento.
Nota: a través de la reflexión, podemos acceder a las variables y métodos privados de una clase con la ayuda de su objeto de clase e invocar el método utilizando el objeto como se explicó anteriormente. Usamos a continuación dos métodos para este propósito.
Método 3: Class.getDeclaredField(FieldName): se utiliza para obtener el campo privado. Devuelve un objeto de tipo Campo para el nombre de campo especificado.
Método 4: Field.setAccessible(true):Permite acceder al campo independientemente del modificador de acceso utilizado con el campo.
Observaciones importantes extraídas de la API de Reflection
- Funciones de extensibilidad: una aplicación puede hacer uso de clases externas definidas por el usuario mediante la creación de instancias de objetos de extensibilidad utilizando sus nombres completos.
- Herramientas de depuración y prueba : los depuradores usan la propiedad de reflexión para examinar miembros privados de clases.
- Sobrecarga de rendimiento: las operaciones reflexivas tienen un rendimiento más lento que sus contrapartes no reflexivas y deben evitarse en secciones de código que se llaman con frecuencia en aplicaciones sensibles al rendimiento.
- Exposición de componentes internos: el código reflexivo rompe las abstracciones y, por lo tanto, puede cambiar el comportamiento con las actualizaciones de la plataforma.
Ejemplo
Java
// Java Program to demonstrate the Use of Reflection
// Importing required classes
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
// Class 1
// Of Whose object is to be created
class Test {
// creating a private field
private String s;
// Constructor of this class
// Constructor 1
// Public constructor
public Test() { s = "GeeksforGeeks"; }
// Constructor 2
// no arguments
public void method1()
{
System.out.println("The string is " + s);
}
// Constructor 3
// int as argument
public void method2(int n)
{
System.out.println("The number is " + n);
}
// Constructor 4
// Private method
private void method3()
{
System.out.println("Private method invoked");
}
}
// Class 2
// Main class
class GFG {
// Main driver method
public static void main(String args[]) throws Exception
{
// Creating object whose property is to be checked
// Creating an object of class 1 inside main()
// method
Test obj = new Test();
// Creating class object from the object using
// getClass() method
Class cls = obj.getClass();
// Printing the name of class
// using getName() method
System.out.println("The name of class is "
+ cls.getName());
// Getting the constructor of the class through the
// object of the class
Constructor constructor = cls.getConstructor();
// Printing the name of constructor
// using getName() method
System.out.println("The name of constructor is "
+ constructor.getName());
// Display message only
System.out.println(
"The public methods of class are : ");
// Getting methods of the class through the object
// of the class by using getMethods
Method[] methods = cls.getMethods();
// Printing method names
for (Method method : methods)
System.out.println(method.getName());
// Creates object of desired method by
// providing the method name and parameter class as
// arguments to the getDeclaredMethod() method
Method methodcall1
= cls.getDeclaredMethod("method2", int.class);
// Invoking the method at runtime
methodcall1.invoke(obj, 19);
// Creates object of the desired field by
// providing the name of field as argument to the
// getDeclaredField() method
Field field = cls.getDeclaredField("s");
// Allows the object to access the field
// irrespective of the access specifier used with
// the field
field.setAccessible(true);
// Takes object and the new value to be assigned
// to the field as arguments
field.set(obj, "JAVA");
// Creates object of desired method by providing the
// method name as argument to the
// getDeclaredMethod()
Method methodcall2
= cls.getDeclaredMethod("method1");
// Invokes the method at runtime
methodcall2.invoke(obj);
// Creates object of the desired method by providing
// the name of method as argument to the
// getDeclaredMethod() method
Method methodcall3
= cls.getDeclaredMethod("method3");
// Allows the object to access the method
// irrespective of the access specifier used with
// the method
methodcall3.setAccessible(true);
// Invoking the method at runtime
methodcall3.invoke(obj);
}
}
Producción:
Cursos relacionados
Fundamentos de programación Java: curso a su propio ritmo
¡Comienza tu viaje de programación de la manera más fácil! Aprenda los conceptos básicos de Java y avance de lo básico a avanzado con nuestro Curso de base de programación Java: curso a su propio ritmo . Este curso cubre temas como variables y tipos de datos, operadores, bucles, funciones en Java y mucho más, organizado por expertos líderes de la industria con años de experiencia. ¡Inscríbete y conviértete en un experto en JAVA!
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA