Reflexão (Reflection) Java

Neste tutorial, vamos aprender sobre reflection, que é uma característica do Java programming que permite que verifiquemos e modifiquemos classes, métodos, etc.

No Java, reflection permite que verifiquemos e operemos sobre classes, interfaces, construtores, métodos e campos no tempo de execução.

O nome da classe Java é Class

Antes de aprender sobre reflection no Java, precisamos entender uma classe Java chamada Class.

Existe uma classe chamada Class no Java, que mantém todas as informações sobre objetos e classes no tempo de execução.

O objeto Class descreve as propriedades de uma classe específica. Este objeto é usado para reflection.

Criar um objeto da classe chamada Class

Podemos criar objetos Class, através de:

• Usar o método forName()

O método forName() aceita um parâmetro de string (o nome da classe) e retorna um objeto Class. O objeto retornado faz referência à classe especificada pela string. Por exemplo,

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

• Usar o método getClass()

　O método getClass() usa um objeto específico da classe para criar um novo objeto Class. Por exemplo,

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

• Usar .class

Também podemos usar.classCriação de objetos Class por extensão de nome. Por exemplo,

Class c1　= Dog.class;

Após criar objetos Class, podemos usá-los para reflection.

Obter interface

Podemos usar o método getInterfaces() da classe Class para coletar informações sobre as interfaces implementadas pela classe. Este método retorna um array de interfaces.

Exemplo: Obter interface

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("Eu sou um cão.");
　　　}
　　　public void makeSound() {
　　　　　　System.out.println("Latir latir");
　　　}
}
class ReflectionDemo {
　　public static void main(String[] args) {
　　　　　　try {
　　　　　　　　　　//Criar um objeto da classe Dog
　　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　//Usar getClass() para criar objeto Class
　　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　
　　　　　　　　　　//Procurar interfaces implementadas por Dog
　　　　　　　　　　Class[] objInterface = obj.getInterfaces();
　　　　　　　　　　for(Class c : objInterface) {
　　　　　　　　　　　　　　//Imprimir o nome da interface
　　　　　　　　　　　　　　System.out.println("Nome da Interface: ")　+　c.getName());
　　　　　　　　　　}
　　　　　　}
　　　　　　catch(Exception e) {
　　　　　　　　　　e.printStackTrace();
　　　　　　}
　　　}
}

Resultados de saída

Nome da Interface: Animal
Nome da Interface: Mammal

Obter superclasse e modificador de acesso

O método getSuperclass() da classe Class pode ser usado para obter informações sobre a superclasse de um tipo específico.

Além disso, o Class oferece um método getModifier(), que retorna os modificadores da classe em forma inteira.

Exemplo: Obter superclasse e modificador de acesso

import java.lang.Class;
import java.lang.reflect.*;
interface Animal {
　　　public void display();
}
public class Dog implements Animal {
　　　public void display() {
　　　　　　　System.out.println("Eu sou um cão.");
　　　}
}
class ReflectionDemo {
　　　public static void main(String[] args) {
　　　　　　　try {
　　　　　　　　　　　//Criar um objeto da classe Dog
　　　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　　//Usar getClass() para criar objeto Class
　　　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　　　　//Obter modificador de acesso de Dog em forma inteira
　　　　　　　　　　　int modifier = obj.getModifiers();
　　　　　　　　　　　System.out.println("Modificador: ",　+　Modifier.toString(modifier));
　　　　　　　　　　　//Encontrar a superclasse de Dog
　　　　　　　　　　　Class superClass = obj.getSuperclass();
　　　　　　　　　　　System.out.println("Superclasse: ")　+　superClass.getName());
　　　　　　　}
　　　　　　　catch(Exception e) {
　　　　　　　　　　　e.printStackTrace();
　　　　　　　}
　　　}
}

Resultados de saída

Modificador:　public
Superclasse: Animal

Reflexão de campo, método e construtor

O pacote java.lang.reflect fornece classes que podem ser usadas para operar os membros da classe. Por exemplo:

• Classe Método - Fornecer informações sobre os métodos da classe

• Classe Campo - Fornecer informações sobre os campos da classe

• Classe Construtor　 - Fornecer informações sobre os construtores da classe

Reflexão Java com campos

　Podemos usar vários métodos fornecidos pela classe Field para verificar e modificar diferentes campos da classe.

• getFields() - Retornar todos os campos públicos da classe e de suas superclasses

• getDeclaredFields()　 - Retornar todos os campos da classe

• getModifier() - Retornar modificador do campo em forma inteira

• set(classObject, value) - Usar valor especificado para definir valor do campo

• get(classObject) - Obter valor do campo

• setAccessible(boolean) - Tornar o campo privado acessível

Atenção:Se conhecemos o nome do campo, podemos usar

• getField("fieldName") - Retornar nome do campo da classefieldNamedo campo público.

• getDeclaredField("fieldName") - Retornar nome do campo da classefieldNamedo campo.
  

Exemplo: Acessar 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();
　　　　　　　　　　//Criar objeto Class
　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　//Manipular o campo público type da classe Dog
　　　　　　　　　Field field1　= obj.getField("type");
　　　　　　　　//Definir o valor do campo
　　　　　　　　　field1.set(d1, "labrador");
　　　　　　　　//Obter o valor do campo convertendo em string
　　　　　　　　　String typeValue = (String)field1.get(d1);
　　　　　　　　　System.out.println("type: ",　+　typeValue);
　　　　　　　　　//Obter o modificador de acesso do tipo
　　　　　　　　　int mod1　= field1.getModifiers();
　　　　　　　　　String modifier1　= Modifier.toString(mod1);
　　　　　　　　　System.out.println("Modificador: ",　+　modifier1);
　　　　　　　　　System.out.println(" ");
　　　　　}
　　　　　catch(Exception e) {
　　　　　　　　　e.printStackTrace();
　　　　　}
　　}
}

