Kotlin. Rusz głową! - ebook

Kariera Kotlina nabrała rozpędu, gdy w 2017 roku na konferencji Google ogłoszono go jednym z oficjalnie wspieranych języków programowania aplikacji dla Androida. Jest lubiany za zwartą składnię, elastyczność i ścisłą integrację z kodem Javy. Oczywiście odpowiada też kryteriom nowoczesnego i innowacyjnego języka programowania. Jest bardzo dobrym wyborem dla każdego, kto chce się stać profesjonalnym programistą, ale też osoby programujące hobbystycznie będą zadowolone z jego możliwości. Problemów z tym idealnym językiem programowania jest niewiele: trzeba poznać Kotlina, zrozumieć kilka niuansów i nauczyć się kodowania...

Ta książka, podobnie jak inne pozycje z serii Rusz głową!, została przygotowana zgodnie z jedyną w swoim rodzaju metodyką nauczania wykorzystującą zasady funkcjonowania ludzkiego mózgu. Dzięki niej nauczysz się myśleć jak najlepsi programiści i niepostrzeżenie zaczniesz tworzyć wydajny kod w Kotlinie. Autorzy zastosowali najlepsze osiągnięcia psychologii, neurologii i innych nauk o uczeniu się, stąd niecodzienny wygląd i struktura książki. W efekcie zamiast klasycznego podręcznika otrzymujesz polisensoryczne doświadczenie poznawcze zaprojektowane tak, aby już wkrótce Kotlin stał się pewnym, niezawodnym narzędziem w Twoich rękach!

W tej książce między innymi:

• solidne podstawy tworzenia kodu i pisanie pierwszych projektów
• typy sparametryzowane w Kotlinie
• praca na obiektach: dziedziczenie, klasy, kolekcje
• funkcje wyższego rzędu i wyrażenia lambda
• współbieżność wykonywania kodu i najciekawsze rozszerzenia

Kotlin: oto radość z pisania kodu!

Wprowadzenie

• Dla kogo jest przeznaczona ta książka? (xxii)
  
• Wiemy, co sobie myślisz (xxiii)
  
• Wiemy, co sobie myśli Twój mózg (xxiii)
  
• Metapoznanie - myślenie o myśleniu (xxv)
  
• Oto co zrobiliśmy (xxvi)
  
• Przeczytaj to (xxviii)
  
• Zespół recenzentów technicznych (xxx)
  
• Podziękowania (xxxi)

ROZDZIAŁ 1. Zaczynamy. Szybki skok

• Witamy w Kotliczynie (2)
  
• Kotlina można używać niemal wszędzie (3)
  
• Co zrobimy w tym rozdziale (4)
  
• Instalowanie IntelliJ IDEA (Community Edition) (7)
  
• Stwórzmy prostą aplikację (8)
  
• Właśnie utworzyłeś swój pierwszy projekt w Kotlinie (11)
  
• Dodaj do projektu nowy plik Kotlina (12)
  
• Anatomia funkcji main (13)
  
• Dodaj funkcję main do pliku App.kt (14)
  
• Jazda próbna (15)
  
• Co możemy nakazać w funkcji main? (16)
  
• W kółko i w kółko, i w kółko... (17)
  
• Przykład pętli (18)
  
• Rozgałęzienia warunkowe (19)
  
• Używanie if do zwracania wartości (20)
  
• Aktualizujemy funkcję main (21)
  
• Stosowanie interaktywnej powłoki Kotlina (23)
  
• W REPL można wpisywać fragmenty mające wiele wierszy kodu (24)
  
• Wymieszane komunikaty (27)
  
• Twój przybornik do Kotlina (30)

ROZDZIAŁ 2. Typy proste i zmienne. Być zmienną

• Twój kod potrzebuje zmiennych (32)
  
• Co się dzieje, kiedy zadeklarujesz zmienną? (33)
  
• Zmienna zawiera referencję do obiektu (34)
  
• Typy proste Kotlina (35)
  
