Inhaltsverzeichnis - mitp · Inhaltsverzeichnis 8 7.4.2 Anonyme Klassen via Objekt-Ausdruck . . . ....

5

Inhaltsverzeichnis

Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1 Eigenschaften von Kotlin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211.1 Eine neue Sprache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211.2 Kotlin und Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231.3 Vorteile von Kotlin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241.4 Ziele der Entwicklung von Kotlin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

1.4.1 Übersichtlichkeit, präziser Ausdruck . . . . . . . . . . . . . . . . . . . 251.4.2 Sicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281.4.3 Interoperabilität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

2 Arbeiten mit Kotlin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332.1 Entwicklungsumgebung einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

2.1.1 IntelliJ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332.1.2 Android Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

2.2 Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392.2.1 Kotlin-Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402.2.2 Kotlin-Compiler mit Gradle. . . . . . . . . . . . . . . . . . . . . . . . . . . 402.2.3 Integrierte Entwicklungsumgebungen/IDE. . . . . . . . . . . . . . 412.2.4 Konvertierung von existierendem Code . . . . . . . . . . . . . . . . . 41

3 Kotlin by example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433.1 Hello world! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443.2 Hello null! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

3.2.1 Ein erster Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473.2.2 Eine erste Exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483.2.3 Eine erste Variable – Null-Sicherheit . . . . . . . . . . . . . . . . . . . 493.2.4 Let und Lambdas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503.2.5 Eine erste Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

3.3 Hello Android! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553.4 Hello Kotlin!. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

4 Grundlagen und Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634.1 Expressions vs. Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

© des Titels »Kotlin« (ISBN 9783958458536) 2020 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/853

Inhaltsverzeichnis

6

4.2 Strukturierung von Code durch Dateien, Klassen, Funktionen und Blöcke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

4.3 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 694.3.1 Direkte Funktionsaufrufe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704.3.2 Benutzung von Lambdas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

4.4 Variablen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724.4.1 Deklaration: Immutable vs. Mutable, Zuweisung . . . . . . . . . 744.4.2 Typen und Typsicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 774.4.3 Null-Sicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 774.4.4 Typinferenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 844.4.5 Generics benutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 854.4.6 Boxing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

4.5 Besonderheiten der Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 884.5.1 Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 884.5.2 Boolean . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 904.5.3 Chars und Strings – Zeichen und Zeichenketten . . . . . . . . . 904.5.4 Objekte und Any . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 934.5.5 Arrays und Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 944.5.6 Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 984.5.7 Ranges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

5 Grundstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1015.1 Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1015.2 Verzweigungen mit if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1015.3 Verzweigung mit when . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1035.4 Schleifen mit for und while. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

5.4.1 for-Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1065.4.2 while-Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1095.4.3 repeat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1105.4.4 break/named break und continue . . . . . . . . . . . . . . . . . . . . . . 1105.4.5 Funktionsbasierte Alternativen . . . . . . . . . . . . . . . . . . . . . . . . 112

5.5 Exception Handling mit try/catch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1145.6 Annotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1165.7 Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

5.7.1 Type-Casting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1195.7.2 Type-Casting und null . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1205.7.3 Smart Casts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1215.7.4 Type Aliases. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122


Inhaltsverzeichnis

7

6 Funktionen und Lambdas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1256.1 Funktionale Entwicklung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1256.2 Syntax von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

6.2.1 Kurzformen von Funktionsdefinitionen. . . . . . . . . . . . . . . . . 1296.2.2 Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1296.2.3 Variable Anzahl von Parametern . . . . . . . . . . . . . . . . . . . . . . 1316.2.4 Rückgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1326.2.5 Destrukturierende Deklarationen . . . . . . . . . . . . . . . . . . . . . . 1336.2.6 Kombination mehrerer Funktionsaufrufe . . . . . . . . . . . . . . . 135

6.3 Höhere Funktion und Lambdas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1366.3.1 Funktionen als Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1366.3.2 Funktionstyp für Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

6.4 Chaining von Lambdas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1386.5 Rekursive Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1386.6 Spezielle Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

6.6.1 Lokale Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1396.6.2 Inline-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1416.6.3 Infix-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1436.6.4 Actual-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1436.6.5 Überladene Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

7 Packages, Klassen und Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1457.1 Architektur und Entwurf. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1457.2 Packages, Klassen und Interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

7.2.1 Klassen und Interfaces organisieren das Modell . . . . . . . . . . 1467.2.2 Klassen und Interfaces, Vererbung . . . . . . . . . . . . . . . . . . . . . 1467.2.3 Packages organisieren das Projekt . . . . . . . . . . . . . . . . . . . . . 1497.2.4 Sichtbarkeitsmodifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1517.2.5 Import . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

7.3 Von der Klasse zum Objekt – Meet the members . . . . . . . . . . . . . . . 1547.3.1 Konstruktoren und Initializer . . . . . . . . . . . . . . . . . . . . . . . . . 1547.3.2 Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1587.3.3 Custom Getter/Setter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1597.3.4 Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1617.3.5 Innere Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1637.3.6 Companion Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

7.4 Objekt-Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1667.4.1 Singletons via Objekt-Deklaration. . . . . . . . . . . . . . . . . . . . . . 166


Inhaltsverzeichnis

8

7.4.2 Anonyme Klassen via Objekt-Ausdruck . . . . . . . . . . . . . . . . . 1687.4.3 Object-Statements bei Rückgaben . . . . . . . . . . . . . . . . . . . . . . 169

7.5 Datenklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1707.6 Generics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

7.6.1 Generische Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

7.6.2 Beschränkung der Typen: Invariant, Kovariant, Kontravariant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

7.6.3 Generische Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1777.6.4 Reified parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

7.7 Enum classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1797.8 Sealed classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1817.9 Extensions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1827.10 Destrukturierende Deklarationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184

8 Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1878.1 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

8.1.1 Unit-Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1888.1.2 Integrationstests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1888.1.3 Testsuite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1898.1.4 Mocking und Dependency Injection . . . . . . . . . . . . . . . . . . . . 1898.1.5 Konkret: Wie werden Tests geschrieben? . . . . . . . . . . . . . . . . 190

8.2 Erster JUnit-Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1918.3 Einrichten eines Testprojekts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1938.4 Praxisbeispiel: Verkleinern von Funktionen . . . . . . . . . . . . . . . . . . . . 1948.5 Das Testresultat lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2008.6 Der Test von Hello world! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2028.7 Test einer Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2048.8 Parametrisierte Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2078.9 Testing Kotlin-Style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

8.9.1 Testkomponenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2088.9.2 Spek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2108.9.3 Kotlintest.io . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2108.9.4 kotlin.test: Unit-Tests in Multiplattform-Projekten . . . . . . . . 211

9 Kotlin für Fortgeschrittene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2159.1 Alles zusammenbringen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2159.2 Zielplattformen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2169.3 Kotlin-Standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217

9.3.1 run, let, apply, with, also . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218


Inhaltsverzeichnis

9

9.3.2 Takeif/Takeunless . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2239.3.3 Collections, Arrays und Listen. . . . . . . . . . . . . . . . . . . . . . . . . 2249.3.4 Operationen auf allen iterierbaren Elementen. . . . . . . . . . . . 2269.3.5 Texttools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2339.3.6 Reflection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234

9.4 Delegation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2369.4.1 Property Delegation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2379.4.2 Class Delegation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241

9.5 Service Location/Dependency Injection . . . . . . . . . . . . . . . . . . . . . . . 2469.5.1 Warum eigentlich? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2479.5.2 Service Locator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2489.5.3 Dependency Injection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251

9.6 Coroutines und Nebenläufigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2539.6.1 Launch und Scopes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2539.6.2 Async, Await und Deferred . . . . . . . . . . . . . . . . . . . . . . . . . . . 2579.6.3 Producer, Consumer und Actor . . . . . . . . . . . . . . . . . . . . . . . 258

9.7 Contracts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2589.8 Idiomatischer Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261

