Kotlin Intensiv-Schulung: die ganze Sprache in einer Woche

Erste Schritte: Werkzeuge, Laufzeit und Plattformen

• Technische Anforderungen: JDK 17, 21 oder 25, IntelliJ IDEA und Gradle-Wrapper
• Kompilieren und Ausführen auf der Befehlszeile mit kotlinc und kotlin
• Ausführbares JAR mit -include-runtime und Kotlin-Skripte als .main.kts
• Die Kotlin-Laufzeit: kotlin-stdlib, Bytecode-Ziel jvmTarget und Kompatibilität
• Ausprobieren in Kotlin-Scratch-Dateien im interaktiven Modus statt im abgekündigten REPL von kotlinc
• IntelliJ IDEA im K2-Modus: Projekt anlegen, Refactorings, Bytecode-Ansicht
• Gradle-Projekt mit Kotlin DSL, jvmToolchain und Version Catalog
• Kotlin und Java in einem Projekt: src/main/kotlin neben src/main/java
• Kotlin 2 und der K2-Compiler: schnellere Builds, ein Frontend für alle Plattformen, K1 ab 2.4 entfernt
• Kotlin Multiplatform im Überblick: gemeinsamer Code für JVM, Android, iOS und Web
• Source Sets commonMain, jvmMain, iosMain und der Mechanismus expect/actual
• Compose Multiplatform und Kotlin/Wasm: Reifegrad und Einsatzfelder einordnen

Kotlin-Grundlagen: Variablen, Typen und Ausdrücke

• val und var: Unveränderlichkeit als Standard, const val für Konstanten
• Typinferenz: wo der Compiler den Typ ableitet und wo explizite Typen helfen
• Grundtypen: Zahlen, Boolean, Char, String, vorzeichenlose Typen, Umwandlungen
• Kommentare und KDoc, API-Dokumentation mit Dokka erzeugen
• Pakete und Dateistruktur: Paketname unabhängig vom Verzeichnis
• Importe, Alias mit as und die Standard-Importe der Standardbibliothek
• Zeichenketten-Vorlagen, Raw Strings mit trimIndent und Mehrfach-Dollar-Interpolation
• Bereiche mit .., ..<, downTo und step, Prüfungen mit in
• Schleifen: for, while, do-while, Labels mit break@ und continue@
• Ausnahmen: try als Ausdruck, throw vom Typ Nothing, keine Checked Exceptions
• Fehler als Rückgabewert mit runCatching und Result
• Klassen instanziieren ohne new, benannte Argumente im Konstruktoraufruf
• Referentielle Gleichheit === und strukturelle Gleichheit == über equals
• Der this-Ausdruck und qualifiziertes this@Klasse in verschachtelten Lambdas
• Sichtbarkeitsmodifikatoren public, internal, private auf Dateiebene
• Kontrollfluss als Ausdruck: if, when und try liefern Werte
• Die Nullsyntax ?, ?., ?: und !! im ersten Überblick
• Der when-Ausdruck: Bereiche, Typprüfungen, Guard-Bedingungen, Vollständigkeit
• Typhierarchie: Any, Unit, Nothing und ihre nullbaren Gegenstücke
• Vorbedingungen und Invarianten mit require, check und error
• Code-Verträge mit contract { }: returns und callsInPlace für Smart Casts

Objektorientierte Programmierung in Kotlin

• Klassen mit primärem Konstruktor, init-Blöcken und sekundären Konstruktoren
• Schnittstellen mit Standardimplementierungen und abstrakten Eigenschaften
• Vererbung: Klassen sind final, mit open und override gezielt freigeben
• Sichtbarkeit bei Vererbung: protected und internal über Modulgrenzen
• Abstrakte Klassen und abstrakte Mitglieder
• Schnittstelle oder abstrakte Klasse: Zustand, Konstruktoren, Mehrfachimplementierung
• Polymorphismus über Schnittstellen und offene Klassen, dynamischer Dispatch
• Regeln beim Überschreiben: Konflikte gleichnamiger Mitglieder mit super<Typ> lösen
• Vererbung versus Komposition: warum Kotlin standardmäßig final ist
• Klassendelegation mit by: Schnittstellen implementieren ohne Weiterleitungscode
• Versiegelte Klassen und Schnittstellen für abgeschlossene Hierarchien
• Enum-Klassen mit Eigenschaften und entries, Value Classes mit @JvmInline

Funktionen in Kotlin

