CKTIS / Java
Anonyme Klassen in Java
Mit einer anonymen Klasse kannst du eine Schnittstelle implementieren oder eine Unterklasse definieren und im selben Ausdruck ein Objekt davon erzeugen.
Version: Java SE 21
Syntax
Anonymous implementation: new InterfaceType() { /* member declarations */ }
Anonymous subclass: new BaseType(constructorArguments) { /* member declarations */ }
In a variable declaration, end the declaration with a semicolon after the closing brace.In Java SE 21 deklariert new Interface() { ... } eine anonyme Klasse und erzeugt ein Objekt davon. Interface steht für den Namen einer vorhandenen Schnittstelle, ... für Deklarationen im Klassenrumpf. Das Objekt gehört zur implementierenden Klasse, nicht zur Schnittstelle selbst. Jede Auswertung erzeugt ein neues Objekt; jedes separate Vorkommen dieser Ausdrucksform deklariert eine eigene Klasse.
Die Form new BaseType(args) { ... } erzeugt ein Objekt einer Unterklasse, sofern BaseType erweitert und ein passender Konstruktor aufgerufen werden kann. Die Argumente werden an den Konstruktor der Oberklasse übergeben. Einen eigenen Konstruktor kannst du nicht explizit deklarieren; Felder, Methoden und Instanzinitialisierer sind im Klassenrumpf dagegen möglich.
Die Klasse muss alle erforderlichen abstrakten Methoden implementieren. Die Implementierungen von Action.perform(), Runnable.run() und Executor.execute(Runnable) müssen public sein. Mit @Override erkennt der Compiler Signaturfehler, etwa wenn du eine Methode versehentlich überlädst, statt sie zu überschreiben.
In einer Instanzmethode der anonymen Klasse bezeichnet this das anonyme Objekt. Ein Lambda führt kein eigenes this ein und benötigt eine funktionale Schnittstelle als Zieltyp. Beide Formen können nur lokale Variablen erfassen, die final oder effektiv final sind, wie label, dem kein neuer Wert zugewiesen wird.
new Executor() { public void execute(Runnable r) ... } skizziert eine anonyme Implementierung von Executor, nicht die Erzeugung eines Threadpools. Hier ruft execute direkt r.run() auf, sodass die Aufgabe synchron im aufrufenden Thread läuft. Andere Executor-Implementierungen können einen anderen Thread oder einen Pool nutzen.
Beispiele
import java.util.concurrent.Executor;
public class AnonymousClassDemo {
interface Action {
void perform();
}
public static void main(String[] args) {
Action open = new Action() {
@Override
public void perform() { System.out.println("Open"); }
};
Action close = new Action() {
@Override
public void perform() { System.out.println("Close"); }
};
Executor direct = new Executor() {
@Override
public void execute(Runnable r) {
r.run();
}
};
String label = "Task ";
Runnable[] tasks = {
new Runnable() {
@Override
public void run() { System.out.println(label + "1"); }
},
new Runnable() {
@Override
public void run() { System.out.println(label + "2"); }
},
new Runnable() {
@Override
public void run() { System.out.println(label + "3"); }
},
new Runnable() {
@Override
public void run() { System.out.println(label + "4"); }
}
};
open.perform();
for (Runnable task : tasks) {
direct.execute(task);
}
close.perform();
}
}Ergebnis
Open Task 1 Task 2 Task 3 Task 4 Close
Zwei verschiedene anonyme Klassen implementieren `Action`, vier weitere implementieren `Runnable`. `Open` erscheint vor `Task 1` bis `Task 4` und `Close` nach allen vier Aufgaben, weil jeder Aufruf von `execute` erst endet, wenn der direkte Aufruf von `run()` abgeschlossen ist.
Zugehörige Lektionen
- Java · Lektion 25 · Fortgeschritten · Version: 2
- Java · Lektion 8 · Mittlere Stufe · Version: 2
- Java · Lektion 51 · Mittlere Stufe · Version: 2
Quellen
- Java Language Specification, Java SE 21 — §15.9 Class Instance Creation Expressions
- Java Language Specification, Java SE 21 — §15.9.5 Anonymous Class Declarations
- Java Language Specification, Java SE 21 — §8.1.3 Inner Classes and Enclosing Instances
- Java Language Specification, Java SE 21 — §8.4.8.3 Requirements in Overriding and Hiding
- Java Language Specification, Java SE 21 — §15.27 Lambda Expressions
- Executor (Java SE 21 & JDK 21)
- Runnable (Java SE 21 & JDK 21)