9.8.1 Unveränderliche/immutable Variablen . . . . . . . . . . . . . . . . . 2619.8.2 Kurzformen für null. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2629.8.3 Kurzschreibweisen für Funktionen . . . . . . . . . . . . . . . . . . . . 2629.8.4 Nutzung von Class Properties . . . . . . . . . . . . . . . . . . . . . . . . . 2629.8.5 Chaining von nicht chainbaren Aufrufen. . . . . . . . . . . . . . . . 2629.8.6 Extensions nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2639.8.7 DSL mit Lambdas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2639.8.8 Infix-Notation für klare Sätze . . . . . . . . . . . . . . . . . . . . . . . . . 263

10 Kotlin für Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26510.1 Android <3 Kotlin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26510.2 Android-Komponenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266

10.2.1 Package-Level und Überblick. . . . . . . . . . . . . . . . . . . . . . . . . . 26610.2.2 Klassenlevel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267

10.3 Bestandteile des Android-Frameworks . . . . . . . . . . . . . . . . . . . . . . . . 27010.3.1 Activities und Fragmente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27110.3.2 Eine minimale App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27210.3.3 Views, Rendering und Layouting . . . . . . . . . . . . . . . . . . . . . . 27510.3.4 Der Lifecycle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28210.3.5 Android Architecture Components. . . . . . . . . . . . . . . . . . . . . 283


Inhaltsverzeichnis

10

10.4 Architektur für größere App-Projekte . . . . . . . . . . . . . . . . . . . . . . . . . 28510.5 Das Architekturmodell MVP(I). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286

10.5.1 Der Vertrag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28710.5.2 Initialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28810.5.3 Daten laden und initiale UI erstellen . . . . . . . . . . . . . . . . . . . 289

10.5.4 Mehrere Presenter/Komponenten . . . . . . . . . . . . . . . . . . . . . 29210.5.5 Updates der UI und Reagieren auf Dateneingaben . . . . . . . . 293

10.6 Das Architekturmodell MVVM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29610.6.1 MVVM-Komponenten anlegen . . . . . . . . . . . . . . . . . . . . . . . . 29710.6.2 Initialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29710.6.3 Daten laden und initiale UI erstellen . . . . . . . . . . . . . . . . . . . 29810.6.4 Updates der UI und Reagieren auf Dateneingaben . . . . . . . . 301

10.7 MVP oder MVVM? It depends ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30210.8 Erweiterung von Android-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30210.9 Android und Coroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30310.10 Delegation für Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304

10.10.1 Property Delegation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30410.10.2 Klassendelegation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306

11 Zielplattformen für Kotlin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31111.1 Multiplattform-Logik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31111.2 Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312

11.2.1 Java-Libraries. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31211.2.2 Reflection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31211.2.3 Streams (Java 8) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31411.2.4 Java Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31411.2.5 Java Annotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31411.2.6 Annotation Use-Site Target . . . . . . . . . . . . . . . . . . . . . . . . . . . 317

11.3 JavaScript in Kotlin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31811.3.1 Einrichtung oder: Wie geht denn das? . . . . . . . . . . . . . . . . . . 31811.3.2 Grundsätzliches zu Kotlin und JS . . . . . . . . . . . . . . . . . . . . . . 31811.3.3 Standalone JS-App . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

11.4 JS-Standard-Bibliothek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32011.4.1 Dynamic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32111.4.2 Promises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32211.4.3 Browser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32211.4.4 JSON-Parsing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32411.4.5 Nutzung von JS-Bibliotheken/-Aufrufen . . . . . . . . . . . . . . . . 326


Inhaltsverzeichnis

11

11.5 Konvertierung von existierendem Java-Code zu JS . . . . . . . . . . . . . . . 32711.6 Konvertierung und Bearbeitung von existierendem JS-Code. . . . . . . 32811.7 Multiplattform-Projekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328

11.7.1 Ein Multiplattform-Projekt beginnen . . . . . . . . . . . . . . . . . . . 33011.7.2 Expected/Actual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333

11.8 Native . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338

12 Rück- und Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339

A Referenztabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341A.1 Factories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341

A.1.1 Factories für Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341A.1.2 Factories für Listen und Maps. . . . . . . . . . . . . . . . . . . . . . . . . 342

A.2 Konvertierung von Listen/Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342A.3 Operationen auf allen iterierbaren Elementen . . . . . . . . . . . . . . . . . . 343

A.3.1 Zugriff auf einzelne Elemente . . . . . . . . . . . . . . . . . . . . . . . . 343A.3.2 Zugriff auf Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344A.3.3 Iteration über alle oder viele Elemente . . . . . . . . . . . . . . . . . . 344A.3.4 Manipulation von Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345A.3.5 Manipulation von Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346

Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347


13

Einleitung

Fast jeder kennt das unangenehme Gefühl, einer wildfremden Person zuzuwin-ken, weil man kurz dachte, die freundliche Geste gälte einem selbst. Galt sie natür-lich nicht, sondern der Person, die sich in direkter Linie hinter der eigenenSchulter im toten Winkel versteckte. Auf der Google I/O 2017 habe ich erlebt, wiesich ein ganz ähnliches Empfinden einstellt, wenn man eine halbe Stunde lang ineine Fernsehkamera blickt, die in etwas mehr als Armeslänge vor einem positio-niert ist. Selbstverständlich wusste ich, dass es keinen Grund gab, mich in dieserWeise zu portraitieren. Doch nach fünf Minuten ... und weiteren zehn ... es konntedoch nicht?

Konnte es natürlich nicht. Es ging um einen 17-jährigen High-School Studenten,den der Lebensweg seiner Eltern als Einwanderer aus Afghanistan und die inAmerika erlebte Hilfsbereitschaft inspiriert hat, selbst etwas zurückzugeben. Inder Reihe vor mir. Sein Projekt verbesserte ohne teure Hardware die Aussagefähig-keit von Mammographien mithilfe von künstlicher Intelligenz. Die von ihm pro-grammierten Routinen erkennen Muster in den Bildern und können so auch ohnemedizinisches Fachpersonal präzisere Vorabdiagnosen zur Verfügung stellen.1

Eine knappe halbe Stunde zuvor gab es eine Ankündigung, die mir diesen Tagauch ohne die bemerkenswert große Kamera im Gedächtnis gehalten hätte: DieAnkündigung von Stephanie Saad Cuthbertson (Director Product ManagementAndroid zu der Zeit), Kotlin zu einer vollständig unterstützten Programmierspra-che für Android zu erklären und mit dem Entwickler JetBrains eine Gesellschaftzur Weiterentwicklung der Sprache zu gründen. Kotlin ist eine vergleichsweisejunge Programmiersprache, deren erste stabile Version 2016 erschien. Seit 2011wird sie von einem Team des Herstellers der Entwicklungsumgebung IntelliJ wei-terentwickelt und gepflegt. Hier besteht auch die offensichtliche Verbindung zuJava und Android, denn auch die von Google primär unterstützte IDE (IntegratedDevelopment Environment oder Entwicklungsumgebung) Android Studio basiertauf IntelliJ.

Dadurch war auch gewährleistet, dass es in Bezug auf die Tools keiner großen Um-gewöhnung bedurfte. Und so haben sicherlich einige Android-Entwickler nach

1 Im Video der Keynote bei 1:50:50 können sich die Leserinnen und Leser dieses Buchs ein Bild von mir im Jahr 2017 machen. Ganz Kamera-Unprofi erkennt man auch den Moment, in dem ich begriffen habe, dass es ganz sicher nicht um mich geht.


Einleitung

14

dieser Ankündigung 2017 ihre ersten Schritte in Kotlin mithilfe der automati-schen Konvertierungsfunktion gemacht und schnell eines erkannt: Die neue Spra-che löst sofort Probleme im bestehenden Code ihrer Anwendung:

� Der Code wird kürzer und übersichtlicher

� Der Code wird sicherer

� Es ist kein Problem, Kotlin und Java miteinander in einem Projekt einzusetzen

� Keine Semikolons(!)

Oder, um es mit den Worten von Google und Jetbrains zu sagen: Wichtige Merk-male von Kotlin sind: Es ist effektiv durch präzise Schreibweisen (concise), sicher(safe) und gut mit verschiedenen Umgebungen zu integrieren (interoperable).