• Jak jawnie zadeklarować typ zmiennej? (37)
  
• Używaj wartości dostosowanej do typu zmiennej (38)
  
• Przypisywanie wartości innej zmiennej (39)
  
• Trzeba skonwertować wartość (40)
  
• Co się dzieje podczas konwertowania wartości? (41)
  
• Uważaj na przepełnienie (42)
  
• Zapisywanie wielu wartości w tablicy (45)
  
• Tworzymy aplikacje HasłoMator (46)
  
• Dodaj kod do pliku HasloMator.kt (47)
  
• Kompilator domyśla się typu tablicy na podstawie jej wartości (49)
  
• var oznacza, że zmienna może wskazywać na inną tablicę (50)
  
• val oznacza, że zmienna zawsze będzie wskazywać tę samą tablicę... (51)
  
• Zamotane referencje (54)
  
• Twój przybornik do Kotlina (58)

ROZDZIAŁ 3. Funkcje. Wychodzimy poza main

• Napiszmy grę: Kamień, nożyce, papier (60)
  
• Ogólny projekt gry (61)
  
• Wybieranie opcji przez grę (63)
  
• Jak się tworzy funkcje? (64)
  
• Do funkcji można przekazywać więcej informacji (65)
  
• Pobieranie informacji z funkcji (66)
  
• Funkcje, których ciałem jest jedno wyrażenie (67)
  
• Dodajemy funkcję getGameChoice do pliku Game.kt (68)
  
• Funkcja getUserChoice (75)
  
• Jak działają pętle for? (76)
  
• Zapytaj gracza, jaką opcję wybiera (78)
  
• Pomieszane komunikaty (79)
  
• Musimy sprawdzić dane wpisane przez gracza (81)
  
• Dodajemy getUserChoice do pliku Game.kt (83)
  
• Dodajemy funkcję printResult do pliku Game.kt (87)
  
• Twój przybornik do Kotlina (89)

ROZDZIAŁ 4. Klasy i obiekty. Trochę klasy

• Typy obiektowe są definiowane przy użyciu klas (92)
  
• Jak projektować własne klasy? (93)
  
• Zdefiniujmy klasę Dog (94)
  
• Jak utworzyć obiekt Dog? (95)
  
• Jak można odwoływać się do właściwości i funkcji? (96)
  
• Tworzymy aplikację Piosenki (97)
  
• Cud tworzenia obiektu (98)
  
• Jak są tworzone obiekty? (99)
  
• Za kulisami: Wywoływanie konstruktora (100)
  
• Dokładniejsze poznawanie właściwości (105)
  
• Elastyczna inicjalizacja właściwości (106)
  
• Jak używać bloków inicjalizatora? (107)
  
• Właściwości MUSZĄ zostać zainicjowane (108)
  
• Jak można weryfikować wartości właściwości? (111)
  
• Pisanie własnego akcesora get (112)
  
• Pisanie własnego akcesora set (113)
  
• Kompletny kod projektu Psy (115)
  
• Twój przybornik do Kotlina (120)

ROZDZIAŁ 5. Klasy pochodne i bazowe. Stosowanie dziedziczenia

• Dziedziczenie umożliwia unikanie powielania kodu (122)
  
• Co mamy zamiar zrobić? (123)
  
• Projektujemy strukturę dziedziczenia klas zwierząt (124)
  
• Używaj dziedziczenia, by unikać powielania kodu w klasach pochodnych (125)
  
• Co powinny przesłaniać klasy pochodne? (126)
  
• Możemy pogrupować niektóre zwierzęta (127)
  
• Dodajemy klasy Canine i Feline (128)
  
• Sprawdzaj hierarchie klas, używając testu JEST (129)
  
• Test JEST działa w dowolnym miejscu drzewa dziedziczenia (130)
  
• Stworzymy parę kotliczyńskich zwierząt (133)
  
• Deklarujemy klasę bazową oraz jej właściwości i funkcje jako otworzone (134)
  
