Skip to content

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:

// die vordefinierten funktionalen Schnittstellen von Java

void main() {
    // 1 - Runnable: kein Parameter, kein Ergebnis: void run()
    Runnable task = new Runnable() {
        @Override
        public void run() {
            Functions.display();
        }
    };
    // Kurzform: eine Methodenreferenz
    task = Functions::display;
    // Ausführung: Wir rufen die einzige abstrakte Methode der Schnittstelle auf
    task.run();

    // 2 - BiFunction<T, U, R>: zwei Parameter, ein Ergebnis
    BiFunction<Integer, Integer, Integer> operation = Functions::add;
    IO.println("operation.apply(2, 3)=" + operation.apply(2, 3));
    // Supplier<T>: kein Parameter, ein Ergebnis
    Supplier<String> greet = Functions::greet;
    IO.println("greet.get()=" + greet.get());
    // primitive Version: IntBinaryOperator, int applyAsInt(int, int), ohne Boxing
    IntBinaryOperator multiply = Functions::multiply;
    IO.println("multiply.applyAsInt(2, 3)=" + multiply.applyAsInt(2, 3));

    // 3 - Consumer<T>: ein Parameter, kein Ergebnis
    Consumer<String> write = IO::println;
    write.accept("Consumer<String> executed IO.println");

    // 4 - Predicate<T>: ein Parameter, ein boolesches Ergebnis
    Predicate<Integer> isEven = Functions::isEven;
    IO.println("isEven.test(8)=" + isEven.test(8));
    List<Integer> numbers = new ArrayList<>(List.of(3, 8, 1, 6, 5, 4));
    // removeIf von Collection erwartet ein Predicate
    boolean modified = numbers.removeIf(isEven);
    IO.println("even numbers removed: " + modified + ", remaining: " + numbers);

    // 5 - Comparator<T>: zwei Parameter vom Typ T, ein int-Ergebnis
    List<String> names = new ArrayList<>(List.of("Paul", "Mélanie", "Jo", "Sébastien"));
    names.sort(Functions::compareLengths);
    IO.println("sorted by length: " + names);

    // 6 - ein Lambda ist ein Objekt: die Instanz einer generierten Klasse, die die Schnittstelle implementiert
    IO.println("class: " + operation.getClass().getName());
    IO.println("interfaces: " + Arrays.toString(operation.getClass().getInterfaces()));
}

// die referenzierten Methoden, in einer Klasse zusammengefasst
// (die implizite Klasse einer kompakten Quelldatei kann nicht benannt werden)
class Functions {

    static void display() {
        IO.println("display() executed by Runnable.run()");
    }

    static int add(int n1, int n2) {
        return n1 + n2;
    }

    static int multiply(int n1, int n2) {
        return n1 * n2;
    }

    static String greet() {
        return "Hello";
    }

    static boolean isEven(int n) {
        return n % 2 == 0;
    }

    static int compareLengths(String s1, String s2) {
        return Integer.compare(s1.length(), s2.length());
    }
}

Ergebnisse:

> java Lambdas01.java
display() executed by Runnable.run()
operation.apply(2, 3)=5
greet.get()=Hello
multiply.applyAsInt(2, 3)=6
Consumer<String> executed IO.println
isEven.test(8)=true
even numbers removed: true, remaining: [3, 1, 5]
sorted by length: [Jo, Paul, Mélanie, Sébastien]
class: Lambdas01$$Lambda/0x0000000020165a28
interfaces: [interface java.util.function.BiFunction]

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]:

// eigene funktionale Schnittstellen definieren

void main() {
    // eine Variable vom Typ Operation erhält die statische Methode increase
    Operation op = Calculations::increase;
    // wir führen die Operation aus
    int n = op.calculate(4, 7);
    IO.println("n=" + n);

    // Erzeugung eines Objekts c1 vom Typ Calculations
    var c1 = new Calculations();
    // wir speichern in op die Methode add des Objekts c1
    op = c1::add;
    n = op.calculate(2, 3);
    IO.println("n=" + n);
    // dann die Methode subtract von c1
    op = c1::subtract;
    n = op.calculate(2, 3);
    IO.println("n=" + n);

    // eine Variable referenziert nur eine Funktion: Um mehrere auszuführen, verwenden wir eine Liste
    List<Operation> operations = new ArrayList<>();
    operations.add(c1::add);
    operations.add(c1::subtract);
    operations.add((n1, n2) -> n1 * n2);
    for (Operation operation : operations) {
        IO.println("-> " + operation.calculate(10, 4));
    }

    // eine default-Methode der Schnittstelle erstellt eine neue Operation
    Operation squaredSum = ((Operation) c1::add).then(x -> x * x);
    IO.println("squaredSum.calculate(1, 2)=" + squaredSum.calculate(1, 2));

    // Operation und IntBinaryOperator haben dieselbe Form, sind aber zwei verschiedene Typen
    IntBinaryOperator other = op::calculate;
    IO.println("other.applyAsInt(5, 1)=" + other.applyAsInt(5, 1));

    // eine generische funktionale Schnittstelle
    Transformation<String, Integer> length = String::length;
    Transformation<Integer, String> stars = "*"::repeat;
    IO.println("length(\"Hello\")=" + length.transform("Hello"));
    IO.println("stars(5)=" + stars.transform(5));
}