Wie das in der Praxis aussieht und warum ich schon nach den ersten Arbeitstagenmit Kotlin kein Java mehr sehen mochte, versuche ich in diesem Buch zu erklären.

Ausrichtung des Buchs

Dieses Buch soll Entwicklern einen Einstieg in die Programmiersprache Kotlinermöglichen. Es konzentriert sich auf die Grundlagen der Sprache und ihre Struk-turen, Befehle und Sprachfeatures. Zusätzlich zur Erläuterung der ursprüngli-chen Aufgabe als ein verbesserter Java-Ersatz wird das aktuelle HaupteinsatzfeldAndroid behandelt und wie Kotlin die Android-Entwicklung verbessern – oderneutral: verändern – kann. Dabei werden aber Kenntnisse von Android vorausge-setzt, um den Fokus auf die Sprache Kotlin beizubehalten.

Das vorliegende Buch möchte dazu motivieren, vor einem Volleinstieg in Kotlindie Konvertierung Schritt für Schritt zu probieren. Das Stichwort lautet Interope-rabilität. Auch in einem großen Java-Spring-Projekt können einzelne Featuresoder Klassen in Kotlin geschrieben oder in der Webanwendung einzelne Con-troller oder Datenklassen ergänzt werden. Bei den Beispielen benutze ich wenigFramework-Code und fokussiere mich auf die Umsetzung der Logik in Kotlin.Wenn, dann wird vor allem Android verwendet.

Generell ist es aber gut möglich, auch sein favorisiertes JavaScript- oder TypeScript-Framework weiterzunutzen. Je elaborierter die Build- und Deployment-Prozessejedoch sind, desto weniger kann ich als App-Entwickler Details der Umsetzungbeleuchten.

Darüber hinaus wagt das Kapitel 11 einen Ausflug in die Welt der Cross-Plattform-Entwicklung. Das ist wichtig für alle, deren Code in Zukunft aus einer Kotlin-Codebasis nicht nur auf Android-Smartphones oder im Browser laufen soll.


Zielgruppe

15

Zielgruppe

Dieses Buch ist für alle geschrieben, die sich für die Entwicklung mit Kotlin inte-ressieren und die bereits grundsätzliche Kenntnisse in der Softwareentwicklunghaben.

Dazu gehört zum Beispiel, dass Sie grundlegende Quelltext-Elemente wie Varia-blen, Konstanten, Kontrollstrukturen und Funktionen kennen und Ihnen Begrif-fe aus der objektorientierten Entwicklung wie Klasse, Objekt und Instanz geläu-fig sind. Programmierparadigmen und Muster der Softwareentwicklung werdenebenfalls nicht ausführlich erklärt, sondern vor allem dort erwähnt, wo es zumVerständnis der Unterschiede zwischen Kotlin und seinen Alternativen dient.Einblicke in die Programmiersprache Java helfen, sind aber nicht zwingend erfor-derlich.

Die meisten Entwickler sammeln ihre ersten Programmiererfahrungen in Kotlinnicht als Einsteiger in die Softwareentwicklung. Sie gehen mit Erwartungen ausbekannten Sprachen oder sogar mit existierendem Code an die Arbeit.

Mit Kotlin lässt sich in dieser Situation besonders gut arbeiten, denn es erfordertfür viele Entwickler (Java, Android) keinen Umstieg auf eine andere Entwicklungs-umgebung und verträgt sich mit bestehenden Infrastrukturen. Durch die hoheFlexibilität im Bereich der Interoperabilität ist es eine gute Strategie, in bestehen-dem Code einfach einmal einen konkreten Anwendungsfall zu ergänzen oder ein-zelne Klassen zu ersetzen. Damit können Entwicklungsteams eine informierteEntscheidung treffen, ohne zwangsläufig vor einem kompletten Neuanfang zustehen.

Aufbau des Buchs

Der Aufbau dieses Buchs folgt meinen Erfahrungen als Hands-On-Entwickler undGeschäftsführer einer Agentur, in der Softwareentwickler verschiedener Erfah-rungsstufen arbeiten.

In unserem Team haben alle Kotlin auf der Basis von Android kennengelernt. Siewaren und sind erfahrene Java-Entwickler und Experten in der Umsetzung vonApps. Wichtige Muster aus der App-Entwicklung und auch die Best Practices inAndroid waren also von vorneherein bekannt. Folgerichtig handelte es sich beiden ersten Experimenten denn auch eher um Java ohne Semikolons. Auf Basiseiner fundierten Kenntnis der APIs und Tools für die Android-Entwicklung hatsich erst im Verlauf der Projekte ein tieferes Verständnis für die weitergehendenMöglichkeiten von Kotlin entwickelt. Das scheint mir typisch für eine Sprache, dieentwickelt wurde, um den Unzulänglichkeiten einer existierenden Vorgängerin zubegegnen. Ich werde deshalb auf den folgenden Seiten ähnlich vorgehen.


Einleitung

16

In Kapitel 1 gebe ich zunächst einen Überblick über die Eigenschaften und Vorteilevon Kotlin, seine Konzepten und die positiven Effekte auf die eigene Codebasis.

In Kapitel 2 erläutere ich kurz die zur Verfügung stehenden Tools, die ich für dieersten Schritte empfehle.

Kapitel 3 enthält kommentierte Beispiele, um zunächst ein Gefühl für die Sprachezu geben und ihre Möglichkeiten zu erkunden. Für diejenigen Leser, die bereitsVorkenntnisse in Android oder zum Beispiel Java haben, wird dieser Einstieg viel-leicht für die ersten eigenen Versuche ausreichen. Einsteiger können dieses Kapitelauch erst mal überspringen. In den darauffolgenden Kapiteln folgt die systemati-sche Betrachtung der einzelnen Sprachelemente.

Kapitel 4 stellt die grundlegende Syntax von Kotlin in den Mittelpunkt, und kon-zentriert sich auf die Grundstrukturen von Programmen und die Datentypen.

Tipp: Schnelleinstieg mit Kotlin KOANS

Wer direkt sehen möchte, wie Kotlin funktioniert, dem sei schon an dieser Stellehttps://kotlinlang.org empfohlen. Unter dem Menüpunkt LEARN findensich dort die sogenannten Kotlin Koans – kleine Übungen, die direkt im Browserkompiliert und getestet werden. Darüber hinaus zeigen sie auch, wie man vonAnfang an mit Tests sinnvolle Validierungen der eigenen Überlegungen durch-führen kann. Insofern ein Must-Read (and try) für den angehenden Kotlin-Ent-wickler.

Auch die Beispiele aus dem Buch können aus dem GitHub-Repository dorthinkopiert, ausprobiert und variiert werden.

In Kapitel 5 werden die Kontrollstrukturen vorgestellt. Es geht also um Verzwei-gen und Wiederholen – und weitere daran angelehnte Sprachfeatures.

Das Kapitel 6 widmet sich den Funktionen und ihren verschiedenen Sonderfor-men. Ich werde dort eine längere Zeit mit höheren Funktionen und Lambdas ver-bringen, aber auch die Grundlagen von Funktionen ausführlich erklären.

Darauf folgt in Kapitel 7 ein ausführlicher Block zu den objektorientierten Antei-len von Kotlin. Hier geht es um alle Besonderheiten von Klassen, Objekten undFunktionen im Zusammenspiel. Dafür wird neben einzelnen Code-Schnipselnein erstes Projekt vorgestellt.

Dieses Projekt beinhaltet eine Expression-Bibliothek, die in der Lage ist, mathema-tische Ausdrücke zu interpretieren und auszurechnen. Bislang liegt dieser Open-Source-Code in Objective-C, Swift und Java vor, in diesem Kapitel entsteht eineKotlin-Version sowie eine Kommandozeilen-Anwendung, die sie nutzbar macht.


Downloads zum Buch

17

Kapitel 8 ist dem Thema automatische Tests in Kotlin gewidmet. Für die Nutzungder Test-Frameworks werden die Inhalte der vorherigen Kapitel als Handwerks-zeug benötigt. Die Tests selbst beziehen sich vor allem auf das Testen von Funk-tionen und Klassen.