• Jak klasa pochodna dziedziczy po bazowej? (135)
  
• Jak (i kiedy) przesłaniać właściwości? (136)
  
• Przesłanianie właściwości pozwala na więcej niż tylko określanie wartości domyślnych (137)
  
• Jak przesłaniać funkcje? (138)
  
• Przesłonięte funkcje i właściwości pozostają otworzone... (139)
  
• Dodajemy klasę Hippo do projektu Zwierzęta (140)
  
• Dodajemy klasy Canine i Wolf (143)
  
• Która funkcja zostanie wywołana? (144)
  
• Kiedy wywołujemy funkcję na rzecz zmiennej, wywoływana jest funkcja obiektu (146)
  
• Typów bazowych można używać w parametrach funkcji i jako typu zwracanego wyniku (147)
  
• Zaktualizowany kod pliku Animals.kt (148)
  
• Twój przybornik do Kotlina (153)

ROZDZIAŁ 6. Klasy abstrakcyjne i interfejsy. Poważny polimorfizm

• Hierarchia klasy Animal raz jeszcze (156)
  
• Obiektów niektórych klas po prostu nie powinno się tworzyć (157)
  
• Abstrakcyjna czy konkretna? (158)
  
• Klasy abstrakcyjne mogą mieć abstrakcyjne właściwości i funkcje (159)
  
• Klasa Animal ma dwie funkcje abstrakcyjne (160)
  
• Jak zaimplementować klasę abstrakcyjną? (162)
  
• TRZEBA zaimplementować wszystkie abstrakcyjne właściwości i funkcje (163)
  
• Zaktualizujmy kod projektu Zwierzęta (164)
  
• Niezależne klasy mogą mieć wspólne zachowania (169)
  
• Interfejsy pozwalają definiować wspólne zachowania POZA hierarchią klasy bazowej (170)
  
• Zdefiniujmy interfejs Roamable (171)
  
• Jak definiować właściwości w interfejsach? (172)
  
• Zadeklaruj, że klasa implementuje interfejs... (173)
  
• Jak implementować wiele interfejsów? (174)
  
• Jak określić, czy stworzyć klasę, klasę pochodną, klasę abstrakcyjną czy interfejs? (175)
  
• Aktualizujemy projekt Zwierzęta (176)
  
• Interfejsy pozwalają na stosowanie polimorfizmu (181)
  
• Gdzie używać operatora is? (182)
  
• Używaj when do porównywania zmiennej z grupą opcji (183)
  
• Operator is zazwyczaj wykonuje inteligentne rzutowanie (184)
  
• Używaj operatora as w celu jawnego rzutowania (185)
  
• Aktualizujemy projekt Zwierzęta (186)
  
• Twój przybornik do Kotlina (189)

ROZDZIAŁ 7. Klasy danych. Używanie danych

• Operator == wywołuje funkcję o nazwie equals (192)
  
• Funkcja equals pochodzi z klasy bazowej Any (193)
  
• Wspólne zachowania zdefiniowane w klasie Any (194)
  
• Możemy chcieć, by funkcja equals sprawdzała, czy obiekty są równoważne (195)
  
• Klasa danych pozwala na tworzenie obiektów danych (196)
  
• Klasy danych przesłaniają odziedziczone zachowania (197)
  
• Kopiowanie obiektów danych przy użyciu funkcji copy (198)
  
• Klasy danych definiują funkcje componentN... (199)
  
• Tworzymy projekt Przepisy (201)
  
• Pomieszane komunikaty (203)
  
• Wygenerowane funkcje używają jedynie właściwości zdefiniowanych w konstruktorze (205)
  
• Inicjalizowanie wielu właściwości może powodować powstawanie kłopotliwego kodu (206)
  
• Jak używać domyślnych wartości konstruktora? (207)
  
• Także funkcje mogą używać wartości domyślnych (210)
  
• Przeciążanie funkcji (211)
  
• Zaktualizujmy projekt Przepisy (212)
  