• Funktionen definieren: Parameter, Rückgabetyp und Unit
• Einzelausdruck-Funktionen mit = und abgeleitetem Rückgabetyp
• Member-Funktionen in Klassen und object-Deklarationen
• Lokale Funktionen mit Zugriff auf Variablen der umgebenden Funktion
• Top-Level-Funktionen statt Utility-Klassen und ihre Abbildung als DateiKt
• Benannte Argumente für lesbare Aufrufe mit vielen Parametern
• Standardwerte für Parameter statt Überladungen
• Erweiterungsfunktionen: statische Auflösung, Sichtbarkeit und Grenzen
• Operatorüberladung mit operator fun: plus, get, invoke, compareTo
• Infix-Funktionen für lesbare Ausdrücke wie 1 to "eins"
• Funktionsliterale: Lambdas und anonyme Funktionen als Werte
• Rekursive Funktionen und Endrekursion mit tailrec
• Variable Argumentanzahl mit vararg und Spread-Operator *
• Scope-Funktionen der Standardbibliothek: let, run, apply, also, with
• Weitere Hilfsfunktionen: takeIf, repeat, buildList, buildString
• Generische Funktionen mit Typparametern
• Reine Funktionen ohne Seiteneffekte: testbar und gut kombinierbar
• Java-Code in Kotlin aufrufen: Getter als Eigenschaften, SAM-Konvertierung
• Kotlin-Code aus Java aufrufen: @JvmStatic, @JvmOverloads, @JvmName, @Throws

Eigenschaften in Kotlin

• Warum Eigenschaften statt Felder: Zugriffslogik ohne Getter-Setter-Boilerplate
• Getter und Setter überschreiben, Backing Field field
• Sichtbarkeit von Settern einschränken mit private set
• Späte Initialisierung mit lateinit und Prüfung über ::prop.isInitialized
• Delegierte Eigenschaften und eigene Delegates mit getValue und setValue
• Eigenschaften an eine Map delegieren, z. B. für Konfigurationswerte
• lateinit versus lazy: Thread-Sicherheit, Initialisierungszeitpunkt, Einsatz
• Beobachtbare Eigenschaften mit Delegates.observable und vetoable
• Nicht-Null-Eigenschaften mit Delegates.notNull ohne Startwert

Nullsicherheit, Reflection und Annotationen

• Nullbare Typen im Typsystem: String und String? sind verschiedene Typen
• Intelligente Typumwandlung: Smart Casts nach is- und Null-Prüfungen
• Sicherer Zugriff mit ?. und Verkettung mit let
• Der Elvis-Operator ?: mit Standardwert, return oder throw
• Sichere Konvertierung mit as? statt ClassCastException
• Optionale Parameter: Standardwerte oder nullbare Typen bewusst wählen
• Plattformtypen aus Java-Bibliotheken und Nullability-Annotationen wie JSpecify
• Reflection mit KClass, KProperty, ::class und der Bibliothek kotlin-reflect
• Konstruktoren per Reflection aufrufen: primaryConstructor und callBy
• Objekte und Companion-Objekte: Singletons, Factory-Funktionen, statische Mitglieder
• Annotationen deklarieren und anwenden, Use-Site-Targets @field:, @get:, @param:
• Annotationsverarbeitung mit KSP statt kapt

Generics in Kotlin

• Parametrisierte Funktionen und Typinferenz beim Aufruf
• Parametrisierte Typen: generische Klassen und Schnittstellen
• Begrenzter Polymorphismus: obere Schranken und where-Klauseln
• Varianz an der Deklaration: out für Erzeuger, in für Verbraucher
• Der Typ Nothing als Untertyp aller Typen, z. B. bei emptyList() und TODO()
• Typprojektion an der Verwendungsstelle und Stern-Projektion *
• Typlöschung auf der JVM und ihre Folgen für Überladungen und Prüfungen
• Typprüfung zur Laufzeit mit reified-Typparametern in Inline-Funktionen
• Rekursive Typgrenzen wie T : Comparable<T>
• Algebraische Datentypen aus sealed-Hierarchien und Datenklassen
• Definitiv nicht-nullbare Typen T & Any bei generischem Java-Code

Datenklassen in Kotlin

• Einführung in Datenklassen: Wertobjekte mit einer Zeile Code
• Automatisch erzeugte Getter und Setter aus val- und var-Eigenschaften
• Generierte Methoden copy, toString, hashCode, equals und componentN
• Regeln für Datenklassen: Primärkonstruktor, nicht open, nur Konstruktoreigenschaften zählen
• Destrukturierende Deklarationen in val, for-Schleifen und Lambdas
• Destrukturierte Typen: Pair, Triple und eigene componentN-Operatoren
• data object für zustandslose Fälle in sealed-Hierarchien
• Datenklassen als Java Records veröffentlichen mit @JvmRecord

Collections und Sequenzen in Kotlin

• Klassenhierarchie: Iterable, Collection, List, Set, Map und Mutable-Varianten
• Arrays: Array<T> und primitive Arrays wie IntArray für Interop und Performance
• Listen erzeugen und bearbeiten: listOf, mutableListOf, buildList
• Maps: mapOf, getOrPut, withDefault und Iteration über Einträge
• Sets und Mengenoperationen union, intersect und subtract
• Schreibgeschützte Ansichten sind nicht unveränderlich: Sicht versus Kopie
• Indizierter Zugriff mit [], getOrNull und getOrElse
• Sequenzen: verzögerte Auswertung, generateSequence und sequence { yield() }
• Sammeloperationen: groupBy, associateBy, fold, windowed, zip

