Nowoczesne aplikacje mobilne dla studenta i technika programisty "Kotlin i Android Jetpack Compose" Bartłomiej Wlach

Spis treści książki

SPIS TREŚCI
1 WPROWADZENIE ............................................................................................. 11
1.1 SŁOWO WSTĘPU .................................................................................................. 11
1.2 KOTLIN ............................................................................................................... 11
1.3 KOTLIN VS JAVA ................................................................................................... 12
1.4 KODY ŹRÓDŁOWE PROGRAMÓW .............................................................................. 15
2 INSTALACJA ŚRODOWISK PROGRAMISTYCZNYCH ............................................. 19
2.1 ANDROID STUDIO ................................................................................................. 19
2.1.1 Instalacja Android Studio ........................................................................ 19
2.2 INTELLIJ .............................................................................................................. 22
2.2.1 Instalacja Intellij ...................................................................................... 22
2.2.2 Tworzenie projektu .................................................................................. 29
3 KOTLIN ............................................................................................................ 35
3.1 HELLO WORLD/OPERACJE WEJŚCIA I WYJŚCIA ............................................................ 35
3.1.1 Wyjście .................................................................................................... 35
3.1.2 Wejście .................................................................................................... 37
3.2 ZMIENNE, STAŁE ORAZ TYPY DANYCH ........................................................................ 38
3.2.1 Typy danych ............................................................................................. 38
3.2.2 Zmienne oraz stałe .................................................................................. 39
3.2.2.1 Zmienne Var .................................................................................................... 39
3.2.2.2 Zmienne Val ..................................................................................................... 41
3.2.2.3 Stałe ................................................................................................................. 42
3.3 INSTRUKCJE WARUNKOWE ..................................................................................... 43
3.4 PĘTLE ................................................................................................................ 48
3.4.1 For ........................................................................................................... 48
3.4.2 forEach .................................................................................................... 50
3.4.3 While i do-while ....................................................................................... 52
3.5 TABLICE, ZBIORY, MAPY I TYM PODOBNE ................................................................... 53
3.5.1 Tablice/Array ........................................................................................... 53
3.5.2 Zbiory ....................................................................................................... 56
3.5.3 Listy ......................................................................................................... 61
3.5.4 Mapy ....................................................................................................... 62
3.6 KONWERSJA TYPÓW ............................................................................................. 63
3.6.1 Konwertowanie typów danych ................................................................ 63
3.6.2 Smart Cast ............................................................................................... 67
3.7 FUNKCJE ............................................................................................................. 69
3.7.1 Funkcja bez parametrowa, niezwracająca żadnej wartości .................... 69
3.7.2 Funkcja z parametrami ............................................................................ 69
3.7.3 Funkcja jednoliniowa ............................................................................... 70
3.7.4 Funkcja jako wyrażenie lambda .............................................................. 71
3.7.5 Funkcja z parametrami zwracająca wartości .......................................... 72
3.7.6 Funkcja Inline........................................................................................... 75
3.7.7 Funkcje inline z parametrami noinline .................................................... 76
3.7.8 Funkcja wyższego rzędu .......................................................................... 77
3.7.9 Rekurencja ............................................................................................... 82
3.7.10 Przeciążenia ............................................................................................. 85
3.7.11 Funkcje Biblioteczne ................................................................................ 86
3.7.12 Funkcje Lokalizowane .............................................................................. 88
3.7.13 Funkcje Rozszerzające ............................................................................. 89
3.8 KLASY ................................................................................................................ 93
3.8.1 OOP czyli programowanie zorientowane obiektowo .............................. 93
3.8.2 Tworzymy pierwszą klasę ........................................................................ 94
3.8.3 Tworzymy pierwsze programy OOP ........................................................ 97
3.8.4 Polimorfizm, Dziedziczenie .................................................................... 104
3.8.5 Interfejsy i klasy abstrakcyjne ............................................................... 109
3.8.6 Hermetyzacja ........................................................................................ 111
3.8.7 klasy zagnieżdżone i wewnętrzne .......................................................... 112
3.8.8 Klasy zapieczętowane ............................................................................ 114
3.8.9 Klasy Generics i klasy wyliczeniowe ....................................................... 115
3.8.10 Delegacja ............................................................................................... 117
3.8.11 Klasy danych .......................................................................................... 120
3.8.12 Singleton ................................................................................................ 121
3.9 WYJĄTKI ........................................................................................................... 123
3.9.1 Try-catch ................................................................................................ 123
3.9.2 Throw .................................................................................................... 125
3.9.3 Try-catch-finally ..................................................................................... 127
3.9.4 Własne wyjątki ...................................................................................... 129
3.10 ASYNCHRONICZNOŚĆ .......................................................................................... 130
3.10.1 Coroutines oraz suspend fun ................................................................. 131
3.10.2 Dispatcher oraz Scope ........................................................................... 135
3.11 PODSUMOWANIE ............................................................................................... 137
4 JETPACK COMPOSE ........................................................................................ 141
4.1 WPROWADZENIE/KONFIGURACJA JETPACK COMPOSE ............................................... 141
4.1.1 Pierwsza aplikacja ................................................................................. 141
4.1.2 Kod całej aplikacji .................................................................................. 162
4.2 WSTĘP DO NOWOCZESNYCH APLIKACJI MOBILNYCH NA SYSTEMY ANDROID .................... 165
4.2.1 Czym jest Jetpack Compose? ................................................................. 165
4.2.2 Dlaczego warto używać Jetpack Compose? Wady i zalety .................... 166
4.3 TWORZENIE UI/KOMPONENTY W JETPACK COMPOSE ............................................... 168
4.3.1 Podstawowe komponenty ..................................................................... 168
4.3.2 Komponenty hierarchiczne .................................................................... 171
4.3.3 Modifier ................................................................................................. 175
4.3.4 Zaawansowane komponenty hierarchiczne .......................................... 177
4.4 ZARZĄDZANIE STANEM ........................................................................................ 186
4.4.1 Czym jest Stan? ..................................................................................... 186
4.4.2 Stan lokalny czyli remeber oraz mutuableStateOf ................................ 187
4.4.3 Przechowywanie stanu za pomocą rememberSaveable, derivedStateOf
188
4.5 ZAAWANSOWANE KOMPONENTY ........................................................................... 190
4.6 KOMUNIKACJA MIĘDZY KOMPONENTAMI ................................................................ 198
4.6.1 Przekazywanie stanu jako parametr ..................................................... 198
4.6.2 ViewModel oraz StateFlow .................................................................... 203
4.6.3 Single Source of Truth ............................................................................ 209
4.7 ZAAWANSOWANE TECHNIKI .................................................................................. 210
4.7.1 Bazy danych oraz asynchroniczne ładow .............................................. 210
4.7.2 Obsługa wyjątków ................................................................................. 219
4.7.3 Nawigacja ............................................................................................. 222
4.7.4 Rozbicie kodu projektu na kilka plików ................................................. 226
4.7.5 Motywy ................................................................................................. 227
4.7.5.1 Tworzymy aplikację zmieniającą motywy ...................................................... 227
4.7.5.2 Kod aplikacji ................................................................................................... 236
4.7.6 Powiadomienia/Komunikaty ................................................................. 239
4.7.6.1 Toast .............................................................................................................. 239
4.7.6.2 Snackbar ........................................................................................................ 240
4.7.6.3 Okno dialogowe ............................................................................................. 244
4.7.6.4 Powiadomienia .............................................................................................. 247
4.7.7 Typografia ............................................................................................. 253
4.7.8 Animacje ................................................................................................ 256
4.7.8.1 animateAsState ............................................................................................. 256
4.7.8.2 AnimatedVisibility .......................................................................................... 260
4.7.8.3 Crossfade ....................................................................................................... 261
4.7.8.4 animateContentSize ...................................................................................... 262
4.7.8.5 UpdateTransition ........................................................................................... 263
4.7.9 SideEffects ............................................................................................. 266
4.7.10 Alternatywne metody zapisu danych .................................................... 269
5 PROJEKT KOŃCOWY ....................................................................................... 275
5.1.1 Proces tworzenia projektu ..................................................................... 275
5.1.2 Podsumowanie ...................................................................................... 313
5.1.3 Kod całego projektu............................................................................... 314
6 BIBLIOGRAFIA ................................................................................................ 341

pokaż cały spis treści

ukryj recenzje