Reflexión (Reflection) en Java

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

En Java, la reflexión permite que verifiquemos y operemos con clases, interfaces, constructores, métodos y campos en tiempo de ejecución.

El nombre de la clase Java es Class

Antes de aprender sobre reflexión en Java, necesitamos entender una clase Java llamada Class.

En Java, hay una clase llamada Class que mantiene toda la información sobre los objetos y clases en tiempo de ejecución.

El objeto Class describe las propiedades de una clase específica. Este objeto se utiliza para realizar reflexión.

Crear objeto de la clase llamada Class

Podemos crear objetos Class de la siguiente manera:

• Usar método forName()

El método forName() acepta un parámetro de cadena (el nombre de la clase) y devuelve un objeto Class. El objeto devuelto hace referencia a la clase especificada por la cadena. Por ejemplo:

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

• Usar método getClass()

　El método getClass() utiliza un objeto de clase específica para crear un nuevo objeto Class. Por ejemplo:

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

• Usar .class

También podemos usar.classCrear objeto Class mediante el nombre del archivo de extensión. Por ejemplo:

Class c1　= Dog.class;

Después de crear el objeto Class, podemos usar estos objetos para realizar reflexión.

Obtener interfaz

Podemos usar el método getInterfaces() de Class para recopilar información sobre las interfaces implementadas por una clase. Este método devuelve un array de interfaces.

Ejemplo: obtener interfaz

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("Ladrar ladrar");
　　　}
}
class ReflectionDemo {
　　public static void main(String[] args) {
　　　　　　try {
　　　　　　　　　　//Crear un objeto de la clase Dog
　　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　//Crear un objeto de la clase Dog usando getClass()
　　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　
　　　　　　　　　　//Buscar interfaces implementadas por Dog
　　　　　　　　　　Class[] objInterface = obj.getInterfaces();
　　　　　　　　　　for(Class c : objInterface) {
　　　　　　　　　　　　　　//Imprimir nombre de interfaz
　　　　　　　　　　　　　　System.out.println("Nombre de interfaz: ")　+　c.getName());
　　　　　　　　　　}
　　　　　　}
　　　　　　catch(Exception e) {
　　　　　　　　　　e.printStackTrace();
　　　　　　}
　　　}
}

Resultado de salida

Nombre de la interfaz: Animal
Nombre de la interfaz: Mammal

Obtener la superclase y el modificador de acceso

El método getSuperclass() de la clase Class se puede usar para obtener información sobre la superclase de una clase específica.

Además, el Class proporciona un método getModifier() que devuelve los modificadores de la clase en forma de entero.

Ejemplo: obtener la superclase y el 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 {
　　　　　　　　　　　//Crear un objeto de la clase Dog
　　　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　　//Crear un objeto de la clase Dog usando getClass()
　　　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　　　　//Obtener el modificador de acceso de Dog en forma de entero
　　　　　　　　　　　int modifier = obj.getModifiers();
　　　　　　　　　　　System.out.println("Modificador: ");　+　Modifier.toString(modifier));
　　　　　　　　　　　//Encontrar la superclase de Dog
　　　　　　　　　　　Class superClass = obj.getSuperclass();
　　　　　　　　　　　System.out.println("Superclase: ")　+　superClass.getName());
　　　　　　　}
　　　　　　　catch(Exception e) {
　　　　　　　　　　　e.printStackTrace();
　　　　　　　}
　　　}
}

Resultado de salida

Modificador:　public
Superclase: Animal

Reflexión de campos, métodos y constructores

El paquete java.lang.reflect proporciona clases que se pueden usar para operar con miembros de la clase. Por ejemplo:

• Clase de método - Proporciona información sobre los métodos de la clase

• Clase de campo - Proporciona información sobre los campos de la clase

• Clase de constructor　 - Proporciona información sobre los constructores de la clase

Reflexión Java y campos

　Podemos usar varios métodos proporcionados por la clase Field para verificar y modificar diferentes campos de la clase.

• getFields() - Devolver todos los campos públicos de la clase y sus superclases

• getDeclaredFields()　 - Devolver todos los campos de la clase

• getModifier() - Devolver los modificadores del campo en forma de entero

• set(classObject,value) - Establecer el valor del campo con el valor especificado

• get(classObject) - Obtener el valor del campo

• setAccessible(boolean) - 使私有字段可访问

Nota:Si sabemos el nombre del campo, podemos usar

• getField("fieldName") - Devolver el nombre del campo desde la clasefieldNamedel campo público.

• getDeclaredField("fieldName") - Devolver el nombre del campo desde la clasefieldNamedel campo.
  

Ejemplo: acceder 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();
　　　　　　　　　　//Crear el objeto Class
　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　//操纵Dog类的公共字段type
　　　　　　　　　Field field1　= obj.getField("type");
　　　　　　　　//设置字段的值
　　　　　　　　　field1.set(d1, "labrador");
　　　　　　　　//通过转换成字符串来获取字段的值
　　　　　　　　　String typeValue = (String)field1.get(d1);
　　　　　　　　　System.out.println("type: ");　+　typeValue);
　　　　　　　　　//获取类型的访问修饰符
　　　　　　　　　int mod1　= field1.getModifiers();
　　　　　　　　　String modifier1　= Modifier.toString(mod1);
　　　　　　　　　System.out.println("Modificador: ");　+　modifier1);
　　　　　　　　　System.out.println(" ");
　　　　　}
　　　　　catch(Exception e) {
　　　　　　　　　e.printStackTrace();
　　　　　}
　　}
}

