
Programmieren lernen mit Kotlin
Description
Alles über E-Books | Antworten auf Fragen rund um E-Books, Kopierschutz und Dateiformate finden Sie in unserem Info- & Hilfebereich.
More details
Other editions
Additional editions


Persons
ISNI: 0000 0001 1421 2803
Content
- 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
System requirements
File format: PDF
Copy protection: Watermark-DRM (Digital Rights Management)
System requirements:
- Computer (Windows; MacOS X; Linux): Use the free software Adobe Reader, Adobe Digital Editions, or any other PDF viewer of your choice (see eBook Help).
- Tablet/Smartphone (Android; iOS): Install the free app Adobe Digital Editions or another reading app for eBooks, e.g., PocketBook (see eBook Help).
- E-reader: Bookeen, Kobo, Pocketbook, Sony, Tolino and many more (only limited: Kindle).
The file format PDF always displays a book page identically on any hardware. This makes PDF suitable for complex layouts such as those used in textbooks and reference books (images, tables, columns, footnotes). Unfortunately, on the small screens of e-readers or smartphones, PDFs are rather annoying, requiring too much scrolling.
This eBook uses Watermark-DRM, a „soft” copy protection. This means that there are no technical restrictions to prevent illegal distribution. However, there is a personalised watermark embedded in the eBook that can be used to identify the purchaser of the eBook in the event of misuse and to provide evidence for legal purposes.
For more information, see our eBook Help page.