Programmieren lernen mit Kotlin

Name: Programmieren lernen mit Kotlin | Grundlagen, Objektorientierung und fortgeschrittene Konzepte
Brand: Hanser
Price: 39.99 EUR
Availability: OnlineOnly

Grundlagen, Objektorientierung und fortgeschrittene Konzepte

Christian Kohls Alexander Dobrynin(Autor*in)

Hanser (Verlag)

2. Auflage

Erschienen am 9. Oktober 2023

564 Seiten

E-Book

PDF mit Wasserzeichen-DRM

Systemvoraussetzungen

978-3-446-47849-7 (ISBN)

39,99 €inkl. 7% MwSt.

Systemvoraussetzungen

für PDF mit Wasserzeichen-DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Weitere Details

Weitere Ausgaben

Personen

Inhalt

Intro
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ür main
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
Stichwortverzeichnis

Inhalt (PDF)

Systemvoraussetzungen

Als PDF speichern Als Link merken