Java Academy · Aula

Classes Locais e Anônimas

Declare classes dentro de métodos e crie implementações anônimas de interfaces dinamicamente.

Classes Locais e Anônimas é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Classes locais e anônimas

Classes locais são definidas dentro de um método. Classes anônimas são classes locais sem nome — elas combinam a declaração e a instanciação da classe. Ambas capturam variáveis locais efetivamente finais.

Declaração de classe local

Uma classe local é declarada dentro do corpo de um método. Ela pode acessar os membros da classe envolvente e as variáveis locais efetivamente finais.

static void greet(String language) {
    // Local class — defined inside the method
    class Greeter {
        String sayHello(String name) {
            // Can access 'language' — it is effectively final
            return switch (language) {
                case "EN" -> "Hello, " + name;
                case "ES" -> "Hola, " + name;
                case "FR" -> "Bonjour, " + name;
                default   -> "Hi, " + name;
            };
        }
    }

    Greeter g = new Greeter();
    System.out.println(g.sayHello("Alice"));
}
greet("ES"); // Hola, Alice

Variáveis efetivamente finais

Classes locais e anônimas só podem capturar variáveis locais que sejam efetivamente finais — elas nunca são atribuídas novamente após a inicialização.

void process(int threshold) {
    // threshold is effectively final (never reassigned)
    Runnable r = new Runnable() {
        public void run() {
            System.out.println("Threshold: " + threshold);
        }
    };
    r.run();

    // threshold = 10; // If you add this, the anonymous class won't compile
}

Noções básicas sobre classes anônimas

Uma classe anônima implementa uma interface ou estende uma classe diretamente, em uma única expressão.

interface Comparator<T> {
    int compare(T a, T b);
}

// Anonymous class implementing Comparator
java.util.Comparator<String> byLength = new java.util.Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return Integer.compare(a.length(), b.length());
    }
};

List<String> words = new ArrayList<>(List.of("banana", "fig", "apple", "kiwi"));
words.sort(byLength);
System.out.println(words); // [fig, kiwi, apple, banana]

Classe anônima ou lambda

Para interfaces de método único abstrato (SAM), as lambdas substituem as classes anônimas. As classes anônimas ainda são necessárias para interfaces com vários métodos ou ao estender classes abstratas.

// Anonymous class for single-method interface
Runnable r1 = new Runnable() {
    public void run() { System.out.println("Running!"); }
};

// Lambda — cleaner for SAM interfaces
Runnable r2 = () -> System.out.println("Running!");

// Must use anonymous class for multi-method interface:
java.io.FilenameFilter filter = new java.io.FilenameFilter() {
    public boolean accept(java.io.File dir, String name) {
        return name.endsWith(".java");
    }
}; // FilenameFilter is not a SAM — no lambda shorthand

Classe anônima com estado

As classes anônimas podem ter campos, ao contrário das lambdas. Isso é útil quando é necessário manter um estado dentro da implementação anônima.

interface Counter { int increment(); int get(); }

Counter counter = new Counter() {
    private int count = 0;

    public int increment() { return ++count; }
    public int get()       { return count; }
};

System.out.println(counter.increment()); // 1
System.out.println(counter.increment()); // 2
System.out.println(counter.get());       // 2

Padrão de ouvinte anônimo

Antes das lambdas, as classes anônimas eram o padrão para ouvintes de eventos na programação de GUI e Android.

// Modern Android/Swing style: anonymous class listener
Button loginButton = new Button(); // hypothetical
loginButton.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick() {
        System.out.println("Login button clicked!");
    }
});

// Modern equivalent with lambda (if OnClickListener is SAM):
loginButton.setOnClickListener(() -> System.out.println("Clicked!"));

Classe local para lógica complexa

As classes locais funcionam bem quando é necessário ter uma classe com vários métodos em um único lugar — algo complexo demais para uma lambda, mas específico demais para uma classe de nível superior.

static List<String> processData(List<String> data, String prefix) {
    // Local class: complex enough for a class, used only here
    class DataProcessor {
        List<String> result = new ArrayList<>();

        void process(String item) {
            // prefix is effectively final
            if (item.startsWith(prefix)) {
                result.add(item.toUpperCase());
            }
        }
    }
    DataProcessor dp = new DataProcessor();
    data.forEach(dp::process);
    return dp.result;
}
System.out.println(processData(List.of("apple","avocado","banana"), "a"));
// [APPLE, AVOCADO]

Classe anônima para classe abstrata

As classes anônimas podem estender classes abstratas, substituindo métodos abstratos sem criar uma subclasse nomeada.

abstract class ReportFormatter {
    abstract String formatHeader(String title);
    abstract String formatBody(List<String> rows);

    String format(String title, List<String> rows) {
        return formatHeader(title) + "\n" + formatBody(rows);
    }
}

ReportFormatter csvFormatter = new ReportFormatter() {
    public String formatHeader(String t) { return "\"" + t + "\""; }
    public String formatBody(List<String> rows) {
        return String.join("\n", rows);
    }
};
System.out.println(csvFormatter.format("Sales", List.of("a,1","b,2")));

Antipadrão da inicialização com chaves duplas

O truque da inicialização com chaves duplas usa classes anônimas para inicializar coleções. Ele cria uma subclasse com um inicializador de instância. Evite-o — é ineficiente e propenso a erros.

// Anti-pattern: double-brace initialization
Map<String, Integer> map = new HashMap<String, Integer>() {{
    put("a", 1);
    put("b", 2);
}};
// Creates an anonymous HashMap subclass — wasteful!

// GOOD: use Map.of() or Map.ofEntries()
Map<String, Integer> better = Map.of("a", 1, "b", 2);

// Or a mutable map:
Map<String, Integer> mutable = new HashMap<>(Map.of("a", 1, "b", 2));

Escolha: lambda, anônima ou local

Guia de decisão:

Lambda: método abstrato único, sem estado adicional e sem herança
Classe anônima: vários métodos, necessidade de estado ou extensão de uma classe abstrata
Classe local: necessidade de reutilização dentro do método, vários métodos ou estado complexo

Verificação rápida

O que uma classe anônima sempre faz em uma única expressão?

Recapitulação: classes locais e anônimas

Principais conclusões:

As classes locais são definidas dentro de métodos e podem acessar variáveis locais efetivamente finais
As classes anônimas combinam a declaração e a instanciação da classe em uma única expressão
As classes anônimas podem ter campos e vários métodos — ao contrário das lambdas
As lambdas substituem classes anônimas para interfaces de método único abstrato
Use classes locais quando a lógica for complexa o suficiente para exigir uma classe, mas específica de um único método
Evite a inicialização com chaves duplas — ela cria subclasses anônimas desnecessárias

Perguntas Frequentes

A aula “Classes Locais e Anônimas” é grátis?

Sim — o texto completo de “Classes Locais e Anônimas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Classes Locais e Anônimas”?

Declare classes dentro de métodos e crie implementações anônimas de interfaces dinamicamente. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Classes Locais e Anônimas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Classes Aninhadas Estáticas
Classes Internas e Acesso à Classe Externa
Classes Locais e Anônimas
Escolha da Estratégia de Aninhamento

← Voltar para Java Academy