Kofler Kotlin

Das umfassende Handbuch
1. Auflage 2020
ISBN: 978-3-8362-7279-7
Verlag: Rheinwerk
Format: EPUB
Kopierschutz: 0 - No protection

E-Book, Deutsch, 823 Seiten

Reihe: Rheinwerk Computing

Kotlin ist das neue Schweizer Taschenmesser in der Softwareentwicklung. Ob mobile Apps oder Geschäftslogik am Backend, ob objektorientierte Paradigmen oder funktionale Programmierung mit Lambdas: Kotlin vereint die Stärken zahlreicher beliebter Sprachen zu einem modern Werkzeug für alle Fälle. In diesem umfassenden Handbuch gibt Michael Kofler Ihnen dazu einen Einblick in alle Sprachfeatures und zeigt Ihnen, wie Sie zeitgemäß Software entwicklen.

Aus dem Inhalt:

• Crashkurs für Java-Umsteiger
• IDEs: IntelliJ und Android Studio
• Operatoren, Datentypen, Variablen, Klassen, Methoden: Alle Grundlagen
• Lambda-Ausdrücke und funktionale Programmierung
• Objektorientierte Programmierung inkl. Extensions, Delegation und Generics
• Asynrchrone Programmierung und Koroutinen
• Netzwerkfunktionen, XML und JSON
• App-Programmierung mit Jetpack und Jetpack Compose
• Backend-Entwicklung mit Ktor und Exposed
• REST-APIs entwicklen und anwenden
• Pakete, Module und Importe

Dr. Michael Kofler studierte Telematik an der TU Graz. Er zählt zu den erfolgreichsten und vielseitigsten Computerbuchautoren im deutschen Sprachraum. Zu seinen Themengebieten zählen neben Linux auch macOS, MySQL, KVM, Visual Basic und Excel-VBA. Viele seiner Bücher wurden übersetzt. Michael Kofler arbeitet auch als Software-Entwickler, Berater sowie als Lehrbeauftragter an einer Fachhochschule.

Autoren/Hrsg.

Kofler, Michael

Inhaltsverzeichnis

  Vorwort ... 13




TEIL I  Kotlin ... 17



  1.  Hello World! ... 19


       1.1 ... Über Kotlin ... 19

       1.2 ... Installation ... 21

       1.3 ... »Hello World!« mit und ohne IDE ausführen ... 24



  2.  Crashkurs ... 29


       2.1 ... Elementare Syntaxregeln ... 29

       2.2 ... Konventionen ... 41

       2.3 ... Von Java zu Kotlin ... 42



  3.  Operatoren ... 47


       3.1 ... Übersicht ... 47

       3.2 ... Anmerkungen ... 49

       3.3 ... Priorität von Operatoren ... 59



  4.  Variablenverwaltung ... 61


       4.1 ... Variablen ... 61

       4.2 ... Unveränderliche Variablen ... 63

       4.3 ... Konstanten und Enumerationen ... 64

       4.4 ... Der Umgang mit »null« ... 65



  5.  Datentypen ... 69


       5.1 ... Die wichtigsten Kotlin-Datentypen ... 69

       5.2 ... Zahlen ... 72

       5.3 ... Bereiche (Ranges) ... 74

       5.4 ... Zufallszahlen ... 76

       5.5 ... Boolesche Ausdrücke ... 77



  6.  Zeichenketten ... 79


       6.1 ... Die Klasse »Char« ... 80

       6.2 ... Die Klasse »String« ... 82

       6.3 ... Mit Zeichenketten arbeiten ... 85

       6.4 ... Beispiel: Passwortqualität testen ... 94

       6.5 ... Die Klasse »StringBuilder« ... 97



  7.  Datum und Uhrzeit ... 99


       7.1 ... Neue Java-Klassen (»java.time«) ... 100

       7.2 ... Herkömmliche Java-Klassen (»Date« und »Calendar«) ... 107

       7.3 ... Die »Duration and Time Measurement API« (kotlin.time) ... 113



  8.  Listen, Sets, Maps und Arrays ... 117


       8.1 ... Listen ... 118

       8.2 ... Sets ... 132

       8.3 ... Maps ... 135

       8.4 ... Sequenzen ... 136

       8.5 ... Arrays ... 140



  9.  Verzweigungen und Schleifen ... 147


       9.1 ... Die »if«-Verzweigung ... 147

       9.2 ... Die »when«-Verzweigung ... 150

       9.3 ... Die »for«-Schleife ... 152

       9.4 ... Die »while«-Schleife ... 154

       9.5 ... Die »repeat«-Schleife ... 155

       9.6 ... »break« und »continue« ... 156

       9.7 ... Beispiele: Summen, Produkte, Duplikate und Co. ... 157



