Programmieren lernen mit Kotlin

Inhalt

Vorwort

1 Einführung

1.1 Eine Sprache für viele Plattformen

1.2 Deshalb ist Kotlin so besonders

1.3 Darauf dürfen Sie sich freuen

Teil I: Konzeptioneller Aufbau von Computern und Software

2 Komponenten eines Computers

2.1 Beliebige Daten als binäre Zahlen

2.2 Wie Zahlen in Texte, Bilder und Animationen umgewandelt werden

2.3 Zahlen als ausführbarer Code

3 Zugriff auf den Speicher

3.1 Organisation des Speichers

3.2 Daten im Speicher und Datenverarbeitung im Prozessor

3.3 Heap und Stack

3.4 Programme als Code schreiben statt als Zahlenfolgen

4 Interpreter und Compiler

4.1 Virtuelle Maschinen, Bytecode und Maschinencode

4.2 Kotlin – eine Sprache, viele Plattformen

5 Syntax, Semantik und Pragmatik

5.1 Syntax

5.2 Semantik

5.3 Pragmatik

6 Eingabe – Verarbeitung – Ausgabe

7 Los geht's

7.1 Integrierte Entwicklungsumgebungen

7.2 Projekt anlegen

Teil II: Grundlagen des Programmierens

8 Anweisungen und Ausdrücke

8.1 Ausdrücke

8.1.1 Literale

8.1.2 Operationen

8.1.3 Variablen und Funktionsaufrufe

8.2 Evaluation von Ausdrücken

8.2.1 Evaluieren von Operatoren

8.2.2 Evaluieren von Funktionen

8.2.3 Evaluieren von Variablen

8.3 Zusammenspiel von Werten und Typen

8.3.1 Typprüfungen durch den Compiler

8.3.2 Typen als Bausteine

9 Basis-Datentypen

9.1 Numerics

9.2 Characters und Strings

9.3 Booleans

9.4 Arrays

9.5 Unit

9.6 Any

9.7 Nothing

9.8 Zusammenfassung

10 Variablen

10.1 Deklaration, Zuweisung und Verwendung

10.2 Praxisbeispiel

10.2.1 Relevante Informationen extrahieren

10.2.2 Das Problem im Code lösen

11 Kontrollstrukturen

11.1 Fallunterscheidungen mit if

11.1.1 if-Anweisung

11.1.2 if-Ausdruck

11.2 Pattern-Matching mit when

11.2.1 Interpretieren von Werten

11.2.2 Typüberprüfungen

11.2.3 Überprüfen von Wertebereichen

11.2.4 Abbilden von langen if-else-Blöcken

11.3 Wiederholung von Code mit while-Schleifen

11.3.1 Zählen, wie oft etwas passiert

11.3.2 Gameloop

11.4 Iterieren über Datenstrukturen mit for-Schleifen

11.4.1 Iteration mit Arrays

11.4.2 Iteration mit Ranges

11.4.3 Geht das alles nicht auch mit einer while-Schleife?

12 Funktionen

12.1 Top-Level- und Member-Functions

12.2 Funktionsaufrufe (Applikation)

12.3 Syntax

12.4 Funktionsdefinition (Deklaration)

12.5 Funktionen als Abstraktion

12.6 Scoping

12.7 Rekursive Funktionen

12.7.1 Endlose Rekursion

12.7.2 Terminierende Rekursion

12.7.3 Rekursion vs. Iteration

12.7.4 Von Iteration zur Rekursion

12.8 Shadowing von Variablen

12.9 Pure Funktionen und Funktionen mit Seiteneffekt

12.9.1 Das Schlechte an Seiteneffekten

12.9.2 Ohne kommen wir aber auch nicht aus

12.9.3 Was denn nun?

12.10 Die Ideen hinter Funktionaler Programmierung

12.11 Lambdas

12.12 Closures

12.13 Funktionen höherer Ordnung

12.13.1 Funktionen, die Funktionen als Parameter akzeptieren

12.13.2 Funktionen, die Funktionen zurückgeben

12.14 Zusammenfassung

12.15 Das war's

Teil III: Objektorientierte Programmierung

13 Was sind Objekte?

14 Klassen

14.1 Eigene Klassen definieren

14.2 Konstruktoren

14.2.1 Aufgaben des Konstruktors

14.2.2 Primärer Konstruktor

14.2.3 Parameter im Konstruktor verwenden

14.2.4 Initialisierungsblöcke

14.2.5 Klassen ohne expliziten Konstruktor