// Definition einer funktionalen Schnittstelle: eine einzige abstrakte Methode
// die zwei ganze Zahlen als Parameter akzeptiert und eine ganze Zahl zurückgibt
@FunctionalInterface
interface Operation {
    int calculate(int n1, int n2);

    // eine default-Methode zählt nicht: Die Schnittstelle bleibt funktional
    default Operation then(IntUnaryOperator next) {
        return (n1, n2) -> next.applyAsInt(calculate(n1, n2));
    }
}

// eine generische funktionale Schnittstelle: T -> R
@FunctionalInterface
interface Transformation<T, R> {
    R transform(T value);
}

// eine Klasse, deren Methoden die Form der Schnittstelle Operation haben
class Calculations {
    // zwei Instanzmethoden
    int add(int n1, int n2) {
        IO.println("add(" + n1 + "," + n2 + ")");
        return n1 + n2;
    }

    int subtract(int n1, int n2) {
        IO.println("subtract(" + n1 + "," + n2 + ")");
        return n1 - n2;
    }

    // eine statische Methode
    static int increase(int n1, int n2) {
        IO.println("increase(" + n1 + "," + n2 + ")");
        return n1 + 2 * n2;
    }
}

Ergebnisse:

> java Lambdas02.java
increase(4,7)
n=18
add(2,3)
n=5
subtract(2,3)
n=-1
add(10,4)
-> 14
subtract(10,4)
-> 6
-> 40
add(1,2)
squaredSum.calculate(1, 2)=9
subtract(5,1)
other.applyAsInt(5, 1)=4
length("Hello")=5
stars(5)=*****

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):

> java Lambdas02.java
Lambdas02.java:5: error: incompatible types: Operation is not a functional interface
    Operation op = Calculations::increase;
                   ^
    multiple non-overriding abstract methods found in interface Operation
...
Lambdas02.java:47: error: Unexpected @FunctionalInterface annotation
@FunctionalInterface
^
  Operation is not a functional interface
    multiple non-overriding abstract methods found in interface Operation
9 errors
error: compilation failed

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:

// von anonymen Klassen zu Lambda-Ausdrücken

void main() {
    // 1 - eine anonyme Klasse: Die die Schnittstelle implementierende Klasse wird an Ort und Stelle geschrieben
    IntBinaryOperator add = new IntBinaryOperator() {
        @Override
        public int applyAsInt(int n1, int n2) {
            return n1 + n2;
        }
    };
    IO.println("anonymous class: add(2, 3)=" + add.applyAsInt(2, 3));

    // 2 - dasselbe mit einem Lambda-Ausdruck (Java 8): Parameter -> Rumpf
    IntBinaryOperator subtract = (int n1, int n2) -> {
        return n1 - n2;
    };
    IO.println("block-body lambda: subtract(2, 3)=" + subtract.applyAsInt(2, 3));

    // 3 - die Parametertypen werden aus der Zielschnittstelle abgeleitet
    IntBinaryOperator multiply = (n1, n2) -> n1 * n2;
    IO.println("expression-body lambda: multiply(2, 3)=" + multiply.applyAsInt(2, 3));

    // 4 - ein einziger Parameter: Die Klammern sind optional
    IntUnaryOperator square = x -> x * x;
    Predicate<String> isEmpty = s -> s.isEmpty();
    IO.println("square(7)=" + square.applyAsInt(7) + ", isEmpty(\"\")=" + isEmpty.test(""));

    // 5 - kein Parameter: leere Klammern
    Supplier<String> greet = () -> "Hello";
    Runnable beep = () -> IO.println("beep!");
    IO.println(greet.get());
    beep.run();

    // 6 - ein Blockrumpf mit mehreren Anweisungen
    BiConsumer<String, Integer> repeat = (text, times) -> {
        for (int i = 0; i < times; i++) {
            IO.print(text);
        }
        IO.println();
    };
    repeat.accept("ab", 3);

    // 7 - unbenannte Parameter (Java 22): Wir brauchen ihre Werte nicht
    BiConsumer<Object, String> listener = (_, _) -> IO.println("event received");
    listener.accept(null, "click");

    // 8 - ein Lambda, das direkt als Methodenparameter übergeben wird
    List<Integer> numbers = new ArrayList<>(List.of(3, 8, 1, 6, 5, 4));
    List<Integer> evens = new ArrayList<>(numbers);
    evens.removeIf(n -> n % 2 != 0);
    IO.println("evens: " + evens);
    numbers.sort((n1, n2) -> Integer.compare(n2, n1));
    IO.println("descending order: " + numbers);
}

