Modificadores de Campos e Métodos com Reflection em Java

Ao inspecionar uma classe com Reflection, muitas vezes é crucial saber não apenas quais membros existem, mas também como eles foram declarados. Para isso, a API oferece a classe utilitária java.lang.reflect.Modifier.

As classes Field, Method, Constructor e a própria Class possuem o método getModifiers(). Ele retorna um valor do tipo int que representa os modificadores aplicados ao membro ou tipo. Este valor não é um número comum; ele funciona como um conjunto de bit flags (máscaras de bits), em que cada bit indica a presença ou ausência de um modificador específico, como public, static ou final.

A classe Modifier fornece métodos estáticos para decodificar esse valor e verificar quais modificadores estão presentes, como:

isPublic(int mod)
isPrivate(int mod)
isProtected(int mod)
isStatic(int mod)
isFinal(int mod)
isAbstract(int mod)
isSynchronized(int mod)
entre outros.

Decodificação Manual dos Modificadores

É possível verificar manualmente a presença de cada modificador. Isso é útil quando sua lógica precisa reagir a modificadores específicos — por exemplo, ignorar campos estáticos (static).

import java.lang.reflect.*;

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

        Field[] fields = cl.getDeclaredFields();

        System.out.println("Análise dos campos da classe Person:");
        for (Field f : fields) {
            int mod = f.getModifiers(); // valor inteiro com os modificadores

            // Verificação manual dos modificadores
            if (Modifier.isPublic(mod))   System.out.print("public ");
            if (Modifier.isPrivate(mod))  System.out.print("private ");
            if (Modifier.isProtected(mod))System.out.print("protected ");

            if (Modifier.isStatic(mod))   System.out.print("static ");

            // Tipo e nome do campo
            System.out.printf("%s %s;%n", f.getType().getName(), f.getName());
        }
    }
}

class Person {
    public String name;
    private int id;
    private static int count;

    public String getName() { return name; }
    public static int getCount() { return count; }

    Person(String name) {
        this.name = name;
        this.id = ++count;
    }
}

Saída esperada:

Análise dos campos da classe Person:
public java.lang.String name;
private int id;
private static int count;

Aplicando o Mesmo Conceito a Métodos

O mesmo processo vale para métodos. Basta iterar sobre os métodos obtidos com getDeclaredMethods().

Method[] methods = Person.class.getDeclaredMethods();

System.out.println("Análise dos métodos da classe Person:");
for (Method m : methods) {
    int mod = m.getModifiers();

    // Verificação manual dos modificadores
    if (Modifier.isPublic(mod))   System.out.print("public ");
    if (Modifier.isPrivate(mod))  System.out.print("private ");
    if (Modifier.isProtected(mod))System.out.print("protected ");

    if (Modifier.isStatic(mod))   System.out.print("static ");

    // Tipo de retorno e nome do método
    System.out.printf("%s %s();%n", m.getReturnType().getName(), m.getName());
}

Saída (parcial):

Análise dos métodos da classe Person:
public java.lang.String getName();
public static int getCount();

Simplificando com `Modifier.toString()`

Quando não é necessário tratar modificadores individualmente, a classe Modifier oferece o método toString(int mod), que converte o valor inteiro em uma representação textual com todos os modificadores, na ordem canônica do Java.

import java.lang.reflect.*;

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

        Field[] fields = cl.getDeclaredFields();
        System.out.println("Campos:");
        for (Field f : fields) {
            String modifiers = Modifier.toString(f.getModifiers());
            System.out.printf("%s %s %s;%n",
                modifiers,
                f.getType().getName(),
                f.getName()
            );
        }

        Method[] methods = cl.getDeclaredMethods();
        System.out.println("\nMétodos:");
        for (Method m : methods) {
            String modifiers = Modifier.toString(m.getModifiers());
            System.out.printf("%s %s %s();%n",
                modifiers,
                m.getReturnType().getName(),
                m.getName()
            );
        }
    }
}

O uso de toString() torna o código mais enxuto e fácil de manter, sem perder clareza.

Resumo

Classe Modifier: Utilitária da Reflection para decodificar modificadores de classes e membros (public, static, final, etc.).
getModifiers(): Método presente em Field, Method, Constructor e Class que retorna um inteiro representando os modificadores como máscaras de bits.
Duas Abordagens:
1. Manual (isPublic, isStatic etc.): Útil quando é preciso reagir a modificadores específicos em tempo de execução.
2. Automática (toString()): Ideal para logs, depuração ou exibição, fornecendo uma descrição textual completa dos modificadores.

Com essas técnicas, é possível inspecionar de forma detalhada tanto campos quanto métodos de qualquer classe, adaptando a saída de acordo com a necessidade da aplicação.