14.2.6 Zusätzliche Eigenschaften festlegen

14.2.7 Klassen mit sekundären Konstruktoren

14.2.8 Default Arguments

14.2.9 Named Arguments

14.3 Funktionen und Methoden

14.3.1 Objekte als Parameter

14.3.2 Methoden: Funktionen auf Objekten ausführen

14.3.3 Von Funktionen zu Methoden

14.4 Datenkapselung

14.4.1 Setter und Getter

14.4.2 Berechnete Eigenschaften

14.4.3 Methoden in Eigenschaften umwandeln

14.4.4 Sichtbarkeitsmodifikatoren

14.5 Spezielle Klassen

14.5.1 Daten-Klassen

14.5.2 Enum-Klassen

14.5.3 Singuläre Objekte

14.6 Verschachtelte Klassen

14.6.1 Statische Klassen

14.6.2 Lokale Klassen

14.6.3 Innere Klassen

14.6.4 Anonyme innere Objekte

14.7 Klassen und Objekte sind Abstraktionen

15 Movie Maker – Ein Simulationsspiel

15.1 Überlegungen zur Klassenstruktur

15.1.1 Eigenschaften und Methoden von Movie

15.1.2 Eigenschaften und Methoden von Director

15.1.3 Eigenschaften und Methoden von Actor

15.1.4 Genre als Enum

15.1.5 Objektstruktur

15.2 Von der Skizze zum Programm

15.2.1 Movie-Maker-Projekt anlegen

15.2.2 Genre implementieren

15.2.3 Actor und Director implementieren

15.2.4 Erfahrungszuwachs bei Fertigstellung eines Films

15.3 Komplexe Objekte zusammensetzen

15.3.1 Skills als eine Einheit zusammenfassen

15.3.2 Begleit-Objekt für Skills

15.3.3 Objektkomposition und Objektaggregation

15.3.4 Zusammensetzung der Klasse Movie

15.3.5 Film produzieren

15.3.6 Ein Objekt für Spieldaten

Teil IV: Vererbung und Polymorphie

16 Vererbung

16.1 Vererbungsbeziehung

16.2 Klassenhierarchien

16.3 Eigenschaften und Methoden vererben

17 Polymorphie

17.1 Überschreiben von Methoden

17.1.1 Eine Methode unterschiedlich überschreiben

17.1.2 Dynamische Bindung

17.1.3 Überschreiben eigener Methoden

17.1.4 Überladen von Methoden

17.2 Typen und Klassen

17.2.1 Obertypen und Untertypen

17.2.2 Generalisierung und Spezialisierung

17.2.3 Typkompatibilität

17.2.4 Upcast und Downcast

17.2.5 Vorsicht bei der Typinferenz

17.2.6 Smart Casts

18 Abstrakte Klassen und Schnittstellen

18.1 Abstrakte Klassen

18.2 Schnittstellen

18.2.1 Schnittstellen definieren

18.2.2 Schnittstellen implementieren

18.2.3 Schnittstellen für polymorphes Verhalten

18.2.4 Standardverhalten für Interfaces

18.2.5 Mehrere Interfaces implementieren

18.3 Alles sind Typen

Teil V: Robustheit

19 Nullfähigkeit

19.1 Nullfähige Typen

19.1.1 Typen nullfähig machen

19.1.2 Optional ist ein eigener Typ

19.2 Sicherer Zugriff auf nullfähige Typen

19.2.1 Überprüfen auf null

19.2.2 Safe Calls

19.2.3 Verkettung von Safe Calls

19.3 Nullfähige Typen auflösen

19.3.1 Überprüfen mit if-else

19.3.2 Der Elvis-Operator rockt

19.3.3 Erzwungenes Auflösen

20 Exceptions

20.1 Sowohl Konzept als auch eine Klasse

20.2 Beispiele für Exceptions

20.2.1 ArrayIndexOutOfBoundsException

20.2.2 ArithmeticException

20.3 Exceptions aus der Java-Bibliothek

20.4 Exceptions auffangen und behandeln

20.4.1 Schreiben in eine Datei

20.4.2 Metapher: Balancieren über ein Drahtseil

20.5 Exceptions werfen

20.6 Exceptions umwandeln

20.6.1 Von Exception zu Optional

20.6.2 Von Optional zu Exception

20.6.3 Exceptions vs. Optionals

20.7 Exceptions weiter werfen

20.8 Sinn und Zweck von Exceptions

21 Movie Maker als Konsolenspiel umsetzen