10.  Funktionen ... 163


       10.1 ... Funktionen definieren und aufrufen ... 164

       10.2 ... Parameter ... 168

       10.3 ... Rekursion ... 172

       10.4 ... Lokale Funktionen ... 175

       10.5 ... Die »main«-Funktion ... 176

       10.6 ... Beispiel: Pfadsuche ... 177



11.  Lambda-Ausdrücke und funktionale Programmierung ... 189


       11.1 ... Hello Lambda! ... 190

       11.2 ... Lambda-Ausdrücke und Funktionen für Fortgeschrittene ... 192

       11.3 ... Beispiel: Funktionen erzeugen und verarbeiten ... 197

       11.4 ... »map«, »filter«, »reduce« und Co. ... 199

       11.5 ... Beispiel: Textanalyse mit Lambda-Ausdrücken ... 211

       11.6 ... Beispiel: Dosenpyramide in drei Farben ... 213

       11.7 ... Objekte verarbeiten (»apply«, »let«, »with« etc.) ... 218

       11.8 ... Inline-Funktionen ... 223



12.  Klassen und Objekte ... 227


       12.1 ... Klassen ... 227

       12.2 ... Der Konstruktor ... 233

       12.3 ... Eigenschaften ... 240

       12.4 ... Eigenschaften später initialisieren ... 245

       12.5 ... Zugriffssteuerung ... 249

       12.6 ... Beispiel: Bankkonto ... 251

       12.7 ... Objekte ohne Klassen ... 253

       12.8 ... Beispiel: Quiz ... 261

       12.9 ... Enumerationen ... 266



13.  Vererbung, Schnittstellen, Extensions ... 271


       13.1 ... Vererbung ... 272

       13.2 ... Vererbung (Konstruktoren, abstrakte Klassen, Polymorphie) ... 278

       13.3 ... Die Klasse »Any« ... 284

       13.4 ... Datenklassen ... 287

       13.5 ... Beispiel: Schachfiguren ... 289

       13.6 ... Schnittstellen ... 296

       13.7 ... Beispiel: Geometrische Objekte mit Schnittstellen verarbeiten ... 303

       13.8 ... Extensions ... 304

       13.9 ... Receiver-Funktionen ... 309

       13.10 ... Infix-Funktionen ... 312

       13.11 ... Operator Overloading ... 313

       13.12 ... Beispiel: Rechnen mit komplexen Zahlen ... 316

       13.13 ... Delegation ... 317



14.  Reflection, Generics und Annotationen ... 327


       14.1 ... Reflection ... 328

       14.2 ... Generics ... 330

       14.3 ... Generische Typen: Zusatzregeln und Sonderfälle ... 333

       14.4 ... Annotationen ... 344

       14.5 ... Type-safe Builder ... 348



15.  Exceptions ... 357


       15.1 ... Fehlerabsicherung ... 358

       15.2 ... Selbst Fehler auslösen (»throw«) ... 365

       15.3 ... Arbeitstechniken ... 367



16.  Pakete, Importe und Module ... 369


       16.1 ... Pakete ... 369

       16.2 ... Importe ... 370

       16.3 ... Module ... 373




TEIL II  Programmiertechniken ... 375



17.  Asynchrone Programmierung ... 377


       17.1 ... Hello Coroutines! ... 378

       17.2 ... Koroutinen ausführen ... 382

       17.3 ... Koroutinen abbrechen ... 390

       17.4 ... Exceptions in asynchronem Code ... 395

       17.5 ... Den Zugriff auf gemeinsame Daten synchronisieren ... 398

       17.6 ... Suspending Functions ... 401

       17.7 ... Asynchroner Code in Android-Apps ... 404

       17.8 ... Beispiel: Effizient numerisch integrieren ... 407



18.  Dateien verarbeiten (I/O, JSON, XML) ... 411


       18.1 ... Umgang mit Dateien und Verzeichnissen ... 412

       18.2 ... Textdateien lesen und schreiben ... 419

       18.3 ... Download von Dateien ... 422

       18.4 ... JSON und Serialisierung ... 422

       18.5 ... JSON-Beispiel: Die »New-York-Times«-Bestseller ... 430

       18.6 ... XML ... 432



