Reflexión Java
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.
Hay una clase en Java llamada Class que guarda toda la información sobre objetos y clases en tiempo de ejecución. El objeto de Clase se puede utilizar para realizar la reflexión.
Reflejo de las clases de Java
Para reflejar una clase de Java, primero debemos crear un objeto de Class .
Y, al usar el objeto, podemos llamar a varios métodos para obtener información sobre métodos, campos y constructores presentes en una clase.
Existen tres formas de crear objetos de Clase:
class Dog {...}
// create object of Class
// to reflect the Dog class
Class a = Class.forName("Dog");
Aquí, el forName() El método toma el nombre de la clase a reflejar como su argumento.
// create an object of Dog class
Dog d1 = new Dog();
// create an object of Class
// to reflect Dog
Class b = d1.getClass(); Aquí, estamos usando el objeto del Perro class para crear un objeto de Class .
// create an object of Class
// to reflect the Dog class
Class c = Dog.class;
Ahora que sabemos cómo podemos crear objetos del Class . Podemos usar este objeto para obtener información sobre la clase correspondiente en tiempo de ejecución.
Ejemplo:Reflexión de Clase Java
import java.lang.Class;
import java.lang.reflect.*;
class Animal {
}
// put this class in different Dog.java file
public class Dog extends Animal {
public void display() {
System.out.println("I am a dog.");
}
}
// put this in Main.java file
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// get name of the class
String name = obj.getName();
System.out.println("Name: " + name);
// get the access modifier of the class
int modifier = obj.getModifiers();
// convert the access modifier to string
String mod = Modifier.toString(modifier);
System.out.println("Modifier: " + mod);
// get the superclass of Dog
Class superClass = obj.getSuperclass();
System.out.println("Superclass: " + superClass.getName());
}
catch (Exception e) {
e.printStackTrace();
}
}
} Salida
Name: Dog Modifier: public Superclass: Animal
En el ejemplo anterior, hemos creado una superclase:Animal y una subclase:Perro . Aquí, estamos tratando de inspeccionar la clase Dog .
Note la declaración,
Class obj = d1.getClass();
Aquí, estamos creando un objeto obj de Clase usando el getClass() método. Usando el objeto, estamos llamando a diferentes métodos de Class .
- obj.getName() - devuelve el nombre de la clase
- obj.getModifiers() - devuelve el modificador de acceso de la clase
- obj.getSuperclase() - devuelve la superclase de la clase
Para obtener más información sobre Class , visite Java Class (documentación oficial de Java).
Nota :Estamos usando el Modifier class para convertir el modificador de acceso entero a una cadena.
Reflejo de campos, métodos y constructores
El paquete java.lang.reflect proporciona clases que se pueden usar para manipular miembros de clase. Por ejemplo,
- Clase de método - proporciona información sobre los métodos en una clase
- Clase de campo - proporciona información sobre los campos de una clase
- Clase de constructor - proporciona información sobre los constructores en una clase
1. Reflexión de los métodos de Java
El Method class proporciona varios métodos que se pueden usar para obtener información sobre los métodos presentes en una clase. Por ejemplo,
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
// methods of the class
public void display() {
System.out.println("I am a dog.");
}
private void makeSound() {
System.out.println("Bark Bark");
}
}
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// using object of Class to
// get all the declared methods of Dog
Method[] methods = obj.getDeclaredMethods();
// create an object of the Method class
for (Method m : methods) {
// get names of 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
Method Name: display Modifier: public Return Types: void Method Name: makeSound Modifier: private Return Types: void
En el ejemplo anterior, estamos tratando de obtener información sobre los métodos presentes en Dog clase. Como se mencionó anteriormente, primero hemos creado un objeto obj de Class usando el getClass() método.
Observe la expresión,
Method[] methods = obj.getDeclaredMethod();
Aquí, el getDeclaredMethod() devuelve todos los métodos presentes dentro de la clase.
Además, hemos creado un objeto m del Method clase. Aquí,
- m.getName() - devuelve el nombre de un método
- m.getModifiers() - devuelve el modificador de acceso de los métodos en forma de número entero
- m.getReturnType() - devuelve el tipo de retorno de los métodos
El Method La clase también proporciona varios otros métodos que se pueden usar para inspeccionar métodos en tiempo de ejecución. Para obtener más información, visite la clase Java Method (documentación oficial de Java).
2. Reflejo de Campos Java
Al igual que los métodos, también podemos inspeccionar y modificar diferentes campos de una clase usando los métodos del Field clase. Por ejemplo,
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
public String type;
}
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// access and set the type field
Field field1 = obj.getField("type");
field1.set(d1, "labrador");
// get the value of the field type
String typeValue = (String) field1.get(d1);
System.out.println("Value: " + typeValue);
// get the access modifier of the field type
int mod = field1.getModifiers();
// convert the modifier to String form
String modifier1 = Modifier.toString(mod);
System.out.println("Modifier: " + modifier1);
System.out.println(" ");
}
catch (Exception e) {
e.printStackTrace();
}
}
} Salida
Value: labrador Modifier: public
En el ejemplo anterior, hemos creado una clase llamada Perro . Incluye un campo público llamado tipo . Note la declaración,
Field field1 = obj.getField("type"); Aquí, estamos accediendo al campo público del Perro class y asignándolo al objeto field1 del Campo clase.
Luego usamos varios métodos del Field clase:
- campo1.set() - establece el valor del campo
- campo1.get() - devuelve el valor del campo
- campo1.getModifiers() - devuelve el valor del campo en forma de número entero
Del mismo modo, también podemos acceder y modificar campos privados. Sin embargo, el reflejo del campo privado es un poco diferente al campo público. Por ejemplo,
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
private String color;
}
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// access the private field color
Field field1 = obj.getDeclaredField("color");
// allow modification of the private field
field1.setAccessible(true);
// set the value of color
field1.set(d1, "brown");
// get the value of field color
String colorValue = (String) field1.get(d1);
System.out.println("Value: " + colorValue);
// get the access modifier of color
int mod2 = field1.getModifiers();
// convert the access modifier to string
String modifier2 = Modifier.toString(mod2);
System.out.println("Modifier: " + modifier2);
}
catch (Exception e) {
e.printStackTrace();
}
}
} Salida
Value: brown Modifier: private
En el ejemplo anterior, hemos creado una clase llamada Perro . La clase contiene un campo privado llamado color . Fíjate en la declaración.
Field field1 = obj.getDeclaredField("color");
field1.setAccessible(true);
Aquí, estamos accediendo a color y asignándolo al objeto field1 del Field clase. Luego usamos field1 para modificar la accesibilidad de color y nos permite realizar cambios en él.
Luego usamos field1 para realizar varias operaciones en el color del campo privado.
Para obtener más información sobre los diferentes métodos de Field , visite Java Field Class (documentación oficial de Java).
3. Reflejo de Java Constructor
También podemos inspeccionar diferentes constructores de una clase utilizando varios métodos proporcionados por Constructor clase. Por ejemplo,
import java.lang.Class;
import java.lang.reflect.*;
class Dog {
// public constructor without parameter
public Dog() {
}
// private constructor with a single parameter
private Dog(int age) {
}
}
class Main {
public static void main(String[] args) {
try {
// create an object of Dog
Dog d1 = new Dog();
// create an object of Class
// using getClass()
Class obj = d1.getClass();
// get all constructors of Dog
Constructor[] constructors = obj.getDeclaredConstructors();
for (Constructor c : constructors) {
// get the name of constructors
System.out.println("Constructor Name: " + c.getName());
// get the access modifier of constructors
// convert it into string form
int modifier = c.getModifiers();
String mod = Modifier.toString(modifier);
System.out.println("Modifier: " + mod);
// get the number of parameters in constructors
System.out.println("Parameters: " + c.getParameterCount());
System.out.println("");
}
}
catch (Exception e) {
e.printStackTrace();
}
}
} Salida
Constructor Name: Dog Modifier: public Parameters: 0 Constructor Name: Dog Modifier: private Parameters: 1
En el ejemplo anterior, hemos creado una clase llamada Perro . La clase incluye dos constructores.
Estamos usando la reflexión para encontrar la información sobre los constructores de la clase. Note la declaración,
Constructor[] constructors = obj.getDeclaredConstructor();
Aquí, estamos accediendo a todos los constructores presentes en Dog y asignándolos a una matriz constructores del Constructor tipo.
Luego usamos el objeto c para obtener diferentes informaciones sobre el constructor.
- c.getNombre() - devuelve el nombre del constructor
- c.getModifiers() - devuelve los modificadores de acceso del constructor en forma de número entero
- c.getParameterCount() - devuelve el número de parámetros presentes en cada constructor
Para conocer más métodos del Constructor clase, visita la clase Constructor
Java