Kapitel 9 steigt tiefer in die komplexeren Konzepte von Kotlin ein, die auf dieserBasis aufbauen. Thema ist hier die Organisation von größeren Projekten durchArchitekturmuster. Die Nebenläufigkeit mit Kotlin-Coroutines nimmt einen gutenTeil des Kapitels ein und last but not least bespreche ich die Veränderungen imDenken und im Code, die sich aus der Kombination von funktionalem und objekt-orientiertem Stil ergeben.

Kapitel 10 ist Android gewidmet – hier entsteht eine vollständige App in Kotlin.Auch wenn das Kapitel mit den Grundlagen beginnt, ist es hier nicht möglich, alleAspekte und Bibliotheken von Android zu behandeln. Der Schwerpunkt liegt aufmoderner Architektur und den Anteilen, die sich durch Kotlin besser umsetzenlassen.

Kotlin ist seit der Version 1.2 in Bezug auf Interoperabilität einen Schritt weiterge-kommen und bietet auch Optionen zum Kompilieren in JavaScript und nativeniOS-Code. Dazu mehr in Kapitel 11.

Downloads zum Buch

Im Repository https://github.com/kotlin-karlszwillus finden sich Android-Beispiele, die Kotlin-Portierung der Expression-Bibliothek und die Listings ausden anderen Kapiteln zum Ausprobieren, mit Sourcecode-Dokumentation.

Wer mit GitHub nicht vertraut ist, kann den Großteil der Inhalte auch über dieWebsite des Verlags herunterladen: www.mitp.de/853

Über die Projekte in diesem Buch

Es gibt im Buch kein durchgehendes Projekt, mit dem alle verschiedenen Bereichevon Kotlin gestreift werden. Vielmehr habe ich aus der Praxis verschiedene Ver-satzstücke aus Projekten herausgelöst, die einzelne Schritte und Techniken derjeweiligen Kapitel illustrieren. So können Sie sich auch einzelne Themen im Buchansehen, ohne sich in ein großes Beispielprojekt eindenken zu müssen.

Am Anfang des Buchs stehen noch die einzelnen Anweisungen und Ausdrückeim Mittelpunkt, hier handelt es sich um einfach gewählte Beispiele.

Damit ich in der Lage bin, auch komplexere Aufgaben zu zeigen, benutze ich eineOpen-Source-Bibliothek, die ich einmal von der Kommandozeile und später auchin einer App verwende. Sie stellt eine vollwertige Sprache zum Lösen von Ausdrü-


Einleitung

18

cken innerhalb von Formularen oder anderen Anwendungen zur Verfügung. IhrName ist NRExpressionLib, sie stammt vom iOS-Entwickler Nikolai Ruhe ausBerlin – wir haben in mehreren Projekten zusammengearbeitet. Da unsereFirma sie bereits von Swift nach Java portiert hat, gehe ich nun einen Schritt weiterund konvertiere sie in die Sprache Kotlin. Diese Aufgabe ist kein klassischer Ein-stiegspunkt, doch die Konvertierung, auch mithilfe der automatischen Konvertie-rungsfunktion, führte auch mich zu einigen interessanten Herausforderungen, andenen sich zum Beispiel die Inkompatibilitäten zwischen der Handhabung vonGenerics und den strengen Regeln für Typen bei Kotlin zeigen lassen.

Ein zweites Projekt stammt aus der Praxis und bildet eine Bibliothek von Medita-tionsübungen ab. Aufgaben wie Navigation und die Darstellung von Listen kannich anhand dieser Listings einfacher demonstrieren. Diese App steht nicht als voll-ständiges Codebeispiel zur Verfügung, sondern lediglich in Auszügen, bzw. ein-zelnen Komponenten, die ausprobiert werden können. Sie ist aber im Play Storeals »Key Meditation« kostenlos verfügbar.

Nicht alle Listings im Buch stammen aus diesen beiden Projekten. Einige steheneinfach für sich oder kommen in leicht abgewandelter Form aus dem Arbeitsalltageines App-Entwicklers.

� Die Codebeispiele im Buch sind daher Auszüge aus längeren Listings, die aufder Seite des Verlags unter www.mitp.de/853 und im öffentlichen Repositoryunter https://github.com/kotlin-karlszwillus zur Verfügung stehen.

� Auf eine vollständige Befehlsreferenz habe ich zugunsten der bekanntenOnline-Quellen verzichtet, der Anhang A enthält aber kürzere Übersichten zuden Standardpackages, die sich auch plattformübergreifend verwenden lassen.

� Eine Mischung von Deutsch und Englisch lässt sich nicht ganz vermeiden. BeiFachbegriffen gebe ich den englischen Versionen den Vorzug und verwendeeingedeutschte oder übersetzte Bezeichner nur dort, wo sie vergleichbar allge-meingültig sind.

Was nicht in diesem Buch steht

Jeder Autor entscheidet über Schwerpunkte und Inhalte eines Buchs, doch für deneinen oder anderen mag es wichtiger sein, welche Themen nicht behandelt wer-den. Für mich sind dies in aller Kürze: keine RX-basierte Entwicklung, so gut wiekeine experimentellen Features (mit Ausnahmen bei Coroutines und Contracts),kein Kotlin/Native und nur wenig über Multiplattform-Projekte.

Kotlin ist eine Sprache, deren Entwicklung noch in vollem Gang ist. Dabei werdenvor allem auch im Bereich der Interoperabilität immer wieder neue Welten er-schlossen. Mit der Version 1.2 ist Kotlin/Native dazugekommen, ein Setup für dieAnbindung verschiedener Umgebungen, die auf C und moderneren Ableitungen


Weiterentwicklung von Kotlin

19

davon basieren. Damit ist theoretisch ein Einstieg in die Entwicklung von iOS-und Desktop-Varianten möglich. Hierfür sind zum jetzigen Zeitpunkt noch sehrviel Wissen und Basteltalent in den ursprünglichen Sprachen notwendig, das mirfehlt. Ich freue mich aber auf weiteren Fortschritt in diesem Bereich.

Das zweite Thema, das lediglich gestreift wird, sind Multiplattform-Projekte. Tat-sächlich ist ein Projekt in einem solchen Szenario umgesetzt, doch die Unterstüt-zung ist auch in der Version 1.3 noch als experimentell gekennzeichnet. Ausdiesem Grund habe ich mich entschieden, auch diesen Teil nur anzureißen undfür eine spätere Ergänzung aufzuheben.

Zuletzt habe ich persönlich keine starke Zuneigung zur reaktiven Programmie-rung mit RxJava oder RxKotlin, auch wenn sie ihre Vorteile hat und auch regelmä-ßig Teil von datenintensiven Projekten ist. In der vorliegenden Ausgabe war mirder Fokus auf den Kotlin-eigenen Mechanismen im Bereich Coroutines, Observerund Mapping wichtiger. Für Android habe ich die Vorstellung von LiveData undViewModel vorgezogen, die in dem gleichen Bereich im Einsatz sind, der heutehäufig von Rx-Komponenten abgedeckt wird.

Weiterentwicklung von Kotlin

Ein wichtiges Anliegen habe ich in Bezug auf Aktualität und Updates der Sprache:Selbstverständlich werden sich von der Erstellung dieses Manuskripts bis zur Ver-öffentlichung Dinge ändern.

Insbesondere im Bereich von Bibliotheken verändern sich Möglichkeiten undAPIs schnell und häufig. Zwar habe ich darauf geachtet, welche Veränderungen zurErstellung des Manuskripts bereits absehbar waren, doch bereits mit dem nächstengrößeren Update können sich auch grundlegende Mechanismen ändern.

Als Beispiel seien hier die Coroutines genannt, die mit der Version 1.2 eingeführtwurden und ein Ersatz für Java-basiertes Multithreading sind. Daher möchte die-ses Buch vor allem die Grundlagen vermitteln, mit denen Sie funktionierenden,gut strukturierten und durchdachten Kotlin-Code erstellen können.

Über den Autor

