¿Qué es la reflexión en Java
- Objeto de clase
-
Clase
forName()Método en Java -
Clase
getClass()Método en Java - Métodos útiles para la reflexión en Java
- Métodos útiles para la reflexión sobre los métodos
- Métodos útiles para la reflexión sobre campos
- Conclusión
Este tutorial presenta el reflejo y cómo usarlo en Java. Java tiene una función de API de reflexión que nos permite inspeccionar y modificar clases, interfaces, etc.
En este tutorial, aprendemos qué es la API de reflexión y sus usos. Reflection en Java nos permite observar y alterar clases, interfaces, constructores, métodos y campos durante el tiempo de ejecución, incluso si no conocemos el nombre de la clase durante el tiempo de compilación.
La creación de nuevos objetos, la invocación de métodos y la obtención/establecimiento de valores de campo se pueden realizar con reflexión. Entendamos con algunos ejemplos.
Primero debemos importar el siguiente paquete para usar la API de reflexión.
java.lang.reflect.*
Importa todas las clases contenidas en la API de reflexión.
Objeto de clase
Después de importar el paquete, necesitamos crear un objeto de clase para usar los métodos API de reflexión.
La clase existe en Java ya que realiza un seguimiento de todos los datos sobre objetos y clases durante el tiempo de ejecución. La reflexión se puede ejecutar en el objeto Clase.
Un objeto de clase se puede crear de tres maneras. Examinaremos cada método uno por uno.
Pero antes de eso, creemos una clase que usaremos a lo largo de este tutorial.
class Furniture {
public String name;
private int price;
public Furniture(String name, int price) {
this.name = name;
this.price = price;
}
public void update_price(int up_price) {
this.price = up_price;
}
private float cal_discount(int discount) {
float discounted_price = (1 - discount / 100) * this.price;
return discounted_price;
}
}
Ahora, vamos a crear un objeto de clase Clase de la clase muebles.
Clase forName() Método en Java
Class class proporciona un método forName() para cargar objetos.
Para utilizar este método, debemos conocer el nombre de la clase sobre la que queremos reflexionar. Luego pasamos el nombre de la clase como argumento al método forName().
Mira el código a continuación:
Class class
= Class.forName("Furniture");
Este método lanza una excepción ClassNotFoundException si Java no puede encontrar la clase.
Clase getClass() Método en Java
Llamamos a este método sobre el objeto de la clase sobre el que queremos reflexionar. Este método devuelve la clase del objeto.
Mira el código a continuación:
Furniture furniture = new Furniture("Chair", 8565);
Class f = furniture.getClass();
También podemos usar la función .class para obtener objetos de clase para la reflexión.
// create a class object to relect on furniture
Class f = Furniture.class;
Métodos útiles para la reflexión en Java
El objeto de clase tiene los tres métodos siguientes, que se pueden utilizar para reflexionar sobre la clase.
getName(): Este método devuelve el nombre de la clase.getModifiers(): Este método devuelve un número entero que representa el modificador de acceso de la clase. Luego podemos convertir este entero a String usando el métodoModifier.toString().getSuperclass(): Este método devuelve la Superclase del método.
Veamos un ejemplo para entender estos métodos.
import java.lang.reflect.Modifier;
public class SimpleTesting {
public static void main(String[] args) {
// create an object of furniture class
Furniture furniture = new Furniture("Chair", 8565);
// create a class object to relect on furniture
Class f = furniture.getClass();
// get the name of the class
String class_name = f.getName();
System.out.println("The class name is " + class_name);
// get the class modifier
int f_modifier = f.getModifiers();
String f_mod = Modifier.toString(f_modifier);
System.out.println("The modifier of the class is " + f_mod);
// get the superclass of the class
Class f_superclass = f.getSuperclass();
System.out.println("The Superclass of the class is " + f_superclass.getName());
}
}
Producción :
The class name is Furniture
The modifier of the class is
The Superclass of the class is java.lang.Object
Métodos útiles para la reflexión sobre los métodos
Java proporciona una clase llamada Método que se ocupa de los métodos durante la reflexión.
Un método llamado getDeclaredMethods() devuelve un array de todos los métodos definidos en la clase. Los métodos devueltos pertenecen a la clase Method.
La clase Method contiene varios métodos para recuperar información sobre los métodos de una clase. Usaremos los siguientes métodos de la clase de método:
Method.getName(): Este método devuelve el nombre del método.Method.getModifiers(): Este método devuelve un número entero que representa el modificador de acceso del método.Method.getReturnType(): Este método devuelve el tipo de retorno del método.
Veamos un ejemplo para entender estos métodos.
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class SimpleTesting {
public static void main(String[] args) {
// create an object of furniture class
Furniture furniture = new Furniture("Chair", 8565);
// create a class object to relect on furniture
Class f = furniture.getClass();
// using object f of Class to
// get all the declared methods of Furniture
Method[] f_methods = f.getDeclaredMethods();
for (Method f_method : f_methods) {
// get the name of the method
System.out.println("Method Name: " + f_method.getName());
// get the access modifier of methods
int f_modifier = f_method.getModifiers();
System.out.println("Modifier: " + Modifier.toString(f_modifier));
// get the return type of the methods
System.out.println("Return Types: " + f_method.getReturnType());
System.out.println(" ");
}
}
}
Producción :
Method Name: update_price
Modifier: public
Return Types: void
Method Name: cal_discount
Modifier: private
Return Types: float
En el ejemplo anterior, estamos tratando de conocer los métodos definidos en la clase Mobiliario. Primero tenemos que crear un objeto Class usando el método getClass().
Métodos útiles para la reflexión sobre campos
También podemos inspeccionar y cambiar diferentes campos de una clase usando los métodos de la clase Field. Hay un método llamado.
class.getField
(<field name>)
Este método toma un argumento: el nombre del campo al que queremos acceder y devuelve un objeto Field del campo pasado. Luego podemos usar el objeto de la clase Field para llamar a varios métodos.
Usaremos los siguientes métodos de la clase Field.
Field.set(): Este método establece el valor del campo.Field.get(): Este método devuelve el valor almacenado en el campo.Field.getModifier(): Este método devuelve un número entero que representa el modificador de acceso del campo.
Veamos un ejemplo para entender estos métodos.
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class SimpleTesting {
public static void main(String[] args) throws Exception {
// create object of the furniture class
Furniture furniture = new Furniture("Chair", 8565);
// create a class object to relect on furniture
Class f = furniture.getClass();
// using object f of Class to
// acces the name field of Furniture
Field f_name = f.getField("name");
// get the value of the field
String f_name_value = (String) f_name.get(furniture);
System.out.println("Field value before changing: " + f_name_value);
// changing the field value
f_name.set(furniture, "Table");
// get the value of the field
f_name_value = (String) f_name.get(furniture);
System.out.println("Field value after changing: " + f_name_value);
// get the access modifier
int f_name_mod = f_name.getModifiers();
// convert the access modifier to String form
String f_name_modifier = Modifier.toString(f_name_mod);
System.out.println("Modifier: " + f_name_modifier);
System.out.println(" ");
}
}
Producción :
Field value before changing: Chair
Field value after changing: Table
Modifier: public
Acceder a un campo privado es similar excepto que tenemos que modificar la accesibilidad del campo privado usando el método setAccessible() y pasando true como argumento.
Mire el código de ejemplo a continuación; estamos tratando de acceder y modificar el precio del campo privado de la clase Mobiliario.
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class SimpleTesting {
public static void main(String[] args) throws Exception {
// create object of the furniture class
Furniture furniture = new Furniture("Chair", 8565);
// create a class object to reflect on furniture
Class f = furniture.getClass();
// using object f of Class to
// access the price field of Furniture
Field f_price = f.getDeclaredField("price");
// modifying the accessibility
f_price.setAccessible(true);
// get the value of the field
int f_price_value = (Integer) f_price.get(furniture);
System.out.println("Field value before changing: " + f_price_value);
// changing the field value
f_price.set(furniture, 453);
// get the value of the field
f_price_value = (Integer) f_price.get(furniture);
System.out.println("Field value after changing: " + f_price_value);
// get the access modifier
int f_price_mod = f_price.getModifiers();
// convert the access modifier to String form
String f_price_modifier = Modifier.toString(f_price_mod);
System.out.println("Modifier: " + f_price_modifier);
System.out.println(" ");
}
}
Producción :
Field value before changing: 8565
Field value after changing: 453
Modifier: private
Conclusión
Tenemos una comprensión suficiente de la reflexión en Java después de leer este artículo.
También estudiamos las clases y métodos en Java utilizados para la reflexión. Aprendimos cómo obtener el nombre de la clase y sus métodos y campos.
Usando la API de reflexión, podemos obtener rápidamente información sobre la clase.