Diese Seite wurde von der Cloud Translation API übersetzt.

Kotlin Bootcamp für Programmierer 6: Funktionale Manipulation

Dieses Codelab ist Teil des Kotlin-Bootcamps für Programmierer. Sie können diesen Kurs am besten nutzen, wenn Sie die Codelabs der Reihe nach durcharbeiten. Je nach Ihrem Wissen können Sie einige Abschnitte möglicherweise überfliegen. Dieser Kurs richtet sich an Programmierer, die eine objektorientierte Sprache kennen und Kotlin lernen möchten.

Einführung

Dies ist das letzte Codelab im Kotlin-Bootcamp. In diesem Codelab erfahren Sie mehr über Anmerkungen und gekennzeichnete Unterbrechungen. Sie lernen Lambdas und Funktionen höherer Ordnung kennen, die wichtige Bestandteile von Kotlin sind. Außerdem erfahren Sie mehr über das Inlining von Funktionen und SAM-Schnittstellen (Single Abstract Method). Schließlich erfahren Sie mehr über die Kotlin-Standardbibliothek.

In diesem Kurs wird keine einzelne Beispiel-App entwickelt. Stattdessen sollen die Lektionen Ihr Wissen erweitern, sind aber weitgehend unabhängig voneinander, sodass Sie Abschnitte, mit denen Sie vertraut sind, überspringen können. Um die Beispiele zu veranschaulichen, wird in vielen ein Aquarium verwendet. Wenn Sie die ganze Geschichte des Aquariums sehen möchten, können Sie sich den Udacity-Kurs Kotlin Bootcamp for Programmers ansehen.

Was Sie bereits wissen sollten

Die Syntax von Kotlin-Funktionen, -Klassen und -Methoden
Neue Klasse in IntelliJ IDEA erstellen und Programm ausführen
Grundlagen von Lambdas und Funktionen höherer Ordnung

Lerninhalte

Grundlagen zu Anmerkungen
Pausen mit Labels verwenden
Weitere Informationen zu Funktionen höherer Ordnung
Single Abstract Method-Schnittstellen (SAM)
Die Kotlin-Standardbibliothek

Aufgaben

Einen einfachen Vermerk erstellen
Verwenden Sie einen beschrifteten Break.
Lambda-Funktionen in Kotlin
Funktionen höherer Ordnung verwenden und erstellen.
Rufen Sie einige Single Abstract Method-Schnittstellen auf.
Verwenden Sie einige Funktionen aus der Kotlin-Standardbibliothek.

Anmerkungen sind eine Möglichkeit, Metadaten an Code anzuhängen. Sie sind nicht spezifisch für Kotlin. Die Anmerkungen werden vom Compiler gelesen und zum Generieren von Code oder Logik verwendet. Viele Frameworks wie Ktor und Kotlinx sowie Room verwenden Annotationen, um zu konfigurieren, wie sie ausgeführt werden und mit Ihrem Code interagieren. Wahrscheinlich werden Sie erst auf Anmerkungen stoßen, wenn Sie Frameworks verwenden. Es ist jedoch nützlich zu wissen, wie man eine Anmerkung liest.

Es gibt auch Anmerkungen, die über die Kotlin-Standardbibliothek verfügbar sind und die Art und Weise steuern, wie Code kompiliert wird. Sie sind sehr nützlich, wenn Sie Kotlin- in Java-Code exportieren, aber ansonsten benötigen Sie sie nicht so oft.

Annotationen werden direkt vor dem Element platziert, das annotiert wird. Die meisten Elemente können annotiert werden, z. B. Klassen, Funktionen, Methoden und sogar Kontrollstrukturen. Einige Anmerkungen können Argumente enthalten.

Hier ist ein Beispiel für einige Anmerkungen.

@file:JvmName("InteropFish")
class InteropFish {
   companion object {
       @JvmStatic fun interop()
   }
}

Das bedeutet, dass der exportierte Name dieser Datei InteropFish mit der Anmerkung JvmName ist. Die Anmerkung JvmName hat das Argument "InteropFish". Im Companion-Objekt weist @JvmStatic Kotlin an, interop() zu einer statischen Funktion in InteropFish zu machen.