Meine eigene Ausbildung nennt sich Medienwirt – ein Diplomstudium, das mirweitreichende Freiheiten und Interpretationsmöglichkeiten gewährt hat. So konnteich die Programmierung, bis dahin Hobby und Schulfach, auch an der Universitätweiterverfolgen, dann unter dem Stichwort »Neue Medien«. Heute arbeite ich alsGeschäftsführer der Agentur Karlmax Berlin an verschiedenen Kundenprojektenim Bereich Apps.


Einleitung

20

Meine tägliche Arbeit hat bis vor Kurzem auch noch stark in den Projekten stattge-funden, sodass ich auch mit Kotlin dort meinen ersten Kontaktpunkte hatte.

Unsere Agentur hatte das Glück, dass wir mit zwei Kunden zum Zeitpunkt derBekanntgabe von Kotlin als offizieller Entwicklungssprache für Android bereitsüber ein Jahr an Projekten mit Kotlin arbeiten durften. Die positiven Einflüsse aufeine Android-App kannten wir so bereits durch konkrete Projekte. Nicht zuletztmit dieser Erfahrung im Rücken möchte ich alle Entwickler aus dem Java- undAndroid-Umfeld einladen, sich mit Kotlin zu beschäftigen.


33

Kapitel 2

Arbeiten mit Kotlin

2.1 Entwicklungsumgebung einrichten

Um die ersten Schritte mit den Beispielen der kommenden Kapitel ausführen zukönnen, ist jetzt der Zeitpunkt, eine entsprechende Umgebung zu konfigurieren,um Kotlin auszuprobieren. Meine Empfehlung ist es, hierzu auf eine der frei ver-fügbaren Entwicklungsumgebungen zu setzen.

Da die ersten Schritte in einem neuen Tool eventuell nicht ganz selbsterklärendsind, stelle ich die beiden wichtigsten Umgebungen vor und zeige sie bis zum erstenminimalen funktionierenden Beispiel. Nun ändern sich Softwareversionen in derRegel schneller als Bücher, doch die grundlegenden Fragen der Organisation habenhöchstwahrscheinlich noch eine Weile Bestand, auch wenn die Screens sich biszur Drucklegung eventuell in Details schon wieder geändert haben.

Es besteht die Wahl zwischen zwei Varianten:

� IntelliJ Community Edition: Für alle, deren Fokus nicht direkt auf Android liegt, oderdie eventuell auch komplexere Cross-Plattform-Projekte ausprobieren möchten

� Android Studio: Für diejenigen, deren Projekte auf Android beschränkt sind

2.1.1 IntelliJ

Nach der Auswahl PROJEKT > NEU stehen verschiedene Optionen für Kotlin-Projektezur Verfügung.

Abb. 2.1: Projektassistent von IntelliJ


Kapitel 2Arbeiten mit Kotlin

34

Für die Beispielprojekte in den ersten Kapiteln reicht in der Regel das einfacheKOTLIN(JAVA)-Projekt aus. In den späteren Kapiteln wird dann auch die Variantefür JavaScript, beziehungsweise ein Cross-Plattform-Projekt, verwendet. Wie anden Bezeichnern bereits ersichtlich ist, handelt es sich zum Teil um experimen-telle Features. Diese sind nutzbar, es ist jedoch nicht garantiert, dass nach einemUpdate der Sprache oder der Tools alles noch läuft wie zuvor.

Im nächsten Schritt muss das Kind einen Namen bekommen. Wer Maven (einanderes Tool zur Buildorganisation, vergleichbar mit Gradle) nutzt, wird die Ein-teilung in Artifact-ID, Group-ID und Version kennen. Die Group-ID kann leer blei-ben, die Artifact-ID sollte den Projektnamen erhalten, und die Version kann auchzunächst auf dem Default-Wert stehen bleiben.

Abb. 2.2: Projektdetails

Die Projekte in IntelliJ werden standardmäßig mit Gradle konfiguriert und ge-baut. Daher ist dieser Schritt wichtig. Im Normalfall sollte hier der Gradle-Wrap-per aus der Basisinstallation gute Dienste tun.

Es kann im Einzelfall vorkommen, dass sich der aktuelle Wrapper nicht mit derVersion von Plug-ins oder auch Java verträgt, in diesem Fall kann Gradle auchmanuell installiert werden. Sollte das Tool Update-Bedarf anmelden, empfiehlt essich in der Regel, diesem Rat zu folgen.

Tipp: Update Gradle-Wrapper

Falls sich Fehlermeldungen beim Erstellen des ersten Projekts zeigen, die anzei-gen, dass Komponenten nicht gefunden werden oder der Gradle Sync nichterfolgreich durchgeführt wird, empfiehlt sich ein Check der Version(en) vonJava, IntelliJ, Kotlin-Plug-in für IntelliJ und Gradle-Wrapper. Sollte dieser nichtaktuell sein, ist ein Update möglich:

./gradlew wrapper --gradle-version 4.8.1 (aktuelle Version)


2.1Entwicklungsumgebung einrichten

35

Mehr Informationen zu Gradle und Stand-Alone-Downloads gibt es unter fol-gender Adresse:

https://gradle.org/

Abb. 2.3: Positives Feedback vom gradle in einem leeren Projekt

Mit diesem leeren Projekt kann es im Prinzip losgehen.

Als Nächstes müssen noch grundlegende Verzeichnisse angelegt werden (oder dieOption NEUE MODULE mit leerem Source-Verzeichnis anlegen und in den Settingsanhaken.)

Die Ordnerstruktur sollte folgenden Aufbau haben: src/main/kotlin.

Nun ist es an der Zeit, darin die erste Datei anzulegen. Passend zum Projekt soll sieden Namen firstrun.kt tragen. Diese Datei benötigt ein wenig »overhead«, damitdie Ausführung leicht möglich ist. Die Anweisungen machen die Kotlin-Anwen-dung kompatibel zur JVM. Das Ergebnis dieser Schritte sollte dann so aussehen:

Abb. 2.4: Projektbildschirm mit Struktur (links), Code (rechts) und Build-Fenster (unten)



36

Der letzte Schritt ist dann, eine Run-Configuration zu erstellen, damit der Play-But-ton zum Ausprobieren des Codes glühen kann.

Dazu wählen Sie in dem leeren Dropdown-Menü neben dem ausgegrauten Play-Button (vorheriger Screen rechts oben) den Punkt EDIT CONFIGURATIONS ... oderKONFIGURATIONEN BEARBEITEN .... Dort folgt mit dem Klick auf das PLUS das Aus-wahlmenü für die Konfigurationstypen.

Hier wählen Sie KOTLIN aus, um die grundlegenden Einstellungen für das ersteProjekt zu öffnen (s. Abbildung 2.5)

Bei diesem letzten Schritt müssen Sie einmal die gerade erzeugte Klasse in demhervorgehobenen Bereich USE CLASSPATH OF SUBMODULE auswählen.

Abb. 2.5: Build-Konfigurationen

Abb. 2.6: Build-Konfigurationsdetails


2.1Entwicklungsumgebung einrichten

37

Im folgenden Kapitel folgt Inhalt, mit dem die main-Methode gefüllt und auspro-biert werden kann.

2.1.2 Android Studio

Mit dem Projektassistenten legen Sie auch in Android Studio eine leere Applika-tion an. Dieser Schritt generiert bereits ersten Kotlin-Code und ein leeres Layout,in dem Sie direkt arbeiten können und das auf dem Simulator oder dem eigenenHandy einen App Screen erzeugen sollte.

Abb. 2.7: Projektassistent Android Studio

Im ersten Schritt scheint das Template EMPTY ACTIVITY zu passen, da es eine funk-tionierende Grundlage schafft, ohne viel Android-Infrastruktur zu erstellen, die inden ersten Schritten nicht notwendig ist. Wer sich mit Android auskennt, kannselbstverständlich auch mit einer ANDROID TV APP oder einer FRAGMENT VIEW-MODEL-Variante beginnen.



38

Abb. 2.8: Projektdetails konfigurieren

