Startseite / Language / Von anonymen Klassen zu Lambdas und Methodenreferenzen
Language Einsteiger

Von anonymen Klassen zu Lambdas und Methodenreferenzen

Anonyme Klassen mit einer einzigen Methode durch prägnante Lambdas und Methodenreferenzen ersetzen.

Functional Programming Interfaces
Code-Vergleich
✕ Anonymous class 
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent event) {
        save(event);
    }
});
✓ Java 8+ 
button.addActionListener(this::save);
Problem mit diesem Code entdeckt? Sag uns Bescheid.
Warum der moderne Weg gewinnt
⚡

Weniger Boilerplate

Die Klassendeklaration und das Überschreiben der Methode entfallen.

👁

Bessere Lesbarkeit

Lenkt die Aufmerksamkeit auf die ausgeführte Operation.

🔒

Weiterhin typsicher

Der Compiler prüft die Signatur des Zielfunktionsinterfaces.

Alter Ansatz
Anonyme Klasse
Moderner Ansatz
Methodenreferenz
Seit JDK
8
Schwierigkeitsgrad
Einsteiger
JDK-Unterstützung
Von anonymen Klassen zu Lambdas und Methodenreferenzen
Verfügbar

Verfügbar seit JDK 8 (März 2014).

Wie es funktioniert

Funktionale Interfaces können mit Lambdas oder Methodenreferenzen implementiert werden. Dadurch entfällt der Verwaltungsaufwand anonymer Klassen, während die statische Typisierung und derselbe Callback-Vertrag erhalten bleiben.

Zugehörige Dokumentation
Lambda Expressions ↗ Method References ↗
Beweis
Beweisquelle ansehen ↗
Verwandte Muster
Language Fortgeschritten

Default interface methods

Java 7
// Need abstract class to share behavior
public abstract class AbstractLogger {
    public void log(String msg) {
        System.out.println(
            timestamp() + ": " + msg);
    }
    abstract String timestamp();
}

// Single inheritance only
public class FileLogger
    extends AbstractLogger { ... }
Java 8+
public interface Logger {
    default void log(String msg) {
        IO.println(
            timestamp() + ": " + msg);
    }
    String timestamp();
}

// Multiple interfaces allowed
public class FileLogger
    implements Logger, Closeable { ... }
Hover für Modernes ➜
JDK 8+ →
Streams Einsteiger

Predicate.not() for negation

Java 8
List<String> nonEmpty = list.stream()
    .filter(s -> !s.isBlank())
    .collect(Collectors.toList());
Java 11+
List<String> nonEmpty = list.stream()
    .filter(Predicate.not(String::isBlank))
    .collect(Collectors.toList());
Hover für Modernes ➜
JDK 11+ →
Collections Einsteiger

Collection bulk operations instead of mutation loops

Iterator mutation loop
for (Iterator<Order> it = orders.iterator(); it.hasNext();) {
    if (it.next().cancelled()) {
        it.remove();
    }
}
Java 8+
orders.removeIf(Order::cancelled);
Hover für Modernes ➜
JDK 8+ →