21.1 Die Gameloop

21.2 Einen neuen Film produzieren

21.3 Statistik anzeigen

22 Entwurfsmuster

22.1 Das Strategiemuster

22.1.1 Im Code verstreute Fallunterscheidungen mit when

22.1.2 Probleme des aktuellen Ansatzes

22.1.3 Unterschiedliche Strategien für die Ausgabe

22.1.4 Nutzen der Strategie

22.2 Das Dekorierermuster

22.2.1 Probleme des gewählten Ansatzes

22.2.2 Dekorierer für Komponenten

22.2.3 Umsetzung des Dekorierers

22.2.4 Nutzen des Dekorierers

22.3 Weitere Entwurfsmuster

23 Debugger

Teil VI: Datensammlungen und Collections

24 Überblick

24.1 Pair und Triple

24.1.1 Verwendung

24.1.2 Syntaktischer Zucker

24.1.3 Destructuring

24.1.4 Einsatzgebiete

24.2 Arrays

24.2.1 Direkter Datenzugriff

24.2.2 Arrays mit null-Referenzen

24.2.3 Arrays mit primitiven Daten

24.2.4 Arrays vs. Listen

24.3 Listen

24.3.1 Unveränderliche Listen

24.3.2 Veränderliche Listen

24.3.3 List und MutableList sind verwandte Schnittstellen

24.4 Sets

24.4.1 Sets verwenden

24.4.2 Mengen-Operationen

24.5 Maps

24.5.1 Maps erzeugen

24.5.2 Arbeiten mit Maps

24.5.3 Maps durchlaufen

25 Funktionen höherer Ordnung für Datensammlungen

25.1 Unterschiedliche Verarbeitung von Listen

25.1.1 Imperative Verarbeitung von Listen

25.1.2 Funktionale Verarbeitung von Listen

25.1.3 Funktionen als kombinierbare Arbeitsanleitungen

25.1.4 Aufbau von Funktionen höherer Ordnung am Beispiel von map

25.2 Hilfreiche Funktionen für Datensammlungen

25.3 Anwendungsbeispiele für Funktionen höherer Ordnung

25.4 Sequenzen

25.4.1 Eager Evaluation – viel zu fleißig

25.4.2 Lazy Evaluation – Daten bei Bedarf verarbeiten

25.4.3 Sequenzen verändern die Reihenfolge

25.4.4 Fleißig oder faul – was ist besser?

26 Invarianz, Kovarianz und Kontravarianz

26.1 Typsicherheit durch Typ-Parameter

26.1.1 Invarianz

26.1.2 Die Grenzen von Invarianz

26.1.3 Kovarianz

26.1.4 Kontravarianz

26.2 Invarianz, Kovarianz und Kontravarianz im Vergleich

27 Listen selbst implementieren

27.1 Was ist eine Liste?

27.1.1 Unterschiedliche Listen als konkrete Formen

27.1.2 Eine Schnittstelle für alle möglichen Listen

27.1.3 Typ-Parameter selbst definieren (Generics)

27.1.4 Verschiedene Implementierungen derselben Schnittstelle

27.2 Implementierung der SimpleList durch Delegation

27.3 Implementierung der SimpleList mit Arrays

27.3.1 Datenstruktur

27.3.2 Direkte Abbildung der Listen-Operationen auf ein Array

27.3.3 Listen-Operationen mit aufwendiger Laufzeit bei Arrays

28 Verkettete Listen

28.1 Basisstruktur der verketteten Liste

28.2 Implementierung der verketteten Liste

28.3 Umsetzung der Funktionen

28.3.1 Einfügen am Anfang einer verketteten Liste

28.3.2 Zugriff auf das erste Element der verketteten Liste

28.3.3 Zugriff auf das letzte Element der verketteten Liste

28.3.4 Allgemeines Schema zum Durchlaufen einer verketteten Liste

28.3.5 Elemente der verketteten Liste zählen

28.3.6 Zugriff auf das n-te Element

28.4 Über alle Listenelemente iterieren

28.4.1 Die Schnittstelle Iterable

28.4.2 Iterator implementieren

28.4.3 Iterator verwenden

28.4.4 Interne Iteration

29 Testen und Optimieren

29.1 Korrektheit von Programmen

29.2 Testfälle in JUnit schreiben

29.2.1 Assertions

29.2.2 Implementierung der Liste testen

29.3 Teste zuerst

29.4 Klasseninvariante

29.4.1 Alternative Implementierung von size() für die verkettete Liste