Sie können auch eigene Anmerkungen erstellen. Das ist jedoch hauptsächlich dann sinnvoll, wenn Sie eine Bibliothek schreiben, die zur Laufzeit bestimmte Informationen zu Klassen benötigt, also Reflection.

Schritt 1: Neues Paket und neue Datei erstellen

Erstellen Sie unter src ein neues Paket: example.
Erstellen Sie im Beispiel eine neue Kotlin-Datei, Annotations.kt.

Schritt 2: Eigene Anmerkung erstellen

Erstellen Sie in Annotations.kt eine Plant-Klasse mit zwei Methoden, trim() und fertilize().

class Plant {
        fun trim(){}
        fun fertilize(){}
}

Erstellen Sie eine Funktion, die alle Methoden in einer Klasse ausgibt. Mit ::class können Sie Informationen zu einer Klasse zur Laufzeit abrufen. Verwenden Sie declaredMemberFunctions, um eine Liste der Methoden einer Klasse abzurufen. (Dazu müssen Sie kotlin.reflect.full.* importieren.)

import kotlin.reflect.full.*    // required import

class Plant {
    fun trim(){}
    fun fertilize(){}
}

fun testAnnotations() {
    val classObj = Plant::class
    for (m in classObj.declaredMemberFunctions) {
        println(m.name)
    }
}

Erstellen Sie eine main()-Funktion, um Ihre Testroutine aufzurufen. Führen Sie das Programm aus und beobachten Sie die Ausgabe.

fun main() {
    testAnnotations()
}

⇒ trim
fertilize

Erstellen Sie einen einfachen Vermerk, ImAPlant.

annotation class ImAPlant

Das ist nur eine Anmerkung.

Fügen Sie die Annotation vor der Klasse Plant ein.

@ImAPlant class Plant{
    ...
}

Ändern Sie testAnnotations(), um alle Anmerkungen eines Kurses zu drucken. Verwenden Sie annotations, um alle Anmerkungen einer Klasse abzurufen. Führen Sie das Programm aus und sehen Sie sich das Ergebnis an.

fun testAnnotations() {
    val plantObject = Plant::class
    for (a in plantObject.annotations) {
        println(a.annotationClass.simpleName)
    }
}

⇒ ImAPlant

Ändern Sie testAnnotations(), um die Annotation ImAPlant zu finden. Mit findAnnotation() können Sie nach einer bestimmten Anmerkung suchen. Führen Sie das Programm aus und sehen Sie sich das Ergebnis an.

fun testAnnotations() {
    val plantObject = Plant::class
    val myAnnotationObject = plantObject.findAnnotation<ImAPlant>()
    println(myAnnotationObject)
}

⇒ @example.ImAPlant()

Schritt 3: Gezielte Anmerkung erstellen

Anmerkungen können auf Getter oder Setter ausgerichtet sein. Wenn das der Fall ist, können Sie sie mit dem Präfix @get: oder @set: anwenden. Das kommt häufig vor, wenn Frameworks mit Anmerkungen verwendet werden.

Deklarieren Sie zwei Anmerkungen: OnGet, die nur auf Property-Getters angewendet werden kann, und OnSet, die nur auf Property-Setters angewendet werden kann. Verwenden Sie @Target(AnnotationTarger.PROPERTY_GETTER) oder PROPERTY_SETTER für jedes.

annotation class ImAPlant

@Target(AnnotationTarget.PROPERTY_GETTER)
annotation class OnGet
@Target(AnnotationTarget.PROPERTY_SETTER)
annotation class OnSet

@ImAPlant class Plant {
    @get:OnGet
    val isGrowing: Boolean = true

    @set:OnSet
    var needsFood: Boolean = false
}

Annotationen sind sehr nützlich, um Bibliotheken zu erstellen, die Dinge sowohl zur Laufzeit als auch manchmal zur Kompilierzeit untersuchen. In typischem Anwendungscode werden jedoch nur Anmerkungen verwendet, die von Frameworks bereitgestellt werden.

Kotlin bietet mehrere Möglichkeiten, den Ablauf zu steuern. Sie kennen bereits return, das von einer Funktion an die umschließende Funktion zurückgegeben wird. Die Verwendung von break ist wie return, nur für Schleifen.