Im nächsten Schritt legen Sie die Details fest, eventuell fällt hier auch erneuteDownloadzeit für die richtige Android-Version an. Im Beispiel habe ich mich füreine recht alte API-Level entschieden, in einem Testprojekt kann das gerne aktuel-ler sein. Der Name der App kann frei gewählt werden, der Package-Name mussden Konventionen für Java-Packages folgen und darf nur Kleinbuchstaben ohneSonderzeichen enthalten.

Das Resultat ist eine Minimalapp im Code, die auch direkt zum Ausführen konfi-guriert ist.

Die ersten Beispiele in diesem Buch gehen davon aus, dass der Code auf der Kon-sole ausgeführt wird. Es ist aber kein Problem, die Beispiele leicht anzupassenund sie dann entweder aus der Konsole von Android zu sehen oder aber in einemTextView und damit auch direkt in einer App auszugeben.


2.2Tools

39

Abb. 2.9: Hauptfenster Android Studio mit Projektdaten

Hinweis: Nutzung mit einem Android-Projekt

Um die einfache Konsolenausgabe zu erreichen, die in den Codebeispielen mitprint("Irgendwas") gemacht wird, kann in einer Android-App System.out.print("Irgendwas") verwendet werden – bzw. die Variante mit println.

Um Ausgaben mit dem Textview in einer App zu machen, muss dieser einmal inder Applikation aus der Layout-Datei gelesen werden (oder mittels kotlin-android-extensions direkt importiert) und kann dann mit textView.text = "Irgendwas"genutzt werden, um die Ausgabe zu machen.

Führt man die App einmal aus und lässt sie sich anzeigen, so grüßen die Worte»Hello world« in einem ansonsten leeren App-Screen mit dem Titel Kotlin App.

2.2 Tools

Kotlin als Programmiersprache ist einigermaßen Tool-agnostisch. Sie können ineinem beliebigen Text-Editor entwickeln. Größeren Komfort und sinnvolle Unter-stützung bietet jedoch die integrierte Entwicklungsumgebung (IDE) IntelliJ oderdas davon abgeleitete Android Studio.



40

Von meiner Seite gibt es daher auch die klare Empfehlung, mit der IntelliJ-Com-munity-Edition für die ersten Beispiele zu arbeiten. Für Entwickler von Android-Apps gibt es wenig Gründe, nicht in Android Studio weiterzumachen und gegebe-nenfalls die entsprechende Kotlin-Unterstützung zu aktivieren.

Um kleine Code-Schnipsel einmal direkt in Aktion zu sehen, habe ich außerdemimmer wieder auf die Online-Compiler unter https://try.kotlinlang.orgzurückgegriffen.

2.2.1 Kotlin-Compiler

Die grundlegendste Möglichkeit, Kotlin zu nutzen, ist der Kotlin-Compiler auf derKommandozeile. Der Compiler wird dabei verwendet, um den bestehenden Codemit der Kotlin-Runtime zu bündeln und dann in ein ausführbares JAR zu konver-tieren, welches mit einer Java-Umgebung lauffähig ist.

Darüber hinaus kann der Kotlin-Compiler auch als interaktive Shell oder zumScripting verwendet werden.

Tipp

Zum Umgang mit dem Kotlin-Compiler und seiner Installation: https://kotlinlang.org/docs/tutorials/command-line.html

Die ersten Code-Beispiele kann man theoretisch auf diese Art ausführen, es istaber an sich nicht zu empfehlen, da es keinerlei Unterstützung durch eine Umge-bung gibt und auch das Management von Bibliotheken manuellen Aufwandbedeutet.

2.2.2 Kotlin-Compiler mit Gradle

Auf der Konsole kann auch das Buildsystem Gradle die Arbeit an größeren Projek-ten vereinfachen. In beiden IDEs ist es dafür auch standardmäßig eingebunden.Gradle konfiguriert und managt die Abhängigkeiten eines Programms. So benö-tigt schon die einfachste »Hello world!«-Anwendung mindestens die Kotlin Run-time Library. Falls man unbedingt ohne eine Entwicklungsumgebung arbeitenwollte, wäre die Empfehlung, mindestens Gradle zusätzlich zu nutzen.

Tipp Gradle lokal installieren

Unter der domain https://gradle.org/ gibt es die Gradle Build Tools als Stand-alone-Software. Als nächster Schritt helfen dann die Getting Started Guides:https://gradle.org/guides/#getting-started.


2.2Tools

41

In diesem Fall wird eine Konfigurationsdatei namens build.gradle erstellt, inder die Einstellungen festgehalten werden. Damit kümmert sich das Build Tooldann um den Download von Bibliotheken und Frameworks und konfiguriert denKotlin/Java-Compiler entsprechend der gewünschten Einstellungen.

2.2.3 Integrierte Entwicklungsumgebungen/IDE

Kotlin ist als Multiplattform-Projekt nicht auf ein Tool festgelegt, aber für einegroße Zahl an Umsteigern dürften die Produkte von JetBrains eine bekannte Refe-renz sein. Der Support im Tool (IntelliJ ab Version 15, Android Studio ab Version3.0) entspricht dem Standard, der aus der Java-Entwicklung bekannt ist.

Dazu gehören Syntax Highlighting, Code completion und automatische Importsebenso wie die von IntelliJ bekannten Inspections und Analysetools für den Code.

Wie es der Name schon nahelegt, ist die Android-Studio IDE auf Android-Appsfestgelegt, weitergehender Support, wie zum Beispiel Projekt-Templates für eineJS-Anwendung, fehlet hier. Umgekehrt ist das allgemeine IntelliJ-Bundle mit allennotwendigen Komponenten für die komplette Android-Entwicklung ausgestattet.

IntelliJ erlaubt auch die Entwicklung von Android-Anwendungen und zusätzlichauch die weiteren Verwendungen von Kotlin. Die Beispiele in diesem Buch sindgrößtenteils mit der IntelliJ-IDE und Android Studio entstanden. Beide IDEs sindunter bestimmten Bedingungen frei erhältlich.

Tipp: Download URLs

http://www.jetbrains.com/idea/download/index.html

https://developer.android.com/studio/

2.2.4 Konvertierung von existierendem Code

Eine sehr praktische Funktion – über beide IDE leicht zu erreichen – ist die Kon-vertierung von bestehendem Java-Quelltext in Kotlin. So kann man die neue Spra-che von bekanntem Terrain her erobern. Bei der Umsetzung entsteht in der Regelnicht die ideale Kotlin-Lösung, aber im besten Fall schon mal kompilierender undfunktionierender Code.

Doch es gibt ein paar Aspekte zu beachten, die auch nach der automatischenCode-Konvertierung noch notwendig sind. Zum einen tut sich die Konvertierungmit komplexen if/switch-Anweisungen schwer und erzeugt bisweilen duplizier-ten Code.

Zum anderen wird die Konvertierung alle Unsauberkeiten in Bezug auf denUmgang mit Null-Sicherheit oder Typen aufdecken und damit unter Umständen



42

auf relativ ungünstige bzw. teure Strukturen konvertieren, die besser manuell kor-rigiert werden. Zum Teil kam es hier bei meiner Arbeit an Projekten für das Buchauch zu Fehlern, die entweder nicht kompilierte oder aber Laufzeitfehler zeigten.

Last but not least entsteht auch im besten Fall Java-Code in Kotlin-Notierung. DieParadigmen funktionaler Parameter werden also eher wenig bis gar nicht umge-setzt. Die Konvertierungsroutine erzeugt zum Beispiel veränderliche Variablen,die in Kotlin zum Beispiel besser als immutable deklariert werden sollten.


347

Stichwortverzeichnis

@Annotations 116Schleifen-Label 111

Aabstract 147abstrakte Klassen 147Activity 55Actual 333actual 143also 218Android 55, 265

Activity 23, 55, 271Adapter-Views 281Änderungen durch Kotlin 266Application 271architecture components 283Architektur 283Coroutinen 303Delegation 304Delegation-Basisklasse 306Extension-Funktionen 265Extension-Methode 305Extension-Property 305Fragment 271Interactor 287JetPack 271Klassendelegation 306Kotlin-Vorteile 265, 267Layout-Dateien 55Lifecycle 271, 282Package-Struktur 266Probleme 23Remote API nutzen 300Repository 287RetroFit 300Scope einer Coroutine 304Vererbung reduzieren 268Views 282