19.  Datenbankzugriff (Exposed) ... 437


       19.1 ... Hello Exposed! ... 438

       19.2 ... Verbindungsaufbau und Transaktionen ... 442

       19.3 ... Data Access Objects (DAO) ... 448

       19.4 ... DAO-Beispiel: Bücherdatenbank ... 455

       19.5 ... SQL als Domain-specific Language (DSL) ... 462



20.  JavaFX ... 473


       20.1 ... Hello JavaFX! ... 473

       20.2 ... TornadoFX ... 477




TEIL III  App-Entwicklung ... 481



21.  Hello Android! ... 483


       21.1 ... Android Studio installieren ... 484

       21.2 ... Das erste Projekt in Android Studio ... 486

       21.3 ... Emulator einrichten ... 488

       21.4 ... Smartphone einrichten ... 492

       21.5 ... Aufbau eines Android-Studio-Projekts ... 494

       21.6 ... Eigener Button, eigener Code ... 498

       21.7 ... Personalisierung der App ... 505



22.  App: Fahrenheit-Umrechner ... 509


       22.1 ... Layout ... 510

       22.2 ... Der Code zur Temperaturumrechnung ... 512

       22.3 ... Debugging ... 518

       22.4 ... Screenshots ... 522



23.  Android Basics ... 525


       23.1 ... Android-Grundlagen ... 525

       23.2 ... Steuerelemente ... 527

       23.3 ... Texte anzeigen und eingeben (»TextView«, »EditText«) ... 529

       23.4 ... Buttons ... 533

       23.5 ... ImageView ... 535

       23.6 ... Layoutregeln ... 541

       23.7 ... Listen und Tabellen (»RecyclerView«) ... 548

       23.8 ... Preferences ... 561

       23.9 ... Permissions ... 564



24.  Aktivitäten, Fragmente und Menüs ... 573


       24.1 ... Aktivitäten und Fragmente ... 574

       24.2 ... Beispiel: App mit drei leeren Fragmenten ... 576

       24.3 ... Datenaustausch zwischen Fragmenten ... 586

       24.4 ... Beispiel: Datenaustausch zwischen drei Fragmenten ... 593

       24.5 ... Einfache Menüs (Overflow Menu) ... 597



25.  App: Währungsumrechner ... 603


       25.1 ... Die Klasse »CurrencyCalculator« ... 604

       25.2 ... Hauptaktivität ... 610

       25.3 ... Fragment zur Währungsumrechnung (»MainFragment«) ... 611

       25.4 ... Einstellungsfragment (»SetupFragment«) ... 616

       25.5 ... Fragment mit App-Informationen (»AboutFragment«) ... 620



26.  Jetpack Compose ... 623


       26.1 ... Hello Compose! ... 625

       26.2 ... Steuerelemente ... 635

       26.3 ... Container ... 641

       26.4 ... Listen ... 645

       26.5 ... Theming ... 648

       26.6 ... Aktivitäten und Fragmente ... 651

       26.7 ... Beispiel: Fahrenheit-Umrechner ... 656




TEIL IV  Backend und Server ... 661



27.  Hello Server! ... 663


       27.1 ... Hello Ktor! ... 665

       27.2 ... Beispiel: URL-Verkürzer ... 670

       27.3 ... Beispiel: URL-Verkürzer mit Datenbank-Server ... 675



28.  Ktor-Programmiertechniken ... 681


       28.1 ... Projekt- und Programmaufbau ... 682

       28.2 ... Routing ... 684

       28.3 ... Request und Response ... 690

       28.4 ... HTML- und CSS-Dokumente zusammensetzen ... 694

       28.5 ... REST-APIs ... 701

       28.6 ... Authentifizierung ... 709

       28.7 ... Ktor-Debugging ... 715



29.  App: Evaluierungssystem (Backend) ... 719


       29.1 ... Projektaufbau ... 720

       29.2 ... Datenbankdesign ... 723

       29.3 ... Der Datenbank-Code ... 725

       29.4 ... Weboberfläche ... 735

       29.5 ... Die REST-API ... 745