29.4.2 Gewährleistung eines gültigen Zustands

30 Optimierung und Laufzeiteffizienz

30.1 Laufzeit empirisch ermitteln

30.2 Laufzeit theoretisch einschätzen

30.3 Die O-Notation

30.4 Praktische Beispiele für die O-Notation

31 Unveränderliche verkettete Liste

31.1 Datenstruktur für die unveränderliche Liste

31.1.1 Fallunterscheidung durch dynamische Bindung

31.1.2 Explizite Fallunterscheidung innerhalb der Funktion

31.1.3 Neue Listen erzeugen statt Liste verändern

31.1.4 Hilfsfunktionen über Companion-Objekt bereitstellen

31.2 Rekursive Implementierungen

31.2.1 map und fold als rekursive Implementierung

31.2.2 forEach und Endrekursion

Teil VII: Android

32 Grundlagen

32.1 Erstellen eines Projekts

32.2 Aufbau von Android Studio

32.3 Funktionsweise einer Android-App

32.4 Projektstruktur einer Android-App

33 Entwicklung einer Android-App

33.1 Integration der Daten

33.2 StartActivity erstellen (manuell)

33.2.1 Anlegen des Layouts

33.2.2 Erstellen der Activity

33.2.3 Registrieren der Activity

33.3 Persistenz

33.3.1 Definition der Schnittstelle

33.3.2 Implementierung mit Shared Preferences

33.3.3 Zentrales Instanziieren mit Extension Functions

33.3.4 Zugriff auf die Datenbankinstanz

33.4 CreateMovieActivity erstellen (automatisiert)

33.4.1 Erstellen der Activity

33.4.2 Starten der Activity

33.4.3 Implementieren des Layouts

33.4.4 Implementieren der Activity

33.5 Ergebnisdialog

33.5.1 Erstellen des Layouts

33.5.2 Erstellen und Anzeigen des Dialogs

33.6 Letzter Feinschliff

Teil VIII: Nebenläufigkeit

34 Grundlagen

34.1 Threads

34.1.1 Nicht-determinierter Ablauf

34.1.2 Schwergewichtige Threads

34.2 Koroutinen (Coroutines)

34.2.1 Koroutine vs. Subroutine

34.2.2 Coroutines vs. Threads

34.3 Zusammenfassung der Konzepte

35 Coroutines verwenden

35.1 Nebenläufige Begrüßung

35.1.1 Koroutine im Global Scope starten

35.1.2 Mehrere Koroutinen nebenläufig starten

35.1.3 Künstliche Wartezeit einbauen mit sleep

35.1.4 Informationen über den aktuellen Thread

35.2 Blockieren und Unterbrechen

35.2.1 Mehrere Koroutinen innerhalb von runBlocking starten

35.2.2 Zusammenspiel von Threads

35.3 Arbeit auf Threads verteilen

35.4 Jobs

35.5 Nebenläufigkeit auf dem main-Thread

35.5.1 Zusammenspiel von blockierenden und unterbrechenden Abschnitten

35.5.2 Abwechselnde Ausführung

35.6 Strukturierte Nebenläufigkeit mit Coroutine Scopes

35.7 runBlocking für main

35.8 Suspending Functions

35.8.1 Unterbrechen und Fortsetzen – Behind the scenes

35.8.2 Eigene Suspending Functions schreiben

35.8.3 Async

35.8.4 Strukturierte Nebenläufigkeit mit Async

35.8.5 Auslagern langläufiger Berechnungen

35.9 Dispatcher

35.9.1 Dispatcher festlegen

35.9.2 Wichtige Dispatcher für Android

36 Wettlaufbedingungen

36.1 Beispiel: Bankkonto

36.1.1 Auftreten einer Wettlaufbedingung

36.1.2 Unplanbare Wechsel zwischen Threads

36.2 Vermeidung von Wettlaufbedingungen

36.2.1 Threadsichere Datenstrukturen

36.2.2 Thread-Confinement

36.2.3 Kritische Abschnitte

37 Deadlocks

38 Aktoren

39 Da geht noch mehr

39.1 Infix-Notation

39.2 Operatoren überladen

39.3 Scope-Funktionen

39.3.1 apply-Funktion

39.3.2 let-Funktion

39.3.3 also-Funktion

39.3.4 Unterschiede der Scope-Funktionen

39.3.5 with-Funktion

39.4 Extension Functions

39.5 Weitere Informationsquellen

Stichwortverzeichnis