Resultados de saída

type: labrador
Modificador:　public

Exemplo: acesso a 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();
　　　　　　//Criar objeto classe Class
　　　　　　Class obj = d1.getClass();
　　　　　　//Acessar campo privado
　　　　　　Field field2　= obj.getDeclaredField("color");
　　　　　
　　　　　　//Tornar o campo privado acessível
　　　　　　field2.setAccessible(true);
　　　　　　//Definir o valor do campo color
　　　　　　field2.set(d1, "brown");
　　　　　　//　Obter o valor do tipo convertendo em String
　　　　　　String colorValue = (String)field2.get(d1);
　　　　　　System.out.println("cor: ",　+　colorValue);
　　　　　　//Obter o modificador de acesso do campo color
　　　　　　int mod2　= field2.getModifiers();
　　　　　　String modifier2　= Modifier.toString(mod2);
　　　　　　System.out.println("modifier: ",　+　modifier2);
　　　}
　　　catch(Exception e) {
　　　　　　e.printStackTrace();
　　　}
　}
}

Resultados de saída

cor: brown
modificador: private

Java reflexão e métodos

Como os campos, podemos usar os vários métodos fornecidos pela classe Method para verificar diferentes métodos da classe.

• getMethods() - Retorna todos os métodos públicos da classe e de suas superclasses

• getDeclaredMethod() - Retorna todos os métodos da classe

• getName() - Retorna o nome do método

• getModifiers() - Retorna o modificador de acesso do método em forma inteira

• getReturnType() - Retorna o tipo de retorno do método

Exemplo: reflexão de método

import java.lang.Class;
import java.lang.reflect.*;
class Dog {
　　　public void display() {
　　　　　　System.out.println("Eu sou um cão.");
　　　}
　　　protected void eat() {
　　　　　　System.out.println("Eu como comida para cão.");
　　　}
　　　private void makeSound() {
　　　　　　System.out.println("Bark Bark");
　　　}
}
class ReflectionDemo {
　　　public static void main(String[] args) {
　　　　　　try {
　　　　　　　　　　Dog d1　= new Dog();
　　　　　　　　　　//Cria um objeto Class
　　　　　　　　　　Class obj = d1.getClass();
　　　　　　　　　　
　　　　　　　　　　//Usa getDeclaredMethod() para obter todos os métodos
　　　　　　　　　　Method[] methods = obj.getDeclaredMethods();
　　　　　　　　　　//Obtém o nome do método
　　　　　　　　　　for(Method m : methods) {
　　　　　　　　　　　　　　　
　　　　　　　　　　　　　System.out.println("Nome do método: ");　+　m.getName());
　　　　　　　　　　　　　　
　　　　　　　　　　　　　//Obtém o modificador de acesso do método
　　　　　　　　　　　　　int modifier = m.getModifiers();
　　　　　　　　　　　　　System.out.println("Modificador: ",　+　Modifier.toString(modifier));
　　　　　　　　　　　　　　
　　　　　　　　　　　　　//Obtém o tipo de retorno do método
　　　　　　　　　　　　　System.out.println("Return Types: ");　+　m.getReturnType());
　　　　　　　　　　　　　System.out.println(" ");
　　　　　　　　　　}
　　　　　　　}
　　　　　　　catch(Exception e) {
　　　　　　　　　　　e.printStackTrace();
　　　　　　　}
　　　}
}

Resultados de saída

Nome do método: display
Modificador:　public
Return type: void
Nome do método: eat
Modificador: protected
Retorno do tipo: void
Nome do método: makeSound
Modificador:　private
Retorno do tipo: void

Java reflexão e construtores

Podemos usar vários métodos fornecidos pela classe Constructor para verificar diferentes construtores da classe.

• getConstructors() - Retorna todos os construtores públicos da classe e da superclasse da classe

• getDeclaredConstructor() -Retorna todos os construtores

• getName() - Retorna o nome do construtor

• getModifiers() - Retorna o modificador de acesso do construtor em forma de inteiro

• getParameterCount() - Retorna o número de parâmetros do construtor

Exemplo: reflexão de construtores

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();
　　　　　　　　　　　//Obtém todos os construtores de uma classe usando getDeclaredConstructor()
　　　　　　　　　　　Constructor[] constructors = obj.getDeclaredConstructors();
　　　　　　　　　　　for(Constructor c : constructors) {
　　　　　　　　　　　　　　　//Obter o nome do construtor
　　　　　　　　　　　　　　　System.out.println("Nome do construtor: ",　+　c.getName());
　　　　　　　　　　　　　　　//Obter o modificador de acesso do construtor
　　　　　　　　　　　　　　　int modifier = c.getModifiers();
　　　　　　　　　　　　　　　System.out.println("Modificador: ",　+　Modifier.toString(modifier));
　　　　　　　　　　　　　　　//Obter o número de parâmetros do construtor
　　　　　　　　　　　　　　　System.out.println("Número de parâmetros: ",　+　c.getParameterCount());
　　　　　　　　　　}
　　　　　　　}
　　　　　　　catch(Exception e) {
　　　　　　　　　　　e.printStackTrace();
　　　　　　　}
　　　　}
}

Resultados de saída

Nome do construtor:　Dog
Modificador:　public
Número de parâmetros:　0
Nome do construtor:　Dog
Modificador:　public
Número de parâmetros:　1
Nome do construtor:　Dog
Modificador:　private
Número de parâmetros:　2