Ergebnisse:

> java Lambdas03.java
anonymous class: add(2, 3)=5
block-body lambda: subtract(2, 3)=-1
expression-body lambda: multiply(2, 3)=6
square(7)=49, isEmpty("")=true
Hello
beep!
ababab
event received
evens: [8, 6, 4]
descending order: [8, 6, 5, 4, 3, 1]

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:

// mehr zu Lambdas und Methodenreferenzen

void main() throws Exception {
    // 1 - ein Lambda hat von sich aus keinen Typ: Der Kontext bestimmt ihn
    // var twice = x -> x * 2;  // abgelehnt: das Lambda braucht einen Zieltyp
    var twice = (IntUnaryOperator) x -> x * 2;
    IO.println("twice(21)=" + twice.applyAsInt(21));
    // derselbe Lambda-Text kann zwei verschiedene Schnittstellen implementieren
    Supplier<String> supplier = () -> "Hello";
    Callable<String> callable = () -> "Hello";
    IO.println(supplier.get() + " / " + callable.call());

    // 2 - mit var deklarierte Parameter (Java 11): erlaubt, sie zu annotieren oder final zu machen
    BinaryOperator<String> concatenate = (final var s1, final var s2) -> s1 + s2;
    IO.println(concatenate.apply("lam", "bda"));

    // 3 - die vier Arten von Methodenreferenzen
    // a) statische Methode: Class::staticMethod
    Function<String, Integer> convert = Integer::parseInt;
    IO.println("convert(\"42\") + 1 = " + (convert.apply("42") + 1));
    // b) Instanzmethode eines bestimmten Objekts: object::method
    String name = "Pierre";
    Supplier<String> inUpperCase = name::toUpperCase;
    IO.println("inUpperCase.get()=" + inUpperCase.get());
    // c) Instanzmethode eines beliebigen Objekts: Class::instanceMethod
    //    das Objekt, auf dem die Methode aufgerufen wird, wird zum ersten Parameter
    UnaryOperator<String> upperCase = String::toUpperCase;
    Comparator<String> ignoreCase = String::compareToIgnoreCase;
    IO.println("upperCase(\"paul\")=" + upperCase.apply("paul")
            + ", ignoreCase(\"abc\", \"ABC\")=" + ignoreCase.compare("abc", "ABC"));
    // d) Konstruktor: Class::new
    Supplier<List<String>> createList = ArrayList::new;
    Function<String, StringBuilder> createBuffer = StringBuilder::new;
    IntFunction<int[]> createArray = int[]::new;
    List<String> list = createList.get();
    list.add("element");
    IO.println(list + " " + createBuffer.apply("abc").reverse() + " " + createArray.apply(3).length);

    // 4 - geprüfte Exceptions: Callable.call kann sie auslösen, Supplier.get nicht
    Callable<Integer> read = () -> {
        throw new IOException("missing file");
    };
    try {
        read.call();
    } catch (IOException ex) {
        IO.println("exception received: " + ex.getMessage());
    }

    // 5 - jede Auswertung eines Lambdas oder einer Methodenreferenz kann ein neues Objekt erzeugen
    Supplier<String> r1 = name::toUpperCase;
    Supplier<String> r2 = name::toUpperCase;
    IO.println("r1 == r2: " + (r1 == r2) + ", r1.equals(r2): " + r1.equals(r2));
}

Ergebnisse:

