Eine verschachtelte Klasse ist eine Klasse, die in einer anderen Klasse definiert ist. Java hat vier Arten — statisch verschachtelt, innere (nicht-statisch), lokal und anonym — jede mit unterschiedlichem Zugriff auf die äußere Klasse und unterschiedlichen Anwendungsfällen.
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
Eine static verschachtelte Klasse verhält sich wie eine Top-Level-Klasse, ist aber namensraummäßig in der äußeren verschachtelt. Sie hält keine Referenz zu einer äußeren Instanz — wird für die Gruppierung von Hilfsfunktionen verwendet (z. B. ein Builder, Node in einer Datenstruktur).
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
Eine nicht-statische innere Klasse hält eine implizite Referenz zu ihrer äußeren Instanz, sodass sie auf die Instanzfelder des äußeren Objekts zugreifen kann. (Warnung: Diese Referenz kann Speicherlecks verursachen, wenn die innere Instanz länger existiert als die äußere.)
void process() {
class Helper { // local to this method
void run() { ... }
}
new Helper().run();
}
Selten verwendet; auf die Methode beschränkt.
// 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"); }
};
Eine anonyme Klasse ist eine einmalige Implementierung einer Schnittstelle oder Klasse, die an einem Stück definiert und instanziiert wird — historisch üblich für Event-Handler und Callbacks. Modernes Java ersetzt diese oft durch Lambdas, wenn das Ziel eine funktionale Schnittstelle ist:
button.addActionListener(e -> handleClick()); // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
Verschachtelte Klassen sind ein nützliches Werkzeug zum logischen Gruppieren von Klassen, die nur in einem Kontext verwendet werden, wodurch die Kapselung und Lesbarkeit erhöht werden.
Das Verständnis der Arten — besonders die statisch-gegen-innere Unterscheidung (statisch = unabhängig, innere = hält eine äußere-Instanz-Referenz) — ist wichtig für Design und zur Vermeidung von Fehlern: Die implizite äußere Referenz innerer Klassen kann Speicherlecks verursachen, und die Wahl von statisch, wenn man die äußere Instanz nicht benötigt, ist die sauberere Standardvariante.
Anonyme Klassen waren die klassische Methode, um inline-Implementierungen bereitzustellen (Event-Handler, Comparatoren), und zu wissen, dass sie für funktionale Schnittstellen weitgehend durch Lambdas ersetzt wurden, spiegelt moderne Java-Flüssigkeit.
Sie erscheinen überall in der Standard-Bibliothek (z. B. Map.Entry ist eine verschachtelte Schnittstelle, Builder sind statisch verschachtelte Klassen), was sie zu praktischem, häufig angetroffenen Wissen macht.