• Ciąg dalszy kodu... (213)
  
• Twój przybornik do Kotlina (217)

ROZDZIAŁ 8. Wartość null i wyjątki. Cały i zdrów

• Jak usuwać ze zmiennych referencje do obiektu? (220)
  
• Referencje usuwamy, używając null (221)
  
• Typów akceptujących null możesz używać wszędzie tam, gdzie typów, które null nie akceptują (222)
  
• Jak utworzyć tablice typu akceptującego null? (223)
  
• Jak odwoływać się do funkcji i właściwości typów akceptujących null? (224)
  
• Dbaj o bezpieczeństwo, używając bezpiecznych wywołań (225)
  
• Bezpieczne wywołania można łączyć w łańcuch (226)
  
• Ciąg dalszy historii... (227)
  
• Bezpiecznych wywołań można używać do przypisywania wartości... (228)
  
• Używaj let, by wykonywać kod, jeśli wartości będą różne od null (231)
  
• Stosowanie let z elementami tablic (232)
  
• Zamiast używać wyrażenia if... (233)
  
• Operator !! celowo zgłasza wyjątek NullPointerException (234)
  
• Tworzymy projekt Wartości Null (235)
  
• Ciąg dalszy kodu... (236)
  
• Wyjątki są zgłaszane w wyjątkowych sytuacjach (239)
  
• Przechwytuj wyjątki, używając try i catch (240)
  
• Użyj finally, by określić czynności, które mają być wykonane zawsze (241)
  
• Wyjątek to obiekt typu Exception (242)
  
• Wyjątki można zgłaszać jawnie (244)
  
• Try i catch to wyrażenia (245)
  
• Twój przybornik do Kotlina (250)

ROZDZIAŁ 9. Kolekcje. Zorganizuj się

• Tablice mogą być przydatne... (252)
  
• ...są jednak rzeczy, których tablice nie potrafią (253)
  
• Jeśli masz wątpliwości, sięgnij do Biblioteki (254)
  
• List, Set oraz Map (255)
  
• Fantastyczne listy... (256)
  
• Tworzenie listy MutableList... (257)
  
• Możemy usunąć wartość... (258)
  
• Można zmieniać kolejność i operować na większych grupach elementów... (259)
  
• Utwórz projekt Kolekcje (260)
  
• Listy dopuszczają duplikaty (263)
  
• Jak tworzyć zbiory? (264)
  
• Jak zbiory wyszukują duplikaty? (265)
  
• Kody mieszające i równość (266)
  
• Reguły przesłaniania funkcji hashCode i equals (267)
  
• Jak używać klasy MutableSet? (268)
  
• Aktualizujemy projekt Kolekcje (270)
  
• Czas na mapy (276)
  
• Sposoby korzystania z map (277)
  
• Tworzenie map MutableMap (278)
  
• Z mapy MutableMap można usuwać elementy (279)
  
• Mapy Map i MutableMap można kopiować (280)
  
• Kompletny kod projektu Kolekcje (281)
  
• Wymieszane komunikaty (285)
  
• Twój przybornik do Kotlina (287)

ROZDZIAŁ 10. Typy sparametryzowane. Odróżniaj wariancję od kontrawariancji

• Kolekcje używają typów sparametryzowanych (290)
  
• Jak jest zdefiniowany typ MutableList? (291)
  
• Stosowanie parametrów typów w MutableList (292)
  
• Co można robić ze sparametryzowanymi klasami i interfejsami? (293)
  
• Oto co mamy zamiar zrobić (294)
  
• Tworzymy hierarchię klasy Pet (295)
  
• Definiujemy klasę Contest (296)
  
• Dodajemy właściwość scores (297)
  
• Tworzymy funkcję getWinners (298)
  
• Tworzymy kilka obiektów Contest (299)
  
• Tworzymy projekt TypySparametryzowane (301)
  
• Hierarchia typu Retailer (305)
  
• Definiujemy interfejs Retailer (306)
  
