Uma classe aninhada é uma classe definida dentro de outra classe. Java tem quatro tipos — aninhada estática, interna (não-estática), local e anônima — cada uma com acesso diferente à classe envolvente e casos de uso distintos.
public class Outer {
private static int data = 10;
static class Nested { // static → no reference to an Outer INSTANCE
void show() {
System.out.println(data); // can access static members of Outer only
}
}
}
Outer.Nested n = new Outer.Nested(); // created without an Outer instance
Uma classe aninhada static se comporta como uma classe de nível superior, mas é nomeada dentro da externa. Ela não mantém uma referência a uma instância externa — usada para agrupar utilitários (ex.: um Builder, Node em uma estrutura de dados).
public class Outer {
private int value = 5;
class Inner { // non-static → has an implicit reference to Outer
void show() {
System.out.println(value); // can access Outer's INSTANCE members (even private)
}
}
}
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // needs an Outer instance to create
Uma classe interna não-estática mantém uma referência implícita à sua instância envolvente, então pode acessar os campos de instância do objeto externo. (Cuidado: essa referência pode causar vazamentos de memória se a instância interna sobreviver à externa.)
void process() {
class Helper { // local to this method
void run() { ... }
}
new Helper().run();
}
Raramente usada; limitada ao escopo do método.
// implement an interface/abstract class inline, for single use
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) { handleClick(); }
});
Runnable task = new Runnable() {
public void run() { System.out.println("running"); }
};
Uma classe anônima é uma implementação única de uma interface ou classe, definida e instanciada de uma vez — historicamente comum para manipuladores de eventos e callbacks. Java moderno frequentemente substitui essas com lambdas quando o alvo é uma interface funcional:
button.addActionListener(e -> handleClick()); // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
Classes aninhadas são uma ferramenta útil para agrupar logicamente classes que são usadas apenas em um contexto, aumentando o encapsulamento e a legibilidade.
Entender os tipos — especialmente a distinção entre estática e interna (estática = independente, interna = mantém uma referência à instância envolvente) — importa tanto para o design quanto para evitar bugs: a referência externa implícita de classes internas pode causar vazamentos de memória, e escolher estática quando você não precisa da instância externa é o padrão mais limpo.
Classes anônimas eram a forma clássica de fornecer implementações inline (manipuladores de eventos, comparadores), e saber que elas são amplamente substituídas por lambdas para interfaces funcionais reflete fluência em Java moderno.
Elas aparecem em toda a biblioteca padrão (ex.: Map.Entry é uma interface aninhada, construtores são classes aninhadas estáticas), tornando-as conhecimento prático e frequentemente encontrado.
Uma biblioteca de perguntas de entrevista de TI com respostas detalhadas — de Júnior a Sênior.
Doar