> java Lambdas04.java
twice(21)=42
Hello / Hello
lambda
convert("42") + 1 = 43
inUpperCase.get()=PIERRE
upperCase("paul")=PAUL, ignoreCase("abc", "ABC")=0
[element] cba 3
exception received: missing file
r1 == r2: false, r1.equals(r2): false

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:

// Funktionen komponieren: andThen, compose, and, or, negate, comparing, thenComparing

void main() {
    // 1 - Function: andThen (erst this, dann die andere) und compose (erst die andere)
    Function<Integer, Integer> plusOne = x -> x + 1;
    Function<Integer, Integer> timesTwo = x -> x * 2;
    IO.println("plusOne.andThen(timesTwo).apply(5)=" + plusOne.andThen(timesTwo).apply(5));
    IO.println("plusOne.compose(timesTwo).apply(5)=" + plusOne.compose(timesTwo).apply(5));
    // eine aus einer Liste von Funktionen aufgebaute Verarbeitungskette
    List<UnaryOperator<String>> steps =
            List.of(String::strip, String::toLowerCase, s -> s.replace(' ', '-'));
    Function<String, String> normalize = Function.identity();
    for (UnaryOperator<String> step : steps) {
        normalize = normalize.andThen(step);
    }
    IO.println("normalize(\"  My Nice Title \")=" + normalize.apply("  My Nice Title "));

    // 2 - Predicate: and, or, negate, Predicate.not
    Predicate<String> isShort = s -> s.length() <= 4;
    Predicate<String> startsWithP = s -> s.startsWith("P");
    List<String> firstNames = List.of("Paul", "Mélanie", "Jo", "Sébastien", "Pierre");
    IO.println("short and P: " + filter(firstNames, isShort.and(startsWithP)));
    IO.println("short or P: " + filter(firstNames, isShort.or(startsWithP)));
    IO.println("not short: " + filter(firstNames, isShort.negate()));
    IO.println("not empty: " + filter(List.of("a", "", "b"), Predicate.not(String::isEmpty)));

    // 3 - Consumer: andThen verkettet zwei Verarbeitungen desselben Werts
    List<String> log = new ArrayList<>();
    Consumer<String> display = s -> IO.println("display: " + s);
    Consumer<String> remember = log::add;
    Consumer<String> both = display.andThen(remember);
    both.accept("first");
    both.accept("second");
    IO.println("log: " + log);

    // 4 - Comparator: comparing, thenComparing, reversed
    List<Person> persons = new ArrayList<>(List.of(new Person("Paul", 32),
            new Person("Mélanie", 25), new Person("Jo", 32), new Person("Sébastien", 25)));
    persons.sort(Comparator.comparing(Person::age).thenComparing(Person::name));
    IO.println("by age then name: " + persons);
    persons.sort(Comparator.comparingInt(Person::age).reversed()
            .thenComparing(Person::name, Comparator.reverseOrder()));
    IO.println("by descending age then descending name: " + persons);
    // BinaryOperator.minBy erstellt eine Funktion aus einem Comparator
    BinaryOperator<Person> youngest = BinaryOperator.minBy(Comparator.comparingInt(Person::age));
    IO.println("youngest(Paul, Mélanie)=" + youngest.apply(persons.get(0), persons.get(3)));
}

// behält die Elemente, die das Prädikat erfüllen
static <T> List<T> filter(List<T> elements, Predicate<? super T> predicate) {
    List<T> result = new ArrayList<>();
    for (T element : elements) {
        if (predicate.test(element)) {
            result.add(element);
        }
    }
    return result;
}

record Person(String name, int age) {
    @Override
    public String toString() {
        return name + "(" + age + ")";
    }
}

Ergebnisse:

> java Lambdas05.java
plusOne.andThen(timesTwo).apply(5)=12
plusOne.compose(timesTwo).apply(5)=11
normalize("  My Nice Title ")=my-nice-title
short and P: [Paul]
short or P: [Paul, Jo, Pierre]
not short: [Mélanie, Sébastien, Pierre]
not empty: [a, b]
display: first
display: second
log: [first, second]
by age then name: [Mélanie(25), Sébastien(25), Jo(32), Paul(32)]
by descending age then descending name: [Paul(32), Jo(32), Sébastien(25), Mélanie(25)]
youngest(Paul, Mélanie)=Mélanie(25)

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:

// Variablenerfassung und Closures

// ein Feld der impliziten Klasse: Lambdas können es verändern
int nbCalls;

