Reflexión en Java

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: 

java.lang.reflect

  • 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.

reflection

 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:

  1. getDeclaredMethod()
  2. 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

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *