Lokale und anonyme Klassen
Deklarieren Sie Klassen innerhalb von Methoden und erstellen Sie anonyme Implementierungen von Schnittstellen direkt bei Bedarf.
Lokale und anonyme Klassen ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.
Lokale und anonyme Klassen
Lokale Klassen werden innerhalb einer Methode definiert. Anonyme Klassen sind lokale Klassen ohne Namen – sie verbinden Klassendeklaration und Instanziierung. Beide erfassen effektiv finale lokale Variablen.
Deklaration einer lokalen Klasse
Eine lokale Klasse wird innerhalb des Methodenkörpers deklariert. Sie kann auf die Member der einschließenden Klasse und auf effektiv finale lokale Variablen zugreifen.
static void greet(String language) {
// Local class — defined inside the method
class Greeter {
String sayHello(String name) {
// Can access 'language' — it is effectively final
return switch (language) {
case "EN" -> "Hello, " + name;
case "ES" -> "Hola, " + name;
case "FR" -> "Bonjour, " + name;
default -> "Hi, " + name;
};
}
}
Greeter g = new Greeter();
System.out.println(g.sayHello("Alice"));
}
greet("ES"); // Hola, AliceEffektiv finale Variablen
Lokale und anonyme Klassen können nur lokale Variablen erfassen, die effektiv final sind – sie werden nach ihrer Initialisierung nie neu zugewiesen.
void process(int threshold) {
// threshold is effectively final (never reassigned)
Runnable r = new Runnable() {
public void run() {
System.out.println("Threshold: " + threshold);
}
};
r.run();
// threshold = 10; // If you add this, the anonymous class won't compile
}Grundlagen anonymer Klassen
Eine anonyme Klasse implementiert ein Interface oder erweitert eine Klasse direkt innerhalb eines einzigen Ausdrucks.
interface Comparator<T> {
int compare(T a, T b);
}
// Anonymous class implementing Comparator
java.util.Comparator<String> byLength = new java.util.Comparator<String>() {
@Override
public int compare(String a, String b) {
return Integer.compare(a.length(), b.length());
}
};
List<String> words = new ArrayList<>(List.of("banana", "fig", "apple", "kiwi"));
words.sort(byLength);
System.out.println(words); // [fig, kiwi, apple, banana]Anonyme Klasse oder Lambda
Bei Single-Abstract-Method-(SAM-)Interfaces ersetzen Lambdas anonyme Klassen. Anonyme Klassen werden weiterhin für Interfaces mit mehreren Methoden oder zum Erweitern abstrakter Klassen benötigt.
// Anonymous class for single-method interface
Runnable r1 = new Runnable() {
public void run() { System.out.println("Running!"); }
};
// Lambda — cleaner for SAM interfaces
Runnable r2 = () -> System.out.println("Running!");
// Must use anonymous class for multi-method interface:
java.io.FilenameFilter filter = new java.io.FilenameFilter() {
public boolean accept(java.io.File dir, String name) {
return name.endsWith(".java");
}
}; // FilenameFilter is not a SAM — no lambda shorthandAnonyme Klasse mit Zustand
Anonyme Klassen können im Gegensatz zu Lambdas Felder besitzen. Das ist nützlich, wenn Sie innerhalb der anonymen Implementierung einen Zustand verwalten müssen.
interface Counter { int increment(); int get(); }
Counter counter = new Counter() {
private int count = 0;
public int increment() { return ++count; }
public int get() { return count; }
};
System.out.println(counter.increment()); // 1
System.out.println(counter.increment()); // 2
System.out.println(counter.get()); // 2Muster für anonyme Listener
Vor Lambdas waren anonyme Klassen das Standardmuster für Event-Listener in der GUI- und Android-Programmierung.
// Modern Android/Swing style: anonymous class listener
Button loginButton = new Button(); // hypothetical
loginButton.setOnClickListener(new OnClickListener() {
@Override
public void onClick() {
System.out.println("Login button clicked!");
}
});
// Modern equivalent with lambda (if OnClickListener is SAM):
loginButton.setOnClickListener(() -> System.out.println("Clicked!"));Lokale Klasse für komplexe Logik
Lokale Klassen eignen sich gut, wenn Sie an einer einzigen Stelle eine Klasse mit mehreren Methoden benötigen – für ein Lambda ist die Logik zu komplex, für eine Top-Level-Klasse jedoch zu spezifisch.
static List<String> processData(List<String> data, String prefix) {
// Local class: complex enough for a class, used only here
class DataProcessor {
List<String> result = new ArrayList<>();
void process(String item) {
// prefix is effectively final
if (item.startsWith(prefix)) {
result.add(item.toUpperCase());
}
}
}
DataProcessor dp = new DataProcessor();
data.forEach(dp::process);
return dp.result;
}
System.out.println(processData(List.of("apple","avocado","banana"), "a"));
// [APPLE, AVOCADO]Anonyme Klasse für abstrakte Klassen
Anonyme Klassen können abstrakte Klassen erweitern und abstrakte Methoden überschreiben, ohne eine benannte Unterklasse zu erstellen.
abstract class ReportFormatter {
abstract String formatHeader(String title);
abstract String formatBody(List<String> rows);
String format(String title, List<String> rows) {
return formatHeader(title) + "\n" + formatBody(rows);
}
}
ReportFormatter csvFormatter = new ReportFormatter() {
public String formatHeader(String t) { return "\"" + t + "\""; }
public String formatBody(List<String> rows) {
return String.join("\n", rows);
}
};
System.out.println(csvFormatter.format("Sales", List.of("a,1","b,2")));Anti-Pattern: Initialisierung mit doppelten geschweiften Klammern
Der Trick der Initialisierung mit doppelten geschweiften Klammern verwendet anonyme Klassen zur Initialisierung von Collections. Dabei wird eine Unterklasse mit einem Instanzinitialisierer erstellt. Vermeiden Sie diesen Ansatz – er ist ineffizient und fehleranfällig.
// Anti-pattern: double-brace initialization
Map<String, Integer> map = new HashMap<String, Integer>() {{
put("a", 1);
put("b", 2);
}};
// Creates an anonymous HashMap subclass — wasteful!
// GOOD: use Map.of() or Map.ofEntries()
Map<String, Integer> better = Map.of("a", 1, "b", 2);
// Or a mutable map:
Map<String, Integer> mutable = new HashMap<>(Map.of("a", 1, "b", 2));Auswahl: Lambda, anonyme oder lokale Klasse
Entscheidungshilfe:
- Lambda: eine abstrakte Methode, kein zusätzlicher Zustand, keine Vererbung
- Anonyme Klasse: mehrere Methoden, benötigter Zustand oder Erweiterung einer abstrakten Klasse
- Lokale Klasse: Wiederverwendung innerhalb der Methode, mehrere Methoden oder komplexer Zustand
Kurztest
Was tut eine anonyme Klasse immer innerhalb eines einzigen Ausdrucks?
Zusammenfassung: Lokale und anonyme Klassen
Die wichtigsten Erkenntnisse:
- Lokale Klassen werden innerhalb von Methoden definiert und können auf effektiv finale lokale Variablen zugreifen
- Anonyme Klassen verbinden Klassendeklaration und Instanziierung in einem Ausdruck
- Anonyme Klassen können im Gegensatz zu Lambdas Felder und mehrere Methoden besitzen
- Lambdas ersetzen anonyme Klassen für Interfaces mit einer abstrakten Methode
- Verwenden Sie lokale Klassen, wenn die Logik komplex genug für eine Klasse, aber auf eine Methode beschränkt ist
- Vermeiden Sie Initialisierungen mit doppelten geschweiften Klammern – sie erstellen unnötige anonyme Unterklassen
Häufig gestellte Fragen
Ist die Lektion „Lokale und anonyme Klassen“ kostenlos?
Ja — der vollständige Text von „Lokale und anonyme 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 „Lokale und anonyme Klassen“?
Deklarieren Sie Klassen innerhalb von Methoden und erstellen Sie anonyme Implementierungen von Schnittstellen direkt bei Bedarf. 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 3 von 4.
Wie lange dauert die Lektion „Lokale und anonyme 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