void main() {
    // 1 - ein Lambda kann die lokalen Variablen verwenden, die es umgeben ...
    int threshold = 5;
    Predicate<Integer> exceeds = n -> n > threshold;
    IO.println("threshold=" + threshold + " : exceeds(7)=" + exceeds.test(7));
    // ... sofern sie effektiv final sind: threshold = 10; würde abgelehnt
    int otherThreshold = 10;
    Predicate<Integer> exceedsOther = n -> n > otherThreshold;
    IO.println("threshold=" + otherThreshold + " : exceeds(7)=" + exceedsOther.test(7));

    // 2 - ein Lambda kann eine erfasste lokale Variable nicht verändern ...
    // int total = 0; IntConsumer accumulate = n -> total += n;  // abgelehnt
    // ... aber es kann das Objekt verändern, das sie referenziert
    AtomicInteger total = new AtomicInteger();
    IntConsumer accumulate = n -> total.addAndGet(n);
    accumulate.accept(3);
    accumulate.accept(4);
    IO.println("total=" + total.get());
    // ... oder ein Feld des aktuellen Objekts (das Lambda erfasst this)
    Runnable count = () -> nbCalls++;
    count.run();
    count.run();
    IO.println("nbCalls=" + nbCalls);

    // 3 - ein Closure: Das erfasste Objekt überlebt die Methode, die es erzeugt hat
    IntSupplier counterA = createCounter();
    IntSupplier counterB = createCounter();
    IO.println("A : " + counterA.getAsInt() + " " + counterA.getAsInt() + " " + counterA.getAsInt());
    IO.println("B : " + counterB.getAsInt() + " " + counterB.getAsInt());

    // 4 - die for-Schleife: Die Variable i ändert sich, sie kann nicht erfasst werden
    List<Runnable> actions = new ArrayList<>();
    for (int i = 0; i < 3; i++) {
        // actions.add(() -> IO.print(i + " "));  // abgelehnt: i ist nicht effektiv final
        int copy = i;
        actions.add(() -> IO.print(copy + " "));
    }
    IO.print("for, capture of a copy: ");
    actions.forEach(Runnable::run);
    IO.println();

    // die for-each-Schleife deklariert bei jeder Iteration eine neue Variable: Sie ist effektiv final
    actions.clear();
    for (int j : new int[] { 0, 1, 2 }) {
        actions.add(() -> IO.print(j + " "));
    }
    IO.print("for-each: ");
    actions.forEach(Runnable::run);
    IO.println();
}

// eine Methode, die eine Funktion zurückgibt
static IntSupplier createCounter() {
    // lokales Objekt, vom zurückgegebenen Lambda erfasst
    AtomicInteger value = new AtomicInteger();
    return () -> value.incrementAndGet();
}

Ergebnisse:

1
2
3
4
5
6
7
8
9
> java Lambdas06.java
threshold=5 : exceeds(7)=true
threshold=10 : exceeds(7)=false
total=7
nbCalls=2
A : 1 2 3
B : 1 2
for, capture of a copy: 0 1 2 
for-each: 0 1 2 

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:

// ein Parameter eines funktionalen Schnittstellentyps

void main() {
    // Ausführung der Methode add
    IO.println(execute(Methods::add, 2, 3));
    // Ausführung der Methode subtract
    IO.println(execute(Methods::subtract, 2, 3));
    // Ausführung einer Methode der Java-Bibliothek mit der passenden Form
    IO.println(execute(Math::max, 2, 3));
    // Ausführung eines Lambdas: Es wird keine benannte Methode benötigt
    IO.println(execute((n1, n2) -> n1 * n2, 2, 3));
}

// Ausführung einer als Parameter empfangenen Operation
static int execute(Operation op, int n1, int n2) {
    return op.calculate(n1, n2);
}

// zwei Methoden, die die Form der Schnittstelle Operation haben
class Methods {
    static int add(int n1, int n2) {
        IO.println("add(" + n1 + "," + n2 + ")");
        return n1 + n2;
    }

    static int subtract(int n1, int n2) {
        IO.println("subtract(" + n1 + "," + n2 + ")");
        return n1 - n2;
    }
}

// die funktionale Schnittstelle
@FunctionalInterface
interface Operation {
    int calculate(int n1, int n2);
}

Ergebnisse:

1
2
3
4
5
6
7
> java Lambdas07.java
add(2,3)
5
subtract(2,3)
-1
3
6

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:

// Klassen, die die funktionale Schnittstelle implementieren