30.  App: Evaluierungssystem (Client) ... 753


       30.1 ... Den Ktor-Client in Android-Apps verwenden ... 755

       30.2 ... Ktor-Client-Programmiertechniken ... 758

       30.3 ... Projektaufbau der Evaluierungs-App ... 761

       30.4 ... Liste der Evaluierungen anzeigen ... 766

       30.5 ... Einmal-Login ... 772

       30.6 ... Evaluierung durchführen ... 775

       30.7 ... Evaluierungsergebnisse anzeigen ... 781



  A.  IntelliJ, Android Studio und Gradle ... 783


       A.1 ... IntelliJ und Android Studio ... 783

       A.2 ... Gradle ... 795



  Index ... 807

Leseproben

2    Crashkurs

Bevor ich Ihnen Kotlin in den nächsten Kapiteln systematisch vorstelle, gibt dieser Crashkurs einen ersten Überblick über die wichtigsten Syntaxregeln und hilft so bei der Orientierung. Der Crashkurs setzt voraus, dass Sie schon programmieren können und prinzipiell wissen, was Variablen, Funktionen usw. sind. Sollte das bei Ihnen nicht der Fall sein, ist es vermutlich besser, dieses Kapitel zu überspringen. (Generell richtet sich dieses Buch nicht primär an Programmiereinsteiger.)

Eine Motivation für diesen Crashkurs besteht darin, dass es unmöglich ist, eine Programmiersprache linear zu erklären. Egal, wo ich beginne – immer muss ich etwas anderes voraussetzen. Dieses Kapitel schafft insofern ein erstes Fundament. Seien Sie nicht irritiert, wenn Sie nicht jeden Begriff und jede Konstruktion auf Anhieb verstehen – in den weiteren Kapiteln folgen dann ausführlichere Erläuterungen sowie mehr Details und Varianten.

Das Kapitel endet mit einer kurzen Gegenüberstellung von Java- und Kotlin-Code. Wenn Sie schon mit Java programmiert haben, sehen Sie so auf ersten Blick einige wichtige Unterschiede zwischen Java und Kotlin.

2.1    Elementare Syntaxregeln

Kotlin-Anweisungen sind normalerweise einzeilig. Mehrzeilige Anweisungen sind erlaubt, wenn aufgrund von Klammern oder Operatoren klar ist, dass sie in der folgenden Zeile fortgesetzt werden:

println(
"Hello World!")
var a = 3 +
4 + 5

Wenn eine Zeile dagegen eine vollständige Anweisung bildet, ist eine Fortsetzung nicht möglich:

var b = 3
 + 4 + 5

Strichpunkte zum Abschluss von Anweisungen sind nicht erforderlich, aber erlaubt. Allerdings müssen Sie Strichpunkte verwenden, wenn Sie mehrere Anweisungen in einer Zeile anordnen möchten:

var a=3; var b=4; var c=5

Kommas

In Kotlin werden, wie in fast allen Programmiersprachen, Parameter durch Kommas getrennt:

val lst1 = listOf("Lorem", "ipsum", "dolores", "est")

Es ist erlaubt, auch nach dem letzten Parameter ein Komma anzugeben. Das ist vor allem dann praktisch, wenn Sie die Reihenfolge der Parameter später ändern wollen. Dann können Sie eine Zeile markieren und nach oben oder unten verschieben, ohne dass es Syntaxprobleme gibt:

val lst = listOf(
"est",
"Lorem",
"dolores",
"ipsum",
)

Kommentare

Einzeilige Kommentare werden mit // eingeleitet, mehrzeilige Kommentare starten mit /* und enden mit */. Derartige Kommentare dürfen auch verschachtelt werden.

var x = 4

Strukturierung

Code wird durch die geschwungenen Klammern { und } strukturiert. Wenn in einer Schleife, Verzweigung etc. nur eine Anweisung ausgeführt werden soll, dann dürfen die Klammern entfallen.

Code-Einrückungen sind optional und nicht Teil der Syntax. Es ist aber üblich, Code pro Ebene um vier Zeichen einzurücken. (In diesem Buch gibt es vereinzelt Listings, die mit nur zwei Zeichen pro Ebene eingerückt sind, um allzu viele Zeilenumbrüche zu vermeiden.)

Die meisten Anweisungen müssen sich innerhalb von Klassen oder Funktionen befinden. In der höchsten Ebene einer Code-Datei sind nur relativ wenige Konstrukte erlaubt, neben Klassen und Funktionen unter anderem Deklarationen von globalen Konstanten, Variablen oder Funktionen sowie Package- und Import-Anweisungen.

Variablen und Konstanten

