Reflexión Java

En este tutorial, aprenderemos la reflexión, una característica de la programación Java que nos permite inspeccionar y modificar clases, métodos, etc.

En Java, la reflexión nos permite inspeccionar y manipular clases, interfaces, constructores, métodos y campos en tiempo de ejecución.

---

Clase de Java llamada Clase

Antes de aprender sobre la reflexión en Java, necesitamos saber sobre la clase de Java llamada Class.

Hay una clase en Java llamada Classque mantiene toda la información sobre objetos y clases en tiempo de ejecución.

El objeto de Classdescribe las propiedades de una clase particular. Este objeto se usa para realizar la reflexión.

---

Crear objetos de la clase llamada Clase

Podemos crear objetos de Classpor

• utilizando el método forName ()

forName()toma un argumento de cadena (nombre de una clase) y devuelve un objeto de Class. El objeto devuelto se refiere a la clase especificada por la cadena. Por ejemplo,

Class Dog {  }
Class c1 = Class.forName("Dog");

• utilizando el método getClass ()

El getClass()método usa el objeto de una clase particular para crear un nuevo objeto de Class. Por ejemplo,

Dog d1 = new Dog()
Class c1 = d1.getClass();

• usando .class

También podemos crear objetos Classutilizando la extensión .class . Por ejemplo,

Class c1 = Dog.class;

Una vez que Classse crean los objetos de , podemos usar estos objetos para realizar la reflexión.

---

Obtener interfaces

Podemos utilizar el getInterfaces()método de Classrecopilar información sobre las interfaces implementadas por la clase. Este método devuelve una matriz de interfaces.

Ejemplo: obtener interfaces

import java.lang.Class;
import java.lang.reflect.*;

interface Animal {
   public void display();
}

interface Mammal {
   public void makeSound();
}

class Dog implements Animal, Mammal {
   public void display() {
      System.out.println("I am a dog.");
   }

   public void makeSound() {
      System.out.println("Bark bark");
   }
}

class ReflectionDemo {
  public static void main(String[] args) {
      try {
          // create an object of Dog class
          Dog d1 = new Dog();

          // create an object of Class using getClass()
          Class obj = d1.getClass();
        
          // find the interfaces implemented by Dog
          Class[] objInterface = obj.getInterfaces();
          for(Class c : objInterface) {

              // print the name of interfaces
              System.out.println("Interface Name: " + c.getName());
          }
      }

      catch(Exception e) {
          e.printStackTrace();
      }
   }
}

Salida

Nombre de interfaz: Animal
Nombre de interfaz: Mammal

---

Obtenga Superclase y Modificador de Acceso

El método getSuperclass()de la clase Classse puede utilizar para obtener información sobre la superclase de una clase en particular.

Y también, Classproporciona un método getModifier()que devuelve el modificador de clase en forma entera.

Ejemplo: Obtener Superclase y Modificador de Acceso

import java.lang.Class;
import java.lang.reflect.*;

interface Animal {
   public void display();
}

public class Dog implements Animal {
   public void display() {
       System.out.println("I am a dog.");
   }
}

class ReflectionDemo {
   public static void main(String[] args) {
       try {
           // create an object of Dog class
           Dog d1 = new Dog();

           // create an object of Class using getClass()
           Class obj = d1.getClass();

          // Get the access modifier of Dog in integer form
           int modifier = obj.getModifiers();
           System.out.println("Modifier: " + Modifier.toString(modifier));

           // Find the superclass of Dog
           Class superClass = obj.getSuperclass();
           System.out.println("Superclass: " + superClass.getName());
       }

       catch(Exception e) {
           e.printStackTrace();
       }
   }
}

Salida

Modificador: público
Superclase: Animal

Para conocer más métodos Class, visite java.lang.Class .

---

Campos reflectores, métodos y constructores

El paquete java.lang.reflectproporciona clases que pueden usarse para manipular miembros de clase. Por ejemplo,

• Clase de método : proporciona información sobre los métodos de una clase.
• Clase de campo : proporciona información sobre los campos de una clase.
• Clase de constructor : proporciona información sobre los constructores de una clase.

---

Reflejo de un campo

Podemos inspeccionar y modificar diferentes campos de una clase usando varios métodos proporcionados por la Fieldclase.

• getFields (): devuelve todos los campos públicos de la clase y su superclase
• getDeclaredFields () : devuelve todos los campos de la clase
• getModifier () - devuelve el modificador de campos en forma entera
• set (classObject, value) : establece el valor de un campo con el valor especificado
• get (classObject) : obtiene el valor de un campo
• setAccessible (boolean) : hace que el campo privado sea accesible

Nota: Si conocemos el nombre de un campo, podemos usar

• getField ("fieldName") : devuelve el campo público que tiene el nombre fieldName de la clase.
• getDeclaredField ("fieldName") : devuelve el campo que tiene el nombre fieldName de la clase.

Para conocer más métodos de la Fieldvisita de clase, Clase de campo .

Ejemplo: acceso al campo público

import java.lang.Class;
import java.lang.reflect.*;

class Dog {
  public String type;
}