• Możemy tworzyć obiekty CatRetailer, DogRetailer i FishRetailer... (307)
  
• Użyj out, by typ sparametryzowany był kowariantny (308)
  
• Aktualizujemy projekt TypySparametryzowane (309)
  
• Potrzebujemy klasy Vet (313)
  
• Tworzenie obiektów Vet (314)
  
• Użyj in, by typ sparametryzowany był kontrawariantny (315)
  
• Typ sparametryzowany może być lokalnie kontrawariantny (316)
  
• Aktualizujemy projekt TypySparametryzowane (317)
  
• Twój przybornik do Kotlina (324)

ROZDZIAŁ 11. Lambdy i funkcje wyższego rzędu. Kod używany jak dane

• Prezentacja lambd (326)
  
• Jak wygląda kod lambdy? (327)
  
• Lambdy można zapisywać w zmiennych (328)
  
• Wyrażenia lambda mają typ (331)
  
• Kompilator może wywnioskować typ parametrów lambdy (332)
  
• Używaj lambdy dostosowanej do typu zmiennej (333)
  
• Tworzenie projektu Lambdy (334)
  
• Możesz przekazać lambdę do funkcji (339)
  
• Wywołanie lambdy w ciele funkcji (340)
  
• Co się dzieje podczas wywołania funkcji? (341)
  
• Lambdę można przenieść poza nawiasy ()... (343)
  
• Aktualizujemy projekt Lambdy (344)
  
• Funkcje mogą zwracać lambdy (347)
  
• Piszemy funkcję, która pobiera I zwraca lambdy (348)
  
• Jak można używać funkcji combine? (349)
  
• Użyj typealias, by nadać inną nazwę istniejącemu typowi danych (353)
  
• Aktualizujemy kod projektu (354)
  
• Twój przybornik do Kotlina (361)

ROZDZIAŁ 12. Wbudowane funkcje wyższego rzędu. Wzmocnij swój kod

• Kotlin udostępnia sporo funkcji wyższego rzędu (364)
  
• Funkcje min i max operują na prostych typach danych (365)
  
• Bliższe spojrzenie na parametry funkcji minBy i maxBy (366)
  
• Funkcje sumBy i sumByDouble (367)
  
• Tworzymy projekt Spożywczak (368)
  
• Poznaj funkcję filter (371)
  
• Używaj funkcji map, by przekształcać kolekcje (372)
  
• Co się dzieje podczas wykonywania kodu? (373)
  
• Ciąg dalszy historii... (374)
  
• Funkcja forEach działa jak pętla (375)
  
• Funkcja forEach nie zwraca wyniku (376)
  
• Aktualizujemy projekt Spożywczak (377)
  
• Użyj groupBy, by podzielić kolekcję na grupy (381)
  
• Funkcji groupBy można używać w łańcuchach wywołań (382)
  
• Jak używać funkcji fold (383)
  
• Za kulisami: funkcja fold (384)
  
• Więcej przykładów użycia funkcji fold (386)
  
• Aktualizujemy projekt Spożywczak (387)
  
• Pomieszane komunikaty (391)
  
• Twój przybornik do Kotlina (394)
  
• Wyjeżdżamy... (395)

Dodatek A. Koprocedury. Współbieżne wykonywanie kodu

Dodatek B. Testowanie. Pociągnij swój kod do odpowiedzialności

Dodatek C. Pozostałości. Dziesięć najważniejszych rzeczy (których nie opisaliśmy)

• 1. Pakiety i importowanie (416)
  
• 2. Modyfikatory widoczności (418)
  
• 3. Klasy wyliczeniowe (420)
  
• 4. Klasy zapieczętowane (422)
  
• 5. Klasy zagnieżdżone i wewnętrzne (424)
  
• 6. Deklaracje obiektów i wyrażenia (426)
  
• 7. Rozszerzenia (429)
  
• 8. Return, break i continue (430)
  
• 9. Więcej zabawy z funkcjami (432)
  
• 10. Współdziałanie (434)