Statische verschachtelte Klassen
Definieren Sie statische verschachtelte Klassen als zugehörige Hilfstypen ohne Referenz auf eine einschließende Instanz.
Statische verschachtelte Klassen ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Statische verschachtelte Klassen
Eine statische verschachtelte Klasse wird innerhalb einer anderen Klasse mit dem Schlüsselwort static definiert. Sie enthält keine Referenz auf die Instanz der äußeren Klasse – sie ist lediglich logisch mit ihr gruppiert.
Eine statische verschachtelte Klasse deklarieren
Verwenden Sie den Namen der äußeren Klasse, um von außerhalb auf die verschachtelte Klasse zuzugreifen.
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;
}
}Zugriff von außerhalb
Verweisen Sie auf eine öffentliche statische verschachtelte Klasse als 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:8080Statische verschachtelte Klasse vs. innere Klasse
Der entscheidende Unterschied: Statische verschachtelte Klassen verfügen NICHT über eine implizite Referenz auf die Instanz der äußeren Klasse. Innere (nicht statische) Klassen verfügen über eine solche Referenz.
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
}
}
}Builder-Muster mit statischer Verschachtelung
Das klassische Builder-Muster verwendet eine statische verschachtelte Klasse, sodass Aufrufer keine äußere Instanz benötigen, um einen Builder zu erstellen.
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); }
}
}Eintrag in Maps
Map.Entry ist ein bekanntes statisches verschachteltes Interface, das zum Durchlaufen von Schlüssel-Wert-Paaren verwendet wird.
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());
}Testen mit einer statischen verschachtelten Klasse
In Unit-Tests kann eine statische verschachtelte Klasse Test-Fixtures oder Mock-Implementierungen aufnehmen, die auf die Testklasse beschränkt sind.
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();
// ...
}
}Statische Verschachtelung für Domänenlogik
Gruppieren Sie verwandte Typen mithilfe statischer verschachtelter Klassen, um Domänenmodelle übersichtlicher zu organisieren.
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; }
}
// ...
}Vergleich: Statische verschachtelte Klasse vs. Top-Level-Klasse
Bevorzugen Sie eine statische verschachtelte Klasse, wenn eine Klasse nur im Kontext der äußeren Klasse verwendet wird. Verwenden Sie eine Top-Level-Klasse, wenn sie breiter einsetzbar ist.
Statische Verschachtelung mit Generics
Statische verschachtelte Klassen nehmen an Generics genauso teil wie Top-Level-Klassen.
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 30Speichereffizienz
Statische verschachtelte Klassen enthalten keine Referenz auf die äußere Instanz. Dadurch wird verhindert, dass das äußere Objekt versehentlich im Speicher gehalten wird, was bei langlebigen Strukturen zu Speicherlecks führen kann.
Schnelltest
Was unterscheidet eine statische verschachtelte Klasse von einer inneren (nicht statischen) Klasse?
Zusammenfassung: Statische verschachtelte Klassen
Die wichtigsten Erkenntnisse:
- Statische verschachtelte Klassen werden mit der äußeren Klasse gruppiert, haben aber keine Referenz auf eine äußere Instanz
- Zugriff von außerhalb: OuterClass.NestedClass
- Eine implizite Referenz fehlt, daher wird das versehentliche Halten der äußeren Instanz im Speicher verhindert
- Das Builder-Muster verwendet häufig eine statische verschachtelte Builder-Klasse
- Map.Entry ist ein bekanntes statisches verschachteltes Interface
- Bevorzugen Sie statische Verschachtelung, wenn die innere Klasse keinen Zugriff auf die äußere Instanz benötigt
Häufig gestellte Fragen
Ist die Lektion „Statische verschachtelte Klassen“ kostenlos?
Ja — der vollständige Text von „Statische verschachtelte Klassen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Statische verschachtelte Klassen“?
Definieren Sie statische verschachtelte Klassen als zugehörige Hilfstypen ohne Referenz auf eine einschließende Instanz. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Java Academy zu starten?
Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Statische verschachtelte Klassen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?
Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Statische verschachtelte Klassen
- Innere Klassen und Zugriff auf die äußere Klasse
- Lokale und anonyme Klassen
- Die passende Verschachtelungsstrategie wählen