Android-Extensions 59Android KTX 285Android Studio 33, 37, 41

Bytecode-Ansicht 142Download 41

Android-ViewKonstruktoren überladen 315

Annotationsbenutzen 116Parameter 117Test 191, 203Use-Site target 317

anonyme Klasse 166, 168Anweisungen 63Anweisungsblock 64Any 73, 93, 148apply 218Architekturmodelle 24Arrays 47, 73, 94, 224, 225

copyOf 76erstellen 226erzeugen 61, 76Factories 226Initialisieren 94Iteration 230mehrdimensional 95, 122nutzen 224Skalararrays 95, 225Standard-Konstruktor 227transformieren 231Zugriff 91, 228

Arrays vs. Listen 224as 119, 120as? 119, 120Assertion 203async 258Attribute 145Ausdrücke 63Autoboxing 86Automatische Tests 47, 187

Assertion 203Auswertung 200Behaviour Driven Design 209Beispiel 195Codequalität 201Integrationstests 187Matcher 209Mock 189Multiplattform 211



348

parametrisierte Tests 193RSpec 209Setup 206Strategien 206SystemOutRule 203Testabdeckung 200Testgestaltung 192Unit-Tests 187

await 258

Bbacking field 160Behaviour Driven Design 209Blackbox-Tests 188boole'scher Ausdruck 49Boolean 72, 90Boxing 81, 85break 111by 237Byte 72, 88Bytecode-Optimierung

inline 141

CCall-Chaining 61capitalize 113, 234Casts 119

Smart cast 121catch 115Char 73, 90class 55, 65Class Delegation 241class members 146Clean Architecture 285Code

Architekturmodell 145Strukturierung 145

Code Coverage 201Code-Konvertierung 41Codequalität 201Collection 224Companion Object 58, 165

Methoden aufrufen 166Comparator 230componentN 134, 170, 185continue 111Contracts 258

callInPlace 260returns 261Smartcasts 260Zusicherungen 259

copyOf 76

CoroutinenActor 258Android 303async 258await 258experimentelle Klassen 258launch 253Scope 253, 255ScopeBuilder 255Suspend-Funktion 254

Coroutines 253Custom Setter 239

Ddata 60, 170Datenklasse 60, 170Datentyp

Char 90Range 99

Datentypen 72? 77Array 47, 73, 94Boolean 72, 90Byte 72, 88Casting 89Char 73Double 73, 88dynamic 321Fließkommazahlen 88Float 73, 88Funktionen 137Ganzzahlen 88Generics 85Generische Typen 85Int 47, 72, 88konvertieren 118Konvertierung 119, 120List 53, 73Liste 96Long 88Map 98nullbar 49Range 73Set 96Short 88skalare 73String 47, 73, 90Zahlen 88

Deferred 258dekompilierte Java-Klassen 143delay 255Delegation 236

Android 268, 269, 304



349

Class Delegation 241, 243Custom 241Custom Property Delegation 305inject 251Klassendelegation 306lazy 237map 237, 241Observable 239observable 237property 237Property Delegation 304Vetoable 240vetoable 237

Delegation vs. Vererbung 236, 241Dependency Injection 190, 246, 248, 250, 251Dependency Inversion 285Destrukturierende Deklarationen 184Destrukturierung von Deklarationen 133Document Object Model 323Dokumentation 218

Plattformen 30DOM 323Domain-Specific-Languages 187Double 73, 88do while 109Downloads 17, 18DSL 187

Eeager loading 252else 102Elvis-Operator 50Enums 179

ordinal 180toString 180valueOf 180

Enums vs. Sealed Klasse 181Exception 48, 115Exception handling 114expected 143, 333Expressions 63Extension-Funktionen 26, 59, 182

Android 269, 302für eigene Klassen 184importieren 154Vererbung 183

FFactory 157finally 115first 229firstOrNull 228Float 73, 88

fold 112folding 232for 106, 107, 108forEach 112foreach 107Fragezeichen-Operator 50fun 45, 127Funktion

Deklaration 45Funktionskörper 67Kurzschreibweisen 45Parameter 45

Funktionale Programmierung 22, 125Beispiel 27Höhere Funktionen 24Paradigma 125reine Funktion 24Seiteneffekte 44unveränderliche Datenstrukturen 25

Funktionen 125actual 143, 333als Parameter 136anonyme Funktion 137Aufrufen 70ComponentN 134Definieren 127einzeilig 129expected 143, 333first-class citizens 126Funktionskopf 71, 128generische Funktionen 177höhere Funktionen 51infix 143inline 141, 178Lambdas 126lokale Funktionen 139Methoden (in Klassen) 161named parameter 130Namen 127Operator überladen 144Parameter 127, 129reified 178rekursiv 138return 128, 132Rückgabetyp 127Scope-Funktionen 218Signatur 128Top-Level 66Unit 127variable Parameter 131verketten 135

Funktionsaufrufe 70



350

GGenerics 85, 171

Beschränkung 173invariante Typen 174Klassendefinition 171kontravariante Typen 176kovariante Typen 175mehrere Typen 172Varianz 174Vererbung 173

generische Klassen 171generische Methoden 177generische Typen 171getOrElse 229getOrPut 229Getter 159Gherkin Cucumber Style 210Google I/O 13Gradle 34, 40

Versionskonflikt 34Wrapper 34

Gradle-ProjektAndroid 272

HHamKrest 190höhere Funktionen 51, 136

IIDE

Android Studio 33, 41IntelliJ 41

idiomatische Ausdrücke 44if 49, 102if/else 102import 56, 152infix 143init 155Initializer 74, 156inject 251inline 141Inlining

Funktionen 141Lambdas 141

innere Klassen 163Int 47, 72, 88Integrationstests 187IntelliJ 13, 33, 41

BYTECODE-ANSICHT 142Download 41

Interactor 248Interface 147

internal 69, 152Interoperabilität 22Inversion of Control 246isNotNullOrEmpty 234it 52Iterable 106

JJava 41

Annotation-Kompatibilität 317Annotations 314Autoboxing 86Bibliotheken nutzen 312char as int 89Collections 314Default-Parameter 315Derivate 21final 75final static-Werte 165funktionale Muster 126implizites Casting 89instanceof 121Interoperabilität 311JvmOverloads 315Kompatibilität 22Konvertieren 41Kotlin-Kompatibilität 30Multiplattform 312Packackes (Unterschiede) 149Probleme 21, 127Reflection 234, 312, 314Sichtbarkeitsmodifier 152Sichtbarmachung 316skalare Datentypen 73statische Felder 316Streams 314switch/case 104ternärer Operator 102Threading 253throws 115überladene Funktionen 130Wertecache 87Zielplattform 312

Java-AnnotationsJvmField 315JvmOverloads 315JvmStatic 315

Java-Entwicklung 21Java-Kompatibilität 30JavaScript

Bibliotheken 311Document 319, 323



351

DOM 319, 323dynamic 321external 327Funktionen aufrufen 326IntelliJ-Projekt einrichten 318JavaScript-Runtime 318js 327JSON 324Kotlin aus JS aufrufen 319MVP 320Promise 253, 320statische Typen 29TypeScript 29, 311Unterschiede 29

Java-Virtual-Machine 58JetBrains 13joinToString 233JS

Aufruf 327JUnit 190, 191

After 207AfterClass 207assertFalse 192assertTrue 192Before 207BeforeClass 207parametrisierte Tests 207

JUnit 4 191JUnit 5 192JVM 58

KKClass 235KFunction 235Klassen 55

abstrakte 147Actual 333anonyme Klasse 166, 168anonyme Klassen (Rückgabe) 169Attribute 145class member 65companion object 157, 165ComponentN 170, 185Custom Getter/Setter 159Datenklassen 59, 170Deklaration 65Eigenschaften 146enum 179expected 333Extensions 182Factory 165Importe und Packaging 154