void main() {
    // Ausführung der Operation Add
    IO.println(execute(new Add(), 2, 3));
    // Ausführung der Operation Subtract
    IO.println(execute(new Subtract(), 2, 3));
    // dieselbe Methode execute akzeptiert weiterhin Lambdas
    IO.println(execute((n1, n2) -> n1 * n2, 2, 3));
    // eine Schnittstelle mit zwei abstrakten Methoden akzeptiert kein Lambda mehr: Eine Klasse ist nötig
    NamedOperation division = new NamedOperation() {
        @Override
        public int calculate(int n1, int n2) {
            return n1 / n2;
        }

        @Override
        public String name() {
            return "integer division";
        }
    };
    IO.println(division.name() + " : " + division.calculate(7, 2));
}

// Ausführung der einzigen Methode der Schnittstelle Operation
static int execute(Operation op, int n1, int n2) {
    return op.calculate(n1, n2);
}

// Schnittstelle Operation
interface Operation {
    int calculate(int n1, int n2);
}

// eine nicht funktionale Schnittstelle: zwei abstrakte Methoden
interface NamedOperation extends Operation {
    String name();
}

// Klasse Add
class Add implements Operation {
    @Override
    public int calculate(int n1, int n2) {
        IO.println("Add(" + n1 + "," + n2 + ")");
        return n1 + n2;
    }
}

// Klasse Subtract
class Subtract implements Operation {
    @Override
    public int calculate(int n1, int n2) {
        IO.println("Subtract(" + n1 + "," + n2 + ")");
        return n1 - n2;
    }
}

Ergebnisse:

1
2
3
4
5
6
7
> java Lambdas08.java
Add(2,3)
5
Subtract(2,3)
-1
6
integer division : 3

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]:

// die vom Ereignis getragene Information
class TemperatureTooHighEvent extends EventObject {
    @Serial
    private static final long serialVersionUID = 1L;
    // Temperatur zum Zeitpunkt des Ereignisses
    private final double temperature;
    // Zeitpunkt des Ereignisses
    private final LocalTime time = LocalTime.now();

    TemperatureTooHighEvent(Emitter source, double temperature) {
        super(source);
        this.temperature = temperature;
    }

    // die Quelle ist notwendigerweise ein Emitter: Wir überschreiben getSource mit einem genaueren Typ
    @Override
    public Emitter getSource() {
        return (Emitter) super.getSource();
    }

    double getTemperature() {
        return temperature;
    }

    LocalTime getTime() {
        return time;
    }
}

// die Schnittstelle, die die Ereignis-Listener implementieren müssen
@FunctionalInterface
interface TemperatureTooHighListener extends EventListener {
    void temperatureTooHigh(TemperatureTooHighEvent e);
}

// die Klasse, die das Ereignis signalisiert
class Emitter {
    // Schwelle, die das Ereignis auslöst
    static final double THRESHOLD = 19;
    // Name des Emitters
    private final String name;
    // beobachtete Temperatur
    private double temperature;
    // die registrierten Listener
    private final List<TemperatureTooHighListener> listeners = new CopyOnWriteArrayList<>();

    Emitter(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }

    double getTemperature() {
        return temperature;
    }

    void setTemperature(double temperature) {
        this.temperature = temperature;
        if (temperature > THRESHOLD) {
            // wir melden das Ereignis an die Listener
            fireTemperatureTooHigh(new TemperatureTooHighEvent(this, temperature));
        }
    }

    // Registrierung eines Listeners
    void addTemperatureTooHighListener(TemperatureTooHighListener listener) {
        listeners.add(Objects.requireNonNull(listener));
    }

    // Abmeldung eines Listeners
    void removeTemperatureTooHighListener(TemperatureTooHighListener listener) {
        listeners.remove(listener);
    }

    // Benachrichtigung aller registrierten Listener über das Ereignis
    protected void fireTemperatureTooHigh(TemperatureTooHighEvent e) {
        for (TemperatureTooHighListener listener : listeners) {
            listener.temperatureTooHigh(e);
        }
    }
}

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]:

// eine Klasse, die sich als Listener des Ereignisses registriert
class Subscriber {
    // Name des Abonnenten
    private final String name;
    // maximale Anzahl akzeptierter Alarme
    private final int nbAlertsMax;
    // Anzahl empfangener Alarme
    private int nbAlerts;
    // der Listener, nur einmal erzeugt, damit er wieder abgemeldet werden kann
    private final TemperatureTooHighListener listener = this::evtTemperatureTooHigh;

    Subscriber(String name, int nbAlertsMax) {
        this.name = name;
        this.nbAlertsMax = nbAlertsMax;
    }