Mit einem Break mit Label haben Sie in Kotlin zusätzliche Kontrolle über Schleifen. Bei einem break, das mit einem Label qualifiziert ist, wird direkt nach der mit diesem Label markierten Schleife zum Ausführungspunkt gesprungen. Das ist besonders nützlich, wenn Sie es mit verschachtelten Schleifen zu tun haben.

Jeder Ausdruck in Kotlin kann mit einem Label versehen werden. Labels haben die Form einer Kennung, gefolgt vom Zeichen @.

Testen Sie in Annotations.kt einen Break mit Label, indem Sie aus einer inneren Schleife ausbrechen.

fun labels() {
    outerLoop@ for (i in 1..100) {
         print("$i ")
         for (j in 1..100) {
             if (i > 10) break@outerLoop  // breaks to outer loop
        }
    }
}

fun main() {
    labels()
}

Führen Sie das Programm aus und beobachten Sie die Ausgabe.

⇒ 1 2 3 4 5 6 7 8 9 10 11

Sie können auch ein Label für continue verwenden. Anstatt die Schleife mit dem Label zu verlassen, wird mit dem Label „continue“ mit der nächsten Iteration der Schleife fortgefahren.

Lambdas sind anonyme Funktionen, also Funktionen ohne Namen. Sie können sie Variablen zuweisen und als Argumente an Funktionen und Methoden übergeben. Sie sind äußerst nützlich.

Schritt 1: Einfache Lambda-Funktion erstellen

Starten Sie die REPL in IntelliJ IDEA über Tools > Kotlin > Kotlin REPL.
Erstellen Sie eine Lambda-Funktion mit dem Argument dirty: Int, die eine Berechnung durchführt, indem dirty durch 2 geteilt wird. Weisen Sie die Lambda-Funktion einer Variablen mit der Bezeichnung waterFilter zu.

val waterFilter = { dirty: Int -> dirty / 2 }

Rufen Sie waterFilter auf und übergeben Sie den Wert 30.

waterFilter(30)

⇒ res0: kotlin.Int = 15

Schritt 2: Filter-Lambda erstellen

Erstellen Sie im REPL eine Datenklasse, Fish, mit einer Property, name.

data class Fish(val name: String)

Erstelle eine Liste mit drei Fish mit den Namen Flipper, Moby Dick und Dory.

val myFish = listOf(Fish("Flipper"), Fish("Moby Dick"), Fish("Dory"))

Fügen Sie einen Filter hinzu, um nach Namen zu suchen, die den Buchstaben „i“ enthalten.

myFish.filter { it.name.contains("i")}

⇒ res3: kotlin.collections.List<Line_1.Fish> = [Fish(name=Flipper), Fish(name=Moby Dick)]

Im Lambda-Ausdruck bezieht sich it auf das aktuelle Listenelement. Der Filter wird nacheinander auf jedes Listenelement angewendet.

Wenden Sie joinString() auf das Ergebnis an und verwenden Sie ", " als Trennzeichen.

myFish.filter { it.name.contains("i")}.joinToString(", ") { it.name }

⇒ res4: kotlin.String = Flipper, Moby Dick

Die Funktion joinToString() erstellt einen String, indem die gefilterten Namen mit dem angegebenen String verbunden werden. Sie ist eine der vielen nützlichen Funktionen, die in die Kotlin-Standardbibliothek integriert sind.

Wenn Sie eine Lambda- oder andere Funktion als Argument an eine Funktion übergeben, wird eine Funktion höherer Ordnung erstellt. Der Filter oben ist ein einfaches Beispiel dafür. filter() ist eine Funktion, der Sie ein Lambda übergeben, das angibt, wie jedes Element der Liste verarbeitet werden soll.

Das Schreiben von Funktionen höherer Ordnung mit Erweiterungslambdas ist einer der anspruchsvollsten Aspekte der Kotlin-Sprache. Es dauert eine Weile, bis man gelernt hat, wie man sie schreibt, aber sie sind wirklich praktisch.

Schritt 1: Neuen Kurs erstellen

Erstellen Sie im Paket example eine neue Kotlin-Datei mit dem Namen Fish.kt.
Erstellen Sie in Fish.kt die Datenklasse Fish mit dem Attribut name.

data class Fish (var name: String)

Erstellen Sie eine Funktion fishExamples(). Erstellen Sie in fishExamples() einen Fish mit dem Namen "splashy" (alles in Kleinbuchstaben).

fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
}

Erstellen Sie eine main()-Funktion, die fishExamples() aufruft.

fun main () {
    fishExamples()
}

Klicken Sie zum Kompilieren und Ausführen des Programms auf das grüne Dreieck links neben main(). Es gibt noch keine Ausgabe.

Schritt 2: Funktion höherer Ordnung verwenden

Mit der Funktion with() können Sie auf kompaktere Weise einen oder mehrere Verweise auf ein Objekt oder Attribut erstellen. this wird verwendet. with() ist eine Funktion höherer Ordnung. Im Lambda geben Sie an, was mit dem bereitgestellten Objekt geschehen soll.

Verwenden Sie with(), um den Fischname in fishExamples() großzuschreiben. Innerhalb der geschweiften Klammern verweist this auf das Objekt, das an with() übergeben wird.

fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    with (fish.name) {
        this.capitalize()
    }
}

Es gibt keine Ausgabe. Fügen Sie daher ein println() hinzu. Die this ist implizit und nicht erforderlich. Sie können sie also entfernen.

fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    with (fish.name) {
        println(capitalize())
    }
}

⇒ Splashy

Schritt 3: Funktion höherer Ordnung erstellen

with() ist eine Funktion höherer Ordnung. Um zu sehen, wie das funktioniert, können Sie eine eigene, stark vereinfachte Version von with() erstellen, die nur für Strings funktioniert.

Definieren Sie in Fish.kt eine Funktion myWith(), die zwei Argumente akzeptiert. Die Argumente sind das Objekt, für das der Vorgang ausgeführt werden soll, und eine Funktion, die den Vorgang definiert. Die Konvention für den Argumentnamen mit der Funktion ist block. In diesem Fall gibt die Funktion nichts zurück, was mit Unit angegeben wird.

fun myWith(name: String, block: String.() -> Unit) {}

In myWith() ist block() jetzt eine Erweiterungsfunktion von String. Die Klasse, die erweitert wird, wird oft als Empfängerobjekt bezeichnet. name ist in diesem Fall das Empfängerobjekt.

Wenden Sie im Text von myWith() die übergebene Funktion block() auf das Empfängerobjekt name an.

fun myWith(name: String, block: String.() -> Unit) {
    name.block()
}

Ersetzen Sie in fishExamples() with() durch myWith().

fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    myWith (fish.name) {
        println(capitalize())
    }
}

fish.name ist das Namensargument und println(capitalize()) die Blockfunktion.

Führen Sie das Programm aus. Es funktioniert wie zuvor.

⇒ Splashy

Schritt 4: Weitere integrierte Erweiterungen ansehen

Die Lambda-Funktion für die Erweiterung with() ist sehr nützlich und gehört zur Kotlin-Standardbibliothek. Hier sind einige weitere, die nützlich sein könnten: run(), apply() und let().

Die Funktion run() ist eine Erweiterung, die mit allen Typen funktioniert. Sie verwendet ein Lambda als Argument und gibt das Ergebnis der Ausführung des Lambdas zurück.

Rufen Sie in fishExamples() die Funktion run() für fish auf, um den Namen zu erhalten.

fish.run {
   name
}

Dadurch wird nur die name-Property zurückgegeben. Sie können das Ergebnis einer Variablen zuweisen oder ausgeben. Das ist kein wirklich nützliches Beispiel, da Sie einfach auf die Eigenschaft zugreifen könnten. run() kann jedoch für kompliziertere Ausdrücke nützlich sein.

Die Funktion apply() ähnelt run(), gibt aber das geänderte Objekt zurück, auf das sie angewendet wurde, anstatt des Ergebnisses des Lambda-Ausdrucks. Das kann nützlich sein, um Methoden für ein neu erstelltes Objekt aufzurufen.

Erstellen Sie eine Kopie von fish und rufen Sie apply() auf, um den Namen der neuen Kopie festzulegen.

val fish2 = Fish(name = "splashy").apply {
     name = "sharky"
}
println(fish2.name)

⇒ sharky

Die Funktion let() ähnelt apply(), gibt aber eine Kopie des Objekts mit den Änderungen zurück. Das kann nützlich sein, um mehrere Bearbeitungsvorgänge zu verketten.

