Classi annidate statiche
Definisca classi annidate statiche come tipi di supporto associati, senza un riferimento all'istanza della classe contenitrice.
Classi annidate statiche è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.
Classi annidate statiche
Una classe annidata statica è definita all'interno di un'altra classe con la parola chiave static. Non contiene un riferimento all'istanza della classe esterna: è semplicemente raggruppata logicamente con essa.
Dichiarazione di una classe annidata statica
Utilizzi il nome della classe esterna per accedere alla classe annidata dall'esterno.
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;
}
}Accesso dall'esterno
Faccia riferimento a una classe annidata statica pubblica come 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 annidata statica e classe interna
La differenza principale è che le classi annidate statiche NON hanno un riferimento implicito all'istanza esterna. Le classi interne (non statiche) invece SÌ.
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
}
}
}Pattern Builder con classe annidata statica
Il classico pattern Builder utilizza una classe annidata statica, così i chiamanti non hanno bisogno di un'istanza esterna per creare un 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); }
}
}Entry nelle mappe
Map.Entry è una nota interfaccia annidata statica utilizzata per iterare sulle coppie chiave-valore.
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());
}Test con una classe annidata statica
Nei test unitari, una classe annidata statica può contenere fixture di test o implementazioni mock con visibilità limitata alla classe di test.
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 annidata statica per la logica di dominio
Raggruppi i tipi correlati utilizzando classi annidate statiche per organizzare meglio i modelli di dominio.
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; }
}
// ...
}Confronto: classe annidata statica e classe di primo livello
Preferisca una classe annidata statica quando una classe viene utilizzata solo nel contesto della classe esterna. Utilizzi una classe di primo livello quando ha un'applicabilità più ampia.
Classi annidate statiche con generics
Le classi annidate statiche partecipano ai generics proprio come le classi di primo livello.
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 30Efficienza della memoria
Le classi annidate statiche non mantengono un riferimento all'istanza esterna. Questo evita di conservare accidentalmente in memoria l'oggetto esterno, cosa che può causare perdite di memoria nelle strutture di lunga durata.
Verifica rapida
Che cosa distingue una classe annidata statica da una classe interna (non statica)?
Riepilogo: classi annidate statiche
Punti chiave:
- Le classi annidate statiche sono raggruppate con la classe esterna, ma non hanno un riferimento all'istanza esterna
- Accesso dall'esterno: OuterClass.NestedClass
- L'assenza di un riferimento implicito evita di conservare accidentalmente in memoria l'istanza esterna
- Il pattern Builder utilizza comunemente una classe Builder annidata statica
- Map.Entry è una nota interfaccia annidata statica
- Preferisca una classe annidata statica quando la classe interna non deve accedere all'istanza esterna
Domande Frequenti
La lezione «Classi annidate statiche» è gratuita?
Sì — il testo completo di «Classi annidate statiche» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.
Cosa imparerò in «Classi annidate statiche»?
Definisca classi annidate statiche come tipi di supporto associati, senza un riferimento all'istanza della classe contenitrice. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Java Academy?
Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Classi annidate statiche»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Java Academy?
Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Classi annidate statiche
- Classi interne e accesso alla classe esterna
- Classi locali e anonime
- Scegliere la strategia di annidamento più adatta