Funktionen höherer Ordnung und funktionale Programmierung

• Funktionen höherer Ordnung: Funktionstypen als Parameter und Rückgabewerte
• Closures: Lambdas mit Zugriff auf veränderliche Variablen der Umgebung
• Anonyme Funktionen und ihr lokales return im Vergleich zu Lambdas
• Funktionsreferenzen mit ::, gebundene Referenzen und Konstruktorreferenzen
• Funktionstypen mit Empfänger T.() -> R als Grundlage für Builder
• Funktionen in der JVM: Lambdas über invokedynamic, fun interface für SAM
• Komposition von Funktionen mit eigenen Erweiterungsfunktionen
• Inline-Funktionen, noinline, crossinline und nicht-lokale Rückgaben
• Currying und partielle Anwendung mit Funktionstypen
• Memoisierung reiner Funktionen mit Maps und lazy
• Typaliase für lange Funktions- und Generic-Typen
• Typisierte Fehler mit Arrow: Either, either { } und raise
• Benutzerdefinierte DSLs mit @DslMarker für Konfiguration, HTML und Tests
• Validierung mit Fehlerakkumulation: zipOrAccumulate und NonEmptyList

Coroutines und Flow in Kotlin

• Unterbrechbare Funktionen mit suspend und das Prinzip der Fortsetzung
• Coroutine-Builder launch, async und runBlocking
• Strukturierte Nebenläufigkeit mit coroutineScope und Eltern-Kind-Beziehungen
• Jobs: Lebenszyklus, join, cancelAndJoin und SupervisorJob
• Kontext und Anwendungsbereich: CoroutineContext, CoroutineScope, withContext
• Abbruch und Scheitern: kooperativer Abbruch, ensureActive, withTimeout
• Parallele Ergebnisse mit async, await und awaitAll
• Dispatcher Default, IO, Main und limitedParallelism
• Fehlerbehandlung mit CoroutineExceptionHandler und supervisorScope
• Kalte Datenströme mit Flow: Operatoren, flowOn, catch und Gegendruck
• StateFlow, SharedFlow und Channel für Zustand und Ereignisse
• Coroutines testen mit runTest und virtueller Zeit

Serialisierung mit kotlinx.serialization

• Einrichtung: Compiler-Plugin und Laufzeitbibliothek in Gradle
• Konfiguration von Json: ignoreUnknownKeys, explicitNulls, prettyPrint
• JSON serialisieren und deserialisieren mit @Serializable, encodeToString, decodeFromString
• Protobuf-Serialisierung mit ProtoBuf und @ProtoNumber
• Anmerkungen und Regeln: @SerialName, @Transient, Standardwerte, polymorphe sealed-Typen
• Eigene Serializer für Typen wie Instant oder Value Classes

Testen in Kotlin

• Grundlagen: kotlin.test auf JUnit 5 und Testausführung mit Gradle
• Kotest: einen Spec-Stil auswählen – FunSpec, StringSpec oder BehaviorSpec
• Projekt-Konfiguration von Kotest, Matcher und assertSoftly
• Prüfung von Eigenschaften: Property-based Testing mit Arb-Generatoren
• Tabellengesteuertes Testen mit Datentests und withData
• Tags, Bedingungen und Konfiguration: Tests gezielt ein- und ausschließen
• Mocking mit MockK: every, verify und coEvery für suspend-Funktionen
• Codequalität mit detekt, ktlint und Testabdeckung über Kover

Kotlin mit Junie und anderen Coding-Agenten

• Junie in IntelliJ IDEA: Kotlin-Aufgaben mit ./gradlew test als Abschlussbedingung formulieren
• allWarningsAsErrors im Kotlin-Compiler, damit Agentenänderungen keine Warnungen hinterlassen
• Explicit-API-Modus explicitApi(): der Agent muss Sichtbarkeit und Rückgabetypen ausschreiben
• Vom Agenten umgeschriebene Kotlin-Funktionen mit Kotest-Eigenschaftstests gegen das Original prüfen
• Varianzfehler und Typinferenz-Probleme vom Agenten erklären lassen, die Lösung selbst wählen
• Typische Agentenmuster zurückweisen: verschachtelte Scope-Funktionen, GlobalScope, unnötige var

Praxisprojekt: Veranstaltungsplaner mit eigener DSL

• Domänenmodell für Termine, Räume und Teilnehmende mit sealed-Typen, Datenklassen und Value Classes
• Typsichere DSL mit @DslMarker, in der Veranstaltungen und Räume beschrieben werden
• Raumkonflikte mit Collections und Sequenzen erkennen, Fehler mit Either sammeln
• Verfügbarkeiten parallel per Coroutines abfragen, Ergebnis als JSON speichern
• Planungsregeln mit Kotest-Eigenschaftstests und MockK absichern