Resultado de salida

type: labrador
Modificador:　public

示例：访问私有字段

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();
　　　　　　//创建类Class对象
　　　　　　Class obj = d1.getClass();
　　　　　　//访问私有字段
　　　　　　Field field2　= obj.getDeclaredField("color");
　　　　　
　　　　　　//使私有字段可访问
　　　　　　field2.setAccessible(true);
　　　　　　//设置color值
　　　　　　field2.set(d1, "brown");
　　　　　　//　获取类型转换成字符串的值
　　　　　　String colorValue = (String)field2.get(d1);
　　　　　　System.out.println("color: ");　+　colorValue);
　　　　　　//获取color的访问修饰符
　　　　　　int mod2　= field2.getModifiers();
　　　　　　String modifier2　= Modifier.toString(mod2);
　　　　　　System.out.println("modifier: ");　+　modifier2);
　　　}
　　　catch(Exception e) {
　　　　　　e.printStackTrace();
　　　}
　}
}

Resultado de salida

color: brown
modifier: private

Java 反射与方法

像字段一样，我们可以使用Method类提供的各种方法来检查类的不同方法。

• getMethods() - 返回该类及其超类的所有公共方法

• getDeclaredMethod() - 返回该类的所有方法

• getName() - 返回方法的名称

• getModifiers() - 以整数形式返回方法的访问修饰符

• getReturnType() - 返回方法的返回类型

示例：方法反射

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();
　　　　　　　　　　//Crear un objeto Class
　　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　　　
　　　　　　　　　　//Obtener todos los métodos utilizando getDeclaredMethod()
　　　　　　　　　　Method[] methods = obj.getDeclaredMethods();
　　　　　　　　　　//Obtener el nombre del método
　　　　　　　　　　for(Method m : methods) {
　　　　　　　　　　　　　　　
　　　　　　　　　　　　　System.out.println("Nombre del método: ");　+　m.getName());
　　　　　　　　　　　　　　
　　　　　　　　　　　　　//Obtener el modificador de acceso del método
　　　　　　　　　　　　　int modifier = m.getModifiers();
　　　　　　　　　　　　　System.out.println("Modificador: ");　+　Modifier.toString(modifier));
　　　　　　　　　　　　　　
　　　　　　　　　　　　　//Obtener el tipo de retorno del método
　　　　　　　　　　　　　System.out.println("Return Types: ");　+　m.getReturnType());
　　　　　　　　　　　　　System.out.println(" ");
　　　　　　　　　　}
　　　　　　　}
　　　　　　　catch(Exception e) {
　　　　　　　　　　　e.printStackTrace();
　　　　　　　}
　　　}
}

Resultado de salida

Nombre del método: display
Modificador:　public
Return type: void
Nombre del método: eat
Modificador: protected
Tipo de retorno: void
Nombre del método: makeSound
Modificador:　private
Tipo de retorno: void

Reflexión Java y constructores

También podemos usar varios métodos proporcionados por la clase Constructor para verificar diferentes constructores de la clase.

• getConstructors() - Devuelve todos los constructores públicos de la clase y sus superclases

• getDeclaredConstructor() -Devuelve todos los constructores

• getName() - Devuelve el nombre del constructor

• getModifiers() - Devuelve el modificador de acceso del constructor en forma de entero

• getParameterCount() - Número de parámetros del constructor devuelto

Ejemplo: reflexión de constructores

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();
　　　　　　　　　　　//Obtener todos los constructores de una clase utilizando getDeclaredConstructor()
　　　　　　　　　　　Constructor[] constructors = obj.getDeclaredConstructors();
　　　　　　　　　　　for(Constructor c : constructors) {
　　　　　　　　　　　　　　　//Obtener el nombre del constructor
　　　　　　　　　　　　　　　System.out.println("Nombre del constructor: ");　+　c.getName());
　　　　　　　　　　　　　　　//Obtener el modificador de acceso del constructor
　　　　　　　　　　　　　　　int modifier = c.getModifiers();
　　　　　　　　　　　　　　　System.out.println("Modificador: ");　+　Modifier.toString(modifier));
　　　　　　　　　　　　　　　//Obtener la cantidad de parámetros del constructor
　　　　　　　　　　　　　　　System.out.println("Número de parámetros: ");　+　c.getParameterCount());
　　　　　　　　　　}
　　　　　　　}
　　　　　　　catch(Exception e) {
　　　　　　　　　　　e.printStackTrace();
　　　　　　　}
　　　　}
}

Resultado de salida

Nombre del constructor:　Dog
Modificador:　public
Número de parámetros:　0
Nombre del constructor:　Dog
Modificador:　public
Número de parámetros:　1
Nombre del constructor:　Dog
Modificador:　private
Número de parámetros:　2