Verwende let(), um den Namen von fish abzurufen, schreibe ihn groß, hänge einen weiteren String an ihn an, ermittle die Länge des Ergebnisses, addiere 31 zur Länge und gib das Ergebnis aus.

println(fish.let { it.name.capitalize()}
.let{it + "fish"}
.let{it.length}
.let{it + 31})

⇒ 42

In diesem Beispiel ist der von it referenzierte Objekttyp zuerst Fish, dann String, dann wieder String und schließlich Int.

Wenn Sie fish nach dem Aufrufen von let() ausgeben, sehen Sie, dass sich nichts geändert hat.

println(fish.let { it.name.capitalize()}
    .let{it + "fish"}
    .let{it.length}
    .let{it + 31})
println(fish)

⇒ 42
Fish(name=splashy)

Lambdas und Funktionen höherer Ordnung sind sehr nützlich, aber es gibt etwas, das Sie wissen sollten: Lambdas sind Objekte. Ein Lambda-Ausdruck ist eine Instanz einer Function-Schnittstelle, die selbst ein Untertyp von Object ist. Sehen Sie sich noch einmal das vorherige Beispiel für myWith() an.

myWith(fish.name) {
    capitalize()
}

Die Function-Schnittstelle hat eine Methode, invoke(), die überschrieben wird, um den Lambda-Ausdruck aufzurufen. Ausgeschrieben würde das in etwa so aussehen:

// actually creates an object that looks like this
myWith(fish.name, object : Function1<String, Unit> {
    override fun invoke(name: String) {
        name.capitalize()
    }
})

Normalerweise ist das kein Problem, da das Erstellen von Objekten und das Aufrufen von Funktionen nicht viel Overhead verursacht, d. h. Speicher und CPU-Zeit. Wenn Sie jedoch etwas wie myWith() definieren, das Sie überall verwenden, kann sich der Overhead summieren.

Kotlin bietet inline als Möglichkeit, diesen Fall zu behandeln, um den Aufwand zur Laufzeit zu reduzieren, indem der Compiler etwas mehr Arbeit hat. (In der vorherigen Lektion zu reifizierten Typen haben Sie bereits etwas über inline gelernt.) Wenn Sie eine Funktion als inline markieren, wird der Quellcode bei jedem Aufruf der Funktion vom Compiler in die Funktion „inline“ transformiert. Das heißt, der Compiler ändert den Code, um den Lambda-Ausdruck durch die Anweisungen im Lambda-Ausdruck zu ersetzen.

Wenn myWith() im obigen Beispiel mit inline gekennzeichnet ist:

inline myWith(fish.name) {
    capitalize()
}

wird sie in einen direkten Aufruf umgewandelt:

// with myWith() inline, this becomes
fish.name.capitalize()

Das Inlining großer Funktionen erhöht die Größe Ihres Codes. Daher empfiehlt es sich, diese Funktion nur für einfache Funktionen zu verwenden, die häufig verwendet werden, z. B. myWith(). Die Erweiterungsfunktionen aus den Bibliotheken, die Sie zuvor kennengelernt haben, sind mit inline gekennzeichnet. Sie müssen sich also keine Sorgen machen, dass zusätzliche Objekte erstellt werden.

„Single Abstract Method“ bedeutet nur eine Schnittstelle mit einer Methode. Sie sind sehr häufig, wenn APIs verwendet werden, die in der Programmiersprache Java geschrieben wurden. Daher gibt es ein Akronym dafür: SAM. Beispiele sind Runnable mit der einzelnen abstrakten Methode run() und Callable mit der einzelnen abstrakten Methode call().

In Kotlin müssen Sie ständig Funktionen aufrufen, die SAMs als Parameter verwenden. Probieren Sie das folgende Beispiel aus.

Erstellen Sie in example eine Java-Klasse, JavaRun, und fügen Sie Folgendes in die Datei ein.

package example;

public class JavaRun {
    public static void runNow(Runnable runnable) {
        runnable.run();
    }
}

In Kotlin können Sie ein Objekt instanziieren, das eine Schnittstelle implementiert, indem Sie dem Typ object: voranstellen. Dies ist nützlich, um Parameter an SAMs zu übergeben.

Erstelle in Fish.kt eine Funktion runExample(), die mit object: ein Runnable erstellt. Das Objekt sollte run() implementieren, indem "I'm a Runnable" ausgegeben wird.