    // Registrierung bei einem Sender
    void subscribe(Emitter emitter) {
        emitter.addTemperatureTooHighListener(listener);
    }

    // Abmeldung
    void unsubscribe(Emitter emitter) {
        emitter.removeTemperatureTooHighListener(listener);
    }

    // Handler des Ereignisses TemperatureTooHigh
    private void evtTemperatureTooHigh(TemperatureTooHighEvent e) {
        Emitter emitter = e.getSource();
        IO.println("Subscriber [%s]: the source [%s] reported a temperature too high: [%.1f]"
                .formatted(name, emitter.getName(), e.getTemperature()));
        // nach mehr als nbAlertsMax Alarmen meldet sich der Abonnent ab
        nbAlerts++;
        if (nbAlerts == nbAlertsMax) {
            unsubscribe(emitter);
            IO.println("Subscriber [%s]: unsubscribed after %d alert(s)".formatted(name, nbAlerts));
        }
    }
}

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:

// Ereignisbehandlung: ein Sender und Listener

void main() {
    // Erzeugung eines Ereignissenders
    var e1 = new Emitter("e");
    // Erzeugung zweier Abonnenten, die sich bei e1 registrieren
    List<Subscriber> subscribers = List.of(new Subscriber("s0", 3), new Subscriber("s1", 1));
    for (Subscriber subscriber : subscribers) {
        subscriber.subscribe(e1);
    }
    // ein dritter Listener: ein Lambda
    e1.addTemperatureTooHighListener(
            e -> IO.println("Log: %.1f °C at %tT".formatted(e.getTemperature(), e.getTime())));

    // wir lesen die Temperaturen von der Tastatur
    while (true) {
        String input = IO.readln("Temperature (nothing to stop): ");
        // Ende der Eingabe? (readln liefert null, wenn die Standardeingabe geschlossen ist)
        if (input == null || input.isBlank()) {
            break;
        }
        try {
            // wir akzeptieren das Dezimalkomma
            double temperature = Double.parseDouble(input.strip().replace(',', '.'));
            // korrekte Temperatur - wir erfassen sie im Sender
            e1.setTemperature(temperature);
        } catch (NumberFormatException ex) {
            // wir melden den Fehler
            IO.println("Incorrect temperature");
        }
    }
}

Ergebnisse:

> java Lambdas09.java
Temperature (nothing to stop): 17
Temperature (nothing to stop): 21
Subscriber [s0]: the source [e] reported a temperature too high: [21.0]
Subscriber [s1]: the source [e] reported a temperature too high: [21.0]
Subscriber [s1]: unsubscribed after 1 alert(s)
Log: 21.0 °C at 18:58:41
Temperature (nothing to stop): abc
Incorrect temperature
Temperature (nothing to stop): 22,5
Subscriber [s0]: the source [e] reported a temperature too high: [22.5]
Log: 22.5 °C at 18:58:41
Temperature (nothing to stop): 25
Subscriber [s0]: the source [e] reported a temperature too high: [25.0]
Subscriber [s0]: unsubscribed after 3 alert(s)
Log: 25.0 °C at 18:58:41
Temperature (nothing to stop): 30
Log: 30.0 °C at 18:58:41
Temperature (nothing to stop): 

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:

// Ereignisse bei Eigenschaftsänderungen: java.beans.PropertyChangeSupport

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;

void main() {
    var thermometer = new Thermometer("living room");
    // ein Listener für alle Eigenschaften
    PropertyChangeListener log = e -> IO.println("Log: %s.%s : %s -> %s".formatted(
            ((Thermometer) e.getSource()).getName(), e.getPropertyName(), e.getOldValue(), e.getNewValue()));
    thermometer.addPropertyChangeListener(log);
    // ein Listener nur für die Eigenschaft temperature
    thermometer.addPropertyChangeListener("temperature", e -> {
        if ((double) e.getNewValue() > 19) {
            IO.println("Alert: temperature too high");
        }
    });

    thermometer.setTemperature(18);
    thermometer.setTemperature(21.5);
    // gleicher Wert: kein Ereignis
    thermometer.setTemperature(21.5);
    thermometer.setName("lounge");
    // Abmeldung des Logs
    thermometer.removePropertyChangeListener(log);
    thermometer.setTemperature(22);
    IO.println("remaining listeners: " + thermometer.getNbListeners());
}

