7. Funktionstypen, Lambdas und Ereignisse
In vielen Programmen müssen wir einer Funktion nicht Daten, sondern Verhalten übergeben: das Sortierkriterium, die Filterbedingung oder die Aktion, die bei einem Ereignis ausgeführt werden soll. Kotlin begegnet diesem Bedarf, indem es Funktionen wie jeden anderen Wert behandelt: Eine Funktion hat einen Typ – den Funktionstyp, der beispielsweise als [(Int, Int) -> Int] notiert wird. Sie kann in einer Variablen gespeichert, als Parameter übergeben, als Ergebnis einer anderen Funktion zurückgegeben und jederzeit ausgeführt werden. Eine Funktion, die eine Funktion annimmt oder zurückgibt, heißt Funktion höherer Ordnung.
Java besitzt bekanntlich keine Funktionstypen: Es stützt sich auf funktionale Schnittstellen – Schnittstellen mit genau einer abstrakten Methode ([Runnable], [Comparator], [Function<T, R>]…) – und erlaubte erst mit Java 8 (2014), sie mit Lambda-Ausdrücken und Methodenreferenzen zu implementieren. Kotlin unterstützt Lambdas seit seiner allerersten Version und kann auch mit den funktionalen Schnittstellen von Java arbeiten, da es Java-Bibliotheken direkt verwendet. Wir haben Lambdas bereits ausgiebig genutzt, ohne ins Detail zu gehen, nämlich bei den Collection-Operationen aus Kapitel 5: In [persons.filter { it.age >= 18 }] übergeben wir der Funktion [filter] ein Lambda. Dieses Kapitel erklärt, was hinter dieser Syntax steckt. Es schließt mit den Ereignissen, die Kotlin – wie Java – über „Listener“ behandelt: Funktionen, meist Lambdas, die sich bei einem Sender registrieren, um über dortige Vorgänge benachrichtigt zu werden. Grafische Benutzeroberflächen (Swing, JavaFX, Compose) und Web-Frameworks stützen sich gleichermaßen auf diesen 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 im Gradle-Projekt [07-lambdas] organisiert, mit einem Paket pro Programm: [src/main/kotlin/lambdas01/Lambdas01.kt], [src/main/kotlin/lambdas02/Lambdas02.kt]… Sie werden mit [gradlew -q run -Pmain=lambdas01.Lambdas01Kt] oder per Klick auf das grüne Dreieck in IntelliJ oder IDEA ausgeführt. Das Projekt benötigt keine weiteren Bibliotheken als die Kotlin-Standardbibliothek: Funktionstypen, Lambdas und Scope-Funktionen sind enthalten, und die Schnittstellen des Pakets [java.util.function] sind dieselben wie im JDK.
7.1. Funktionstypen und vordefinierte funktionale Schnittstellen
7.1.1. Das Konzept des Funktionstyps
Ein Funktionstyp beschreibt ein Muster (auch Signatur oder Form genannt) einer Funktion: die Typen ihrer Parameter in Klammern, gefolgt von einem Pfeil und dem Typ ihres Rückgabewerts. Eine Variable eines Funktionstyps kann auf jede Funktion dieser Form verweisen und sie ausführen. Hier einige Beispiele:
- [() -> Unit]: eine Funktion ohne Parameter, die kein nützliches Ergebnis zurückgibt ([Unit] übernimmt die Rolle von [void] in Java);
- [() -> String]: eine Funktion ohne Parameter, die eine Zeichenkette zurückgibt;
- [(Int) -> Boolean]: eine Funktion, die eine ganze Zahl annimmt und einen booleschen Wert zurückgibt, mit anderen Worten ein Prädikat;
- [(Int, Int) -> Int]: eine Funktion, die zwei ganze Zahlen annimmt und eine ganze Zahl zurückgibt;
- [(String) -> (Int) -> Int]: eine Funktion, die eine Zeichenkette annimmt und … eine Funktion vom Typ [(Int) -> Int] zurückgibt (der Pfeil wird von rechts nach links gelesen);
- [(() -> Unit)?]: eine Funktion, die fehlen kann; die Klammern sind notwendig, da [() -> Unit?] andernfalls eine Funktion bezeichnen würde, die einen [Unit?] zurückgibt. Hier zeigt sich die Null-Sicherheit in Bezug auf [null] aus Kapitel 3: Eine solche Funktion wird mit [f?.invoke()] aufgerufen;
- [String.(Int) -> String]: eine Funktion mit Empfänger; sie wird – wie eine Erweiterungsfunktion (Kapitel 4) – auf eine Zeichenkette angewendet, die ihr Code als [this] bezeichnet. Sie kann als Erweiterung aufgerufen werden (["ab".f(3)]) oder als gewöhnliche Funktion, deren erster Parameter der Empfänger ist ([f("ab", 3)]).
Parameter können benannt werden, um den Typ zu dokumentieren: [(n1: Int, n2: Int) -> Int] ist derselbe Typ wie [(Int, Int) -> Int].
Es gibt drei Möglichkeiten, einen Wert eines Funktionstyps zu erhalten:
- eine Referenz auf eine bestehende Funktion schreiben, die die richtige Form hat: [val task: () -> Unit = ::display];
- einen Lambda-Ausdruck schreiben: [val task: () -> Unit = { println("task") }];
- eine anonyme Funktion schreiben: [val task = fun() { println("task") }], oder ein Objekt einer Klasse, die den Funktionstyp implementiert (ein Funktionstyp ist, wie wir sehen werden, eine Schnittstelle). Diese beiden Schreibweisen sind weniger gebräuchlich.
Die Funktion wird dann wie eine gewöhnliche Funktion ausgeführt: [task()]. Das ist eine Kurzschreibweise für den Aufruf der Methode [invoke] des Funktionsobjekts: [task.invoke()]. Das ist der erste spürbare Unterschied zu Java, wo Sie die Methode der Schnittstelle mit ihrem Namen aufrufen müssen ([run], [apply], [test]…); Kotlin verhält sich hier wie C#, wo ein Delegate wie eine Methode aufgerufen wird.
7.1.2. Funktionstypen von Kotlin und Schnittstellen aus java.util.function
Vor Java 8 definierte jede Java-Bibliothek ihre eigenen Schnittstellen mit einer einzigen Methode ([Runnable], [Comparator], [ActionListener]…). Java 8 führte das Paket [java.util.function] ein, das 43 generische funktionale Schnittstellen bereitstellt. Kotlin braucht sie nicht: Ein Funktionstyp wird direkt geschrieben. Diese Schnittstellen lassen sich jedoch weiterhin von Kotlin aus verwenden, und Sie werden ihnen bei jedem Aufruf einer Java-Bibliothek begegnen. Die folgende Tabelle ordnet die wichtigsten Java-Schnittstellen den Funktionstypen von Kotlin zu:
Java-Schnittstelle | Kotlin-Typ | Dargestellte Funktionen |
[Runnable]: [void run()] | [() -> Unit] | Keine Parameter, kein Ergebnis |
[Supplier<T>] : [T get()] | [() -> T] | Keine Parameter, ein Ergebnis: ein „Lieferant“ |
[Consumer<T>]: [void accept(T t)] | [(T) -> Unit] | ein Parameter, kein Ergebnis: ein „Konsument“ |
[BiConsumer<T, U>] | [(T, U) -> Unit] | zwei Parameter, kein Ergebnis |
[Function<T, R>]: [R apply(T t)] | [(T) -> R] | ein Parameter, ein Ergebnis |
[BiFunction<T, U, R>] | [(T, U) -> R] | zwei Parameter, ein Ergebnis |
[UnaryOperator<T>] | [(T) -> T] | Parameter und Ergebnis vom selben Typ |
[BinaryOperator<T>] | [(T, T) -> T] | Zwei Parameter und ein Ergebnis vom selben Typ |
[Predicate<T>]: [boolean test(T t)] | [(T) -> Boolean] | ein Parameter, ein boolesches Ergebnis: ein „Prädikat“ |
[BiPredicate<T, U>] | [(T, U) -> Boolean] | zwei Parameter, ein boolesches Ergebnis |
[Comparator<T>]: [int compare(T o1, T o2)] | [(T, T) -> Int] | zwei Parameter vom selben Typ, ein ganzzahliges Ergebnis |
[Callable<V>] : [V call()] | [() -> V] | wie [Supplier<V>]; in Kotlin muss keine geprüfte Ausnahme deklariert werden |
[IntBinaryOperator], [IntPredicate]… | [(Int, Int) -> Int], [(Int) -> Boolean]… | Die Java-Versionen für primitive Typen |
In Kotlin gibt es keine praktische Begrenzung der Parameteranzahl eines Funktionstyps: [(Int, Int, Int) -> Int] wird ebenso einfach geschrieben wie die anderen, während Sie in Java, da es keine vordefinierte Schnittstelle mit drei Parametern gibt, eine eigene definieren müssen.
Wie stellt die Java Virtual Machine, die nur Klassen und Schnittstellen kennt, einen Funktionstyp dar? Über generische Schnittstellen der Kotlin-Bibliothek: [kotlin.jvm.functions.Function0<R>], [Function1<P1, R>], [Function2<P1, P2, R>]… bis hin zu [Function22], danach folgt eine Schnittstelle [FunctionN] . Jede hat eine einzige Methode, [invoke]: [(Int, Int) -> Int] wird zu [Function2<Integer, Integer, Integer>] kompiliert, deren Methode [operator fun invoke(p1: Int, p2: Int): Int] ist. Der Modifikator [operator] von [invoke] (siehe Operatorüberladung in Kapitel 4) ermöglicht die Schreibweise [f(2, 3)]. Ein Funktionstyp ist für die JVM also eine funktionale Schnittstelle wie die von Java. Da Java-Generics nur für Objekttypen gelten, werden [Int]-Werte, die an einen [(Int, Int) -> Int] übergeben werden, in [Integer] umgewandelt und umgekehrt (Boxing und Unboxing). Java vermeidet diese Umwandlungen durch seine spezialisierten Schnittstellen ([IntBinaryOperator]…); Kotlin vermeidet sie auf andere Weise, mit den [inline]-Funktionen, auf die wir später eingehen.
Das Programm [Lambdas01.kt] verwendet diese Typen mit Funktionsreferenzen:
Ergebnisse:
Kommentare:
- Zeile 11: Die Variable [task] hat den Typ [() -> Unit]. Ihr wird eine Funktionsreferenz zugewiesen: [::display] verweist auf die Top-Level-Funktion [display] , die weiter unten in der Datei deklariert ist (Zeile 79). Der Compiler prüft, ob sie die erforderliche Form hat (keine Parameter, kein Rückgabewert), und erzeugt das Funktionsobjekt, das sie aufruft. In Java wäre eine Hilfsklasse nötig gewesen, die diese Methoden enthält, da die implizite Klasse einer kompakten Quelldatei nicht benannt werden kann; in Kotlin werden Top-Level-Funktionen direkt referenziert;
- Zeile 13: Die Funktion wird ausgeführt, indem sie wie eine gewöhnliche Funktion aufgerufen wird. Die Funktion [display] wird ausgeführt (Zeile 1 der Ergebnisse). Zeile 15: Dasselbe Ergebnis erhält man durch expliziten Aufruf der Methode [invoke] (Zeile 2 der Ergebnisse);
- Zeile 18: [(Int, Int) -> Int] verweist auf eine Funktion mit zwei Parametern vom Typ [Int], die einen [Int] zurückgibt. Die Funktion [add] (Zeile 83) passt. Die Funktion wird über [operation(2, 3)] aufgerufen (Zeile 19);
- Zeile 21: eine parameterlose Funktion, die eine Zeichenkette zurückgibt, das Äquivalent von Javas [Supplier<String>]. Beachten Sie, dass die lokale Variable [greet] denselben Namen trägt wie die Funktion [greet]: In [::greet] ist die Funktion gemeint, in [greet()] die lokale Variable, die die Funktion verdeckt;
- Zeile 25: eine Funktion mit einem Parameter, [String], die nichts zurückgibt – das Äquivalent zu [Consumer<String>] in Java. Die Funktion der Standardbibliothek [println] ist überladen ([println(Int)], [println(Any?)]…): Es ist der erwartete Typ [(String) -> Unit], der es dem Compiler ermöglicht, die richtige Überladung auszuwählen;
- Zeile 29: ein Prädikat, äquivalent zu [Predicate<Integer>]. Zeile 33: Die Erweiterungsfunktion [removeAll] der Kotlin-Bibliothek erwartet gerade einen Parameter vom Typ [(T) -> Boolean]: Sie entfernt aus der veränderlichen Liste alle Elemente, für die das Prädikat [true] ergibt, und gibt [true] zurück, wenn sie mindestens ein Element entfernt hat (Zeile 7 der Ergebnisse);
- Zeile 38: Die Funktion [sortWith] erwartet einen [Comparator<T>]. In Kotlin ist [Comparator] ein Alias für die Java-Schnittstelle [java.util.Comparator]. [Comparator(::compareLengths)] erzeugt einen [Comparator<String>] aus der Funktion [compareLengths]: Das ist eine SAM-Konvertierung („Single Abstract Method“), die aus einer Kotlin-Funktion derselben Form das Objekt erzeugt, das die Java-Schnittstelle implementiert. Die Funktion [compareLengths] (Zeile 91) verwendet [compareTo], das zwei [Int]-Objekte ohne das Risiko eines Überlaufs vergleicht (das eine einfache Subtraktion nicht garantiert);
- Zeilen 42–44: Die Schnittstellen aus
*[java.util.function]können unverändert verwendet werden. Sie werden auf dieselbe Weise über eine expliziteSAM-Konvertierung erzeugt: der Name der Schnittstelle, gefolgt von einer Funktionsreferenz oder einem Lambda. Sie werden dann wie in Java über ihre Java-Methode ausgeführt ([get], [applyAsInt]*, [test]…); - Zeilen 49–52: [removeIf] ist eine Java-Methode der Schnittstelle [Collection]; sie erwartet ein [Predicate]. Sie können ihr ein
*[Predicate](Zeile 49) übergeben, aber auch direkt einen Wert vom Typ*[(Int) -> Boolean](Zeile 51) oder ein Lambda (Zeile 52): Beim Aufruf einer Java-Methode, die eine funktionale Schnittstelle erwartet, führt Kotlin die SAM-Konvertierung automatisch durch. Dadurch lassen sich Java-Bibliotheken von Kotlin aus ebenso angenehm nutzen wie von Java aus. Aus der Anfangsliste (10, 3, 8, 7, 2, 1) werden nacheinander die Elemente größer als 4, die geraden Elemente und dann das Element 1 entfernt (Zeile 11 der Ergebnisse); - Zeilen 56–57 und 72–75: Der Funktion
*[execute]wird eine Funktion übergeben, die fehlen kann, vom Typ*[(() -> Unit)?]. Der sichere Aufruf [callback?.invoke()] bewirkt nichts, wenn [callback] gleich [null] ist. Sie können nicht [callback?()] schreiben: Der sichere Aufruf einer nullable Funktion läuft über [invoke]. Das wird die Standardschreibweise für optionale Listener sein; - Zeile 60: ein Funktionstyp mit Empfänger. Die Referenz [String::repeat] verweist auf die Methode [repeat] der Klasse [String], die auf eine Zeichenkette angewendet wird und eine ganze Zahl erhält. Zeile 61 wird auf zwei Arten aufgerufen: als Erweiterung, ["ab".times(3)], oder als Funktion mit zwei Parametern, [times("cd", 2)]. Funktionen mit Empfänger begegnen uns bei den Scope-Funktionen [apply] und [with] wieder;
- Zeilen 64–68: Eine Funktion ist ein Objekt. Die Klasse der Funktionsreferenz [operation] (Zeile 16 der Ausgabe) ist eine vom Kotlin-Compiler generierte Klasse, die nach der Stelle benannt ist, an der die Referenz steht; die Klasse des Lambdas [sum] (Zeile 18 der Ergebnisse) wird zur Laufzeit von der virtuellen Maschine erzeugt, genau wie Java-Lambdas: Ihr Name enthält [$$Lambda] gefolgt von einer Adresse, die sich von einer Ausführung zur nächsten ändert. In beiden Fällen implementiert die Klasse die Schnittstelle [kotlin.jvm.functions.Function2] (Zeilen 17 und 19 der Ergebnisse). Eine Kotlin-Funktion ist also kein neuer Objekttyp: Sie ist eine Instanz einer gewöhnlichen Klasse, die eine funktionale Schnittstelle implementiert.
7.2. Eigene Funktionstypen definieren
Funktionstypen reichen oft aus, doch möchte man einem Funktionsmuster manchmal einen Namen geben. Kotlin bietet dafür zwei Werkzeuge, die sich ihrer Natur nach stark unterscheiden.
Das erste ist ein Typalias, das mit dem Schlüsselwort [typealias] deklariert wird:
- [typealias BinaryOperation = (n1: Int, n2: Int) -> Int]
Ein Alias erzeugt keinen neuen Typ: [BinaryOperation] ist ein anderer Name für [(Int, Int) -> Int], und beide Schreibweisen sind austauschbar. Der Alias macht den Code lesbarer, wenn der Funktionstyp lang ist oder häufig vorkommt.
Das zweite ist die funktionale Schnittstelle, die mit [fun interface] deklariert wird:
- [fun interface Operation { fun calculate(n1: Int, n2: Int): Int }]
Dies ist das exakte Äquivalent einer funktionalen Java-Schnittstelle: eine Schnittstelle mit nur einer abstrakten Methode (auch SAM oder „Single Abstract Method“-Schnittstelle genannt). Sie darf auch Methoden mit Rumpf und nicht abstrakte Eigenschaften haben; diese zählen nicht. Das Schlüsselwort [fun] vor [interface] erfüllt denselben Zweck wie die Java-Annotation [@FunctionalInterface], mit einem wichtigen Unterschied: Es ist nicht optional. Dieses Schlüsselwort ermöglicht die SAM-Konvertierung – also die Erzeugung eines [Operation]-Objekts aus einem Lambda oder einer Funktionsreferenz: [Operation { n1, n2 -> n1 + n2 }]. Ohne das Schlüsselwort [fun] kann eine Kotlin-Schnittstelle – selbst wenn sie nur eine einzige Methode hat – nur von einer Klasse oder einem anonymen Objekt implementiert werden ([object : Operation { … }]).
Im Vergleich zum Typ [(Int, Int) -> Int] ist der Typ [Operation] ein wirklich neuer Typ, der sich von allen anderen unterscheidet: Er hat einen Namen, der seinen Zweck beschreibt, seine Methode hat einen aussagekräftigen Namen ([calculate] statt [invoke]), er kann zusätzliche Methoden haben, und er kann von einer benannten Klasse implementiert werden. Umgekehrt wird er über seinen Methodennamen ausgeführt ([op.calculate(2, 3)]), nicht über [op(2, 3)].
Eine Variable namens [op] vom Typ [Operation], wie eine Variable vom Typ [(Int, Int) -> Int], verweist jeweils auf nur eine Funktion. Anders als C#, das „Multicast-Delegates“ bietet, gibt es weder in Java noch in Kotlin eine Möglichkeit, mehrere Funktionen in einer einzigen Variablen zu speichern und alle mit einem einzigen Aufruf auszuführen: Bei Bedarf speichern wir die Funktionen in einer Liste und führen sie nacheinander aus. Genau das tun wir bei den Ereignis-Listenern.
Betrachten wir das Beispiel [Lambdas02.kt]:
Ergebnisse:
Kommentare:
- Zeilen 60–64: Definition der funktionalen Schnittstelle [Operation]. In Kotlin können Typdeklarationen an beliebiger Stelle der Datei stehen, vor oder nach der Funktion [main]; wir platzieren sie danach;
- Zeile 64: Eine funktionale Schnittstelle kann Methoden mit Rumpf haben (das Äquivalent der [default]-Methoden von Java). Die Methode [then] erzeugt eine neue [Operation]: Dieses Objekt führt die aktuelle Operation aus und wendet dann die Funktion [next] auf ihr Ergebnis an. Sie gibt ein in [Operation] konvertiertes Lambda zurück, das wir im nächsten Abschnitt untersuchen. Beachten Sie, dass der Parameter [next] keine Schnittstelle wie den [IntUnaryOperator] der Java-Version benötigt: Der Funktionstyp [(Int) -> Int] genügt, und er wird über [next(…)] ausgeführt;
- Zeilen 76–89: Die Klasse [Calculations] hat zwei Instanzmethoden, [add] und [subtract], und eine Methode ihres Companion-Objekts, [increase] (das Äquivalent einer statischen Methode, siehe Kapitel 4); alle drei haben dieselbe Form wie die Methode [calculate];
- Zeile 9: Die Variable [op] hat den Typ [Operation]. Ihr wird das Objekt zugewiesen, das durch die SAM-Konvertierung der Referenz [Calculations::increase] entsteht, welche auf die Methode [increase] des Companion-Objekts der Klasse [Calculations] verweist. Die Konvertierung muss wie folgt geschrieben werden: [Operation(Calculations::increase)] sieht aus wie ein Konstruktoraufruf, aber eine Schnittstelle hat keinen Konstruktor; der Compiler erzeugt das Objekt, das [Operation] implementiert;
- Zeile 11: Die Operation wird durch die Methode [calculate] ausgeführt. Die Methode [increase] wird mit den Parametern ausgeführt, die an [calculate] übergeben wurden;
- Zeile 15: Eine Instanz der Klasse [Calculations] mit dem Bezeichner [c1] wird erzeugt;
- Zeile 17: Die Referenz [c1::add] verweist auf die Methode [add] von dem Objekt [c1]: Man spricht von einer „gebundenen Referenz“. [increase] war eine Methode des Companion-Objekts, während [add] eine Instanzmethode ist: 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 21: Mit der Instanzmethode [subtract] wird dasselbe getan;
- Zeilen 26–32: Um mehrere Operationen auszuführen, werden sie in eine Liste vom Typ [List<Operation>] (abgeleiteter Typ) gelegt, die dann durchlaufen wird. Referenzen und Lambdas können gemischt werden (Zeile 29). Jedes Ergebnis wird abgerufen (Zeilen 7–11 der Ergebnisse);
- Zeile 36: Die Methode [then] wird auf die Operation [Operation(c1::add)] angewendet. Das Lambda [{ x -> x * x }] wird außerhalb der Klammern übergeben, weil es der letzte (und hier einzige) Parameter von [then] ist: Diese Syntax erläutern wir im nächsten Abschnitt genauer. [squaredSum.calculate(1, 2)] berechnet (1+2)², also 9 (Zeilen 12–13 der Ergebnisse). In Java musste die Konvertierung [((Operation) c1::add).then(…)] explizit geschrieben werden; in Kotlin erfüllt die explizite SAM-Konvertierung diesen Zweck;
- Zeile 40: [Operation] und die Java-Schnittstelle [IntBinaryOperator] haben exakt dieselbe Form, sind aber zwei verschiedene Typen ohne Vererbungsbeziehung. Die Zuweisung [val other: IntBinaryOperator = op] würde abgelehnt ([initializer type mismatch: expected 'IntBinaryOperator', actual 'Operation']). Dagegen ist die Referenz [op::calculate] eine Funktion vom Typ [(Int, Int) -> Int]: Die SAM-Konvertierung macht daraus einen [IntBinaryOperator], der die Methode [calculate] des Objekts [op] aufruft ([c1::subtract] an dieser Stelle des Programms);
- Zeilen 68–69: Eine funktionale Schnittstelle kann generisch sein. [Transformation<T, R>] stellt eine Funktion dar, die ein [T] annimmt und ein [R] zurückgibt: Das entspricht [(T) -> R], mit von uns gewählten Namen;
- Zeile 44: [String::length] verweist auf die Eigenschaft [length] der Klasse [String]: Eine Referenz kann ebenso auf eine Eigenschaft wie auf eine Funktion zeigen. Sie wird als Funktion vom Typ [(String) -> Int] verwendet: Die Eigenschaft wird aus der als Parameter übergebenen Zeichenkette gelesen. Die Typen [T = String] und [R = Int] von [Transformation] werden aus der Referenz abgeleitet. Zeile 45: ["*"::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 Referenzen (ungebunden, gebunden), die wir im folgenden Abschnitt im Detail besprechen;
- Zeile 73: ein Typalias. Die Parameter mit den Namen [n1] und [n2] dienen nur der Dokumentation;
- Zeilen 50–54: Das Lambda [f] vom Typ [BinaryOperation] wird ohne Konvertierung der Variablen [g] vom Typ [(Int, Int) -> Int] zugewiesen: Es handelt sich um denselben Typ. Um es in eine [Operation] zu konvertieren, ist jedoch eine SAM-Konvertierung erforderlich (Zeile 54).
Diese Regeln lassen sich überprüfen, indem man Fehler auslöst. Wenn Sie ***[var op: Operation = Calculations::increase]*** ohne explizite Konvertierung schreiben, lehnt der Compiler dies ab:
Die Meldung verrät auch den Typ einer Funktionsreferenz: [KFunction2<Int, Int, Int>], ein Kotlin-Reflection-Typ ([kotlin.reflect]), der zugleich ein [(Int, Int) -> Int] ist. Die implizite SAM-Konvertierung findet nur bei den Argumenten eines Funktionsaufrufs statt (zum Beispiel [values.removeIf(isEven)]), nicht bei einer Zuweisung.
Wird versehentlich eine zweite abstrakte Methode wie [fun invert(n: Int): Int] zur Schnittstelle [Operation] hinzugefügt, markiert der Compiler die Deklaration selbst und jede SAM-Konvertierung, die die Schnittstelle verwendet (gekürzte Ausgabe):
Diese Meldungen stammen vom Compiler [kotlinc]; Gradle zeigt sie mit vorangestelltem [e:] und dem vollständigen Dateipfad an. Wie die von [javac] sind sie auf Englisch.
7.3. Anonyme Objekte, Lambda-Ausdrücke und Referenzen
7.3.1. Von anonymen Objekten zu Lambdas
In den bisherigen Beispielen ist jede Funktion eine benannte Funktion, die an anderer Stelle im Programm definiert ist. Für kurze Funktionen, die nur einmal verwendet werden, ist das umständlich. Java bot ursprünglich die anonyme Klasse an: Die Klasse, die die Schnittstelle implementiert, wird genau dort definiert, wo das Objekt erzeugt wird. Kotlin kennt ein Äquivalent – den Objektausdruck [object : Type { … }], der in Kapitel 4 eingeführt wurde –, verwendet es aber selten, um eine Funktion darzustellen: Von Anfang an unterstützt Kotlin Lambda-Ausdrücke, die eine wesentlich knappere Syntax bieten. Das Programm [Lambdas03.kt] zeigt die verschiedenen Formen:
Ergebnisse:
Kommentare:
- Zeilen 7–12: ein anonymes Objekt. Auf das Schlüsselwort [object] folgen ein Doppelpunkt und der zu implementierende Typ – hier der Funktionstyp [(Int, Int) -> Int] (dies ist, wie wir gesehen haben, eine Schnittstelle) – sowie der Rumpf einer Klasse, die diesen Typ implementiert, indem sie ihre Methode [invoke] überschreibt. Der Compiler erzeugt eine unbenannte Klasse und erstellt eine Instanz davon. Sechs Zeilen, um [n1 + n2] auszudrücken. Dennoch wird es wie eine Funktion ausgeführt: [add(2, 3)];
- Zeile 15: dasselbe mit einem Lambda-Ausdruck. Ein Lambda wird in geschweiften Klammern geschrieben: die Parameterliste, der Operator [->] (ein Pfeil, der als „ergibt“ gelesen wird), dann der Rumpf. Typname und Methodenname sind verschwunden. Da die Parameter typisiert sind, kann der Compiler den Typ des Lambdas selbst bestimmen: [(Int, Int) -> Int]. Das unterscheidet sich von Java, wo ein Lambda nie einen eigenen Typ hat;
- Zeile 19: Die Parametertypen wurden weggelassen. Der Compiler leitet sie aus dem für die Variable deklarierten erwarteten Typ ab: [n1] und [n2] sind vom Typ [Int]. Dies ist die gebräuchlichste Form. In Kotlin gibt es keine Unterscheidung zwischen „Ausdruckskörper“ und „Blockkörper“ wie in Java: Der Rumpf eines Lambdas ist eine Folge von Anweisungen, und der Wert des letzten Ausdrucks ist das Ergebnis des Lambdas;
- Zeile 23: Bei einem einzigen Parameter müssen Sie ihn gar nicht deklarieren, ebenso wenig den Pfeil; er heißt dann implizit [it] („it“, „das“). [{ it * it }] liest sich als „sein Quadrat“. Zeile 24: Der einzige Parameter heißt [s]. Das geschieht, wenn [it] den Code weniger lesbar machen würde, insbesondere bei verschachtelten Lambdas (jedes hätte sein eigenes [it]);
- Zeilen 28–29: Ohne Parameter gibt es keinen Pfeil. Der Typ von
*[greet]*wird als*[() -> String]*abgeleitet; der Typ von*[beep]ist*[() -> Unit]*, da*[println]*[Unit]*liefert; - Zeilen 34–39: Ein Lambda kann beliebige Anweisungen enthalten: Deklarationen, Schleifen, Tests usw. Der Wert des letzten Ausdrucks, [buffer.toString()], ist das Ergebnis. Sie können nicht [return buffer.toString()] schreiben: In einem Lambda beendet ein unmarkiertes [return] das Lambda nicht (siehe unten);
- Zeile 44: Der Unterstrich [_] bezeichnet einen ungenutzten Parameter. Er wird verwendet, wenn die Typsignatur Parameter verlangt, die das Lambda nicht benötigt, was bei Ereignis-Listenern häufig vorkommt. Sie können mehrere solcher Parameter im selben Lambda angeben (Java hat diese Syntax in Version 22 übernommen);
- Zeilen 48–49: Die häufigste Verwendung von Lambdas besteht darin, sie direkt als Parameter an eine Funktion höherer Ordnung zu übergeben. Ist das Lambda der letzte Parameter, wird es außerhalb der Klammern geschrieben; gibt es keine weiteren Parameter, entfallen die Klammern: [numbers.filter { it % 2 == 0 }] statt [numbers.filter({ it % 2 == 0 })]. Diese Regel verleiht Kotlin-Code sein charakteristisches Aussehen und erlaubt es, Funktionen zu schreiben, die Anweisungen der Sprache ähneln ([repeat], [use], [thread], [synchronized]…). Vergleichen Sie dies mit [Lambdas01.kt]: Es ist nicht mehr nötig, eine Funktion [isEven] zu schreiben;
- Zeile 51: ein Lambda, das den üblichen Vergleich umkehrt: Die Liste wird absteigend sortiert. [sortWith] erwartet einen [Comparator] (eine Java-Schnittstelle): Die SAM-Konvertierung erfolgt automatisch;
- Zeile 54: Das Lambda bleibt außerhalb der Klammern, wenn die Funktion weitere Parameter hat: [fold(0) { acc, n -> acc + n }]. Die Funktion [fold] (Kapitel 5) beginnt mit dem Anfangswert 0 und addiert die Elemente nacheinander;
- Zeilen 58–62: Innerhalb eines Lambdas verlässt die Anweisung [return@forEach] das Lambda (und geht damit zum nächsten Element über), genau wie ein [continue] in einer Schleife. Das Label [@forEach] ist implizit: Es ist der Name der Funktion, an die das Lambda übergeben wird. Ein unmarkiertes [return] würde die gesamte Funktion [main] verlassen: Man nennt dies einen nicht lokalen Return, und er ist nur in einem Lambda erlaubt, das an eine Funktion wie [inline] oder [forEach] übergeben wird (wir werden sehen, warum);
- Zeilen 64–68: Sie können das Label auch wählen, indem Sie es vor die öffnende geschweifte Klammer setzen: [odd@{ … }], dann [return@odd];
- Zeilen 70–74: eine anonyme Funktion. Sie wird wie eine normale Funktion geschrieben, aber ohne Namen. Ihr Typ wird abgeleitet: [(Int) -> Boolean]. In einer anonymen Funktion verlässt [return] die anonyme Funktion selbst. Das wird verwendet, wenn der Rumpf mehrere Austrittspunkte hat oder wenn Sie den Ergebnistyp explizit angeben möchten;
- Zeile 78: Die Parameter eines Lambdas können destrukturiert werden (Kapitel 3). Das an [forEach] übergebene Lambda erhält einen Eintrag des assoziativen Arrays ([Map.Entry<String, Int>]). Die in Klammern gesetzte Notation [(name, age)] zerlegt ihn in Schlüssel und Wert. Achtung: [{ name, age -> … }] würde zwei Parameter deklarieren, während [{ (name, age) -> … }] einen einzigen destrukturierten Parameter deklarieren würde.
Betrachten wir noch einmal die Formen eines Lambda-Ausdrucks:
Form | Beispiel |
Typisierte Parameter | [{ a: Int, b: Int -> a + b }] |
Untypisierte Parameter (erwarteter Typ bekannt) | [{ a, b -> a + b }] |
ein einzelner, impliziter Parameter | [{ it * it }] |
keine Parameter | [{ "Hello" }] |
ungenutzte Parameter | [{ _, _ -> println("received") }] |
destrukturierter Parameter | [{ (key, value) -> "$key=$value" }] |
mehrere Anweisungen | [{ x -> println(x) ; x * 2 }] |
Lambda als letzter Parameter | [list.filter { it > 0 }] |
anonyme Funktion | [fun(x: Int): Int { return x * 2 }] |
Ein Lambda ist nicht ganz eine Kurzform für ein anonymes Objekt. In einem anonymen Objekt verweist [this] auf das anonyme Objekt selbst; in einem Lambda verweist [this] auf das Objekt der Methode, die das Lambda umschließt (oder auf den Empfänger bei einem Lambda mit Empfänger). Außerdem kann ein anonymes Objekt eine Schnittstelle mit mehreren Methoden, mehrere Schnittstellen gleichzeitig implementieren oder von einer Klasse erben – was mit einem Lambda unmöglich ist. In diesem Kurs verwenden wir Lambdas, wann immer es möglich ist.
7.3.2. Zusatzinformationen: Typinferenz und Referenzen
Das Programm [Lambdas04.kt] erklärt, wie der Typ eines Lambdas bestimmt wird, und beschreibt die verschiedenen Arten von Referenzen:
Ergebnisse:
Kommentare:
- Zeile 11: Das Lambda [{ x: Int -> x * 2 }] hat einen eigenen Typ, [(Int) -> Int], der aus dem Typ seines Parameters und dem seines Rumpfs berechnet wird. Die Deklaration [val double = { x -> x * 2 }] wird dagegen abgelehnt: Der Compiler kann den Typ von [x] nicht ableiten ([an explicit type is required on a value parameter]). In Java wird [var twice = x -> x * 2;] aus einem grundsätzlicheren Grund abgelehnt: Ein Java-Lambda kann nicht ohne Zieltyp existieren, der die zu implementierende Schnittstelle angibt;
- Zeilen 14–16: Derselbe Lambda-Ausdruck, [{ "Hello" }], ergibt hier [() -> String], dort [Supplier<String>] und anderswo [Callable<String>]. In den beiden letzten Fällen löst der Name der Java-Schnittstelle – der vor dem Lambda steht – die SAM-Konvertierung aus. Es sind drei Objekte verschiedener Klassen, die nur die Form ihrer Methode gemeinsam haben;
- Zeilen 19–41: die Arten von Referenzen. Kotlin nennt sie „Callable References“: Sie verweisen auf Funktionen, aber auch auf Eigenschaften und Konstruktoren:
- Zeile 21: die Referenz auf eine Top-Level-Funktion, [::function]. [::triple] ist äquivalent zum Lambda [{ n -> triple(n) }]. Sie ersetzt die Referenz auf eine statische Methode in Java ([Class::staticMethod]). Für eine Funktion eines Companion-Objekts schreiben wir [Class::function], wie in [Lambdas02.kt];
- Zeilen 25–26: die Referenz auf eine Methode oder Eigenschaft eines bestimmten Objekts, [object::method], genannt gebundene Referenz. [name::uppercase] ist äquivalent zu [{ name.uppercase() }]: Das Objekt [name] ist ein für alle Mal festgelegt. [name::length] verweist auf die Eigenschaft [length] der Zeichenkette [name];
- Zeilen 30–31: eine Referenz auf eine Methode eines beliebigen Objekts einer Klasse, [Class::method], bekannt als ungebundene Referenz. Das Objekt, auf dem die Methode aufgerufen wird, ist noch nicht bekannt: Es wird zum ersten Parameter der Funktion. [String::uppercase] ist äquivalent zu [{ s: String -> s.uppercase() }]. Für [ignoreCase] wurde ein Lambda bevorzugt, das es erlaubt, das benannte Argument [ignoreCase = true] an [compareTo] zu übergeben;
- Zeile 35: Eine Erweiterungsfunktion wird wie eine Methode referenziert: [String::toInt] ist äquivalent zu [{ s: String -> s.toInt() }];
- Zeilen 38–41: Die Referenz auf einen Konstruktor, [::Class] (in Java: [Class::new]). [::ArrayList] ist äquivalent zu [{ ArrayList() }]; [::StringBuilder] wählt mit dem erwarteten Typ [(String) -> StringBuilder] den Konstruktor, der eine Zeichenkette entgegennimmt; [::IntArray] erzeugt ein Array von ganzen Zahlen der als Parameter übergebenen Größe; [::Person] verweist auf den primären Konstruktor der [Person]-Datenklasse (Zeile 65);
- Zeile 44: Die Erzeugungsfunktionen werden verwendet; [reverse] kehrt den Inhalt von [StringBuilder] um (Zeile 8 der Ergebnisse);
- Zeilen 47–51: Kotlin unterstützt keine geprüften Ausnahmen (Kapitel 3). Ein Lambda vom Typ [() -> Int] kann daher eine [IOException] werfen, ohne etwas zu deklarieren. In Java war das eine echte Herausforderung: Keine Schnittstelle aus [java.util.function] erlaubt geprüfte Ausnahmen, und ein Lambda vom Typ [Supplier<Integer>] , das eine [IOException] wirft, wird abgelehnt; man musste daher [Callable] verwenden, dessen Methode als [throws Exception] deklariert ist. Beachten Sie außerdem, dass das Lambda [{ throw IOException("file missing") }] als [() -> Int] akzeptiert wird: Der Ausdruck [throw] hat den Typ [Nothing], der mit allen Typen kompatibel ist;
- Zeilen 55–59: Zwei Auswertungen derselben Referenz
***[name::uppercase]erzeugen zwei verschiedene Objekte ([r1 === r2]ist gleich*[false]*), aber anders als in Java betrachtet Kotlin sie als *gleich im Sinne von [equals] ([r1 == r2] ist gleich [true]): Zwei Referenzen sind gleich, wenn sie auf dieselbe Funktion verweisen, die mit demselben Objekt verbunden ist. Zwei Lambdas sind, selbst bei identischem Text, nie gleich (Zeile 10 der Ergebnisse). Merken Sie sich das: Es wird beim Abmelden eines Ereignis-Listeners wichtig sein. Beachten Sie schließlich, dass der Typ von*[r1]angegeben werden musste: Die Funktion [uppercase] ist überladen ([uppercase()] und [uppercase(locale: Locale)]), und ohne erwarteten Typ weigert sich der Compiler, eine Wahl zu treffen ([overload resolution ambiguity between candidates]*).
Eine Referenz ist einfach eine Kurzschreibweise für ein Lambda, das lediglich eine Funktion aufruft. Sie wird verwendet, wenn sie die Lesbarkeit verbessert: [String::length] statt [{ it.length }]. In der Praxis sind Kotlin-Lambdas mit [it] so kurz, dass Referenzen etwas seltener verwendet werden als in Java.
7.3.3. Funktionen komponieren
Die funktionalen Schnittstellen von Java besitzen Methoden vom Typ [default] und [static] , die aus bestehenden Funktionen neue erzeugen: [andThen], [compose], [and], [or], [negate]… Die Funktionstypen von Kotlin haben diese nicht: Die Standardbibliothek stellt keine Funktion [andThen] für einen [(A) -> B] bereit. Man kann sie jedoch sehr einfach selbst schreiben, und zwar als Erweiterungsfunktionen auf Funktionstypen (Kapitel 4), da eine Funktion eine Funktion zurückgeben kann. Das Programm [Lambdas05.kt] zeigt dies und führt anschließend die Funktionen der Kotlin-Bibliothek ein, die Comparatoren erzeugen:
Ergebnisse:
Kommentare:
- Zeile 60: Die Erweiterungsfunktion [then] wird auf eine Funktion vom Typ [(A) -> B] angewendet (die Klammern um den Funktionstyp sind erforderlich) und nimmt eine Funktion [next] vom Typ [(B) -> C] entgegen. Sie gibt eine neue Funktion vom Typ [(A) -> C] zurück – das Lambda [{ x -> next(this(x)) }] –, die zunächst die Funktion [this] (den Empfänger der Erweiterung) und dann [next] auf deren Ergebnis anwendet. Das ist die Methode [andThen] der Java-Schnittstelle [Function]. Die drei Typparameter [A], [B] und [C] sind generisch: [then] komponiert beliebige Funktionen mit einem Parameter, sofern das Ergebnis der ersten Funktion zur zweiten passt. Der Modifikator [infix] erlaubt es, [f then g] statt [f.then(g)] zu schreiben;
- Zeile 63: die umgekehrte Komposition, äquivalent zur Java-Methode [compose]: [f after g] wendet zuerst [g], dann [f] an;
- Zeile 11: [plusOne then timesTwo] liefert die Funktion, die zuerst [plusOne] und dann [timesTwo] auf das Ergebnis anwendet: (5 + 1) × 2 = 12. Die Klammern um die Komposition sind notwendig, damit die resultierende Funktion aufgerufen werden kann;
- Zeile 12: [plusOne after timesTwo] wendet zuerst [timesTwo], dann [plusOne] an: 5 × 2 + 1 = 11;
- Zeile 14: Wenn Sie die Methoden der Java-Schnittstelle bevorzugen, erzeugen Sie einfach eine [Function] per SAM-Konvertierung: [andThen] steht dann zur Verfügung, und Sie können ihr ein Kotlin-Lambda übergeben, das seinerseits konvertiert wird. Das Ergebnis ist eine
*[Function], die mit*[apply]ausgeführt wird; - Zeilen 17–18 und 76: [adder] ist eine Funktion, die eine Funktion zurückgibt: [adder(10)] gibt die Funktion zurück, die 10 zu ihrem Parameter addiert. Die zurückgegebene Funktion kann in einer Variablen gespeichert ([plusTen]) oder sofort aufgerufen werden: [adder(3)(5)]. Dieses Verfahren, bei dem ein Parameter festgelegt wird, um eine Funktion der verbleibenden Parameter zu erhalten, heißt partielle Anwendung;
- Zeilen 20–21: eine dynamisch aufgebaute Verarbeitungskette. Wir beginnen mit der Identitätsfunktion ([{ s: String -> s }], die ihren Parameter unverändert zurückgibt) und fügen ihr mit [then] jeden Schritt der Liste hinzu, dank der Funktion [fold] (Kapitel 5): Der akkumulierte Wert [function] ist hier eine Funktion. Die resultierende Funktion [normalize] entfernt führende und nachfolgende Leerzeichen ([trim]), wandelt den Text in Kleinbuchstaben um und ersetzt Leerzeichen durch Bindestriche. Jeder Aufruf von [then] erzeugt eine neue Funktion: Bestehende Funktionen werden nie verändert. Ebenso könnte die Liste der Schritte aus einer Konfigurationsdatei gelesen werden;
- Zeilen 66–70: Die Prädikate werden mit unseren Erweiterungen [and], [or], und [not] kombiniert. Letztere ist als [operator] deklariert: Es ist die Funktion, die der Operator [!] aufruft (siehe Operatorüberladung in Kapitel 4). So schreibt man [!short] für die Negation des Prädikats [short] (Zeile 30). In Java schreibt man [isShort.negate()] und [Predicate.not(String::isEmpty)] für eine Methodenreferenz;
- Zeilen 32–33: Ein Prädikat vom Typ [(CharSequence) -> Boolean] wird von [filterElements] zum Filtern einer Liste von [String] akzeptiert, obwohl der Parameter als [(T) -> Boolean] mit [T = String] deklariert ist. Das liegt daran, dass die Funktionstypen von Kotlin in ihren Parametern kontravariant und in ihren Ergebnissen kovariant sind (Kapitel 4): [(T) -> R] ist in Wirklichkeit [Function1<in T, out R>]. Eine Funktion, die jede [CharSequence] verarbeiten kann, kann auch einen [String] verarbeiten. In Java müssen Sie den Parameter als [Predicate<? super T>] deklarieren, um dieses Ergebnis zu erreichen; in Kotlin geschieht das automatisch;
- Zeilen 36–42 und 73: Die Erweiterung [andAlso] liefert eine Funktion, die zwei Operationen nacheinander auf denselben Wert anwendet, wie die Methode [andThen] der Java-Schnittstelle [Consumer]. Das ist der einfachste Weg, mehrere Operationen mit einem einzigen Aufruf auszuführen. Beachten Sie, dass das Lambda [{ this(it); other(it) }] zwei Anweisungen in derselben Zeile hat, getrennt durch ein Semikolon;
- Zeile 47: Die Funktion [compareBy(f)] der Kotlin-Bibliothek erzeugt einen Comparator, der die Werte von [f] (hier das Alter) vergleicht; [thenBy] legt das Kriterium fest, das bei Gleichstand verwendet wird (hier der Name). Das sind die Entsprechungen zu [Comparator.comparing] und [thenComparing] in Java. Die Referenzen [Person::age] und [Person::name] verweisen auf die Eigenschaften der Datenklasse [Person] (Zeilen 89–90), für die wir die Methode [toString] neu definiert haben, um die Ausgabe zu verkürzen;
- Zeile 49: [reversed] kehrt die bis dahin erhaltene Reihenfolge um, und [thenByDescending] fügt ein absteigendes Kriterium hinzu;
- Zeile 52: [compareBy] akzeptiert auch mehrere Kriterien in Form von Lambda-Ausdrücken, die der Reihe nach angewendet werden: hier die Länge des Namens, gefolgt vom Namen. Es sind zwei als Argumente übergebene Lambdas, da [compareBy] sie in einem Parameter namens [vararg] erhält;
- Zeilen 55–56: Die Funktion [minOf] gibt den kleineren ihrer ersten beiden Parameter zurück, basierend auf dem als dritter Parameter übergebenen Comparator (in Java: [BinaryOperator.minBy]);
- Zeilen 79–86: die Funktion [filterElements] , die für diese Tests verwendet wird. Dies ist eine Funktion höherer Ordnung, die das tut, was die Bibliotheksfunktion [filter] tut: Sie wendet das Prädikat [predicate] auf jedes Element an – wobei sie es wie eine gewöhnliche Funktion aufruft – und behält die Elemente, für die es [true] zurückgibt.
Diese Funktionen erlauben es, komplexe Verarbeitungen durch die Kombination einfacher Funktionen zu schreiben, ohne eine einzige Klasse zu schreiben. Wir kommen bei den Collections und Sequenzen darauf zurück.
7.3.4. Variablenerfassung und Closures
Ein Lambda kann die lokalen Variablen der Funktion verwenden, in der es geschrieben ist. Man sagt, es erfasst diese Variablen. In dieser Hinsicht unterscheidet sich Kotlin deutlich von Java. Java verlangt, dass eine erfasste lokale Variable „effektiv final“ ist: Sie wird nach ihrer Initialisierung nie mehr verändert, weder in der Methode noch im Lambda. Kotlin, wie C#, JavaScript oder Python, kennt keine solche Einschränkung: Ein Lambda kann eine [var]-Variable erfassen, sie auch nach einer Änderung lesen und sie sogar ändern. Das Programm [Lambdas06.kt] zeigt, was diese Freiheit erlaubt, wie sie umgesetzt ist und welche Falle sie mit sich bringt:
Ergebnisse:
Kommentare:
- Zeile 11: Das Lambda verwendet die in Zeile 10 deklarierte lokale Variable [threshold]. [threshold] ist kein Parameter des Lambdas, sondern eine erfasste Variable. Da sie ein [val] ist, erhält das Lambda bei seiner Erzeugung einfach eine Kopie ihres Werts, genau wie in Java;
- Zeilen 15–19: Diesmal erfasst das Lambda eine
*[var]*, was Java ablehnen würde (*[local variables referenced from a lambda expression must be final or effectively final]). Es erhält keine Kopie des Werts, sondern teilt die Variable mit der Funktion [main]: Wenn sich [variableThreshold] auf 10 ändert (Zeile 19), liefert dasselbe Lambda ein anderes Ergebnis (Zeilen 2–3 der Ergebnisse). Das Lambda sieht also den Wert der Variablen zum Zeitpunkt seiner Ausführung*, nicht zum Zeitpunkt seiner Erzeugung. Das ist das Problem, das Java vermeidet, indem es diese Erfassungen verbietet; - Zeilen 23–27: Das Lambda [accumulate] verändert die lokale Variable [total]. In Java müssen Sie ein veränderliches Objekt verwenden ([AtomicInteger], oder den Behelf eines Arrays mit einem Element); in Kotlin schreiben Sie [total += n] direkt;
- Zeile 29: Wie ist das möglich, da die virtuelle Maschine selbst nur die Erfassung von Werten erlaubt? Der Kotlin-Compiler erledigt die Arbeit, die ein Java-Entwickler von Hand erledigen muss: Eine erfasste und veränderte lokale Variable [var] wird nicht mehr auf dem Stack gespeichert, sondern in einem kleinen Objekt der Klasse [kotlin.jvm.internal.Ref.IntRef] (es gibt eines für jeden primitiven Typ und
*[Ref.ObjectRef]für Referenzen), das ein einziges veränderliches Feld hat,*[element]. Die Funktion [main] und das Lambda teilen sich dieses Objekt: Jedes Lesen oder Schreiben von [total], gleich in welchem von beiden, wird zu einem Lesen oder Schreiben von [total.element]. Wir können dies per Reflection überprüfen: Das einzige Feld des Lambda-Objekts hat den Typ [Ref$IntRef] (Zeile 5 der Ergebnisse). Genau das macht der C#-Compiler mit seinen erfassten Variablen; - Zeilen 31–34: Ein Lambda kann auch eine Top-Level-Variable (Zeile 6) oder eine Eigenschaft des aktuellen Objekts lesen und ändern. Hier gibt es nichts zu erfassen: Die Top-Level-Variable ist ein statisches Feld der Klasse [Lambdas06Kt]; bei einer Eigenschaft erfasst das Lambda die Referenz [this];
- Zeilen 64–67: Die Funktion [createCounter] gibt ein Lambda zurück, das seine lokale Variable [value] erfasst und verändert. Normalerweise verschwindet eine lokale Variable, wenn die Funktion endet. Hier ist die Variable in einem Objekt [Ref.IntRef] gespeichert, auf das das Lambda verweist: Sie überlebt [createCounter] so lange, wie das Lambda existiert. Die Kombination aus dem Lambda und den von ihm erfassten Variablen nennt man eine „Closure“;
- Zeilen 37–40: Jeder Aufruf von
*[createCounter]erzeugt eine neue Variable[value]*und damit einen neuen, von den anderen unabhängigen Zähler. Die Ergebnisse (Zeilen 7–8) bestätigen dies; - Zeilen 44–48: In einer Kotlin-Schleife [for] ist die Variable [i] ein [val], das bei jeder Iteration neu ist: Jedes Lambda erfasst sein eigenes, und die drei Lambdas geben 0, 1 und 2 aus. Beachten Sie, dass eine Liste von Funktionen mit [actions.forEach { it() }] ausgeführt wird: [it] ist eine Funktion, die aufgerufen wird;
- Zeilen 53–59: Das ist die Kehrseite der Flexibilität von Kotlin. Die Schleife [while] verwendet eine einzige Variable [k], die bei jeder Iteration verändert wird. Die drei Lambdas erfassen dieselbe Variable und geben ihren Wert aus, wenn sie ausgeführt werden – also nach der Schleife, wenn er gleich 3 ist: Alle geben 3 aus (Zeile 10 der Ergebnisse). Java beseitigt diese Falle zur Kompilierzeit; in Kotlin liegt es beim Entwickler, damit umzugehen. Die Lösung ist dieselbe wie in Java: Im Schleifenrumpf für jede Iteration ein neues [val] deklarieren ([val copy = k]) und dieses erfassen oder, besser noch, eine [for]-Schleife verwenden.
Die Java-Regel hat eine solide Begründung: Ein Lambda kann später oder in einem anderen Thread ausgeführt werden (Kapitel 8). Wenn es lokale Variablen einer Funktion verändern oder lesen kann, während ein anderer Thread sie verändert, kann dies zu unvorhersehbarem Verhalten führen. Kotlin wählt einen anderen, pragmatischeren Ansatz: Das Erfassen einer [var] ist erlaubt, aber die [Ref]-Objekte sind nicht gegen nebenläufigen Zugriff geschützt. Halten wir also fest: Das Erfassen einer [var] ist in einem Single-Thread-Programm und in sofort ausgeführten Lambdas ([forEach], [filter]…) unbedenklich, aber sobald ein Lambda in einem anderen Thread ausgeführt werden kann, muss der gemeinsame veränderliche Zustand durch ein Objekt explizit gemacht werden, dessen Thread-Verhalten ausdrücklich gewählt wird ([AtomicInteger], nebenläufige Collection…). Wir kommen in den Kapiteln 8 und 9 darauf zurück. Auch die später vorgestellten [inline]-Funktionen vermeiden die Erzeugung von [Ref]-Objekten, wenn das Lambda in den aufrufenden Code kopiert wird.
7.4. Inline-Funktionen und Scope-Funktionen
7.4.1. Inline-Funktionen
Ein Lambda ist ein Objekt. Die Übergabe eines Lambdas an eine Funktion höherer Ordnung verursacht daher Kosten: die Erzeugung des Objekts (außer bei einem Lambda, das nichts erfasst und das die virtuelle Maschine wiederverwenden kann), der Aufruf seiner Methode [invoke] , die [Int] ↔ [Integer]-Umwandlungen, die die generischen Schnittstellen [Function1], [Function2]… erzwingen, und die [Ref]-Objekte der erfassten Variablen. Bei einer Funktion wie [filter], die für jedes Element von Collections aufgerufen wird, die mitunter sehr groß sein können, fallen diese Kosten ins Gewicht. Kotlin beseitigt sie mit dem Modifikator [inline]: Wird eine Funktion als [inline fun] deklariert, erzeugt der Compiler keinen Aufruf dieser Funktion, sondern kopiert ihren Code an jede Stelle, an der sie aufgerufen wird, und kopiert auch den Code der ihr übergebenen Lambdas. Dadurch gibt es keine Lambda-Objekte, keine [invoke]-Aufrufe und keine Umwandlungen mehr. Die Funktionen der Standardbibliothek, die Lambdas akzeptieren ([forEach], [filter], [map], [fold], [let], [apply], [repeat], [use], [synchronized]…), sind fast alle [inline]. Java hat kein Äquivalent: Es verlässt sich auf den Just-in-Time-Compiler der virtuellen Maschine, um zur Laufzeit ein vergleichbares Ergebnis zu erzielen.
Das Einfügen des Codes hat eine zweite, auffälligere Folge: Da der Code des Lambdas in die aufrufende Funktion kopiert wird, kann eine unmarkierte [return]-Anweisung von dort aus die aufrufende Funktion verlassen. Das ist der nicht lokale Return , dem wir bei *[forEach] in *[Lambdas03.kt] begegnet sind. Zwei Modifikatoren ergänzen *[inline]*:
- [noinline], angewendet auf einen Funktionsparameter einer [inline]-Funktion, legt fest, dass das entsprechende Lambda nicht kopiert, sondern als gewöhnliches Objekt übergeben werden soll. Das ist notwendig, wenn die Funktion das Lambda behalten will (in einer Liste speichern, als Ergebnis zurückgeben usw.): Kopierter Code lässt sich nicht in einer Liste speichern;
- [crossinline] verlangt, dass das Lambda kopiert wird, verbietet aber nicht lokale Returns. Das ist notwendig, wenn die [inline]-Funktion das Lambda nicht selbst ausführt, sondern in einem anderen Kontext – zum Beispiel innerhalb eines von ihr erzeugten [Runnable]-Objekts: Wenn [Runnable] ausgeführt wird, kann die aufrufende Funktion längst beendet sein, und ein [return] könnte sie nicht mehr verlassen.
Das Programm [Lambdas07.kt] veranschaulicht diese Konzepte (dieses Programm hat im Java-Kurs keine Entsprechung):
Ergebnisse:
Kommentare:
- Zeile 28: Die Funktion [currentMethod] gibt den Namen der Methode zurück, die sie aufgerufen hat. Dazu erzeugt sie ein [Throwable]-Objekt, das den Ausführungsstack zum Zeitpunkt seiner Erzeugung speichert, und liest das zweite Element dieses Stacks (das erste ist [currentMethod] selbst). Damit stellen wir fest, wo der Code eines Lambdas ausgeführt wird;
- Zeilen 31–36: zwei identische Funktionen, eine gewöhnliche und eine als [inline] deklarierte;
- Zeile 7: Das Lambda wird an die gewöhnliche Funktion [execute] übergeben. Der Compiler macht daraus den Rumpf einer privaten Methode der Klasse [Lambdas07Kt] – hier [main$lambda$0] genannt – und erzeugt ein Objekt vom Typ [() -> Unit] , das sie aufruft. Tatsächlich wird [main$lambda$0] ausgeführt (Zeile 1 der Ergebnisse);
- Zeile 8: Das Lambda wird an die Funktion [inline] [executeInline] übergeben. Der Compiler hat den Rumpf von [executeInline] und den des Lambdas in [main] kopiert: Das [println] des Lambdas wird direkt innerhalb der Methode [main] ausgeführt (Zeile 2 der Ergebnisse). Es wurde kein Funktionsobjekt erzeugt;
- Zeilen 41–50: [forEachElement] ist unsere eigene Version von [forEach], [inline], genau wie das Original. In [firstEven] ist die Anweisung [return it] im Lambda ein nicht lokaler Return: Sie verlässt die Funktion [firstEven], indem sie die erste gefundene gerade Zahl zurückgibt (Zeile 3 der Ergebnisse), und die Schleife endet dort. Bei einer gewöhnlichen Funktion wie [execute] würde der Compiler ein solches [return] ablehnen (['return' is prohibited here]): Das Lambda wäre ein eigenes Objekt, das nach dem Ende von [firstEven] ausgeführt werden könnte;
- Zeilen 54–60: eine [inline]-Funktion, die zwei Lambdas annimmt: Sie führt das erste aus und speichert das zweite zur späteren Ausführung in einer Liste. Der zweite Parameter muss als [noinline] deklariert werden: Ohne diesen Modifikator weigert sich der Compiler, das Lambda in der Liste zu speichern ([illegal usage of inline parameter 'stored: () -> Unit'. Add 'noinline' modifier to the parameter declaration.]). Die Zeilen 16–18 verwenden sie (Zeilen 4–6 der Ausgabe);
- Zeile 64: Die Funktion [asTask] erzeugt ein [Runnable]-Objekt (SAM-Konvertierung), das das Lambda [action] ausführt. Der Parameter muss als [crossinline] deklariert werden: Ohne diesen Modifikator lehnt der Compiler ihn ab ([cannot inline 'action: () -> Unit' here: it might contain non-local returns. Add 'crossinline' modifier to parameter declaration 'action: () -> Unit'.]). Die Zeilen 21–24 führen das erhaltene [Runnable] in einem Thread namens [worker] aus (Threads werden in Kapitel 8 behandelt), wie Zeile 7 der Ergebnisse bestätigt.
Sie sollten [inline] nicht auf beliebige Funktionen anwenden: Der Modifikator ist nur für Funktionen nützlich, die funktionale Parameter akzeptieren, und er vergrößert den erzeugten Code (der Compiler gibt für eine [inline]-Funktion ohne funktionale Parameter tatsächlich eine Warnung aus). Schließlich hat er eine dritte Verwendung, die in Kapitel 4 besprochen wird: Nur [inline]-Funktionen können Parameter vom Typ [reified] haben ([inline fun <reified T> …]), deren Typ zur Laufzeit bekannt bleibt, da der Code an die Stelle kopiert wird, an der dieser Typ bekannt ist.
7.4.2. Scope-Funktionen
Die Kotlin-Standardbibliothek stellt fünf kleine, weit verbreitete Funktionen bereit – [inline] – bekannt als „Scope-Funktionen“: [let], [run], [with], [apply] und [also]. Sie tun fast nichts: Jede führt ein Lambda auf einem Objekt aus. Sie unterscheiden sich in zwei Punkten:
- die Art, wie das Lambda auf das Objekt verweist: entweder als sein Parameter [it] (das Lambda hat den Typ [(T) -> R]) oder als sein Empfänger [this], der dann weggelassen werden kann (das Lambda ist ein Lambda mit Empfänger vom Typ [T.() -> R]; siehe [Lambdas01.kt]);
- was die Funktion zurückgibt: entweder das Ergebnis des Lambdas oder das Objekt selbst.
Funktion | Bezeichnetes Objekt | Rückgabe | Typische Verwendung |
[let] | [it] | das Ergebnis des Lambdas | einen Wert transformieren; mit [?.let] einen Wert ungleich null verarbeiten |
[run] | [this] | das Ergebnis des Lambdas | Ein Ergebnis auf Basis der Eigenschaften des Objekts berechnen |
[with(object)] | [this] | das Ergebnis des Lambdas | wie [run], wobei das Objekt als Parameter übergeben wird |
[apply] | [this] | das Objekt | Ein neu erzeugtes Objekt konfigurieren |
[also] | [it] | das Objekt | Zusätzliche Verarbeitung (Logging, Caching usw.), ohne die Aufrufkette zu verändern |
Das Programm [Lambdas08.kt] verwendet sie (im Java-Kurs gibt es dafür kein Äquivalent):
Ergebnisse:
Kommentare:
- Zeilen 45–48: eine gewöhnliche Klasse [Person] mit veränderlichen Eigenschaften;
- Zeilen 7–9: [apply] führt das Lambda mit dem Objekt als Receiver aus: Innerhalb des Lambdas steht [age = 32] für [this.age = 32]. Anschließend gibt es das Objekt zurück, das [paul] zugewiesen wird. So wird ein Objekt in einem einzigen Ausdruck erzeugt und konfiguriert. Seine Signatur veranschaulicht den Mechanismus: [inline fun <T> T.apply(block: T.() -> Unit): T];
- Zeile 15: [also] führt das Lambda mit dem Objekt als Parameter [it] aus und gibt anschließend das Objekt zurück. Damit erzielt man einen Seiteneffekt (hier das Hinzufügen zu einer Liste), ohne eine Zwischenvariable einführen zu müssen;
- Zeile 19: [let] führt das Lambda mit dem Objekt als Parameter [it] aus und gibt das Ergebnis des Lambdas zurück: Das ist eine Transformation;
- Zeilen 21–23: Die häufigste Verwendung von [let], wie in Kapitel 3 gesehen: [city?.let { … }] führt das Lambda nur aus, wenn [city] nicht [null] ist, und innerhalb des Lambdas ist [it] vom Typ [String] und nicht [String?]. Ist [city] gleich [null], ist der Ausdruck gleich [null], und der Elvis-Operator [?:] liefert den Standardwert;
- Zeile 27: [run] führt das Lambda mit dem Objekt als Receiver aus und gibt dessen Ergebnis zurück: Es verwendet direkt die Eigenschaften [name], [age] und [city] von [paul];
- Zeilen 31–34: [with] tut dasselbe wie [run], doch das Objekt wird ihm als erster Parameter übergeben, und das Lambda steht an zweiter Stelle, außerhalb der Klammern. Alle im Lambda aufgerufenen Methoden ([append], [toString]) gehören zu [StringBuilder]. Die Funktion [buildString] aus Kapitel 5 beruht auf diesem Muster;
- Zeilen 39–41: [takeIf] ist keine Scope-Funktion, wird aber auf dieselbe Weise verwendet: Sie gibt das Objekt zurück, wenn es das Prädikat erfüllt, und andernfalls [null] . Sie lässt sich natürlich mit [?:], [?.let] … kombinieren ([takeUnless] tut das Gegenteil).
Diese Funktionen machen den Code kompakter, doch man sollte sie nicht übermäßig einsetzen: Mehrere verschachtelte Scope-Funktionen, jede mit ihrem eigenen [it] oder [this], machen den Code schnell unlesbar. Eine gut benannte lokale Variable ist oft vorzuziehen.
7.5. Funktionstypen, funktionale Interfaces oder Interfaces?
In vielen Sprachen ist das Konzept einer „als Parameter übergebenen Funktion“ (Funktionszeiger in C, Delegate in C#) vom Konzept eines Interfaces getrennt, und man kann sich fragen, was man wählen soll. In Java stellt sich die Frage anders, da beide Konzepte ein und dasselbe sind: Ein Lambda ist eine Instanz eines Interfaces. Kotlin liegt dazwischen: Es hat Funktionstypen, die sich syntaktisch von Interfaces unterscheiden, für die virtuelle Maschine aber Interfaces sind; und es hat funktionale Interfaces ([fun interface]), die sich mit Lambdas implementieren lassen. Nehmen wir das Beispiel [Lambdas09.kt], das [Lambdas02.kt] ähnelt:
Ergebnisse:
In Zeile 18 erwartet die Funktion [execute] einen Parameter vom Typ [(Int, Int) -> Int]. So lassen sich ihr verschiedene Funktionen übergeben: unsere Top-Level-Funktionen [add] und [subtract] (Zeilen 7 und 9), eine Methode der Java-Bibliothek mit passender Form (Zeile 11: Unter den Überladungen von [Math.max]* wählt der Compiler [int max(int a, int b)]***, was Kotlin als ***[max(a: Int, b: Int): Int]*** sieht) und sogar ein Lambda (Zeile 13): Eine Multiplikationsfunktion musste nicht geschrieben werden. Der Funktionsparameter wurde an letzter Stelle** platziert, damit das Lambda außerhalb der Klammern geschrieben werden kann: Das ist die Konvention in der gesamten Kotlin-Bibliothek, und man sollte sie auch in eigenen Funktionen befolgen.
Mit [fun interface] sehen wir den in Kapitel 4 behandelten Interface-Polymorphismus: Das Programm [Lambdas10.kt] demonstriert dies, indem es dasselbe Interface mit Klassen implementiert:
Ergebnisse:
Kommentare:
- Zeilen 31–32: Das funktionale Interface [Operation] definiert eine Methode [calculate];
- Zeilen 41–49: Die Klassen [Add] und [Subtract] implementieren das Interface [Operation];
- Zeile 25: die Funktion [execute], deren erster Parameter den durch das Interface [Operation] definierten Typ hat. Sie erhält nacheinander eine Instanz der Klasse [Add], eine Instanz der Klasse [Subtract] (Zeilen 7 und 9) und dann ein Lambda (Zeile 11). Für das Lambda erfolgt die Konvertierung von
SAMnach*[Operation]automatisch, da es ein Aufrufargument ist. Für [execute] sind diese drei Objekte vom selben Typ: Objekte, die [Operation]* implementieren; - Zeilen 36–37: Das Interface [NamedOperation] erbt die Methode [calculate] und fügt eine abstrakte Eigenschaft [name] hinzu. Es ist nicht funktional (es kann tatsächlich nicht als
[fun interface]deklariert werden): Es lässt sich nicht mehr mit einem Lambda implementieren; erforderlich ist eine Klasse, hier ein anonymes Objekt (Zeilen 13–16); - Zeilen 57–58: Auch das Umgekehrte gilt: Eine Klasse kann einen Funktionstyp implementieren, da dieser ein Interface ist. Ihre Instanzen werden dann wie Funktionen aufgerufen ([modulo(7, 2)]) und überall übergeben, wo eine Funktion erwartet wird ([applyFunction(modulo, 7, 3)], Zeile 21).
Diese beiden Beispiele zeigen, dass in Kotlin ebenso wie in Java eine Funktion, die ein Verhalten erwartet, Objekte von eigens dafür geschriebenen Klassen, Referenzen und Lambdas akzeptiert. Es bleiben zwei Fragen. Die erste betrifft speziell Kotlin: Ist für einen funktionalen Parameter ein Funktionstyp erforderlich, oder genügt ein [fun interface]?
- Der Funktionstyp ist die Standardwahl. Er erfordert keine Deklaration, wird wie eine Funktion aufgerufen, akzeptiert Lambdas und Referenzen direkt und profitiert von [inline]-Funktionen. Ein [typealias] gibt ihm einen Namen, wenn er lang ist;
- das „fun“-Interface ist gerechtfertigt, wenn man einen wirklich eigenständigen Typ möchte (einen, der sich nicht mit einer anderen Funktion derselben Form verwechseln lässt), eine Methode mit aussagekräftigem Namen, zusätzliche Methoden mit Rumpf oder eine API, die auch für Java-Aufrufer gedacht ist: Für Java ist ein [fun interface] ein gewöhnliches funktionales Interface, verwendbar mit seinen Lambdas, während ein Kotlin-Funktionstyp dort als [Function2<Integer, Integer, Integer>] erscheint, dessen Methode [invoke] ein Objekt zurückgeben muss ([Unit] bei einer Funktion „ohne Rückgabewert“).
Die zweite Frage ist dieselbe wie in Java: Soll das Interface eine einzige Methode oder mehrere haben?
- Eine Funktion, ein Funktionstyp oder ein Interface mit einer einzigen Methode ist flexibler in der Verwendung: Jede vorhandene Funktion mit der richtigen Form passt, und mit einem Lambda kann man die Funktion sogar direkt an der Aufrufstelle schreiben. Es muss keine Klasse geschrieben werden. Diese Flexibilität erklärt, warum moderne Bibliotheken (Collections, die Coroutinen aus Kapitel 9, Spring) ausgiebig funktionale Parameter verwenden;
- ein Interface mit mehreren Mitgliedern ist wieder im Vorteil, sobald das zu implementierende Verhalten mehrere zusammenhängende Operationen umfasst ([calculate] und [name] oben) oder wenn es einen eigenen Zustand und eine eigene Identität benötigt.
Dies gilt für das Interface [ITaxDao] in der [dao]-Schicht aus Kapitel 6: Obwohl es nur ein Mitglied hat – die Eigenschaft [val taxBrackets: List<TaxBracket>] –, haben seine 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 [() -> List<TaxBracket>] hätte technisch genügt, wäre aber deutlich weniger aussagekräftig gewesen. Deshalb reservieren wir Funktionstypen für kurze, einmalige Verhalten (ein Kriterium, eine Transformation, eine Aktion) und „fachliche“ Interfaces für die Rollen der Anwendung, unabhängig von der Anzahl ihrer Mitglieder.
7.6. Ereignisbehandlung
7.6.1. Das Observer-Muster
Als Parameter übergebene Funktionen dienen dazu, Ereignisse einzurichten. Wie Java hat Kotlin kein eigenes Schlüsselwort für Ereignisse (C# hat dafür das Schlüsselwort [event]): Es verwendet die Konventionen, die Java bereits seit Version 1.1 für grafische Komponenten und JavaBeans festgelegt hat, das sogenannte „Listener-Modell“. Eine Klasse [C1], die ein Ereignis [Xxx] signalisieren möchte, geht wie folgt vor:
- Eine Klasse [XxxEvent] kapselt Informationen über das Ereignis, darunter das Objekt, das das Ereignis ausgelöst hat, die sogenannte Quelle. In Java ist es üblich, dass sie von [java.util.EventObject] abgeleitet wird, die die Quelle speichert; in Kotlin genügt eine gewöhnliche Klasse mit schreibgeschützten Eigenschaften, und genau das tun wir;
- Ein Listener-Typ definiert die Form der Funktion, die beim Eintreten des Ereignisses aufgerufen wird. In Java ist das ein Interface namens [XxxListener]; in Kotlin ist es meist ein einfacher Funktionstyp, [(XxxEvent) -> Unit], der durch ein [typealias] benannt wird: Ein Listener ist ein Lambda oder eine Funktionsreferenz;
- die Klasse [C1] verwaltet eine Liste von Funktionen und stellt zwei öffentliche Methoden zum An- und Abmelden bereit: [addXxxListener(listener)] und [removeXxxListener(listener)];
- Möchte eine Instanz [c1] von [C1] das Ereignis signalisieren, erzeugt sie ein Objekt [XxxEvent] und ruft jeden der registrierten Listener auf, wobei sie ihnen dieses Objekt übergibt. Per Konvention übernimmt diese Benachrichtigung eine geschützte Methode [fireXxx(e: XxxEvent)] („fire“), die eine abgeleitete Klasse überschreiben kann, um die Veröffentlichung des Ereignisses zu ändern;
- Möchte ein Objekt [c2] über das Ereignis [Xxx] des Objekts [c1] benachrichtigt werden, abonniert 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 für dasselbe Ereignis eintragen.
In diesem Szenario haben wir:
- eine Klasse, die ein Ereignis signalisiert (auch „veröffentlicht“ oder „sendet“ genannt);
- Objekte, die über dieses Ereignis benachrichtigt werden. Man sagt, sie abonnieren das Ereignis oder tragen sich dafür ein: Das sind die Listener oder Ereignisbehandler;
- einen Listener-Typ, der die Form der Funktionen definiert, die über das Ereignis benachrichtigt werden.
Das 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 eine private Eigenschaft des Senders. Von außen kann man sich nur an- oder abmelden; man kann weder die Liste leeren noch andere Listener ersetzen noch das Ereignis anstelle des Senders auslösen.
7.6.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 sind Funktionen vom Typ [TemperatureTooHighListener];
- eine Klasse namens [Subscriber] registriert sich als Listener für das vorherige Ereignis. Wird sie über das Ereignis benachrichtigt, zeigt sie eine Meldung auf der Konsole an. Ein Listener meldet sich nach dem Erhalt einer festgelegten Anzahl von Warnungen automatisch ab;
- ein Konsolenprogramm erzeugt einen Emitter und zwei Subscriber. Es liest Temperaturen über die Tastatur ein und trägt sie im Emitter ein. Ist eine davon zu hoch, signalisiert der Emitter das Ereignis [TemperatureTooHigh].
Dieses Programm ist im Paket [lambdas11] auf drei Dateien verteilt. Zuerst die Datei [Emitter.kt], die die Ereignisklasse, den Listener-Typ und die Klasse [Emitter] enthält:
Kommentare:
- Zeilen 7–14: Die Klasse [TemperatureTooHighEvent] speichert die Ereignisquelle vom Typ [Emitter] und die Temperatur, die das Ereignis ausgelöst hat. Wir haben den Zeitpunkt des Ereignisses hinzugefügt, [time], der bei der Erzeugung des Objekts initialisiert wird. Alle Eigenschaften sind vom Typ [val]: Ein Listener soll die Ereignisinformationen für nachfolgende Listener nicht ändern können. Wir haben die Klasse nicht wie in Java von [EventObject] abgeleitet: Das hätte hier keinen Nutzen und würde uns zwingen – damit die Quelle vom Typ [Emitter] statt [Any] ist –, die Methode [getSource] neu zu definieren;
- Zeile 18: der Typ des Listeners. Ein Listener ist eine Funktion, die das Ereignisobjekt als Argument erhält und nichts zurückgibt. Wo Java ein Interface
*[TemperatureTooHighListener]* verlangt, das von*[EventListener]*abgeleitet ist, verwendet Kotlin einfach einen funktionalen Typalias. Wir hätten ebenso gut ein***[fun interface TemperatureTooHighListener]***deklarieren können: Das wäre die richtige Wahl, wenn die Listener in Java geschrieben würden; - Zeile 24: der Temperaturschwellenwert, ab dem das Ereignis [TemperatureTooHigh] ausgelöst wird, eine Konstante des Companion-Objekts;
- Zeile 21: Der Emitter hat zur Identifikation einen Namen. Die Klasse ist als [open] deklariert, damit eine abgeleitete Klasse die Methode [fireTemperatureTooHigh] überschreiben kann;
- Zeile 28: die Liste der registrierten Listener, eine Liste von Funktionen. Es ist 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. Wir werden später sehen, warum das hier unerlässlich ist. Diese Liste ist der Standardtyp für Listener-Listen: Die Liste wird bei jedem Ereignis durchlaufen, aber nur selten geändert;
- Zeilen 31–36: Die Eigenschaft [temperature] hat einen benutzerdefinierten Accessor [set] (Kapitel 4): Er speichert den neuen Wert im versteckten Feld [field] und signalisiert dann das Ereignis, wenn er den Schwellenwert überschreitet. Die Veröffentlichung übernimmt die Methode [fireTemperatureTooHigh], der ein Objekt [TemperatureTooHighEvent] übergeben wird; dieses Objekt stammt vom Emitter selbst ([this]) und enthält die Temperatur, die den Schwellenwert überschritten hat. Wo Java eine Methode namens [setTemperature] verlangt, schreibt der Benutzer der Klasse einfach [e1.temperature = 21.0];
- Zeilen 41–42: Das Registrieren eines Listeners fügt ihn der Liste hinzu. Der Parametertyp ist nicht nullable: Der Compiler lehnt jeden Listener vom Typ [null] ab, was Java zur Laufzeit über [Objects.requireNonNull] ablehnen muss;
- Zeilen 46–47: Das Abmelden entfernt den Listener aus der Liste. Die Methode [remove] sucht das zu entfernende Objekt mithilfe von [equals]: Ihr muss daher ein Objekt übergeben werden, das identisch mit dem registrierten Objekt ist;
- Zeilen 51–53: Die Benachrichtigung ruft jeden registrierten Listener in der Reihenfolge seiner Registrierung als Funktion auf: [listener(e)]. Gibt es keine Listener, tut die Schleife nichts: Es gibt keine Sonderfälle zu behandeln.
Hier die Datei [Subscriber.kt]:
Kommentare:
- Zeilen 4–11: Jeder Subscriber wird durch einen Namen identifiziert, und ihm wird die maximale Anzahl an Warnungen zugewiesen, die er akzeptiert ([nbMaxAlerts]). Er zählt die erhaltenen Warnungen ([nbAlerts]);
- Zeilen 14–15: die Registrierung bei einem Emitter. Der Listener ist eine gebundene Referenz, [::onTemperatureTooHigh], das heißt [this::onTemperatureTooHigh]: die Methode dieses Subscribers, [onTemperatureTooHigh];
- Zeilen 19–20: Das Abmelden übergibt eine neue Referenz, [::onTemperatureTooHigh], an [removeTemperatureTooHighListener]. In Java wäre das ein klassischer Fehler: Zwei Auswertungen von
[this::onTemperatureTooHigh]erzeugen zwei Objekte, die[equals]*als verschieden betrachtet, und das Abmelden würde ohne jede Fehlermeldung nichts entfernen; der Listener darf nur einmal erzeugt werden und muss in einem Feld gespeichert sein. Wir haben bei [Lambdas04.kt] gesehen, dass in Kotlin zwei Referenzen auf dieselbe Funktion desselben Objekts gleich sind: [remove] findet daher den registrierten Listener – und nur diesen –, da die Referenzen der anderen Subscriber an andere Objekte gebunden sind. Bei einem Lambda wäre das nicht der Fall: [{ e -> onTemperatureTooHigh(e) }]*, zweimal geschrieben, ergäbe zwei verschiedene Objekte; - Zeile 24: der Ereignisbehandler. Er hat die durch den Typ [TemperatureTooHighListener] vorgegebene Form. Er ist privat: Nur der Subscriber kann ihn bei einem Emitter registrieren. Ein anderer Ansatz besteht darin, den Listener-Typ von der Klasse [Subscriber] selbst implementieren zu lassen ([class Subscriber : TemperatureTooHighListener], mit einer Methode [invoke]) und sich mit [this] zu registrieren. Dieser Ansatz hat den Nachteil, dass die Methode [invoke] öffentlich wird, sodass jeder sie aufrufen könnte;
- Zeile 25: Die Ereignisquelle ist direkt vom Typ [Emitter];
- Zeilen 26–28: Der Handler zeigt den Namen des Subscribers, den Namen des Emitters, der das Ereignis gemeldet hat, und die Temperatur an, die es ausgelöst hat. Das Format [%.1f] zeigt die reelle Zahl mit einer Nachkommastelle an, gemäß den lokalen Konventionen des Rechners (die Kotlin-Funktion [format] verwendet sie; hier ein Dezimalpunkt). Die Zeichenkette wird in zwei Teilen geschrieben, die durch [+] verbunden werden, damit die Zeile auf die Seite passt;
- Zeilen 30–33: Nach [nbMaxAlerts] Warnungen meldet sich der Subscriber vom Emitter ab. Er tut dies während der Ereignisbenachrichtigung, aus seinem eigenen Handler heraus – also während die Methode [fireTemperatureTooHigh] die Liste der Listener durchläuft. Das ist dank [CopyOnWriteArrayList] unbedenklich: [remove] erzeugt ein neues Array, aber die laufende Iteration setzt sich auf dem alten fort.
Schließlich das Hauptprogramm [Lambdas11.kt]:
Ergebnisse (die Standardeingabe wurde per Umleitung geliefert; wir haben die Eingaben hinter den Eingabeaufforderungen, an denen das Programm sie liest, wieder eingefügt):
Kommentare:
- Zeile 7: Erzeugung des Emitters;
- Zeilen 9–11: Erzeugung zweier Subscriber, [s0] (bis zu 3 Warnungen) und [s1] (1 Warnung), die beim Emitter registriert werden;
- Zeilen 14–15: ein dritter Listener, ein außerhalb der Klammern übergebenes Lambda, das als Protokoll dient. Der Typ des Parameters [e] wird aus dem des Parameters von [addTemperatureTooHighListener] abgeleitet. Das Format [%tT] zeigt eine Uhrzeit in der Form [HH:mm:ss] an. Dieses Lambda kann nicht abgemeldet werden: Es hätte in einer Variablen gespeichert werden müssen, um dasselbe Objekt an [removeTemperatureTooHighListener] übergeben zu können. Daher sind direkt im Registrierungsaufruf geschriebene Lambdas Listenern vorbehalten, die so lange registriert bleiben, wie der Emitter existiert;
- Zeilen 19–33: Schleife zur Eingabe von Temperaturen über die Tastatur. [readlnOrNull()] liest eine Zeile; es gibt [null] zurück, wenn die Standardeingabe geschlossen ist, ein Fall, der mit [isNullOrBlank] (Zeile 23) wie eine leere Eingabe behandelt wird. Nach diesem Test weiß der Compiler, dass [input] nicht [null] ist (Smart Cast);
- Zeile 27: [toDoubleOrNull] 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, liefert [toDoubleOrNull] den Wert [null]: Man muss nicht wie in der Java-Version mit [Double.parseDouble] eine Exception abfangen;
- Zeile 33: Ist die eingegebene Temperatur korrekt, wird sie der Eigenschaft [temperature] des Emitters [e1] zugewiesen, dessen Accessor [set] das Ereignis [TemperatureTooHigh] signalisiert, wenn sie größer als 19 °C ist.
Die Ergebnisse zeigen (die Zeiten variieren von Lauf zu Lauf):
- Zeile 1: 17 °C überschreiten den Schwellenwert nicht: kein Ereignis;
- Zeilen 2–6: 21 °C lösen das Ereignis aus. Die drei Listener werden in der Reihenfolge benachrichtigt, in der sie registriert wurden. [s1], der nur eine Warnung akzeptiert, meldet sich sofort ab, doch das hindert das danach registrierte Protokoll nicht daran, benachrichtigt zu werden;
- Zeilen 9–11: [s1] wird nicht mehr benachrichtigt: Das Abmelden über eine neue Referenz hat wie vorgesehen funktioniert;
- Zeilen 12–15: [s0] erhält seine dritte Warnung und meldet sich seinerseits ab;
- Zeilen 16–17: Nur das Protokoll bleibt übrig.
Was würde geschehen, wenn es einfach eine [ArrayList] statt der [CopyOnWriteArrayList] in der Klasse [Emitter] gäbe? Wir haben das getestet: Wenn [s1] sich abmeldet, während die Liste abgearbeitet wird, werden die folgenden Elemente übersprungen, und die Verarbeitung endet sofort. Das Protokoll wird über die Temperaturen 21 und 25 nicht benachrichtigt, ohne jede Fehlermeldung. In anderen Konstellationen wirft die Schleife eine [ConcurrentModificationException]. Eine Listener-Liste muss daher stets Änderungen während des Durchlaufs vertragen: Die [CopyOnWriteArrayList] ist dafür gedacht und unterstützt auch An- und Abmeldungen durch andere Threads (Kapitel 8).
7.6.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. Kotlin und die Java-Bibliothek bieten dafür zwei einander ergänzende Werkzeuge:
- Kotlins delegierte Eigenschaften. Eine als [var p: T by delegate] deklarierte Eigenschaft überträgt das Lesen und Schreiben ihres Werts an ein anderes Objekt, den Delegaten. Die Standardbibliothek stellt mehrere davon bereit, etwa [by lazy { … }], das den Wert der Eigenschaft beim ersten Zugriff berechnet. Das Objekt [kotlin.properties.Delegates] stellt zwei Delegaten bereit, die ein Lambda akzeptieren: [Delegates.observable(initialValue) { property, old, new -> … }] führt das Lambda nach jedem Schreibzugriff auf die Eigenschaft aus; [Delegates.vetoable(initialValue) { property, old, new -> … }] führt es vorher aus und akzeptiert den neuen Wert nur, wenn das Lambda [true] zurückgibt. Der Parameter [property] ist eine Referenz auf die Eigenschaft ([KProperty]), deren Name über [property.name] ermittelt wird;
- die Java-Klasse [java.beans.PropertyChangeSupport], die für uns die Liste der Listener verwaltet. Die Listener implementieren das funktionale Interface [PropertyChangeListener], dessen Methode [void propertyChange(PropertyChangeEvent evt)] ein Ereignis erhält, das die Quelle, den Eigenschaftsnamen sowie den alten und den neuen Wert enthält.
Der Delegat [observable] weiß, wann sich eine Eigenschaft ändert, und [PropertyChangeSupport] weiß, wen es zu benachrichtigen gilt: Das Programm [Lambdas12.kt] verbindet beide:
Ergebnisse:
Kommentare:
- Zeilen 3–4: Das Paket [java.beans] gehört zum Modul [java.desktop] des JDK, nicht zum Modul [java.base]. Da unser Programm kein Java-Modul ist, sind ihm alle Klassen des JDK zugänglich: Wir müssen sie lediglich importieren;
- Zeile 45: Die Klasse [Thermometer] delegiert die Verwaltung ihrer Listener an ein Objekt [PropertyChangeSupport], das mit der Ereignisquelle ([this]) konstruiert wird. Die Methoden in den Zeilen 60–69 reichen An- und Abmeldungen einfach an dieses weiter, und die Eigenschaft [nbListeners] (Zeilen 72–73) liefert die Anzahl der registrierten Listener;
- Zeilen 48–50: eine kleine generische Funktion, die einen Delegaten [Delegates.observable] erzeugt, dessen Lambda jede Änderung an [firePropertyChange] weitergibt, zusammen mit dem Eigenschaftsnamen ([property.name]), dem alten und dem neuen Wert. Sie gibt ein
*[ReadWriteProperty<Any?, T>]* zurück, das Interface für Delegaten veränderlicher Eigenschaften. Wie eine Methode kann ein innerhalb einer Klasse geschriebenes Lambda auf die privaten Eigenschaften des Objekts zugreifen, hier auf[changes]; - Zeilen 53–54: die beiden beobachtbaren Eigenschaften der Klasse. Das Schlüsselwort [by] überträgt ihre Verwaltung an einen Delegaten, der von unserer Funktion [observable] erzeugt wird. Verglichen mit der Java-Version, in der jeder Setter den alten Wert merken, den neuen speichern und
*[firePropertyChange]mit dem als Zeichenkette geschriebenen Eigenschaftsnamen aufrufen muss, passt die Kotlin-Version in eine einzige Zeile pro Eigenschaft, und der Eigenschaftsname kann nicht falsch geschrieben werden. Der Delegat führt das Lambda bei jedem Schreibzugriff aus, auch wenn sich der Wert nicht ändert; jedoch [firePropertyChange]* benachrichtigt die Listener nur, wenn die beiden Werte verschieden sind: Der Schreibzugriff in Zeile 28, der den Wert nicht ändert, erzeugt daher keine Ausgabe; - Zeilen 13–17: ein erster Beobachter, ein in [PropertyChangeListener] umgewandeltes Lambda, das in einer Variablen gespeichert ist, damit es abgemeldet werden kann (Zeile 31). Es ist für alle Eigenschaften des Objekts angemeldet. [e.source] (also [e.getSource()], aus Kotlin als Eigenschaft betrachtet) ist vom Typ [Any], der mit [as] gecastet werden muss. Die Werte sind Objekte: [Double]-Objekte werden mit ihrer Methode [toString] angezeigt, die den Dezimalpunkt verwendet;
- Zeilen 19–21: Ein zweiter Listener, der nur für die Eigenschaft [temperature] registriert ist. Das Lambda wird aus den Klammern herausgezogen und in einen [PropertyChangeListener] umgewandelt (SAM-Konvertierung). Es löst eine Warnung aus, wenn die Temperatur 19 °C überschreitet. [e.newValue as Double] wandelt den neuen Wert vom Typ [Any?] in Double um;
- Zeilen 25–33: Eigenschaftsänderungen erfolgen über einfache Zuweisungen. Die Namensänderung (Zeile 29) wird nur dem Protokoll gemeldet. In Zeile 4 der Ergebnisse zeigt das Protokoll den neuen Namen der Quelle, [lounge]: Das Ereignis wird nach der Änderung gemeldet. Nach dem Abmelden vom Protokoll wird nur noch die Warnung angezeigt, und es bleibt nur ein Listener übrig;
- Zeile 57: Die Eigenschaft [setpoint] verwendet den Delegaten [vetoable]. Sein Lambda, das vor jedem Schreibvorgang aufgerufen wird, akzeptiert den neuen Wert nur, wenn er zwischen 5 und 30 °C liegt ([new in 5.0..30.0]); seine beiden ersten Parameter, die hier nicht benötigt werden, werden mit [_] bezeichnet. Zeilen 36–38: Der Wert 21 wird akzeptiert, der Wert 45 abgelehnt; die Eigenschaft behält ihren vorherigen Wert (Zeilen 7–8 der Ergebnisse). Die JavaBeans-Instanzen haben einen gleichwertigen Mechanismus mit [VetoableChangeSupport] und Listenern, die eine [PropertyVetoException] werfen.
Ohne eine Ereignisklasse oder einen Listener-Typ zu schreiben, erhalten wir so einen vollständigen Mechanismus. [PropertyChangeSupport] wird von den Swing-GUI-Komponenten und von JavaBeans verwendet; JavaFX hat einen eigenen, sehr ähnlichen Mechanismus für beobachtbare Eigenschaften. Die Delegaten [observable] und [vetoable] genügen dagegen für sich allein, wenn es nur einen Beobachter gibt, der zum Zeitpunkt des Schreibens der Klasse bekannt ist. Beachten Sie schließlich, dass Kotlin für asynchrone Ereignisströme den [Flow] aus der Bibliothek kotlinx.coroutines bereitstellt, den wir in Kapitel 9 behandeln ([StateFlow], insbesondere, fungiert als beobachtbare Eigenschaft).
7.7. Lambdas, Collections und Sequenzen
In Kapitel 5 haben wir die funktionalen Operationen von Collections ([filter], [map], [sortedBy]…) und Sequenzen verwendet, indem wir ihnen Lambdas übergeben haben. Nun wissen wir, was diese Parameter sind: Die Funktion [filter] ist in der Standardbibliothek wie folgt deklariert: [inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>].
Es ist eine Erweiterungsfunktion, [inline], deren Parameter ein Funktionstyp ist: Jede Funktion oder jedes Lambda, die bzw. das ein Element erhält und einen Boolean zurückgibt, ist geeignet. Ebenso erwartet [map] ein [(T) -> R], [sortedBy] ein [(T) -> R?], wobei [R] vergleichbar ist, [forEach] entspricht einem [(T) -> Unit], [reduce] einem [(S, T) -> S]… Um ihre Funktionsweise vollständig zu verstehen, schreiben wir unsere eigenen Filter- und Transformationsoperationen. Hier das Programm [Lambdas13.kt]:
Ergebnisse:
Kommentare:
- Zeilen 9–11: Die Lambdas von [filter] und [map] werden zunächst Variablen zugewiesen, um ihre Typen sichtbar zu machen. [map] transformiert jedes Element: Man erhält die Quadrate der geraden Zahlen;
- Zeile 13: dieselbe Berechnung mit dem Stream der Java-API, der aus Kotlin unverändert verwendet werden kann: Die Java-Methode [filter] erwartet ein [Predicate], [map] erwartet eine [Function], und Kotlin-Lambdas werden automatisch konvertiert (SAM-Konvertierung). Er wird in Kotlin für sequenzielle Berechnungen selten verwendet, da die Funktionen für Collections und Sequenzen einfacher sind; er bleibt nützlich für die parallelen Streams aus Kapitel 8 oder wenn eine Java-Bibliothek einen [Stream] zurückgibt;
- Zeilen 51–58: Unsere Funktion [filterBy], geschrieben als Erweiterungsfunktion von [List<T>] und deklariert als [inline], genau wie [filter]. Sie ist generisch: Sie filtert eine Liste von Elementen eines beliebigen Typs [T]. Sie durchläuft die Liste ([this]), ruft für jedes Element das Prädikat auf (Zeile 54) und gibt die Liste der ausgewählten Elemente zurück;
- Zeile 16: Aufruf von [filterBy] mit einem Lambda außerhalb der Klammern. Der Typ [T] wird aus der Liste abgeleitet: [Int]. In Zeile 17 wird ihr eine Funktionsreferenz übergeben: [isOdd] (Zeile 61) hat die Form [(Int) -> Boolean];
- Zeilen 20–25: ein ausführliches Prädikat, das jedes getestete Element anzeigt, angewendet auf eine Liste. Operationen auf Collections sind unmittelbar: [filter] testet alle Elemente und konstruiert die vollständige Ergebnisliste, bevor es zurückkehrt (Zeilen 5–6 der Ergebnisse). In einer Kette [list.filter { … }.map { … }]erzeugt somit jeder Schritt eine Zwischenliste;
- Zeilen 29–34: dasselbe Prädikat, angewendet auf eine Sequenz ([asSequence()]). Das Ergebnis (Zeilen 7–8) zeigt, dass die Definition der Sequenz nichts ausführt: Die Meldung in Zeile 33 wird vor dem ersten Test angezeigt. Erst wenn die Terminaloperation [forEach] die Elemente anfordert, wird das Prädikat ausgeführt, und die Tests wechseln sich mit den Ausgaben von [forEach] ab: Jedes Element durchläuft die gesamte Kette, bevor das nächste in sie eintritt. Das ist die verzögerte (oder „lazy“) Ausführung von Sequenzen, die derjenigen von Java-Streams entspricht. Die Zwischenoperationen der Sequenzen sind nicht [inline]: Sie müssen die Lambdas aufbewahren, um sie später auszuführen;
- Zeilen 64–73: Um eigene Zwischenoperationen zu schreiben – die wie die der Bibliothek lazy sind –, verwenden wir den Sequenz-Konstruktor [sequence]. Er erhält ein Lambda, in dem die Funktion [yield] ein Element der Sequenz erzeugt: Für jedes vom nachgelagerten Teil angeforderte Element setzt das Lambda seine Ausführung dort fort, wo es aufgehört hat, bis zum nächsten [yield] (das ist eine Coroutine, ein Konzept, das wir in Kapitel 9 untersuchen). Das Label
[this@keep]bezeichnet den Receiver der Erweiterungsfunktion[keep], also die ursprüngliche Sequenz: Ohne Label würde [this] den Receiver des Lambdas in [sequence] bezeichnen, da dieses Lambda ein Lambda mit Receiver ist. Die Funktion [keep] lässt nur die Elemente durch, die das Prädikat erfüllen; die Funktion [transform], die doppelt generisch ist ([T] ist der Typ der empfangenen Elemente, [R] ist der Typ der erzeugten Elemente), gibt das Ergebnis der auf jedes Element angewendeten Funktion zurück. Java 24 hat für denselben Zweck Zwischen-Collectoren ([Gatherer]) eingeführt, die eine deutlich komplexere Syntax haben; - Zeilen 39–42: Unsere Erweiterungsfunktionen werden wie Bibliotheksoperationen in die Kette eingefügt: Wir behalten die Städte mit höchstens 5 Buchstaben und wandeln sie dann in Großbuchstaben um. Die Terminaloperation [toList] löst die Berechnung aus;
- Zeilen 45–47: [generateSequence(1) { it * 2 }] definiert eine unendliche Sequenz: 1, gefolgt von jedem Element, das man durch Verdoppeln des vorherigen erhält. Sie ist nur dank der Lazy Evaluation verwendbar: [take(5)] fordert nur die ersten fünf Elemente an, und nur diese werden berechnet. Das an [transform] übergebene Lambda zeigt jede Potenz in der Form [2^n=value] an ([countTrailingZeroBits] zählt die Nullen ganz rechts in der Binärdarstellung, also den Exponenten).
Alle Operationen auf Collections und Sequenzen beruhen auf diesem Muster: Funktionen höherer Ordnung, die Funktionstypen erhalten. Bei Collections sind diese Funktionen [inline] und unmittelbar; bei Sequenzen bewahren sie die Lambdas auf und berechnen die Elemente erst, wenn die Terminaloperation sie anfordert.
7.8. 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.Limit > 20000] analysieren und es beispielsweise in eine SQL-Klausel [WHERE limits > 20000] übersetzen, die vom Datenbankserver ausgeführt wird.
Kotlin hat wie Java kein Äquivalent: Ein Kotlin-Lambda wird immer zu ausführbarem Code kompiliert; man kann es aufrufen, aber seine innere Funktionsweise nicht untersuchen. Mehrere Werkzeuge kommen dem jedoch nahe:
- Eigenschaftsreferenzen: [Person::age] ist ein Objekt ([KProperty1<Person, Int>]), das den Namen der Eigenschaft ([Person::age.name]) und ihren Typ kennt. Eine Bibliothek kann dies nutzen, um eine Abfrage ohne Zeichenkette zu konstruieren: Das tut zum Beispiel Spring Data MongoDB mit seinen Kotlin-Erweiterungen, die es erlauben, ein Kriterium wie [Person::age gt 18] zu schreiben;
- Interne DSL („Domain-Specific Languages“): Dank Lambdas mit Receivern, [infix]-Funktionen und Operatorüberladung kann eine Kotlin-Bibliothek eine SQL-ähnliche Syntax anbieten, die das Programm ausführt, um eine Datenstruktur zu konstruieren, die die Abfrage beschreibt. Das ist das Prinzip der Bibliothek Exposed von JetBrains: [Brackets.selectAll().where { Brackets.limit greater 20000 }];
- Compiler-Plugins: Der Kotlin-Compiler lässt sich mit Plugins erweitern, die den Code transformieren. So funktioniert kotlinx.serialization, ebenso die Plugins [all-open] und [no-arg] , die mit Spring und Hibernate verwendet werden, oder das Plugin [power-assert], das den Ausdruck einer Assertion analysiert, um im Fehlerfall dessen Details anzuzeigen. Das sind jedoch Entwicklungswerkzeuge, keine integrierten Funktionen des Programms.
Hibernate, das wir in Kapitel 11 behandeln werden, bietet dieselben Lösungen wie in Java: eine SQL-ähnliche Abfragesprache, die jedoch in Klassen und Eigenschaften ausgedrückt wird, HQL (["from Bracket t where t.limit > 20000"]), und die Criteria-API von Jakarta Persistence, die die Abfrage über Methodenaufrufe konstruiert ([cb.gt(t.get("limit"), 20000)]). In beiden Fällen besteht die Abfrage aus Daten (einer Zeichenkette oder einem Objektbaum), die Hibernate in SQL übersetzt, während ein an [filter] übergebenes Lambda innerhalb des Kotlin-Programms ausgeführt wird.
7.9. Fazit
Die wichtigsten Punkte dieses Kapitels:
- In Kotlin sind Funktionen Werte: Sie haben einen Funktionstyp ([(Int, Int) -> Int], [() -> Unit], [(T) -> Boolean], [(() -> Unit)?], [T.() -> R]…), können in Variablen gespeichert, als Parameter übergeben, als Ergebnisse zurückgegeben und wie gewöhnliche Funktionen aufgerufen werden. Für die virtuelle Maschine sind sie Objekte, die die Interfaces [Function0], [Function1]… implementieren;
- die Interfaces aus [java.util.function] ([Function], [Supplier], [Consumer], [Predicate]…) sowie [Runnable], [Callable] und [Comparator] bleiben verwendbar: Erwartet eine Java-Methode ein funktionales Interface, konvertiert Kotlin ein Lambda oder eine Referenz automatisch dorthin (SAM-Konvertierung); an anderer Stelle wird die Konvertierung explizit geschrieben: [Comparator { … }];
- um einen Funktionstyp zu benennen, gibt es den Alias [typealias] (einfach ein Alias) und [fun interface] (ein echter neuer Typ, per Lambda implementierbar);
- eine Funktion lässt sich über einen Lambda-Ausdruck gewinnen ([{ a, b -> a + b }], [{ it * it }] – außerhalb der Klammern geschrieben, wenn er der letzte Parameter ist, und mit [return@label] abgeschlossen), über eine anonyme Funktion, über ein anonymes Objekt oder über eine Referenz ([::function], [object::method], [Class::method], [::Class]). Zwei Referenzen auf dieselbe Funktion desselben Objekts sind gleich; zwei Lambdas sind niemals gleich;
- Lambdas erfassen die sie umgebenden Variablen, auch die [var], die sie ändern können (der Compiler speichert sie in [Ref]-Objekten); sie sehen dann den Wert der Variablen zum Zeitpunkt ihrer Ausführung, was in Schleifen und zwischen Threads Vorsicht erfordert;
- Funktionen, die Funktionen zurückgeben, und Erweiterungen von Funktionstypen ([then], [and], [or]…) setzen neue Funktionen zusammen; [compareBy], [thenBy] und [reversed] erzeugen Komparatoren;
- die Funktionen [inline] kopieren ihren Code und den der Lambdas an die Aufrufstelle, ohne Objekt und Konvertierung, und erlauben nicht lokale Returns; [noinline] und [crossinline] behandeln Sonderfälle. Die Scope-Funktionen [let], [run], [with], [apply] und [also] sind die häufigsten Anwendungen davon;
- einen Funktionstyp wählt man für kurzlebiges, einmaliges Verhalten; ein [fun interface] für einen eigenständigen Typ oder eine API, die von Java aus genutzt werden kann; ein Interface mit mehreren Mitgliedern (oder ein „fachliches“ Interface) für eine Rolle in der Anwendung;
- ein Ereignis wird mit dem Listener-Muster eingerichtet: eine Klasse [XxxEvent], ein Listener-Typ (oft ein funktionaler [typealias]), [addXxxListener] / [removeXxxListener], und eine Liste von Funktionen ([CopyOnWriteArrayList]), die von einer Methode [fireXxx] durchlaufen wird. Die delegierten Eigenschaften [Delegates.observable] und [Delegates.vetoable] melden oder filtern Änderungen einer Eigenschaft, und [PropertyChangeSupport] verwaltet für sie die Liste der Listener;
- Operationen auf Collections (unmittelbar, [inline]) und Sequenzoperationen (lazy) sind Funktionen höherer Ordnung; Kotlin hat keine Ausdrucksbäume, und Hibernate formuliert seine Abfragen mit HQL oder der Criteria-API.
Lambdas tauchen in allen folgenden Kapiteln wieder auf: Ein Thread führt ein Lambda aus ([thread { … }]), und ein [ExecutorService] führt ein [Callable] aus (Kapitel 8); eine Coroutine wird mit [launch { … }] oder [async { … }] gestartet (Kapitel 9), Erweiterungsfunktionen von [ResultSet] erhalten in Form eines Lambdas die Transformation einer Ergebniszeile in ein Objekt (Kapitel 10), und Spring-Boot-Webservices verarbeiten HTTP-Anfragen in Methoden, die das Framework als Listener aufruft (Kapitel 13).