Programmieren lernen mit Kotlin · 2.Auflage by Dobrynin, Alexander -- Read -- Imperial Library of Trantor

Index

Titelei Impressum 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 Entwicklungsumgebung 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 10.2.3 Zusammenfassung

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?

11.5 Zusammenfassung

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 Inline-Funktionen 12.10 Pure Funktionen und Funktionen mit Seiteneffekt

12.10.1 Das Schlechte an Seiteneffekten 12.10.2 Ohne kommen wir aber auch nicht aus 12.10.3 Was denn nun?

12.11 Die Ideen hinter Funktionaler Programmierung 12.12 Lambdas 12.13 Closures 12.14 Funktionen höherer Ordnung

12.14.1 Funktionen, die Funktionen als Parameter akzeptieren 12.14.2 Funktionen, die Funktionen zurückgeben

12.15 Zusammenfassung 12.16 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.5.4 Daten-Objekte

14.6 Verschachtelte Klassen

14.6.1 Statische Klassen 14.6.2 Innere Klassen 14.6.3 Lokale innere Klassen 14.6.4 Anonyme innere Objekte

14.7 Inline-Value-Klassen 14.8 Klassen und Objekte sind Abstraktionen 14.9 Zusammenfassung

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 15.3.7 Code zum Projekt

Teil IV: Vererbung und Polymorphie

16 Vererbung

16.1 Vererbungsbeziehung 16.2 Klassenhierarchien 16.3 Eigenschaften und Methoden vererben 16.4 Zusammenfassung

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 SAM-Interfaces 18.2.6 Mehrere Interfaces implementieren

18.3 Alles sind Typen 18.4 Zusammenfassung

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.3.7 Die verbleibenden Methoden implementieren

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 Android Studio

32.1 Erstellen eines Projekts 32.2 Aufbau von Android Studio 32.3 Funktionsweise einer Android-App

32.3.1 MainActivity 32.3.2 Context 32.3.3 Manifest und Gradle-Skripte

32.4 Projektstruktur einer Android-App 32.5 Theming 32.6 Preview

33 Jetpack Compose

33.1 Deklarative UI-Entwicklung 33.2 Composable-Functions 33.3 Layout 33.4 State-Management

33.4.1 MutableState 33.4.2 Die remember-Funktion 33.4.3 State-Hoisting

33.5 Modifier 33.6 App-Architektur

33.6.1 UI-Layer 33.6.2 Data-Layer 33.6.3 Unidirectional-Data-Flow 33.6.4 Lokaler State 33.6.5 Observable-Types

33.7 Composition und Recomposition

33.7.1 Composition-Phase 33.7.2 Layout-Phase 33.7.3 Drawing-Phase

33.8 Persistenz

34 Entwicklung der Movie-Maker-App

34.1 Setup 34.2 ViewModel und DataStore 34.3 Start-Screen

34.3.1 Scaffold 34.3.2 Budget-Screen 34.3.3 Top-Bar

34.4 Produce-Movie-Screen

34.4.1 TitleTextfield 34.4.2 Actor-Pager 34.4.3 Budget-Slider 34.4.4 State-Hoisting 34.4.5 Produce-Movie-Button

34.5 Movie-Produced-Screen 34.6 Movie-Production-Error-Screen 34.7 Navigation

Teil VIII: Nebenläufigkeit

35 Grundlagen

35.1 Threads

35.1.1 Nicht-determinierter Ablauf 35.1.2 Schwergewichtige Threads

35.2 Koroutinen (Coroutines)

35.2.1 Koroutine vs. Subroutine 35.2.2 Coroutines vs. Threads

35.3 Zusammenfassung der Konzepte

36 Coroutines verwenden

36.1 Nebenläufige Begrüßung

36.1.1 Koroutine im Global Scope starten 36.1.2 Mehrere Koroutinen nebenläufig starten 36.1.3 Künstliche Wartezeit einbauen mit sleep 36.1.4 Informationen über den aktuellen Thread

36.2 Blockieren und Unterbrechen

36.2.1 Mehrere Koroutinen innerhalb von runBlocking starten 36.2.2 Zusammenspiel von Threads

36.3 Arbeit auf Threads verteilen 36.4 Jobs 36.5 Nebenläufigkeit auf dem main-Thread

36.5.1 Zusammenspiel von blockierenden und unterbrechenden Abschnitten 36.5.2 Abwechselnde Ausführung

36.6 Strukturierte Nebenläufigkeit mit Coroutine Scopes 36.7 runBlocking fürmain 36.8 Suspending Functions

36.8.1 Unterbrechen und Fortsetzen – Behind the scenes 36.8.2 Eigene Suspending Functions schreiben 36.8.3 Async 36.8.4 Strukturierte Nebenläufigkeit mit Async 36.8.5 Auslagern langläufiger Berechnungen

36.9 Dispatcher

36.9.1 Dispatcher festlegen 36.9.2 Wichtige Dispatcher für Android

37 Wettlaufbedingungen

37.1 Beispiel: Bankkonto

37.1.1 Auftreten einer Wettlaufbedingung 37.1.2 Unplanbare Wechsel zwischen Threads

37.2 Vermeidung von Wettlaufbedingungen

37.2.1 Threadsichere Datenstrukturen 37.2.2 Thread-Confinement 37.2.3 Kritische Abschnitte

38 Deadlocks 39 Aktoren 40 Da geht noch mehr

40.1 Infix-Notation 40.2 Operatoren überladen 40.3 Scope-Funktionen

40.3.1 apply-Funktion 40.3.2 let-Funktion 40.3.3 also-Funktion 40.3.4 Unterschiede der Scope-Funktionen 40.3.5 with-Funktion

40.4 Extension Functions 40.5 Weitere Informationsquellen

← Prev
Back
Next →

← Prev
Back
Next →