reklama - zainteresowany?

Kotlin. Rusz głową! - Helion


ebook
Autor: Dawn Griffiths, David Griffiths
Tytuł oryginału: Head First Kotlin: A Brain-Friendly Guide
Tłumaczenie: Piotr Rajca
ISBN: 978-83-283-5870-6
stron: 472, Format: ebook
Data wydania: 2020-01-14
Księgarnia: Helion

Cena książki: 57,85 zł (poprzednio: 89,00 zł)
Oszczędzasz: 35% (-31,15 zł)

Dodaj do koszyka

Tagi: Java - Programowanie

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!

Dodaj do koszyka

 

Osoby które kupowały "Kotlin. Rusz głową!", wybierały także:

  • Spring w akcji. Wydanie IV
  • Spring w Akcji. Wydanie III
  • Google App Engine. Tworzenie wydajnych aplikacji w Javie

Dodaj do koszyka

Spis treści

Kotlin. Rusz głową! eBook -- spis treści

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)

Dodaj do koszyka

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2020 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.