Classes Aninhadas Estáticas
Defina classes aninhadas estáticas como tipos auxiliares associados, sem uma referência à instância envolvente.
Classes Aninhadas Estáticas é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 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 nested estáticas
Uma classe aninhada estática (nested) é definida dentro de outra classe com a palavra-chave static. Ela não tem uma referência à instância da classe externa — é apenas agrupada logicamente com ela.
Declarando uma classe nested estática
Use o nome da classe externa para acessar a classe nested a partir de fora.
class LinkedList<T> {
private Node<T> head;
// Static nested class — no outer instance reference
private static class Node<T> {
T data;
Node<T> next;
Node(T data) { this.data = data; }
}
public void addFirst(T item) {
Node<T> node = new Node<>(item);
node.next = head;
head = node;
}
}Acessando a partir de fora
Faça referência a uma classe nested estática pública como OuterClass.InnerClass.
class Builder {
public static class Config {
public final String host;
public final int port;
Config(String host, int port) {
this.host = host; this.port = port;
}
}
}
Builder.Config config = new Builder.Config("localhost", 8080);
System.out.println(config.host + ":" + config.port); // localhost:8080Classe nested estática versus Inner
A principal diferença: classes nested estáticas não têm uma referência implícita à instância externa (NOT). Classes Inner (não estáticas) têm essa referência (DO).
class Outer {
private int x = 10;
// Static nested: no access to x
static class StaticNested {
void doSomething() {
// System.out.println(x); // compile error — no outer reference!
System.out.println("Static nested");
}
}
// Inner class: has access to x
class Inner {
void doSomething() {
System.out.println(x); // 10 — can access outer fields
}
}
}Padrão Builder com classe nested estática
O padrão Builder clássico usa uma classe nested estática para que quem chama o código não precise de uma instância externa para criar um Builder.
class Pizza {
private final String size, crust;
private final List<String> toppings;
private Pizza(Builder b) {
this.size = b.size; this.crust = b.crust; this.toppings = List.copyOf(b.toppings);
}
public static class Builder {
private String size = "medium", crust = "thin";
private List<String> toppings = new ArrayList<>();
public Builder size(String s) { this.size = s; return this; }
public Builder crust(String c) { this.crust = c; return this; }
public Builder topping(String t) { this.toppings.add(t); return this; }
public Pizza build() { return new Pizza(this); }
}
}Entrada em mapas
Map.Entry é uma conhecida interface nested estática usada para iterar sobre pares de chave e valor.
import java.util.*;
Map<String, Integer> scores = Map.of("Alice", 95, "Bob", 87, "Carol", 92);
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
System.out.printf("%-10s: %d%n", entry.getKey(), entry.getValue());
}
// Modern: using var
for (var entry : scores.entrySet()) {
System.out.println(entry.getKey() + " -> " + entry.getValue());
}Testando com uma classe nested estática
Em testes unitários, uma classe nested estática pode armazenar dados de suporte para testes ou implementações simuladas limitadas ao escopo da classe de teste.
class UserServiceTest {
// Static nested fake/stub — no outer instance needed
static class FakeUserRepository implements UserRepository {
private final Map<Long, User> store = new HashMap<>();
public void save(User u) { store.put(u.id(), u); }
public Optional<User> findById(long id) {
return Optional.ofNullable(store.get(id));
}
}
// @Test methods use FakeUserRepository
void testFindUser() {
FakeUserRepository repo = new FakeUserRepository();
// ...
}
}Classe nested estática para lógica de domínio
Agrupe tipos relacionados usando classes nested estáticas para melhorar a organização nos modelos de domínio.
class Order {
private final long id;
private final List<LineItem> items;
// Static nested — logically belongs to Order, no outer reference needed
public static class LineItem {
public final String sku;
public final int quantity;
public final double unitPrice;
public LineItem(String sku, int qty, double price) {
this.sku = sku; this.quantity = qty; this.unitPrice = price;
}
public double total() { return quantity * unitPrice; }
}
// ...
}Comparação: classe nested estática versus classe de nível superior
Prefira uma classe nested estática quando ela for usada apenas no contexto da classe externa. Use uma classe de nível superior quando ela tiver uma aplicabilidade mais ampla.
Classe nested estática com tipos genéricos
Classes nested estáticas participam dos tipos genéricos assim como as classes de nível superior.
class Pair<A, B> {
// Static nested with its own type params
public static class Mutable<X, Y> {
public X first;
public Y second;
public Mutable(X first, Y second) {
this.first = first; this.second = second;
}
}
public static <X, Y> Mutable<X, Y> mutableOf(X x, Y y) {
return new Mutable<>(x, y);
}
}
Pair.Mutable<String, Integer> p = Pair.mutableOf("Alice", 30);
System.out.println(p.first + " is " + p.second); // Alice is 30Eficiência de memória
Classes nested estáticas não mantêm uma referência à instância externa. Isso evita reter acidentalmente o objeto externo na memória, o que pode causar vazamentos de memória em estruturas de longa duração.
Verificação rápida
O que distingue uma classe nested estática de uma classe Inner (não estática)?
Recapitulação: classes nested estáticas
Principais conclusões:
- Classes nested estáticas são agrupadas com a classe externa, mas não têm uma referência à instância externa
- Acesso a partir de fora: OuterClass.NestedClass
- A ausência de uma referência implícita evita a retenção acidental da instância externa na memória
- O padrão Builder normalmente usa uma classe Builder nested estática
- Map.Entry é uma conhecida interface nested estática
- Prefira uma classe nested estática quando a classe interna não precisar acessar a instância externa
Perguntas Frequentes
A aula “Classes Aninhadas Estáticas” é grátis?
Sim — o texto completo de “Classes Aninhadas Estáticas” é 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 Aninhadas Estáticas”?
Defina classes aninhadas estáticas como tipos auxiliares associados, sem uma referência à instância envolvente. 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 1 de 4.
Quanto tempo leva a aula “Classes Aninhadas Estáticas”?
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