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
Class
que mantiene toda la información sobre objetos y clases en tiempo de ejecución.
El objeto de
Class
describe 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
Class
por- 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
Class
utilizando la extensión .class . Por ejemplo,
Class c1 = Dog.class;
Una vez que
Class
se crean los objetos de , podemos usar estos objetos para realizar la reflexión.Obtener interfaces
Podemos utilizar el
getInterfaces()
método de Class
recopilar 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 Class
se puede utilizar para obtener información sobre la superclase de una clase en particular.
Y también,
Class
proporciona 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.reflect
proporciona 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
Field
clase.- 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
Field
visita 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
Method
clase.- 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
Method
visita 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
Constructor
clase.- 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
Constructor
clase, 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
0 Comentarios
Dejanos tu comentario para seguir mejorando!