fun runExample() {
    val runnable = object: Runnable {
        override fun run() {
            println("I'm a Runnable")
        }
    }
}

Rufen Sie JavaRun.runNow() mit dem von Ihnen erstellten Objekt auf.

fun runExample() {
    val runnable = object: Runnable {
        override fun run() {
            println("I'm a Runnable")
        }
    }
    JavaRun.runNow(runnable)
}

Rufen Sie runExample() über main() auf und führen Sie das Programm aus.

⇒ I'm a Runnable

Es ist viel Arbeit, etwas zu drucken, aber es ist ein gutes Beispiel dafür, wie ein SAM funktioniert. In Kotlin gibt es natürlich eine einfachere Möglichkeit, dies zu tun: Verwenden Sie anstelle des Objekts ein Lambda, um diesen Code viel kompakter zu gestalten.

Entfernen Sie den vorhandenen Code in runExample, ändern Sie ihn so, dass runNow() mit einem Lambda aufgerufen wird, und führen Sie das Programm aus.

fun runExample() {
    JavaRun.runNow({
        println("Passing a lambda as a Runnable")
    })
}

⇒ Passing a lambda as a Runnable

Mit der Syntax für den letzten Parameteraufruf können Sie das noch kompakter gestalten und die Klammern entfernen.

fun runExample() {
    JavaRun.runNow {
        println("Last parameter is a lambda as a Runnable")
    }
}

⇒ Last parameter is a lambda as a Runnable

Das sind die Grundlagen einer SAM, einer Single Abstract Method. Sie können ein SAM mit einer Zeile Code instanziieren, überschreiben und aufrufen. Verwenden Sie dazu das Muster:
Class.singleAbstractMethod { lambda_of_override }

In dieser Lektion haben Sie Lambdas kennengelernt und sich genauer mit Funktionen höherer Ordnung beschäftigt, die wichtige Bestandteile von Kotlin sind. Außerdem haben Sie etwas über Anmerkungen und gekennzeichnete Pausen gelernt.

Mit Annotationen können Sie dem Compiler bestimmte Informationen mitteilen. Beispiel:
@file:JvmName("Foo")
Verwenden Sie Labels für Breaks, damit Ihr Code aus verschachtelten Schleifen herausspringen kann. Beispiel:
if (i > 10) break@outerLoop // breaks to outerLoop label
In Kombination mit Funktionen höherer Ordnung können Lambdas sehr leistungsstark sein.
Lambdas sind Objekte. Um das Erstellen des Objekts zu vermeiden, können Sie die Funktion mit inline markieren. Der Compiler fügt dann den Inhalt des Lambda-Ausdrucks direkt in den Code ein.
Verwenden Sie inline mit Bedacht, da es die Ressourcennutzung Ihres Programms reduzieren kann.
SAM (Single Abstract Method) ist ein gängiges Muster, das mit Lambdas vereinfacht wird. Das grundlegende Muster ist:
Class.singleAbstractMethod { lamba_of_override }
Die Kotlin-Standardbibliothek bietet zahlreiche nützliche Funktionen, darunter mehrere SAMs. Machen Sie sich also damit vertraut.

Kotlin bietet noch viel mehr als das, was in diesem Kurs behandelt wurde. Sie haben jetzt aber die Grundlagen, um mit der Entwicklung eigener Kotlin-Programme zu beginnen. Wir hoffen, dass Sie sich für diese ausdrucksstarke Sprache begeistern und darauf freuen, mehr Funktionalität zu schaffen, während Sie weniger Code schreiben (insbesondere, wenn Sie von der Programmiersprache Java kommen). Übung und Lernen sind der beste Weg, um ein Experte in Kotlin zu werden. Informieren Sie sich also weiter über Kotlin.

Kotlin-Dokumentation

Wenn Sie weitere Informationen zu einem Thema in diesem Kurs benötigen oder nicht weiterkommen, ist https://kotlinlang.org der beste Ausgangspunkt.

Kotlin-Tutorials

Die Website https://try.kotlinlang.org enthält umfangreiche Tutorials namens „Kotlin Koans“, einen webbasierten Interpreter und eine vollständige Referenzdokumentation mit Beispielen.

