Reflexão Java

Neste tutorial, aprenderemos a reflexão, um recurso da programação Java que nos permite inspecionar e modificar classes, métodos, etc.

Em Java, a reflexão nos permite inspecionar e manipular classes, interfaces, construtores, métodos e campos em tempo de execução.

Existe uma classe em Java chamada Class que mantém todas as informações sobre objetos e classes em tempo de execução. O objeto de Class pode ser usado para realizar a reflexão.

Reflexão das classes Java

Para refletir uma classe Java, primeiro precisamos criar um objeto de Class .

E, usando o objeto, podemos chamar vários métodos para obter informações sobre métodos, campos e construtores presentes em uma classe.

Existem três maneiras de criar objetos de Classe:

1. Usando o método forName()

class Dog {...}

// create object of Class
// to reflect the Dog class
Class a = Class.forName("Dog");

Aqui, o forName() O método leva o nome da classe a ser refletida como seu argumento.

2. Usando o método getClass()

// create an object of Dog class
Dog d1 = new Dog();

// create an object of Class
// to reflect Dog
Class b = d1.getClass();

Aqui, estamos usando o objeto do Dog class para criar um objeto de Class .

3. Usando a extensão .class

// create an object of Class
// to reflect the Dog class
Class c = Dog.class;

Agora que sabemos como podemos criar objetos do Class . Podemos usar este objeto para obter informações sobre a classe correspondente em tempo de execução.

Exemplo:Reflexão de classe 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();
    }
  }
}

Saída

Name: Dog
Modifier: public
Superclass: Animal

No exemplo acima, criamos uma superclasse:Animal e uma subclasse:Cão . Aqui, estamos tentando inspecionar a classe Cachorro .

Observe a afirmação,

Class obj = d1.getClass();

Aqui, estamos criando um objeto obj de Classe usando o getClass() método. Usando o objeto, estamos chamando diferentes métodos de Class .

obj.getName() - retorna o nome da classe
obj.getModifiers() - retorna o modificador de acesso da classe
obj.getSuperclass() - retorna a superclasse da classe

Para saber mais sobre Class , visite Java Class (documentação oficial do Java).

Observação :Estamos usando o Modifier class para converter o modificador de acesso inteiro em uma string.

Refletores de Campos, Métodos e Construtores

O pacote java.lang.reflect fornece classes que podem ser usadas para manipular membros de classe. Por exemplo,

Aula de método - fornece informações sobre métodos em uma classe
Classe de campo - fornece informações sobre campos em uma classe
Classe de construtor - fornece informações sobre construtores em uma classe

1. Reflexão de métodos Java

O Method class fornece vários métodos que podem ser usados para obter informações sobre os métodos presentes em uma classe. Por exemplo,

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();
    }
  }
}

Saída

Method Name: display
Modifier: public
Return Types: void
 
Method Name: makeSound
Modifier: private
Return Types: void

No exemplo acima, estamos tentando obter informações sobre os métodos presentes no Dog classe. Como mencionado anteriormente, primeiro criamos um objeto obj de Class usando o getClass() método.

Observe a expressão,

Method[] methods = obj.getDeclaredMethod();

Aqui, o getDeclaredMethod() retorna todos os métodos presentes dentro da classe.

Além disso, criamos um objeto m do Method classe. Aqui,

m.getName() - retorna o nome de um método
m.getModifiers() - retorna o modificador de acesso dos métodos na forma inteira
m.getReturnType() - retorna o tipo de retorno dos métodos

O Method A classe também fornece vários outros métodos que podem ser usados para inspecionar métodos em tempo de execução. Para saber mais, visite a classe Java Method (documentação oficial do Java).

2. Reflexão de campos Java

Assim como os métodos, também podemos inspecionar e modificar diferentes campos de uma classe usando os métodos do Field classe. Por exemplo,

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();
    }
  }
}

Saída

Value: labrador
Modifier: public

No exemplo acima, criamos uma classe chamada Dog . Inclui um campo público chamado type . Observe a afirmação,

Field field1 = obj.getField("type");

Aqui, estamos acessando o campo public do Dog class e atribuindo-a ao objeto field1 do Campo classe.

Em seguida, usamos vários métodos do Field classe:

campo1.set() - define o valor do campo
campo1.get() - retorna o valor do campo
field1.getModifiers() - retorna o valor do campo na forma inteira

Da mesma forma, também podemos acessar e modificar campos privados. No entanto, o reflexo do campo privado é um pouco diferente do campo público. Por exemplo,

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();
    }
  }
}

Saída

Value: brown
Modifier: private

No exemplo acima, criamos uma classe chamada Dog . A classe contém um campo privado chamado color . Observe a declaração.

Field field1 = obj.getDeclaredField("color");

field1.setAccessible(true);

Aqui, estamos acessando color e atribuindo-o ao objeto field1 do Field classe. Em seguida, usamos field1 para modificar a acessibilidade de color e nos permite fazer alterações nele.

Em seguida, usamos field1 para realizar várias operações na cor do campo privado.

Para saber mais sobre os diferentes métodos de Field , visite Java Field Class (documentação oficial do Java).

3. Reflexo do Construtor Java

Também podemos inspecionar diferentes construtores de uma classe usando vários métodos fornecidos pelo Constructor classe. Por exemplo,

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();
    }
  }
}

Saída

Constructor Name: Dog
Modifier: public     
Parameters: 0        

Constructor Name: Dog
Modifier: private    
Parameters: 1

No exemplo acima, criamos uma classe chamada Dog . A classe inclui dois construtores.

Estamos usando reflexão para encontrar as informações sobre os construtores da classe. Observe a afirmação,

Constructor[] constructors = obj.getDeclaredConstructor();

Aqui, estamos acessando todos os construtores presentes em Dog e atribuindo-os a um array construtores dos Constructor modelo.

Em seguida, usamos o objeto c para obter informações diferentes sobre o construtor.

c.getName() - retorna o nome do construtor
c.getModifiers() - retorna os modificadores de acesso do construtor na forma inteira
c.getParameterCount() - retorna o número de parâmetros presentes em cada construtor

Para saber mais sobre métodos do Constructor class, visite a classe Construtor

Java enum Strings Exceções Java

Java