7. Funktionale Schnittstellen, Lambdas und Ereignisse
In vielen Programmen müssen wir einer Methode nicht Daten, sondern Verhalten übergeben: das Sortierkriterium, die Filterbedingung oder die Verarbeitung, die ausgeführt werden soll, wenn etwas geschieht. Java begegnet diesem Bedarf mit einem einfachen Konzept, auf dem dieses ganze Kapitel beruht: die funktionale Schnittstelle, also eine Schnittstelle, die nur eine einzige abstrakte Methode deklariert. Ein Objekt, das eine solche Schnittstelle implementiert, „trägt“ eine Funktion, die in einer Variablen gespeichert, als Parameter übergeben, als Ergebnis einer Methode zurückgegeben und nach Belieben ausgeführt werden kann.
Vor Java 8 (2014) musste man für jedes auszudrückende Verhalten eine Klasse schreiben – oft eine anonyme Klasse –, was umständlich war. Java 8 führte Lambda-Ausdrücke und Methodenreferenzen ein, mit denen sich dieses Verhalten in einer einzigen Zeile schreiben lässt. Wir haben sie bereits ohne nähere Erläuterung mit der Stream-API in Kapitel 5 verwendet: In [persons.stream().filter(p -> p.age() >= 18)] übergeben wir der Methode [filter] ein Lambda, also eine Instanz einer funktionalen Schnittstelle. Dieses Kapitel erklärt, was hinter dieser Syntax steckt. Es endet mit Ereignissen, die Java mithilfe von „Listenern“ behandelt: Objekte – oft Lambdas –, die sich bei einem Sender registrieren, um über das informiert zu werden, was dort geschieht. Grafische Benutzeroberflächen in Java (Swing, JavaFX) und Web-Frameworks beruhen gleichermaßen auf diesem Mechanismus: Ein Klick auf eine Schaltfläche oder das Eintreffen einer (HTTP-)Anfrage wird den registrierten Listenern signalisiert. Dieser Kurs behandelt keine grafischen Benutzeroberflächen; alle Beispiele sind Konsolenprogramme.
Die Programme dieses Kapitels sind kompakte Quelldateien im Ordner [07-lambdas]. Sie werden mit [java LambdasNN.java] ausgeführt. Beachten Sie, dass eine kompakte Quelldatei automatisch das gesamte Modul [java.base] importiert: Die Schnittstellen der Pakete [java.util.function], [java.util], oder [java.util.concurrent] können dort ohne [import]-Anweisungen verwendet werden.
7.1. Vordefinierte funktionale Schnittstellen
7.1.1. Das Konzept der funktionalen Schnittstelle
Eine funktionale Schnittstelle ist eine Schnittstelle mit genau einer abstrakten Methode. Sie darf zusätzlich beliebig viele [default]- und [static]-Methoden haben (siehe Kapitel 4): Diese zählen nicht mit. Diese eine abstrakte Methode beschreibt ein Muster (auch Signatur oder Form genannt) einer Funktion: die Typen ihrer Parameter und den Typ ihres Rückgabewerts. Eine Variable vom Typ der Schnittstelle kann dann auf jedes Objekt verweisen, das eine Funktion dieser Form bereitstellt, und sie durch Aufruf der Methode ausführen.
Das älteste Beispiel ist die Schnittstelle [java.lang.Runnable], die seit Java 1.0 existiert und eine auszuführende Aufgabe darstellt (wir kommen in Kapitel 8 im Zusammenhang mit Threads darauf zurück). Sie besteht aus einer einzigen Methode: [void run();]. Sie beschreibt eine Funktion,
- die keine Parameter hat;
- die kein Ergebnis zurückgibt ([void]).
Es gibt drei Möglichkeiten, ein Objekt vom Typ [Runnable] zu erzeugen:
- eine Klasse schreiben, die die Schnittstelle implementiert, entweder benannt oder anonym. Das war vor Java 8 die einzige Möglichkeit;
- einen Lambda-Ausdruck schreiben: [Runnable task = () -> IO.println("task");];
- eine Methodenreferenz auf eine vorhandene Methode mit der passenden Form schreiben: [Runnable task = Functions::display;].
In den beiden letzten Fällen erzeugt der Compiler das Objekt, das die Schnittstelle implementiert, selbst: Das Lambda oder die referenzierte Methode wird zum Rumpf der Methode [run]. Die Funktion wird dann durch Aufruf der Schnittstellenmethode ausgeführt: [task.run()]. Anders als andere Sprachen hat Java keine eigene Aufrufsyntax: Die Schnittstellenmethode wird immer über ihren Namen aufgerufen ([run], [apply], [test] …).
7.1.2. Schnittstellen im Paket java.util.function
Vor Java 8 definierte jede Bibliothek ihre eigenen Schnittstellen mit nur einer Methode ([Runnable], [Comparator], [ActionListener] …). Java 8 führte das Paket [java.util.function] ein, das 43 generische funktionale Schnittstellen bereitstellt, die praktisch alle Anforderungen abdecken. Die wichtigsten sind die folgenden:
Schnittstelle | Abstrakte Methode | Dargestellte Funktionen |
[Runnable] ([java.lang]) | [void run()] | Keine Parameter, kein Ergebnis |
[Supplier<T>] | [T get()] | Keine Parameter, ein Ergebnis: ein „Lieferant“ (Supplier) |
[Consumer<T>] | [void accept(T t)] | ein Parameter, kein Ergebnis: ein „Verbraucher“ (Consumer) |
[BiConsumer<T, U>] | [void accept(T t, U u)] | zwei Parameter, kein Ergebnis |
[Function<T, R>] | [R apply(T t)] | ein Parameter, ein Ergebnis vom Typ [R] (immer der letzte Typ) |
[BiFunction<T, U, R>] | [R apply(T t, U u)] | zwei Parameter, ein Ergebnis |
[UnaryOperator<T>] | [T apply(T t)] | eine [Function<T, T>]: Parameter und Ergebnis vom selben Typ |
[BinaryOperator<T>] | [T apply(T t1, T t2)] | eine [BiFunction<T, T, T>] |
[Predicate<T>] | [boolean test(T t)] | ein Parameter, ein boolesches Ergebnis: ein „Prädikat“ (Predicate) |
[BiPredicate<T, U>] | [boolean test(T t, U u)] | zwei Parameter, ein boolesches Ergebnis |
[Comparator<T>] ([java.util]) | [int compare(T o1, T o2)] | zwei Parameter desselben Typs, ein ganzzahliges Ergebnis |
[Callable<V>] ([java.util.concurrent]) | [V call() throws Exception] | Wie [Supplier<V>], kann aber eine geprüfte Exception auslösen |
Java-Generics gelten nur für Objekttypen: Eine [Function<Integer, Integer>] empfängt und liefert [Integer], was automatische Umwandlungen (Boxing und Unboxing) zwischen [int] und [Integer] erfordert. Um diese zu vermeiden, stellt das Paket spezialisierte Versionen für die primitiven Typen [int], [long], und [double] bereit: [IntBinaryOperator] ([int applyAsInt(int left, int right)]), [IntUnaryOperator], [IntPredicate], [IntSupplier], [IntConsumer], [IntFunction<R>] (mit [int] als Parameter), [ToIntFunction<T>] (mit [int] als Ergebnis) sowie ihre Entsprechungen [Long…] und [Double…]. Es gibt keine vordefinierte Schnittstelle mit drei oder mehr Parametern; in diesem Fall müssen Sie eine eigene definieren (siehe den folgenden Abschnitt).
Das Programm [Lambdas01.java] verwendet diese Schnittstellen mit Methodenreferenzen:
Ergebnisse:
Kommentare:
- Zeilen 5–10: Erzeugung eines Objekts vom Typ [Runnable] mithilfe einer anonymen Klasse, also einer Klasse ohne Namen, die genau dort deklariert und instanziiert wird, wo sie gebraucht wird. Sie implementiert die Methode [run], die die Methode [display] in Zeile 52 aufruft. Das war vor Java 8 die erforderliche Syntax;
- Zeile 12: dasselbe mit einer Methodenreferenz: [Functions::display] verweist auf die statische Methode [display] der Klasse [Functions]. Der Compiler prüft, ob sie die Form der Methode [run] hat (keine Parameter, kein Rückgabewert), und erzeugt das Objekt [Runnable] , das sie aufruft. Das ist heute die übliche Syntax;
- Zeile 14: Die Funktion wird durch Aufruf der Methode der Schnittstelle ausgeführt. Die Methode [display] in Zeile 52 wird ausgeführt (Zeile 2 der Ergebnisse);
- Zeilen 48–50: Die referenzierten Methoden sind in einer Klasse namens [Functions] zusammengefasst. Wir hätten sie gern direkt in der Datei neben [main] geschrieben und [Lambdas01::add] genannt. Die implizite Klasse, die eine kompakte Quelldatei umhüllt, kann im Code jedoch nicht benannt werden (der Compiler meldet [cannot find symbol]);
- Zeile 17: [BiFunction<Integer, Integer, Integer>] bezeichnet eine Funktion mit zwei Parametern vom Typ [Integer], die einen [Integer] zurückgibt (der letzte generische Typ). Die Methode [add] in Zeile 56, die mit [int] arbeitet, passt: Der Compiler fügt die Umwandlungen zwischen [int] und [Integer] hinzu. Die Funktion wird über ihre Methode [apply] aufgerufen (Zeile 18);
- Zeile 20: [Supplier<String>] bezeichnet eine parameterlose Funktion, die eine Zeichenkette zurückgibt. Sie wird über ihre Methode [get] aufgerufen;
- Zeile 23: Die primitive Version [IntBinaryOperator] arbeitet direkt mit [int]-Werten, ohne Umwandlung. Ihre Methode heißt [applyAsInt]. Dies ist der bevorzugte Typ für rechenintensive Aufgaben;
- Zeile 27: [Consumer<String>] bezeichnet eine Funktion, die einen Parameter vom Typ [String] entgegennimmt und nichts zurückgibt. Die statische Methode [IO.println(Object)] ist geeignet: Ein [String] ist ein [Object]. Sie wird über ihre Methode [accept] ausgeführt;
- Zeile 31: Ein Prädikat ist eine Funktion, die einen booleschen Wert zurückgibt; es wird über seine Methode [test] ausgeführt (Zeile 32). Die Methode [removeIf] der Schnittstelle [Collection] (Zeile 35) erwartet einen Parameter vom Typ [Predicate]: Sie entfernt aus der Collection alle Elemente, für die das Prädikat [true] zurückgibt, und gibt [true] zurück, wenn sie mindestens ein Element entfernt hat;
- Zeile 40: Die Methode [sort] der Schnittstelle [List] akzeptiert einen [Comparator] , der zwei Elemente vergleicht (das Ergebnis kann negativ, null oder positiv sein, wie bei [compareTo]). Hier werden die Namen aufsteigend nach Länge sortiert. Die Methode [compareLengths] (Zeile 72) verwendet [Integer.compare], das zwei [int]-Werte ohne Überlaufrisiko vergleicht (das eine einfache Subtraktion nicht garantiert);
- Zeilen 44–45: Eine Methodenreferenz ist, wie ein Lambda, ein Objekt. Ihre Klasse, die in Zeile 10 der Ergebnisse angezeigt wird, ist eine zur Laufzeit von der virtuellen Maschine generierte Klasse, deren Name [$$Lambda] gefolgt von einer Adresse enthält, die sich von einer Ausführung zur nächsten ändert. In Zeile 11 der Ergebnisse sehen wir, dass diese Klasse die Schnittstelle [BiFunction] implementiert. Ein Lambda ist also keine neue Art von Objekt: Es ist eine Instanz einer gewöhnlichen Klasse, die eine funktionale Schnittstelle implementiert.
7.2. Eigene funktionale Schnittstellen definieren
Die vordefinierten Schnittstellen reichen oft aus, Sie können aber auch eigene definieren. Schreiben Sie dazu einfach eine Schnittstelle mit einer einzigen abstrakten Methode, zum Beispiel:
- [interface Operation { int calculate(int n1, int n2); }]
Diese Schnittstelle stellt eine Funktion dar, die zwei ganze Zahlen entgegennimmt und eine ganze Zahl zurückgibt. Im Vergleich zu [IntBinaryOperator]* hat der Typ *[Operation] einen Namen, der seinen Zweck beschreibt, seine Methode hat einen sprechenden Namen ([calculate] statt [applyAsInt]*), und seine Parameter haben Namen ([n1], [n2]), die Entwicklungswerkzeuge anzeigen. Ihr ist die Annotation [@FunctionalInterface]* vorangestellt: Sie ist nicht erforderlich, weist aber den Compiler an zu prüfen, dass die Schnittstelle funktional ist, und dokumentiert die Absicht des Entwicklers.
Eine Variable [op] vom Typ [Operation] verweist immer nur auf eine Funktion zur Zeit. Anders als andere Sprachen, die „Multicast-Delegates“ anbieten, bietet Java keine Möglichkeit, mehrere Funktionen in einer einzigen Variablen zu speichern und alle mit einem einzigen Aufruf auszuführen: Bei Bedarf legt man die Funktionen in einer Liste ab und führt sie nacheinander aus. Genau das werden wir bei Ereignis-Listenern tun.
Betrachten wir das Beispiel [Lambdas02.java]:
Ergebnisse:
Kommentare:
- Zeilen 47–55: Definition der funktionalen Schnittstelle [Operation]. In einer kompakten Quelldatei können Typdeklarationen (Klassen, Schnittstellen, Records usw.) vor oder nach der Methode [main] stehen; wir setzen sie danach;
- Zeilen 52–54: Eine funktionale Schnittstelle kann [default]-Methoden haben. Die Methode [then] konstruiert eine neue [Operation]: Diese Methode führt die aktuelle Operation aus und wendet dann die Funktion [next] auf deren Ergebnis an. Sie gibt ein Lambda zurück, das wir im nächsten Abschnitt untersuchen. Die Kompositionsmethoden der vordefinierten Schnittstellen ([andThen], [compose] … usw.) sind nach diesem Muster geschrieben, auf das wir später eingehen;
- Zeilen 64–81: Die Klasse [Calculations] hat zwei Instanzmethoden, [add] und [subtract], und eine statische Methode, [increase], die alle drei dieselbe Form haben wie die Methode [calculate];
- Zeile 5: Die Variable [op] hat den Typ [Operation]. Ihr wird eine Referenz auf die statische Methode [Calculations.increase] zugewiesen;
- Zeile 7: Die Operation wird durch die Methode [calculate] ausgeführt. Die Methode [Calculations.increase] wird mit den an [calculate] übergebenen Parametern ausgeführt;
- Zeile 11: Eine Instanz [c1] der Klasse [Calculations] wird erzeugt;
- Zeile 13: Die Referenz [c1::add] verweist auf die Methode [add] des Objekts [c1]. [increase] war eine statische Methode, [add] dagegen ist eine Instanzmethode: Das macht keinen Unterschied. Im zweiten Fall speichert das vom Compiler erzeugte Objekt zusätzlich das Objekt [c1] , auf dem die Methode aufgerufen wird;
- Zeile 17: Dasselbe geschieht mit der Instanzmethode [subtract];
- Zeilen 22–28: Um mehrere Operationen auszuführen, werden sie in eine Liste [List<Operation>] gelegt, die anschließend durchlaufen wird. Methodenreferenzen und Lambdas lassen sich mischen (Zeile 25). Jedes Ergebnis wird abgerufen (Zeilen 8–12 der Ergebnisse);
- Zeile 31: Die Methode [default] [then] wird auf die Operation [c1::add] angewendet. Die Typumwandlung [(Operation)] ist notwendig: Eine Methodenreferenz hat keinen eigenen Typ, und man kann keine Methode auf ihr aufrufen, solange der Compiler nicht weiß, welche Schnittstelle sie implementiert (wir kommen darauf zurück). [squaredSum.calculate(1, 2)] berechnet (1+2)², also 9 (Zeilen 13–14 der Ergebnisse);
- Zeile 35: [Operation] und [IntBinaryOperator] haben genau dieselbe Form, sind aber zwei verschiedene Typen ohne Vererbungsbeziehung. Die Zuweisung [IntBinaryOperator other = op;] würde abgelehnt ([incompatible types: Operation cannot be converted to IntBinaryOperator]). Dagegen hat die Methodenreferenz [op::calculate] die richtige Form: Sie erzeugt einen [IntBinaryOperator] , der die Methode [calculate] des Objekts [op] aufruft ([c1::subtract] an dieser Stelle des Programms);
- Zeilen 57–61: Eine funktionale Schnittstelle kann generisch sein. [Transformation<T, R>] stellt eine Funktion dar, die ein [T] entgegennimmt und ein [R] zurückgibt: Das entspricht [Function<T, R>], mit von uns gewählten Namen;
- Zeile 39: [String::length] passt zu einer [Transformation<String, Integer>]: Die Methode [length] wird auf der als Parameter übergebenen Zeichenkette aufgerufen. Zeile 40: ["*"::repeat] verweist auf die Methode [repeat(int)] des Zeichenkettenobjekts ["*"]; sie nimmt eine ganze Zahl entgegen und gibt eine Zeichenkette zurück. Dies sind zwei verschiedene Arten von Methodenreferenzen, die wir im folgenden Abschnitt ausführlich besprechen.
Die Annotation [@FunctionalInterface] kommt zum Tragen, wenn der Schnittstelle [int invert(int n);] versehentlich eine zweite abstrakte Methode hinzugefügt wird – zum Beispiel [Operation]. Der Compiler beanstandet dann die Annotation selbst sowie jedes Lambda und jede Methodenreferenz, die die Schnittstelle verwenden (gekürzte Ausgabe):
Die Meldungen des Compilers [javac] sind auf Englisch: Das JDK bietet keine deutsche Übersetzung.
7.3. Anonyme Klassen, Lambda-Ausdrücke und Methodenreferenzen
7.3.1. Von anonymen Klassen zu Lambdas
In den bisherigen Beispielen ist jede Funktion eine benannte Methode, die an anderer Stelle im Programm geschrieben ist. Für kurze Funktionen, die nur einmal verwendet werden, ist das umständlich. Bis Java 7 war die einzige Alternative die anonyme Klasse: Die Klasse, die die Schnittstelle implementiert, wird genau dort geschrieben, wo das Objekt erzeugt wird. Java 8 führte eine wesentlich knappere Syntax ein – die Lambda-Ausdrücke –, die anonyme Klassen für funktionale Schnittstellen praktisch ersetzt haben. Das Programm [Lambdas03.java] zeigt die verschiedenen Formen:
Ergebnisse:
Kommentare:
- Zeilen 5–10: eine anonyme Klasse. Auf den Operator [new] folgen der Name der Schnittstelle, leere Klammern und der Rumpf einer Klasse, die die Schnittstelle implementiert. Der Compiler generiert eine Klasse (mit einem selbst gewählten Namen, [Lambdas03$1]) und erzeugt eine Instanz davon. Sechs Zeilen, um [n1 + n2] auszudrücken;
- Zeilen 14–16: dasselbe mit einem Lambda-Ausdruck. Wir schreiben die Parameterliste, den Operator [->] (einen Pfeil, der als „ergibt“ gelesen wird) und dann den Rumpf. Der Name der Schnittstelle und der Name der Methode sind verschwunden: Der Compiler kennt sie aus dem Typ der Variablen, der als Zieltyp des Lambdas bezeichnet wird. Ein Lambda, dessen Rumpf ein von geschweiften Klammern umschlossener Block ist, heißt Lambda mit Blockrumpf;
- Zeile 20: Die Parametertypen sind verschwunden. Der Compiler leitet sie aus dem Zieltyp [IntBinaryOperator] ab: [n1] und [n2] haben den Typ [int]. Der Rumpf besteht nur noch aus einem Ausdruck, dessen Wert das Ergebnis des Lambdas ist: Dies ist ein Lambda mit Ausdrucksrumpf. Das ist die häufigste Form;
- Zeile 24: Bei einem einzigen Parameter ohne Typangabe sind die Klammern optional. [x -> x * x] liest sich „x ergibt x mal x“. Zeile 25: Ein Lambda mit einem Parameter vom Typ [String] gibt einen booleschen Wert zurück: Es ist ein [Predicate<String>];
- Zeilen 29–30: Ohne Parameter verwendet man leere Klammern. Ein Lambda, dessen Rumpf ein Methodenaufruf vom Typ [void] ist, passt zu einem [Runnable];
- Zeilen 35–40: Ein Lambda mit Blockrumpf kann beliebige Anweisungen enthalten: Deklarationen, Schleifen, Tests usw.;
- Zeile 44: Das Unterstrichzeichen [_] bezeichnet einen anonymen Parameter (Java 22). Er wird verwendet, wenn die Signatur der Schnittstelle Parameter verlangt, die das Lambda nicht braucht, was bei Ereignis-Listenern häufig vorkommt. Mehrere solche Parameter können im selben Lambda stehen;
- Zeilen 49–51: Die häufigste Verwendung von Lambdas besteht darin, sie direkt als Parameter an eine Methode zu übergeben, die eine funktionale Schnittstelle erwartet. Vergleichen Sie mit [Lambdas01.java]: Es ist nicht mehr nötig, eine Methode [isEven] zu schreiben. Hier arbeiten wir mit einer Kopie der Liste, weil [removeIf] die Liste verändert, auf der sie arbeitet;
- Zeile 52: ein Lambda vom Typ [Comparator<Integer>] , das den üblichen Vergleich umkehrt: Die Liste wird absteigend sortiert.
Fassen wir die Formen eines Lambda-Ausdrucks zusammen:
Form | Beispiel |
typisierte Parameter, Blockrumpf | [(int a, int b) -> { return a + b; }] |
nicht typisierte Parameter, Ausdrucksrumpf | [(a, b) -> a + b] |
ein einzelner nicht typisierter Parameter | [x -> x * x] |
keine Parameter | [() -> "Hello"] |
anonyme Parameter | [(_, _) -> IO.println("received")] |
Mit [var] deklarierte Parameter | [(var a, var b) -> a + b] |
Die Parameter sind entweder alle typisiert oder alle nicht typisiert: Beides zu mischen ist nicht möglich. Bei einem Blockrumpf muss ein Lambda, das ein Ergebnis zurückgibt, wie eine Methode auf jedem Ausführungspfad eine [return]-Anweisung enthalten.
Ein Lambda ist nicht ganz dasselbe wie eine verkürzt geschriebene anonyme Klasse. In einer anonymen Klasse verweist [this] auf die Instanz der anonymen Klasse; in einem Lambda verweist [this] auf das Objekt der Methode, die das Lambda umschließt. Außerdem erzeugt eine anonyme Klasse einen neuen Gültigkeitsbereich: Sie kann eine Variable mit demselben Namen wie eine Variable der Methode deklarieren, was ein Lambda nicht kann. Schließlich kann eine anonyme Klasse eine Schnittstelle mit mehreren Methoden implementieren oder von einer abstrakten Klasse erben, was mit einem Lambda unmöglich ist. In diesem Kurs verwenden wir Lambdas, wo immer es möglich ist.
7.3.2. Ergänzung: Zieltyp und Methodenreferenzen
Das Programm [Lambdas04.java] definiert das Konzept des Zieltyps und stellt die vier Arten von Methodenreferenzen vor:
Ergebnisse:
Kommentare:
- Zeile 5: Ein Lambda hat keinen eigenen Typ. Sein Typ ergibt sich aus dem Kontext: dem Typ der Variablen, die es erhält, dem Typ des Parameters, an den es übergeben wird, oder dem durch eine Typumwandlung angegebenen Typ. Die Deklaration [var twice = x -> x * 2;] wird daher vom Compiler abgelehnt: [cannot infer type for local variable twice (lambda expression needs an explicit target-type)]. Er wüsste nicht, welche Schnittstelle er implementieren soll;
- Zeile 6: Mit einer Typumwandlung in [IntUnaryOperator] ist der Zieltyp bekannt, und [var] wird gültig. In der Praxis würde man stattdessen [IntUnaryOperator twice = x -> x * 2;] schreiben;
- Zeilen 9–10: Derselbe Lambda-Ausdruck [() -> "Hello"] implementiert hier einen [Supplier<String>] und dort einen [Callable<String>]. Das sind zwei Objekte verschiedener Klassen, die nur die Form ihrer Methode gemeinsam haben;
- Zeile 14: Seit Java 11 können Lambda-Parameter mit [var] deklariert werden, wodurch sich ein Modifizierer ([final]) oder eine Annotation hinzufügen lässt – was bei einem nicht typisierten Parameter nicht möglich ist;
- Zeilen 17–37: die vier Arten von Methodenreferenzen:
- Zeile 19: eine Referenz auf eine statische Methode, [Class::staticMethod]. [Integer::parseInt] entspricht dem Lambda [s -> Integer.parseInt(s)];
- Zeile 23: eine Referenz auf eine Instanzmethode eines bestimmten Objekts, [object::method]. [name::toUpperCase] entspricht [() -> name.toUpperCase()]: Das Objekt [name] steht ein für alle Mal fest;
- Zeilen 27–28: eine Referenz auf eine Instanzmethode eines beliebigen Objekts einer Klasse, [Class::instanceMethod]. Das Objekt, auf dem die Methode aufgerufen wird, ist noch nicht bekannt: Es wird zum ersten Parameter der Funktion. [String::toUpperCase] entspricht [s -> s.toUpperCase()] (ein Parameter), und [String::compareToIgnoreCase] entspricht [(s1, s2) -> s1.compareToIgnoreCase(s2)] (zwei Parameter), daher [Comparator<String>];
- Zeilen 32–34: die Referenz auf einen Konstruktor, [Class::new]. [ArrayList::new] entspricht [() -> new ArrayList<>()]; [StringBuilder::new] wählt mit einem Zieltyp von [Function<String, StringBuilder>] den Konstruktor, der eine Zeichenkette entgegennimmt; [int[]::new] erzeugt ein Array der als Parameter übergebenen Größe;
- Zeile 37: Die drei Erzeugungsfunktionen werden verwendet; [reverse] kehrt den Inhalt des [StringBuilder] um (Zeile 8 der Ergebnisse);
- Zeilen 40–47: ein wesentlicher Unterschied zwischen [Callable] und [Supplier]. Die Methode [call] ist als [throws Exception] deklariert: Ein Lambda vom Typ [Callable] kann daher eine geprüfte Exception auslösen (siehe Kapitel 3), hier eine [IOException]. Die Methode [get] von [Supplier] deklariert keine Exceptions: Dasselbe Lambda vom Typ [Supplier<Integer>] würde abgelehnt ([unreported exception IOException; must be caught or declared to be thrown]). Keine Schnittstelle des Pakets [java.util.function] erlaubt geprüfte Exceptionen: Ein Lambda, das eine auslöst, muss sie selbst abfangen oder eine Schnittstelle verwenden, deren Methode sie deklariert. Deshalb ist [main] als [throws Exception] deklariert (Zeile 3): Die Aufrufe von [callable.call()] (Zeile 11) und [read.call()] (Zeile 44) könnten theoretisch jede beliebige [Exception] auslösen, die das [catch] in Zeile 45 – beschränkt auf [IOException] – nicht abfängt;
- Zeilen 50–52: Zwei Auswertungen derselben Methodenreferenz [name::toUpperCase] erzeugen zwei verschiedene Objekte, die weder [==] noch [equals] als gleich ansehen (Zeile 10 der Ergebnisse). Merken Sie sich das: Es wird beim Abmelden von einem Ereignis-Listener wichtig sein.
Eine Methodenreferenz ist einfach eine Kurzschreibweise für ein Lambda, das lediglich eine Methode aufruft. Wir verwenden sie, wenn sie die Lesbarkeit verbessert: [String::length] statt [s -> s.length()].
7.3.3. Funktionen komponieren
Vordefinierte funktionale Schnittstellen haben [default] - und [static] -Methoden, die aus vorhandenen Funktionen neue erzeugen, wie die Methode [then] in unserer Schnittstelle [Operation]. Das Programm [Lambdas05.java] listet die wichtigsten auf:
Ergebnisse:
Kommentare:
- Zeile 7: [f.andThen(g)] liefert das Ergebnis der Anwendung von [f] zuerst, dann von [g]: (5 + 1) × 2 = 12;
- Zeile 8: [f.compose(g)] wendet zuerst [g] an, dann [f]: 5 × 2 + 1 = 11;
- Zeilen 10–15: eine dynamisch aufgebaute Verarbeitungskette. Wir beginnen mit der Identitätsfunktion ([Function.identity()], die ihren Parameter unverändert lässt) und fügen mit [andThen] jeden Schritt der Liste hinzu. Die resultierende Funktion [normalize] entfernt führende und nachfolgende Leerzeichen, wandelt den Text in Kleinbuchstaben um und ersetzt Leerzeichen durch Bindestriche. Jeder Aufruf von [andThen] erzeugt eine neue Funktion: Vorhandene Funktionen werden nie verändert. Ebenso könnte die Liste der Schritte aus einer Konfigurationsdatei gelesen werden;
- Zeilen 19–25: Die Prädikate werden mit [and] (und), [or] (oder) und [negate] (nicht) kombiniert. Die statische Methode [Predicate.not] (Java 11) liefert die Negation eines Prädikats: Sie ermöglicht es, [Predicate.not(String::isEmpty)] zu schreiben, während [String::isEmpty.negate()] abgelehnt wird (eine Methodenreferenz hat keinen Typ, solange sie keinen Zieltyp hat);
- Zeilen 28–34: [c1.andThen(c2)] liefert einen [Consumer], der [c1] und dann [c2] auf demselben Wert ausführt. Das ist in Java der einfachste Weg, mehrere Operationen mit einem einzigen Aufruf auszuführen. Zeile 30: [log::add] ist eine Referenz auf die Methode [add] des Objekts [log];
- Zeile 39: [Comparator.comparing(f)] konstruiert einen Comparator, der die Werte von [f] vergleicht (hier das Alter); [thenComparing] gibt das Kriterium an, das bei Gleichstand den Ausschlag gibt (hier der Name). Der Record [Person] (Zeilen 60–65) stellt die Zugriffsmethoden [age()] und [name()] bereit; wir haben seine Methode [toString] neu definiert, um die Ausgabe zu verkürzen;
- Zeilen 41–42: [comparingInt] vermeidet die Umwandlung des Alters in [Integer], [reversed] kehrt die bisher erhaltene Reihenfolge um, und die zweite Form von [thenComparing] nimmt zusätzlich zum Kriterium den Comparator entgegen, der für dieses Kriterium verwendet werden soll: [Comparator.reverseOrder()], die umgekehrte natürliche Reihenfolge;
- Zeilen 45–46: [BinaryOperator.minBy] wandelt einen Comparator in eine Funktion um, die den kleineren ihrer beiden Parameter zurückgibt;
- Zeilen 50–58: die für diese Tests verwendete Methode [filter]. Ihr Parameter hat den Typ [Predicate<? super T>] statt [Predicate<T>]: Sie akzeptiert daher zum Filtern einer Liste von [String] sowohl ein [Predicate<String>] als auch ein [Predicate<Object>] oder ein [Predicate<CharSequence>]. Das ist die in der gesamten Java-Bibliothek befolgte Regel: Ein funktionaler Parameter, der [T] konsumiert[? super T], und ein Parameter, der sie erzeugt , wird mit [? extends T] deklariert.
Mit diesen Methoden lassen sich komplexe Abläufe schreiben, indem man einfache Funktionen kombiniert, ohne eine einzige Klasse zu schreiben. Wir kommen bei der Stream-API darauf zurück.
7.3.4. Variablenerfassung und Closures
Ein Lambda kann die lokalen Variablen der Methode verwenden, in der es definiert ist. Man sagt, es erfasst diese Variablen. Java stellt hierzu eine wichtige Regel auf, die die Sprache von vielen anderen (C#, JavaScript, Python) unterscheidet: Eine erfasste lokale Variable muss „effektiv final“ sein, das heißt, sie wird nach ihrer Initialisierung nie mehr verändert, weder in der Methode noch im Lambda. Das Programm [Lambdas06.java] zeigt, was diese Regel erlaubt und was sie verbietet:
Ergebnisse:
Kommentare:
- Zeile 9: Das Lambda verwendet die in Zeile 8 deklarierte lokale Variable [threshold] . [threshold] ist kein Parameter des Lambdas, sondern eine erfasste Variable. Die Variable wird nie verändert: Sie ist effektiv final, ohne dass sie als [final] deklariert werden müsste (was bei anonymen Klassen bis Java 7 erforderlich war);
- Zeile 11: Würden wir nach der Erzeugung des Lambdas
[threshold = 10;]hinzufügen, würde der Compiler das Lambda in Zeile 9 ablehnen:*[local variables referenced from a lambda expression must be final or effectively final]. Um die Schwelle zu ändern, erzeugen wir eine weitere Variable und ein weiteres Lambda (Zeilen 12–13). Umgekehrt stellt sich die Frage „Sieht das Lambda den Wert der Variablen zum Zeitpunkt seiner Erzeugung oder zum Zeitpunkt seiner Ausführung?“ in Java nicht: Beide sind identisch. Genauer gesagt erhält das Lambda bei seiner Erzeugung eine Kopie* des Variablenwerts; - Zeile 17: Aus demselben Grund kann ein Lambda eine erfasste lokale Variable nicht verändern: [n -> total += n] wird mit derselben Meldung abgelehnt;
- Zeilen 19–23: Die erfasste Variable [total] ändert sich nicht; sie verweist weiterhin auf dasselbe Objekt, [AtomicInteger]. Nichts hindert das Lambda jedoch daran, den Zustand dieses Objekts zu verändern. Die Klasse [AtomicInteger] im Paket [java.util.concurrent.atomic] kapselt eine veränderliche ganze Zahl ([addAndGet], [incrementAndGet], [get] …), die von mehreren Threads sicher verwendet werden kann (Kapitel 8). Wir begegnen auch der Technik des Arrays mit einem einzigen Element ([int[] total = {0};] gefolgt von [total[0] += n]), die diese letztgenannte Eigenschaft nicht besitzt;
- Zeilen 4 und 25–28: Die Regel gilt nur für lokale Variablen. Ein Lambda kann die Felder des aktuellen Objekts lesen und verändern: Es erfasst dann die Referenz [this], die sich selbst nicht ändert. Das Feld [nbCalls] ist ein Feld der impliziten Klasse der kompakten Quelldatei; da die Methode [main] eine Instanzmethode ist, kann das Lambda es inkrementieren;
- Zeilen 58–62: Die Methode
*[createCounter]gibt ein Lambda zurück, das ihre lokale Variable*[value]*erfasst. Normalerweise wird eine lokale Variable zerstört, wenn die Methode endet. Hier hat das zurückgegebene Lambda eine Kopie der Referenz [value] behalten, und das referenzierte Objekt [AtomicInteger] überlebt [createCounter]* , solange das Lambda existiert. Die Kombination aus dem Lambda und den von ihm erfassten Werten heißt „Closure“. Um sie zu erzeugen, speichert die virtuelle Maschine die erfassten Werte in Feldern des Objekts, das sie für das Lambda erzeugt; - Zeilen 31–34: Jeder Aufruf von [createCounter] erzeugt ein neues [AtomicInteger]-Objekt – und damit einen neuen Zähler –, das von den anderen unabhängig ist. Die Ergebnisse (Zeilen 6–7) bestätigen das;
- Zeilen 38–42: In einer gewöhnlichen [for]-Schleife wird die Variable [i] bei jedem Durchlauf verändert ([i++]): Sie ist nicht effektiv final, und das Lambda in Zeile 39 würde abgelehnt. In anderen Sprachen ist diese Erfassung erlaubt und führt zu einem unerwarteten Ergebnis: Die drei Lambdas teilen sich dieselbe Variable [i] und geben alle 3 aus, ihren Wert am Ende der Schleife. Java beseitigt diese Falle zur Kompilierzeit. Die Lösung besteht darin, im Schleifenrumpf eine Variable [copy] zu deklarieren – eine neue pro Durchlauf, die nie verändert wird (Zeile 40) –, sodass jedes Lambda seine eigene erfasst;
- Zeilen 49–51: Bei der „Für jedes Element“-Schleife [for] tritt das Problem nicht auf: Die Variable [j] ist bei jedem Durchlauf eine neue Variable, wird nie verändert und ist daher effektiv final;
- Zeilen 44 und 53: Die Methode [forEach] der Collections erwartet einen [Consumer] und führt ihn auf jedem Element aus. Hier ist jedes Element selbst ein
*[Runnable]*, und die Referenz **[Runnable::run]***(jedes Objekt vom Typ*[Runnable]*, auf dem*[run]aufgerufen wird) führt es aus.
Die Regel zu effektiv finalen Variablen mag restriktiv erscheinen. Sie hat jedoch eine solide Begründung: Ein Lambda kann später oder in einem anderen Thread (Kapitel 8) ausgeführt werden. Könnte es die lokalen Variablen einer Methode verändern, die möglicherweise bereits beendet ist, oder sie lesen, während ein anderer Thread sie verändert, hätten wir es mit schwer vorhersehbarem Verhalten zu tun. Indem Java verlangt, dass Variablen unverändert bleiben, verhindert es diese Situationen; wenn ein gemeinsamer, veränderlicher Zustand wirklich notwendig ist, wird er explizit über ein Objekt abgebildet ([AtomicInteger], Collection …), dessen Verhalten in Bezug auf Threads spezifiziert ist.
7.4. Funktionale Schnittstellen oder Schnittstellen?
In vielen Sprachen unterscheidet sich das Konzept einer „als Parameter übergebenen Funktion“ (Funktionszeiger in C, Delegate in C#) vom Konzept einer Schnittstelle, und man könnte sich fragen, welches man wählen soll. In Java stellt sich die Frage anders, denn beide Konzepte sind ein und dasselbe: Ein Lambda ist eine Instanz einer Schnittstelle. Betrachten wir das Beispiel [Lambdas07.java], das dem Beispiel [Lambdas02.java] ähnelt:
Ergebnisse:
In Zeile 15 erwartet die Methode *[execute] einen Parameter des Typs, der von der funktionalen Schnittstelle *[Operation] in Zeile 34 definiert wird. So können wir ihr verschiedene Funktionen übergeben: statische Methoden unserer Klasse [Methods] (Zeilen 5 und 7), eine Methode der Java-Bibliothek mit der passenden Form (Zeile 9: Unter den Überladungen von *[Math.max]* wählt der Compiler ***[int max(int a, int b)]*) und sogar ein Lambda (Zeile 11): Es war nicht nötig, eine Multiplikationsmethode zu schreiben. Dieser Polymorphismus ist der der Schnittstellen, der in Kapitel 4 behandelt wurde: Das Programm [Lambdas08.java] zeigt dies, indem es dieselbe Schnittstelle mit Klassen implementiert:
Ergebnisse:
Kommentare:
- Zeilen 31–33: Die Schnittstelle [Operation] definiert eine Methode [calculate]. Sie ist nicht mit [@FunctionalInterface] annotiert: Die Annotation dient lediglich der Prüfung, und jede Schnittstelle mit genau einer abstrakten Methode ist funktional;
- Zeilen 41–47 und 50–56: Die Klassen
*[Add]und*[Subtract]implementieren die Schnittstelle*[Operation]*; - Zeilen 26–28: die Methode [execute], deren erster Parameter den Typ der Schnittstelle [Operation] hat. Sie erhält nacheinander eine Instanz der Klasse [Add], eine Instanz der Klasse [Subtract] (Zeilen 5 und 7) und dann ein Lambda (Zeile 9). Für [execute] sind diese drei Objekte vom selben Typ: Es sind Objekte, die [Operation] implementieren;
- Zeilen 36–38: Die Schnittstelle [NamedOperation] erbt die Methode [calculate] und fügt eine Methode [name] hinzu. Mit zwei abstrakten Methoden ist sie nicht mehr funktional: Sie kann nicht mehr durch ein Lambda implementiert werden, es ist eine Klasse erforderlich – hier eine anonyme Klasse (Zeilen 11–21).
Diese beiden Beispiele zeigen, dass man sich in Java nicht zwischen zwei Mechanismen entscheiden muss: Eine Methode, die eine Schnittstelle mit nur einer Methode erwartet, akzeptiert Objekte von Klassen, die eigens dafür geschrieben wurden, Methodenreferenzen und Lambdas gleichermaßen. Die eigentliche Frage lautet also: Soll die Schnittstelle funktional sein, mit nur einer Methode, oder soll sie mehrere Methoden haben?
- Eine Schnittstelle mit nur einer Methode – ob vordefiniert ([Function], [Predicate] …) oder nicht – erweist sich in der Verwendung als flexibler: Jede vorhandene Methode mit der passenden Form genügt, und ein Lambda erlaubt es sogar, die Funktion direkt an der Aufrufstelle zu schreiben. Es muss keine Klasse geschrieben werden. Diese Flexibilität erklärt, warum moderne Bibliotheken (die Stream-API, die asynchrone Programmierung in Kapitel 9, Spring) funktionale Schnittstellen intensiv nutzen;
- eine Schnittstelle mit mehreren Methoden ist dann im Vorteil, wenn das zu implementierende Verhalten mehrere zusammengehörige Operationen umfasst ([calculate] und [name] oben) oder wenn es einen eigenen Zustand und eine eigene Identität benötigt.
Dies gilt für die Schnittstelle [ITaxDao] in der [dao]-Schicht aus Kapitel 6: Obwohl sie nur eine Methode besitzt, [List<TaxBracket> getTaxBrackets()], haben ihre Implementierungen einen Zustand (die gelesenen Steuerstufen, den Dateinamen), werden vom Dependency-Injection-Container erzeugt und stellen eine klar benannte Rolle innerhalb der Anwendung dar. Ein [Supplier<List<TaxBracket>>] hätte technisch genügt, wäre aber deutlich weniger aussagekräftig gewesen. Funktionale Schnittstellen reservieren wir daher für kurze, einmalige Verhaltensweisen (ein Kriterium, eine Transformation, eine Aktion) und „fachliche“ Schnittstellen für die Rollen der Anwendung, unabhängig von der Anzahl der enthaltenen Methoden.
7.5. Ereignisbehandlung
7.5.1. Das Listener-Modell
Funktionale Schnittstellen dienen dazu, Ereignisse einzurichten. Java besitzt kein eigenes Schlüsselwort für Ereignisse: Es verwendet eine Reihe von Konventionen, das sogenannte „Listener-Modell“, das bereits mit Java 1.1 für grafische Komponenten und JavaBeans eingeführt wurde. Eine Klasse [C1] , die ein Ereignis [Xxx] signalisieren möchte, geht wie folgt vor:
- Eine Klasse [XxxEvent], abgeleitet von [java.util.EventObject], kapselt die Informationen zum Ereignis. [EventObject] speichert das Objekt, das das Ereignis ausgelöst hat – die sogenannte Quelle –, die über [getSource()] abgerufen wird;
- eine Schnittstelle [XxxListener], die die leere Schnittstelle [java.util.EventListener] (eine reine Markierung) erweitert, definiert die Methode(n), die beim Eintreten des Ereignisses aufgerufen werden. Mit nur einer Methode ist sie eine funktionale Schnittstelle: Ein Listener kann ein Lambda sein;
- Die Klasse [C1] verwaltet eine Liste von Listenern und stellt zwei öffentliche Methoden zum An- und Abmelden bereit: [addXxxListener(XxxListener l)] und [removeXxxListener(XxxListener l)];
- Wenn eine Instanz [c1] der Klasse [C1] das Ereignis signalisieren möchte, erzeugt sie ein Objekt [XxxEvent] und ruft die Methode jedes registrierten Listeners auf, wobei sie ihm dieses Objekt übergibt. Per Konvention übernimmt diese Benachrichtigung eine geschützte Methode [fireXxx(XxxEvent e)] („fire“), die eine abgeleitete Klasse überschreiben kann, um die Veröffentlichung des Ereignisses zu ändern;
- wenn ein Objekt [c2] über das Ereignis [Xxx] des Objekts [c1] benachrichtigt werden möchte, registriert es sich mit [c1.addXxxListener(...)]. Es kann sich über [c1.removeXxxListener(...)] abmelden, wenn es nicht mehr benachrichtigt werden möchte. Da [c1] eine Liste verwaltet, können sich verschiedene Objekte anmelden, um über dasselbe Ereignis benachrichtigt zu werden.
In diesem Szenario haben wir:
- eine Klasse, die ein Ereignis signalisiert (auch „veröffentlicht“ oder „aussendet“);
- Objekte, die über dieses Ereignis benachrichtigt werden. Man sagt, sie abonnieren das Ereignis bzw. registrieren sich dafür: Dies sind die Listener oder Ereignishandler;
- eine Listener-Schnittstelle, die die Signatur der Methoden festlegt, die über das Ereignis benachrichtigt werden.
Dies ist das Entwurfsmuster Observer: Der Sender kennt seine Abonnenten nicht; er benachrichtigt sie lediglich. Dieses Modell bietet denselben Schutz wie ein eigenes Schlüsselwort: Die Liste der Listener ist ein privates Feld des Senders. Von außen kann man sich nur an- oder abmelden; man kann die Liste nicht leeren, andere Listener nicht ersetzen und das Ereignis nicht anstelle des Senders auslösen.
7.5.2. Ein Beispiel: zu hohe Temperatur
Betrachten wir das folgende Beispiel:
- Eine Klasse namens [Emitter] kapselt eine Temperatur. Überschreitet diese Temperatur einen bestimmten Schwellenwert, muss ein Ereignis ausgelöst werden. Wir nennen dieses Ereignis [TemperatureTooHigh]. Die Informationen zu diesem Ereignis werden in einem Objekt [TemperatureTooHighEvent] gekapselt, und die Listener implementieren die Schnittstelle [TemperatureTooHighListener];
- eine Klasse namens [Subscriber] registriert sich als Listener für das genannte Ereignis. Wird sie über das Ereignis benachrichtigt, zeigt sie eine Meldung auf der Konsole an. Ein Subscriber meldet sich automatisch ab, nachdem er eine festgelegte Anzahl von Warnungen erhalten hat;
- Ein Konsolenprogramm erzeugt einen Sender und zwei Subscriber. Es liest Temperaturen über die Tastatur ein und speichert sie im Sender. Ist eine davon zu hoch, signalisiert der Sender das Ereignis [TemperatureTooHigh].
Alle diese Klassen sind in der kompakten Quelldatei [Lambdas09.java] zusammengefasst, die wir in drei Teilen vorstellen. Zunächst die Ereignisklasse, die Listener-Schnittstelle und die Klasse [Emitter]:
Kommentare:
- Zeilen 1–28: Die Klasse [TemperatureTooHighEvent] ist konventionsgemäß von [EventObject] abgeleitet. Ihr Konstruktor (Zeilen 10–13) übergibt die Ereignisquelle an den Konstruktor von [EventObject] ([super(source)]) und speichert die Temperatur, die das Ereignis ausgelöst hat. Wir haben den Zeitpunkt des Ereignisses hinzugefügt, [time] (Zeile 8). Die Felder sind [final], und die Klasse besitzt nur lesende Zugriffsmethoden: Ein Listener darf die Informationen des Ereignisses für nachfolgende Listener nicht verändern können;
- Zeilen 3–4: [EventObject] implementiert die Schnittstelle [Serializable] (damit Ereignisse protokolliert oder über ein Netzwerk übertragen werden können). Der Compiler verlangt bei Verwendung der Option [-Xlint:all] dann von jeder abgeleiteten Klasse, eine Versionsnummer [serialVersionUID] zu deklarieren. Die Annotation [@Serial] (Java 14) kennzeichnet dieses Feld gegenüber dem Compiler;
- Zeilen 16–19: Die Methode [getSource] von [EventObject] liefert ein [Object]. Wir überschreiben sie mit einem spezifischeren Rückgabetyp, [Emitter], was Java erlaubt (kovarianter Rückgabetyp): Die Listener müssen die Quelle nicht umwandeln. Wir können hier kein
*[record]* verwenden: Ein Record kann von keiner Klasse erben und folglich auch nicht von*[EventObject]*; - Zeilen 30–34: die Listener-Schnittstelle. Sie erweitert [EventListener] und deklariert eine einzige Methode, [temperatureTooHigh], die das Ereignisobjekt erhält: Dies ist eine funktionale Schnittstelle;
- Zeile 39: der Temperaturschwellenwert, ab dem das Ereignis [TemperatureTooHigh] ausgelöst wird;
- Zeile 41: Der Emitter hat zur Identifizierung einen Namen;
- Zeile 45: die Liste der registrierten Listener. Es handelt sich um eine [CopyOnWriteArrayList] aus dem Paket [java.util.concurrent], eine Liste, die bei jeder Änderung ihren Inhalt in ein neues Array kopiert. Eine laufende Iteration setzt sich daher auf dem alten Array fort, selbst wenn die Liste zwischenzeitlich geändert wird. Warum das hier unerlässlich ist, sehen wir später. Diese Liste ist der Standardtyp für Listener-Listen: Die Liste wird für jedes Ereignis durchlaufen, aber nur selten geändert;
- Zeilen 59–65: Die Methode [setTemperature] speichert die neue Temperatur und signalisiert das Ereignis, wenn sie den Schwellenwert überschreitet;
- Zeile 63: Die Veröffentlichung übernimmt die Methode [fireTemperatureTooHigh], der ein Objekt [TemperatureTooHighEvent] übergeben wird; dieses Objekt stammt vom Sender selbst ([this]) und enthält die Temperatur, die den Schwellenwert überschritten hat;
- Zeilen 68–70: Das Registrieren eines Listeners fügt ihn der Liste hinzu. [Objects.requireNonNull] weist einen Listener [null] sofort zurück, der andernfalls viel später, bei der Benachrichtigung, eine [NullPointerException] auslösen würde;
- Zeilen 73–75: Das Abmelden entfernt den Listener aus der Liste. Die Methode [remove] sucht das zu entfernende Objekt mithilfe von [equals]; ihr muss daher dasselbe Objekt übergeben werden, das registriert wurde;
- Zeilen 78–82: Die Benachrichtigung ruft für jeden registrierten Listener die Methode [temperatureTooHigh] auf, und zwar in der Reihenfolge, in der sie registriert wurden. Gibt es keine Listener, tut die Schleife nichts: Es gibt keinen Sonderfall zu behandeln.
Hier ist die Klasse [Subscriber]:
Kommentare:
- Zeilen 4–6: Jeder Subscriber wird durch einen Namen identifiziert und erhält die maximale Anzahl an Warnungen, die er akzeptiert ([nbAlertsMax]);
- Zeile 10: Der Listener des Subscribers ist eine Referenz auf seine private Methode [evtTemperatureTooHigh]. Wir haben bei [Lambdas04.java] gesehen, dass zwei Auswertungen von [this::evtTemperatureTooHigh] zwei verschiedene Objekte erzeugen. Würden wir [emitter.addTemperatureTooHighListener(this::evtTemperatureTooHigh)] in [subscribe] und dann [emitter.removeTemperatureTooHighListener(this::evtTemperatureTooHigh)] in [unsubscribe] schreiben, würde das Abmelden nichts entfernen, und es würde keine Fehlermeldung angezeigt! Daher erzeugen wir den Listener einmal und speichern ihn in einem Feld;
- Zeilen 18–20: die Anmeldung bei einem Sender. Dies liegt in der Verantwortung des Subscribers; er weiß, welches Objekt er zum Abmelden entfernen muss;
- Zeilen 23–25: Das Abmelden entfernt dasselbe Objekt, [listener]. Jeder Subscriber hat sein eigenes Objekt [listener]: [remove] entfernt nur das Objekt des betreffenden Subscribers;
- Zeile 28: der Ereignishandler. Er hat die Form, die die Schnittstelle [TemperatureTooHighListener] vorgibt. Er ist privat: Nur der Subscriber kann ihn bei einem Sender registrieren. Ein anderer, sehr verbreiteter Ansatz besteht darin, dass die Klasse [Subscriber] selbst ([class Subscriber implements TemperatureTooHighListener]) die Listener-Schnittstelle implementiert und sich mit [this] registriert. Der Nachteil dieses Ansatzes ist, dass die Methode [temperatureTooHigh] dadurch öffentlich wird und jeder sie aufrufen könnte;
- Zeile 29: Dank der Neudefinition von [getSource] hat die Ereignisquelle direkt den Typ [Emitter];
- Zeilen 30–31: Der Handler zeigt den Namen des Subscribers, den Namen des Senders, der das Ereignis gemeldet hat, und die Temperatur an, die es ausgelöst hat. Das Format [%.1f] stellt die reelle Zahl mit einer Nachkommastelle dar, hier mit einem Dezimalpunkt;
- Zeilen 33–37: Nach [nbAlertsMax] Warnungen meldet sich der Subscriber beim Sender ab. Der Subscriber tut dies während der Ereignisbenachrichtigung, aus seinem eigenen Handler heraus – also während die Methode [fireTemperatureTooHigh] die Liste der Listener durchläuft. Dank [CopyOnWriteArrayList] ist dies unbedenklich: [remove] erzeugt ein neues Array, aber die laufende Iteration setzt sich auf dem alten fort.
Hier schließlich das Hauptprogramm:
Ergebnisse:
Kommentare:
- Zeile 5: Erzeugung des Senders;
- Zeilen 7–10: Erzeugung zweier Subscriber, [s0] (bis zu 3 Warnungen) und [s1] (1 Warnung), die beim Sender registriert werden;
- Zeilen 12–13: ein dritter Listener, ein Lambda, das als Protokoll dient. Der Typ des Parameters [e] wird aus dem des Parameters [addTemperatureTooHighListener] abgeleitet. Das Format [%tT] stellt eine Uhrzeit in der Form [HH:mm:ss] dar. Dieses Lambda kann nicht abgemeldet werden: Es hätte in einer Variablen gespeichert werden müssen, um es an [removeTemperatureTooHighListener] zu übergeben. Daher sind Lambdas, die direkt im Registrierungsaufruf geschrieben werden, Listenern vorbehalten, die so lange registriert bleiben, wie der Sender existiert;
- Zeilen 16–31: Schleife zur Eingabe von Temperaturen über die Tastatur. [IO.readln(prompt)] zeigt die Eingabeaufforderung an und liest eine Zeile; es liefert [null] , wenn die Standardeingabe geschlossen ist, was als leere Eingabe behandelt wird (Zeile 19);
- Zeile 24: [Double.parseDouble] akzeptiert nur den Dezimalpunkt. Damit ein französischer Benutzer [22,5] eingeben kann, wird das Komma durch einen Punkt ersetzt. Ist die Eingabe keine Zahl, löst [parseDouble] eine [NumberFormatException] aus, die in Zeile 27 abgefangen wird;
- Zeile 26: Ist die eingegebene Temperatur gültig, wird sie an den Emitter [e1] übermittelt, der das Ereignis [TemperatureTooHigh] signalisiert, wenn sie über 19 °C liegt.
Die Ergebnisse zeigen Folgendes (die Standardeingabe wurde aus einer Datei gespeist, weshalb alle Uhrzeiten identisch sind):
- Zeile 2: 17 °C überschreiten den Schwellenwert nicht: kein Ereignis;
- Zeilen 3–7: 21 °C lösen das Ereignis aus. Die drei Listener werden in der Reihenfolge ihrer Registrierung benachrichtigt. [s1], der nur eine Warnung akzeptiert, meldet sich sofort ab, was aber nicht verhindert, dass das danach registrierte Protokoll benachrichtigt wird;
- Zeilen 10–12: [s1] wird nicht mehr benachrichtigt;
- Zeilen 13–16: [s0] erhält seine dritte Warnung und meldet sich seinerseits ab;
- Zeile 18: Nur das Protokoll bleibt übrig.
Was geschähe, wenn in Zeile 45 des ersten Auszugs, in der Klasse [Emitter], einfach eine [ArrayList] stünde? Wir haben es getestet: Wenn [s1] sich abmeldet, während die Liste abgearbeitet wird, werden die nachfolgenden Elemente übersprungen, und die Verarbeitung endet sofort. Das Protokoll wird über die Temperaturen 21 und 25 nicht benachrichtigt, ohne dass eine Fehlermeldung erscheint. In anderen Konfigurationen löst die Iteration eine [ConcurrentModificationException] aus. Eine Liste von Listenern muss daher stets Änderungen während des Durchlaufs vertragen: Die [CopyOnWriteArrayList] ist genau dafür gedacht, und sie unterstützt auch An- und Abmeldungen, die von anderen Threads vorgenommen werden (Kapitel 8).
7.5.3. Ereignisse bei Eigenschaftsänderungen
Der häufigste Ereignistyp tritt auf, wenn sich der Wert einer Eigenschaft eines Objekts ändert: Ein anderes Objekt (eine grafische Benutzeroberfläche, ein Cache, ein Protokoll) möchte über diese Änderung benachrichtigt werden. Die Java-Bibliothek stellt dafür eine einsatzbereite Klasse bereit, [java.beans.PropertyChangeSupport], die für uns die Liste der Listener verwaltet. Die Listener implementieren die funktionale Schnittstelle [PropertyChangeListener], deren Methode [void propertyChange(PropertyChangeEvent evt)] ein Ereignis erhält, das die Quelle, den Namen der Eigenschaft sowie ihren alten und neuen Wert enthält. Das Programm [Lambdas10.java] verwendet sie:
Ergebnisse:
Kommentare:
- Zeilen 3–4: Das Paket [java.beans] gehört zum Modul [java.desktop], nicht zum Modul [java.base]: Es muss explizit importiert werden, selbst in einer kompakten Quelldatei;
- Zeile 33: Die Klasse [Thermometer] delegiert die Verwaltung ihrer Listener an ein Objekt [PropertyChangeSupport], das aus der Ereignisquelle ([this]) konstruiert wird. Die Methoden in den Zeilen 62–72 reichen An- und Abmeldungen einfach an dieses Objekt weiter;
- Zeilen 45–49 und 55–59: Jeder Modifikator speichert den alten Wert, hinterlegt den neuen und ruft [firePropertyChange] mit dem Namen der Eigenschaft und beiden Werten auf. [firePropertyChange] benachrichtigt die Listener nur, wenn die beiden Werte verschieden sind: Zeile 22 erzeugt keine Ausgabe;
- Zeilen 9–11: ein erster Listener, ein in einer Variablen gespeichertes Lambda, damit es abgemeldet werden kann (Zeile 25). Er ist für alle Eigenschaften des Objekts angemeldet. [e.getSource()] liefert ein [Object], das umgewandelt werden muss. Die Werte sind Objekte: Die [double]-Objekte wurden in [Double] umgewandelt, dessen Methode [toString] den Dezimalpunkt verwendet;
- Zeilen 13–17: ein zweiter Sensor, der nur für die Eigenschaft [temperature] registriert ist. Er löst eine Warnung aus, wenn die Temperatur 19 °C überschreitet;
- Zeilen 19–26: Änderungen von Eigenschaften. Die Namensänderung (Zeile 23) wird nur dem Protokoll gemeldet. In Zeile 5 der Ergebnisse zeigt das Protokoll den neuen Namen der Quelle an, [lounge]: Das Ereignis wird nach der Änderung gemeldet;
- Zeilen 26–27: Nach dem Abmelden vom Protokoll wird nur noch die Warnung angezeigt, und es bleibt nur ein Listener übrig.
Ohne eine Ereignisklasse oder eine Listener-Schnittstelle zu schreiben, erhalten wir so einen vollständigen Mechanismus. Er wird von den grafischen Swing-Komponenten und von JavaBeans verwendet; JavaFX hat einen eigenen, sehr ähnlichen Mechanismus auf Basis beobachtbarer Eigenschaften.
7.6. Lambdas und die Stream-API
In Kapitel 5 haben wir die Methoden der Stream-API ([filter], [map], [sorted] …) verwendet, indem wir ihnen Lambda-Ausdrücke übergeben haben. Wir wissen jetzt, was diese Parameter sind: Die Methode [filter] ist in der Schnittstelle [java.util.stream.Stream<T>] wie folgt deklariert: [Stream<T> filter(Predicate<? super T> predicate)].
Ihr Parameter ist ein [Predicate]: Jede Methode und jedes Lambda, das ein Element entgegennimmt und einen booleschen Wert zurückgibt, funktioniert. Ebenso erwartet [map] eine [Function<? super T, ? extends R>], [sorted] erwartet einen [Comparator], [forEach] erwartet einen [Consumer], [reduce] erwartet einen [BinaryOperator] … Um die Funktionsweise der Stream-API vollständig zu verstehen, schreiben wir unsere eigenen Filter- und Transformationsoperationen. Dies ist das Programm [Lambdas11.java]:
Ergebnisse:
Kommentare:
- Zeilen 7–9: Das Lambda von [filter] wird zunächst in einer Variablen vom Typ [Predicate<Integer>] gespeichert, um seinen Typ sichtbar zu machen. [map] erhält seinerseits eine [Function<Integer, Integer>], die jedes Element transformiert: Das ergibt die Quadrate der geraden Zahlen;
- Zeilen 36–44: unsere Methode [filter]. Sie ist generisch: Sie filtert eine Liste von Elementen beliebigen Typs [T] mithilfe eines Prädikats vom Typ [Predicate<? super T>]. Sie durchläuft die Liste, ruft für jedes Element das Prädikat auf (Zeile 39) und gibt die Liste der ausgewählten Elemente zurück;
- Zeile 13: Aufruf von [filter] mit einem Lambda. Der Typ [T] wird aus der Liste abgeleitet: [Integer]. Zeile 14: Ihr wird eine Methodenreferenz übergeben: [isOdd] (Zeile 46) erhält einen [int]; der Compiler fügt die Umwandlung aus [Integer] hinzu;
- Zeilen 17–20: ein ausführliches Prädikat, das jedes Element anzeigt, das es prüft. Das Ergebnis (Zeilen 5–6) zeigt, dass die Definition des Flusses nichts ausführt: Die Meldung in Zeile 21 wird vor dem ersten Test angezeigt. Erst wenn die terminale Operation [forEach] (Zeile 22) die Elemente anfordert, wird das Prädikat ausgeführt, und die Tests wechseln sich mit den Ausgaben von [forEach] ab: Jedes Element durchläuft den gesamten Fluss, bevor das nächste in ihn eintritt. Dies ist die verzögerte (oder „lazy“) Ausführung der Streams. Unsere Methode [filter] dagegen erstellt die gesamte Ergebnisliste, bevor sie sie zurückgibt;
- Zeilen 51–58: Um eigene Zwischenoperationen zu schreiben – die wie die der Stream-API lazy sind –, verwenden wir die Zwischen-Collector ([Gatherer], Java 24), die für Zwischenoperationen das Gegenstück zu den Collectors ([Collector]) sind, die von [collect] verwendet werden. [Gatherer.of] erhält ein Lambda mit drei Parametern, das für jedes Element des Streams aufgerufen wird: einen Zustand (hier unnötig, daher der anonyme Parameter [_]), das Element und die nächste Stufe des Flusses ([downstream]), an die ein Element über [downstream.push(...)] weitergegeben wird. Das Lambda gibt [false] zurück, um den Stream anzuhalten; unsere Funktionen entscheiden das nie selbst: Sie geben das Ergebnis von [push] zurück, das nur dann [false] ist, wenn die nachgelagerte Stufe keine Elemente mehr haben möchte (oder [true] , wenn der Filter ein Element verwirft). Der Filter (Zeile 52) leitet nur die Elemente weiter, die das Prädikat erfüllen; die Transformation (Zeile 57) leitet das Ergebnis der auf jedes Element angewendeten Funktion weiter;
- Zeile 56: [transform] ist doppelt generisch: [T] ist der Typ der empfangenen Elemente und [R] der Typ der erzeugten Elemente. Der Parameter [Function<? super T, ? extends R>] folgt der Regel, der wir bereits begegnet sind: Die Funktion konsumiert [T] und erzeugt [R];
- Zeilen 27–30: Die Stream-Methode [gather] fügt unsere Operationen in die Kette ein, die genauso geschrieben wird wie für die Operationen der Stream-API: Wir behalten Städte mit bis zu 5 Buchstaben und schreiben sie dann groß.
Die gesamte Stream-API ist nach diesem Modell aufgebaut: Operationen, die funktionale Schnittstellen entgegennehmen und neue Streams erzeugen, deren Elemente erst auf Anforderung der terminalen Operation berechnet werden.
7.7. Ausdrucksbäume
Einige Sprachen wie C# erlauben es, ein Lambda nicht in ausführbaren Code, sondern in eine Datenstruktur umzuwandeln, die es beschreibt (ein „Ausdrucksbaum“): Ein Programm kann dann das Lambda [t -> t.getLimit() > 20000] analysieren und beispielsweise in eine SQL-Klausel [WHERE limits > 20000] übersetzen, die vom Datenbankserver ausgeführt wird.
Java hat kein Äquivalent. Ein Java-Lambda wird immer in ausführbaren Code kompiliert: Man kann es aufrufen, aber nicht untersuchen, was es tut. Bibliotheken für den Datenbankzugriff verwenden daher andere Mittel, um eine Abfrage auszudrücken. Hibernate, das wir in Kapitel 11 behandeln, bietet zwei Lösungen: eine SQL-ähnliche Abfragesprache, die in Klassen und Eigenschaften formuliert ist, HQL (["from Bracket t where t.limit > 20000"]), und die Criteria-API von Jakarta Persistence, die die Abfrage durch Methodenaufrufe aufbaut ([cb.gt(t.get("limit"), 20000)]). In beiden Fällen ist die Abfrage ein Datenobjekt (eine Zeichenkette oder ein Objektbaum), das Hibernate in SQL übersetzt, während ein an [filter] übergebenes Lambda innerhalb des Java-Programms ausgeführt wird.
7.8. Fazit
Die wichtigsten Punkte dieses Kapitels:
- Eine funktionale Schnittstelle ist eine Schnittstelle mit nur einer abstrakten Methode. Die vordefinierten Schnittstellen des Pakets [java.util.function] ([Function], [Supplier], [Consumer], [Predicate], ihre Varianten mit zwei Parametern und ihre primitiven Versionen) sowie [Runnable], [Callable] und [Comparator] machen es in der Regel überflüssig, eigene zu definieren; wird dennoch eine definiert, wird sie mit [@FunctionalInterface] annotiert;
- Eine funktionale Schnittstelle kann durch eine Klasse (benannt oder anonym), durch einen Lambda-Ausdruck oder durch eine Methodenreferenz implementiert werden ([Class::staticMethod], [object::method], [Class::instanceMethod], [Class::new]). Ein Lambda hat keinen eigenen Typ: Der Zieltyp bestimmt ihn;
- Lambdas erfassen die sie umgebenden lokalen Variablen, sofern diese Variablen effektiv final sind; veränderlicher Zustand wird über ein Objekt oder ein Feld abgebildet;
- die Methoden [andThen], [compose], [and], [negate], [comparing], [thenComparing] … bilden aus vorhandenen Funktionen neue;
- In Java ist ein Lambda eine Instanz einer Schnittstelle: Für kurze, einmalige Verhaltensweisen wählt man eine funktionale Schnittstelle, für eine Rolle der Anwendung dagegen eine Schnittstelle mit mehreren Methoden (oder eine „fachliche“ Schnittstelle);
- Ein Ereignis wird mit dem Listener-Muster eingerichtet: eine Klasse [XxxEvent] , abgeleitet von [EventObject], eine Schnittstelle [XxxListener], die Methoden [addXxxListener] / [removeXxxListener], und eine Liste von Listenern ([CopyOnWriteArrayList]), die von einer Methode [fireXxx] durchlaufen wird. Um einen Listener abzumelden, muss man das angemeldete Objekt aufbewahren. [PropertyChangeSupport] stellt diesen Mechanismus für Eigenschaftsänderungen fertig bereit;
- die Stream-API basiert auf Operationen, die funktionale Schnittstellen akzeptieren; Java kennt keine Ausdrucksbäume, und Hibernate formuliert seine Abfragen in HQL oder mit der Criteria-API.
Lambdas werden in allen folgenden Kapiteln wieder auftauchen: Ein Thread führt ein [Runnable] aus, und ein [ExecutorService] führt ein [Callable] aus (Kapitel 8), ein [CompletableFuture] verkettet Funktionen (Kapitel 9), und Spring-Boot-Webdienste verarbeiten HTTP-Anfragen in Methoden, die das Framework als Listener aufruft (Kapitel 13).