Manipulação de Campos com Reflection em Java: A Classe Field

Para inspecionar e manipular os campos (variáveis de membro) de uma classe via Reflection, a API do Java fornece a classe java.lang.reflect.Field. Ela oferece métodos para acessar metadados e interagir com os valores dos campos. Os principais são:

String getName(): Retorna o nome do campo.
Class<?> getType(): Retorna o tipo do campo como um objeto Class.
int getModifiers(): Retorna um inteiro que representa os modificadores de acesso do campo (como public, private, final).
Object get(Object obj): Retorna o valor do campo para uma instância específica do objeto.
void set(Object obj, Object value): Atribui um novo valor ao campo de uma instância específica do objeto.

Acesso a Campos

O primeiro passo para manipular um campo é obter o objeto Field que o representa. A classe Class oferece métodos para isso:

Field[] getDeclaredFields(): Retorna um array com todos os campos declarados diretamente na classe, independentemente do modificador de acesso. Não inclui campos herdados.
Field getDeclaredField(String name): Retorna o campo com o nome especificado, declarado diretamente na classe. Lança NoSuchFieldException se não for encontrado.
Field[] getFields(): Retorna um array com os campos públicos da classe e de suas superclasses.
Field getField(String name): Retorna o campo público com o nome especificado, procurando também nas superclasses. Lança NoSuchFieldException se não for encontrado.

Vamos obter os campos declarados na classe Person:

import java.lang.reflect.*;

public class Program {
    public static void main(String[] args) {
        Class<Person> cl = Person.class;

        Field[] fields = cl.getDeclaredFields();
        for (Field f : fields) {
            System.out.printf("Tipo: %s, Nome: %s\n", f.getType().getName(), f.getName());
        }
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void print() {
        System.out.printf("Pessoa: %s, %d anos\n", name, age);
    }
}

A saída será:

Tipo: java.lang.String, Nome: name
Tipo: int, Nome: age

Acessando Campos Privados com `setAccessible`

Por padrão, a Reflection respeita o encapsulamento do Java. Uma tentativa de ler ou escrever em um campo privado (private) com os métodos get() ou set() resultará em uma IllegalAccessException.

Para contornar essa restrição, é necessário chamar o método setAccessible(true) no objeto Field.

field.setAccessible(true);

Esta chamada desativa a verificação de controle de acesso para este campo específico, permitindo a sua manipulação.

Cuidado: O uso de setAccessible(true) é um recurso que quebra o encapsulamento, um dos pilares da programação orientada a objetos. Ele deve ser usado com cautela, geralmente em frameworks, ferramentas de serialização ou testes, onde a manipulação do estado interno de objetos é necessária. O uso indiscriminado pode levar a um código frágil e de difícil manutenção.

Leitura e Escrita de Valores de Campos

Com o objeto Field em mãos e o acesso devidamente configurado, podemos ler e escrever seus valores.

Obtendo o Valor de um Campo (`get`)

O método get(Object obj) retorna o valor de um campo para uma determinada instância. O parâmetro obj é a instância da qual se deseja ler o valor.

import java.lang.reflect.*;

public class Program {
    public static void main(String[] args) {
        Person tom = new Person("Tom", 41);
        Class<?> cl = tom.getClass();

        try {
            Field nameField = cl.getDeclaredField("name");
            Field ageField = cl.getDeclaredField("age");

            // Torna os campos privados acessíveis
            nameField.setAccessible(true);
            ageField.setAccessible(true);

            // Obtém os valores dos campos para o objeto 'tom'
            Object nameValue = nameField.get(tom);
            Object ageValue = ageField.get(tom);

            System.out.println("Nome: " + nameValue); // Nome: Tom
            System.out.println("Idade: " + ageValue); // Idade: 41
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}
// Classe Person omitida para brevidade

Alterando o Valor de um Campo (`set`)

Para alterar o valor de um campo, o método set(Object obj, Object value) é utilizado. O parâmetro obj é a instância a ser modificada, e value é o novo valor.

import java.lang.reflect.*;

public class Program {
    public static void main(String[] args) {
        Person tom = new Person("Tom", 41);
        Class<?> cl = tom.getClass();

        try {
            Field nameField = cl.getDeclaredField("name");
            Field ageField = cl.getDeclaredField("age");

            // Torna os campos privados acessíveis
            nameField.setAccessible(true);
            ageField.setAccessible(true);

            System.out.println("Valores originais:");
            tom.print(); // Pessoa: Tom, 41 anos

            // Altera os valores dos campos no objeto 'tom'
            nameField.set(tom, "Bob");
            ageField.set(tom, 22);

            System.out.println("\nValores modificados:");
            tom.print(); // Pessoa: Bob, 22 anos
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}
// Classe Person omitida para brevidade

Assim, a Reflection oferece um mecanismo flexível para contornar o encapsulamento e interagir dinamicamente com o estado interno dos objetos.

Resumo

Classe Field: É a classe central da Reflection para representar e manipular os campos de uma classe.
Acesso a Campos: Use getDeclaredField() para obter qualquer campo declarado na classe (incluindo privados) e getField() para campos públicos (incluindo herdados).
Acesso a Privados: O método field.setAccessible(true) é essencial para desativar as verificações de acesso e poder manipular campos privados.
Leitura e Escrita: O método get(obj) lê o valor do campo de um objeto, e set(obj, value) escreve um novo valor nele.
Uso Consciente: Quebrar o encapsulamento com Reflection é um recurso avançado que deve ser utilizado com critério e conhecimento de suas implicações.