Udacity-Kurs

Den Udacity-Kurs zu diesem Thema finden Sie unter Kotlin Bootcamp for Programmers.

IntelliJ IDEA

Dokumentation für IntelliJ IDEA finden Sie auf der JetBrains-Website.

Kotlin-Standardbibliothek

Die Kotlin-Standardbibliothek bietet zahlreiche nützliche Funktionen. Bevor Sie eine eigene Funktion oder Schnittstelle schreiben, sollten Sie immer in der Standardbibliothek nachsehen, ob Ihnen jemand Arbeit abgenommen hat. Schauen Sie regelmäßig vorbei, da häufig neue Funktionen hinzugefügt werden.

Kotlin-Tutorials

Die Website https://try.kotlinlang.org enthält umfangreiche Tutorials namens „Kotlin Koans“, einen webbasierten Interpreter und eine vollständige Referenzdokumentation mit Beispielen.

Udacity-Kurs

Den Udacity-Kurs zu diesem Thema finden Sie unter Kotlin Bootcamp for Programmers.

IntelliJ IDEA

Dokumentation für IntelliJ IDEA finden Sie auf der JetBrains-Website.

In diesem Abschnitt werden mögliche Hausaufgaben für Schüler und Studenten aufgeführt, die dieses Codelab im Rahmen eines von einem Kursleiter geleiteten Kurses durcharbeiten. Es liegt in der Verantwortung des Kursleiters, Folgendes zu tun:

Weisen Sie bei Bedarf Aufgaben zu.
Teilen Sie den Schülern/Studenten mit, wie sie Hausaufgaben abgeben können.
Benoten Sie die Hausaufgaben.

Lehrkräfte können diese Vorschläge nach Belieben nutzen und auch andere Hausaufgaben zuweisen, die sie für angemessen halten.

Wenn Sie dieses Codelab selbst durcharbeiten, können Sie mit diesen Hausaufgaben Ihr Wissen testen.

Beantworten Sie diese Fragen

Frage 1

In Kotlin steht SAM für:

▢ Sicherer Argumentabgleich

▢ Einfache Zugriffsmethode

▢ Einzelne abstrakte Methode

▢ Strategische Zugriffsmethode

Frage 2

Welche der folgenden Optionen ist keine Erweiterungsfunktion der Kotlin-Standardbibliothek?

▢ elvis()

▢ apply()

▢ run()

▢ with()

Frage 3

Welche der folgenden Aussagen über Lambdas in Kotlin ist nicht richtig?

▢ Lambdas sind anonyme Funktionen.

▢ Lambdas sind Objekte, sofern sie nicht inline sind.

▢ Lambdas sind ressourcenintensiv und sollten nicht verwendet werden.

▢ Lambdas können an andere Funktionen übergeben werden.

Frage 4

Labels in Kotlin werden mit einer Kennung gefolgt von:

▢ :

▢ ::

▢ @:

▢ @

Glückwunsch! Sie haben das Codelab „Kotlin Bootcamp for Programmers“ abgeschlossen.

Eine Übersicht über den Kurs mit Links zu anderen Codelabs finden Sie unter „Kotlin Bootcamp for Programmers: Welcome to the course“.

Kotlin Bootcamp für Programmierer 6: Funktionale Manipulation Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Einführung

Was Sie bereits wissen sollten

Lerninhalte

Aufgaben

Schritt 1: Neues Paket und neue Datei erstellen

Schritt 2: Eigene Anmerkung erstellen

Schritt 3: Gezielte Anmerkung erstellen

Schritt 1: Einfache Lambda-Funktion erstellen

Schritt 2: Filter-Lambda erstellen

Schritt 1: Neuen Kurs erstellen

Schritt 2: Funktion höherer Ordnung verwenden

Schritt 3: Funktion höherer Ordnung erstellen

Schritt 4: Weitere integrierte Erweiterungen ansehen

Kotlin-Dokumentation

Kotlin-Tutorials

Udacity-Kurs

IntelliJ IDEA

Kotlin-Standardbibliothek

Kotlin-Tutorials

Udacity-Kurs

IntelliJ IDEA

Beantworten Sie diese Fragen

Frage 1

Frage 2

Frage 3

Frage 4

Kotlin Bootcamp für Programmierer 6: Funktionale Manipulation