class ReflectionDemo {
  public static void main(String[] args) {
     try{
         Dog d1 = new Dog();
        // create an object of the class Class
         Class obj = d1.getClass();

        // manipulating the public field type of Dog     
         Field field1 = obj.getField("type");
        // set the value of field
         field1.set(d1, "labrador");
       // get the value of field by converting in String
         String typeValue = (String)field1.get(d1);
         System.out.println("type: " + typeValue);

         // get the access modifier of type
         int mod1 = field1.getModifiers();
         String modifier1 = Modifier.toString(mod1);
         System.out.println("Modifier: " + modifier1);
         System.out.println(" ");
     }
     catch(Exception e) {
         e.printStackTrace();
     }
  }
}

Salida

tipo: labrador
Modificador: público

Ejemplo: acceso al campo privado

import java.lang.Class;
import java.lang.reflect.*;

class Dog {
 private String color;
}

class ReflectionDemo {
public static void main(String[] args) {
   try {
      Dog d1 = new Dog();
      // create an object of the class Class
      Class obj = d1.getClass();

      // accessing the private field
      Field field2 = obj.getDeclaredField("color");
     
      // making the private field accessible
      field2.setAccessible(true);
      // set the value of color
      field2.set(d1, "brown");
      // get the value of type converting in String
      String colorValue = (String)field2.get(d1);
      System.out.println("color: " + colorValue);

      // get the access modifier of color
      int mod2 = field2.getModifiers();
      String modifier2 = Modifier.toString(mod2);
      System.out.println("modifier: " + modifier2);
   }
   catch(Exception e) {
      e.printStackTrace();
   }
 }
}

Salida

color marrón
modificador: privado

---

Reflexión de los métodos de Java

Al igual que los campos, podemos inspeccionar diferentes métodos de una clase utilizando varios métodos proporcionados por la Methodclase.

• getMethods () : devuelve todos los métodos públicos de la clase y su superclase
• getDeclaredMethod () - devuelve todos los métodos de la clase
• getName () : devuelve el nombre de los métodos
• getModifiers () : devuelve el modificador de acceso de los métodos en forma entera
• getReturnType () : devuelve el tipo de método de retorno

Para conocer más métodos de la Methodvisita de clase, Clase de método .

Ejemplo: método de reflexión

import java.lang.Class;
import java.lang.reflect.*;

class Dog {
   public void display() {
      System.out.println("I am a dog.");
   }

   protected void eat() {
      System.out.println("I eat dog food.");
   }

   private void makeSound() {
      System.out.println("Bark Bark");
   }

}

class ReflectionDemo {
   public static void main(String[] args) {
      try {
          Dog d1 = new Dog();

          // create an object of Class
          Class obj = d1.getClass();
          
          // get all the methods using the getDeclaredMethod()
          Method[] methods = obj.getDeclaredMethods();

          // get the name of methods
          for(Method m : methods) {
               
             System.out.println("Method Name: " + m.getName());
              
             // get the access modifier of methods
             int modifier = m.getModifiers();
             System.out.println("Modifier: " + Modifier.toString(modifier));
              
             // get the return types of method
             System.out.println("Return Types: " + m.getReturnType());
             System.out.println(" ");
          }
       }
       catch(Exception e) {
           e.printStackTrace();
       }
   }
}

Salida

Nombre del método: display
Modificador: público
Tipo de retorno: vacío

Nombre del método: comer
Modificador: protegido
Tipo de retorno: vacío

Nombre del método: makeSound
Modificador: privado
Tipo de retorno: vacío

---

Reflexión del constructor

También podemos inspeccionar diferentes constructores de una clase usando varios métodos proporcionados por la Constructorclase.

• getConstructors () : devuelve todos los constructores públicos de una clase y superclase de la clase
• getDeclaredConstructor () - devuelve todos los constructores
• getName () : devuelve el nombre de los constructores
• getModifiers () - devuelve el modificador de acceso de constructores en forma entera
• getParameterCount () - devuelve el número de parámetros de constructores

Para conocer más métodos de la Constructorclase, visite la clase Constructor.

Ejemplo: reflexión del constructor

import java.lang.Class;
import java.lang.reflect.*;

class Dog {

   public Dog() {
      
   }
   public Dog(int age) {
      
   }

   private Dog(String sound, String type) {
      
   }
}

class ReflectionDemo {
   public static void main(String[] args) {
      try {
           Dog d1 = new Dog();
           Class obj = d1.getClass();

           // get all the constructors in a class using getDeclaredConstructor()
           Constructor[] constructors = obj.getDeclaredConstructors();

           for(Constructor c : constructors) {
           // get names of constructors
               System.out.println("Constructor Name: " + c.getName());

           // get access modifier of constructors
               int modifier = c.getModifiers();
               System.out.println("Modifier: " + Modifier.toString(modifier));

           // get the number of parameters in constructors
               System.out.println("Parameters: " + c.getParameterCount());
          }
       }
       catch(Exception e) {
           e.printStackTrace();
       }
    }
}

Salida

Nombre del constructor: Perro
Modificador: público
Parámetros: 0

Nombre del constructor: Perro
Modificador: público
Parámetros: 1

Nombre del constructor: Perro
Modificador: privado
Parámetros: 2