Variablen müssen vor ihrer Verwendung mit var deklariert werden. Die Typangabe erfolgt nach einem Doppelpunkt hinter dem Variablennamen:

var l: Long

Die Typangabe darf entfallen, wenn die Variable sofort initialisiert wird. Kotlin entscheidet sich dann für einen geeigneten Datentyp, der sich später nicht mehr ändern kann.

var i = 3
i = "abc"

Kotlin kennt gleich zwei Arten von Konstanten:

• Mit val deklarierte unveränderliche Variablen (read-only local variables) können zur Laufzeit einmalig mit einem beliebigen Wert initialisiert werden, dürfen sich dann aber nicht mehr ändern. In diesem Buch werden solche Konstanten als »unveränderliche Variablen« bezeichnet.

• Werte von Konstanten, die mit const val deklariert sind, müssen dagegen bereits zum Zeitpunkt des Kompilierens feststehen. Derartige Konstanten sind allerdings nicht in an beliebigen Orten im Code erlaubt. Es ist üblich, const-Konstanten mit lauter Großbuchstaben zu benennen.

Das folgende Listing definiert die »echte« Konstante PI und initialisiert die unveränderliche Variable n mit einer Zufallszahl zwischen 0 und 10:

const val PI = 3.1415

val n = (0..10).random()

n = 7

Der Aufruf der random-Methode zeigt gleich auch eine Besonderheit von Kotlin: Bereiche (ranges) werden in der Form start..ende formuliert und auf verschiedene Weisen eingesetzt, unter anderem auch in Schleifen.

Umgang mit null

In Variablen ist der Zustand null im Sinne von »nicht initialisiert« unzulässig. Soll dies doch erlaubt werden, muss dem Datentyp ein Fragezeichen nachgestellt werden. Kotlin spricht dann von nullable types. Andere Programmiersprachen verwenden oft den Begriff Optional.

Die Schreibweise Type? ist sowohl für elementare Datentypen (Int, Double) als auch für allgemeine Klassen erlaubt.

var perhapsAResult: Int?
perhapsAResult = null
if (perhapsAResult is Int)
println("Ergebnis: " + perhapsAResult)
else
println("Kein Ergebnis verfügbar.")

Statt mit is Int können Sie die Valididät der Daten auch mit einem null-Test sicherstellen:

if (perhapsAResult != null)
println("Ergebnis: " + perhapsAResult)
else
println("Kein Ergebnis verfügbar.")

Zeichenketten

Gewöhnliche Zeichenketten werden zwischen doppelte Anführungszeichen gestellt:

val s = "abc"

Für Zeichenketten, die Sonderzeichen wie \ enthalten oder über mehrere Zeichen reichen sollen, ist die folgende Raw-Syntax mit der Zeichenkombination """ vorgesehen:

val fname = """C:\Users\kofler"""
println(fname)

Um bei mehrzeiligen Zeichenketten die Einrückung zu eliminieren, starten Sie die Zeichenkette in der zweiten Zeile und fügen ihr die Methode trimIndent hinzu:

val sql = """
SELECT * FROM mytable
WHERE id > 20
ORDER BY name""".trimIndent()
println(sql)

Innerhalb von Zeichenketten wird $name durch den Inhalt des Variablennamens sowie ${ausdruck} durch den ausgewerteten Ausdruck ersetzt (String-Interpolation). Die Funktion sin und die Konstante PI befinden sich im Paket kotlin.math, das importiert werden muss. (Wenn Sie die import-Anweisung vergessen, weist IntelliJ Sie darauf hin. Sie können das fehlende Kommando dann bequem mit (Alt)+(¢) in den Code einfügen.)

import kotlin.math.*
val n = 7
println("n=$n")
val pi4 = PI / 4
println("Sinus = ${sin(pi4)}")

Listen, Sets und Maps

Die wichtigste Datenstruktur zur Speicherung mehrerer gleichartiger Daten sind Listen. Die beiden folgenden Zeilen definieren zwei unveränderliche Listen, einmal...

Über Autor(innen)

Kofler, Michael
Michael Kofler hat Telematik an der TU Graz studiert und ist einer der erfolgreichsten deutschsprachigen IT-Fachbuchautoren. Zu seinen Themengebieten zählen neben Linux auch IT-Sicherheit, Python, Swift, Java und der Raspberry Pi. Er ist Entwickler, berät Firmen undarbeitet als Lehrbeauftragter.