// eine Klasse, deren Eigenschaften ihre Änderungen melden
class Thermometer {
    // die Listener-Verwaltung ist an ein PropertyChangeSupport-Objekt delegiert
    private final PropertyChangeSupport changes = new PropertyChangeSupport(this);
    private String name;
    private double temperature;

    Thermometer(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }

    void setName(String name) {
        String old = this.name;
        this.name = name;
        changes.firePropertyChange("name", old, name);
    }

    double getTemperature() {
        return temperature;
    }

    void setTemperature(double temperature) {
        double old = this.temperature;
        this.temperature = temperature;
        changes.firePropertyChange("temperature", old, temperature);
    }

    // Registrierung und Abmeldung der Listener
    void addPropertyChangeListener(PropertyChangeListener listener) {
        changes.addPropertyChangeListener(listener);
    }

    void addPropertyChangeListener(String property, PropertyChangeListener listener) {
        changes.addPropertyChangeListener(property, listener);
    }

    void removePropertyChangeListener(PropertyChangeListener listener) {
        changes.removePropertyChangeListener(listener);
    }

    int getNbListeners() {
        return changes.getPropertyChangeListeners().length;
    }
}

Ergebnisse:

1
2
3
4
5
6
7
> java Lambdas10.java
Log: living room.temperature : 0.0 -> 18.0
Log: living room.temperature : 18.0 -> 21.5
Alert: temperature too high
Log: lounge.name : living room -> lounge
Alert: temperature too high
remaining listeners: 1

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]:

// Lambdas und die Stream-API

void main() {
    List<Integer> numbers = List.of(3, 8, 1, 6, 5, 4, 9, 2);

    // 1 - filter und map erwarten ein Predicate<T> und eine Function<T, R>
    Predicate<Integer> isEven = n -> n % 2 == 0;
    Function<Integer, Integer> square = n -> n * n;
    List<Integer> evenSquares = numbers.stream().filter(isEven).map(square).toList();
    IO.println("Stream: " + evenSquares);

    // 2 - unsere eigene Filtermethode, aufgerufen mit einem Lambda und dann mit einer Methodenreferenz
    IO.println("filter(n > 4): " + Tools.filter(numbers, n -> n > 4));
    IO.println("filter(isOdd): " + Tools.filter(numbers, Tools::isOdd));

    // 3 - die Ausführung wird verzögert: das Prädikat wird erst von der terminalen Operation aufgerufen
    Stream<Integer> large = numbers.stream().filter(n -> {
        IO.print("[test " + n + "] ");
        return n > 7;
    });
    IO.println("the stream is defined, nothing has been executed yet");
    large.forEach(n -> IO.print("-> " + n + " "));
    IO.println();

    // 4 - unsere eigenen Zwischenoperationen mit Gatherern (Gatherer, Java 24)
    List<String> cities = List.of("Angers", "Paris", "Lyon", "Nantes", "Aix");
    List<String> result = cities.stream()
            .gather(Tools.filter(v -> v.length() <= 5))
            .gather(Tools.transform(String::toUpperCase))
            .toList();
    IO.println("gatherers: " + result);
}

class Tools {
    // filtert eine Liste mit einem Prädikat: die Arbeit, die filter leistet
    static <T> List<T> filter(List<T> source, Predicate<? super T> predicate) {
        List<T> result = new ArrayList<>();
        for (T element : source) {
            if (predicate.test(element)) {
                result.add(element);
            }
        }
        return result;
    }

    static boolean isOdd(int n) {
        return n % 2 != 0;
    }

    // eine Zwischenoperation des Streams, die nur die Elemente durchlässt, die das Prädikat erfüllen
    static <T> Gatherer<T, ?, T> filter(Predicate<? super T> predicate) {
        return Gatherer.of((_, element, downstream) -> !predicate.test(element) || downstream.push(element));
    }

    // eine Zwischenoperation, die jedes Element umwandelt: das Äquivalent von map
    static <T, R> Gatherer<T, ?, R> transform(Function<? super T, ? extends R> transformation) {
        return Gatherer.of((_, element, downstream) -> downstream.push(transformation.apply(element)));
    }
}

Ergebnisse:

1
2
3
4
5
6
7
> java Lambdas11.java
Stream: [64, 36, 16, 4]
filter(n > 4): [8, 6, 5, 9]
filter(isOdd): [3, 1, 5, 9]
the stream is defined, nothing has been executed yet
[test 3] [test 8] -> 8 [test 1] [test 6] [test 5] [test 4] [test 9] -> 9 [test 2] 
gatherers: [PARIS, LYON, AIX]

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).