importieren 152init 155Initialisierung 155Initializer 156Initializer vs. Custom Getter 161inner 163innere Klassen 163Interfaces 147Konstruktor 61, 154member 146, 154Member-Funktionen 71member überschreiben 148Methoden 145, 161nested 163open 147primäre und sekundäre Konstruktoren

155privater Konstruktor 157Properties 60, 145, 146, 148, 151, 158,

182, 185Properties deklarieren 158Properties-Sichtbarkeit 158Property-Setter 159Schachtelung 163sealed 181Sichtbarkeitsmodifier 151Strukturelement 146überschreiben 148Unit-Tests 204variable Properties 158veränderliche Properties 82Vererbung 146

KOIN 246, 251factory 252single 252

Konstruktor 61Kontrollstrukturen 101Kotlin

Code-Sharing 338kotlin2js 327kotlin.test 190, 212Kotlin/Native 338Kotlin-Android-Extensions

Layout import 280Kotlintest.io 210

TestCases 211Kurzschreibweisen

Funktionen 129it 52, 72Lambdas 68, 71Type Aliases 122



352

LLambdas 50, 126

Chaining 138it 72Parameter 72Rückgabewert 72, 138Verketten 138

lazy 237lazy-Initialisierung 238let 50, 218List 73, 225Listen 96

erzeugen 61Factories 226fold 232Iteration 230nutzen 224transformieren 231Zugriff 228

lokale Funktionen 139Long 88

Mmap 112, 113, 237Map-Delegate 241mapIndexed 112Mapping 26Maps 98

erzeugen 227Factories 227getOrPut 229iterieren 231Zugriff 229

Matchers 209mehrdimensionale Arrays 95Methoden

abstract 147aufrufen 162definieren 161open 147Sichtbarkeit 162

Mock 189, 190, 247Mocking 189Mockito 190Model-View-Presenter 285, 286Model-View-ViewModel 285Multiplattform 22

iOS 29JavaScript 29JVM 29plattformspezifisch 30

MutableList 225

MutableMaps 225MutableSets 225MVP 247, 285

Activity (View) 289Datenupdates 293Initialisierung 288Kritik 296Nutzereingaben 293Presenter 287, 288Repository 291Testbarkeit 291Vertrag (Contract) 287View 287ViewModel 287Vorteile 286

MVP vs. MVVM 302MVVM 247, 285, 297

Daten laden 298Initialisierung 297LiveData 298MutableLiveData 298Observer 297ViewModel 297Vorteile 296

MVVM-Anwendung 297

Nnamed parameter 130Nebenläufigkeit 253nested class 163non-null-assertion 78null 46, 49Null-Ausschluss 78Null-Pointer 79Null-Sicherheit 77, 83

Oobject 58, 165Objekt-Anweisungen 166Objekt-Ausdrücke 166Objekte 55, 93

Konstruktor 93Objektorientierung 55, 145

Beispiel 26Klassen 146Methoden 162Probleme 23Seiteneffekte 26Vererbung 56, 146Vorteile 28

observable 237, 239open 147



353

operator 144Operatoren

:: 234!! 78? 50, 78, 80, 84* 131$ 61, 92as 119, 120as? 119, 120downTo 99in 91, 176is 121out 175step 99to 227until 99

org.w3c.dom 323override 148

PPackages 56, 149

Grundpackage 149gruppieren 149import 152internal 152Sub-Packages 149Use-Cases 150

ParameterDefault-Wert 61, 130

parametrisierte Tests 207Plattformen

Android 215JS 215JVM 215

primärer Konstruktor 155println 45private 69, 152Projekte

Android 37anlegen 33, 37ausführen 36bearbeiten 35konfigurieren 34Template 37

Properties 60backing fields 160Getter 159Setter 159

Property Delegation 237, 304protected 152public 69, 151

QQUnit 190

RRange 73, 107Ranges 99React Helper 326ReadOnlyProperty 241ReadWriteProperty 241Receiver 71Refactoring 197Reflection 234

Class Members 235KClass 235KFunction 235lateinit 235Properties 235

regular Expression 91reified 178Rekursion 106, 138rekursive Funktion 138repeat 110return 132return early 132reverse 234reversed 113RSpec 209run 218runBlocking 255

SSAM-Klassen 127, 168Scala 21Schleifen 53, 105

abbrechen 111break 111continue 111do while 109for 53, 106, 107foreach 53, 107funktionsbasiert 112Range (for) 107repeat 110while 68, 109

Scope 69Scope-Funktionen 50

also 218apply 218Benutzung 219let 218Parameter 219Rückgabewert 219



354

run 218Schachtelungen 223Transformation 220

Sealed 181Sealed classes 181Sealed Klasse vs. Enum 181sekundäre Konstruktoren 155selbstreflektiver Code 234Semikolons 14Sequence 224Service Location 246Service Locator 247, 249Set 225Sets 96

unique constraint 226Setter 159Shared Preferences

Delegation 305Short 88Sichtbarkeit

einschränken 151internal 152Lokale Variablen 152private 152protected 152public 151

Sichtbarkeitsmodifier 151Sichtbarkeitsmodifikatoren

internal 69private 69public 69

Sieb des Erathostenes 108Singleton 58, 157, 165, 166Skalararray 95, 225skalare Datentypen 73slice 230Smart Cast 121Specification Style 210Spek 210

group 210test 210

Spracheigenschaften 22concise 14funktional 24, 44Interoperabilität 29, 30interoperable 14Null-Sicherheit 24, 28, 46, 50, 58objektorientiert 44safe 14Sicherheit 25, 28statische Typisierung 24, 28, 118

Standardbibliothek 215, 216alle Plattformen 216

plattformspezifische Features 216, 217Standardklassen

importieren 154Statements 63statisch typisiert 77statisch typisierte Sprache 118String 47, 73, 90Strings

Escape-Sequenzen 92Raw-String Format 92String-Templates 61Templates 92Tools 233trimMargin 93

String Templates 92Struktur 65Stub 247sublist 230suspend 254Syntax 63

Ttakeif 223takeunless 223Testabdeckung 189, 201Test-Annotation 203Testbarkeit 26, 187

Beispiel 195Test Driven Development 187Testing

DSL 208Vorteile 198

Testprojekt 193Tests 187Test-Stile 209Testsuite 189Texttools 233toInt 118toLowercase 113Tools 39

Kotlin-Compiler 40Top-Level-Funktion 66, 149

Android 268Top-Level-Properties 149Transformation 231try 115try/catch 114Türme von Hanoi-Algorithmus 139Type Aliases 122Type-Casts

Konvertierung 119Typinferenz 50, 72, 84Typsicherheit 77



355

UUnicode 91Unit 45Unit-Tests 47, 187

Assert 191assertEquals 191

unsafe Cast operator 120use 314

Vval 49, 74var 49, 74vararg 131Variable

null-safe 58Variablen

Boxing 81Deklaration 74Identität 86immutable 74initialisieren 74mutable 74nullbar 77nullbar vs. nicht-nullbar 81Referenz 74Scope 69Sichtbarkeit 67transformieren 77Typinferenz 84unveränderlich 49, 74veränderlich 49, 74

Wert 74Zugriff 75Zuweisung 64

Variablenscope 69Vererbung 56Vererbungshierarchie 146Vererbung vs. Delegation 236, 241Verkettung von Null-Checks 83Verzweigungen 49

if 101when 102, 103

vetoable 237, 240Vorteile 26

Wwhen

Ausdruck 104enum 105Range 104sealed class 105

while 68, 109White-Box Test 188withContext 256withIndex 231

ZZahlen 88

konvertieren 47Zielplattformen 216Zuweisung 64


Inhaltsverzeichnis - mitp · Inhaltsverzeichnis 8 7.4.2 Anonyme Klassen via Objekt-Ausdruck . . . ....

Documents

Transcript of Inhaltsverzeichnis - mitp · Inhaltsverzeichnis 8 7.4.2 Anonyme Klassen via Objekt-Ausdruck . . . ....