Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00039 005320 19042263 na godz. na dobę w sumie
Kotlin w akcji - książka
Kotlin w akcji - książka
Autor: , Liczba stron: 352
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-4720-5 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook (-35%), audiobook).

Kotlin został zaprojektowany jako obiektowy język w pełni interoperacyjny z kodem napisanym w Javie. Został zaprezentowany w 2011 roku. Od tego czasu jest rozwijany, a jego popularność stale rośnie. Kotlin jest językiem o statycznie typowanych zmiennych. Charakteryzuje się czytelną składnią i ścisłą integracją z istniejącymi projektami, bibliotekami i platformami utworzonymi w Javie. Kompiluje się do postaci binarnego kodu JVM, więc można go uruchamiać wszędzie tam, gdzie jest Java, również w Androidzie. Kotlin zainteresuje programistów aplikacji mobilnych również dlatego, że kod napisany w tym języku obciąża system w minimalnym stopniu. Przy tym wszystkim środowisko Kotlina jest w całości otwartym oprogramowaniem do bezpłatnego korzystania w dowolnych celach!

Ta książka jest przeznaczona dla osób, które mają pewne doświadczenia z Javą i chcą szybko poznać Kotlina w stopniu pozwalającym na tworzenie aplikacji serwerowych, dla systemu Android i maszyn JVM. Znalazł się tu opis podstawowych cech języka i jego najważniejszych struktur, a następnie przedstawiono bardziej zaawansowane zagadnienia, takie jak tworzenie wysokopoziomowych abstrakcji i języków domenowych. Duży nacisk położono na integrację kodu Kotlin z istniejącymi projektami Java oraz na sposoby wprowadzania Kotlina do aktualnie użytkowanego środowiska. Zaprezentowano kilka przydatnych bibliotek i narzędzi, znakomicie ułatwiających pracę programiście. Nie zabrakło również licznych przykładów kodu, ilustrujących omawiane zagadnienia.

W tej książce między innymi:

Kotlin - idealny dla Androida!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Kotlin in Action Tłumaczenie: Andrzej Watrak Projekt okładki: Studio Gravite / Olsztyn; Obarek, Pokoński, Pazdrijowski, Zaprucki Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock Images LLC. ISBN: 978-83-283-4720-5 Original edition copyright © 2017 by Manning Publications Co. All rights reserved. Polish edition copyright © 2018 by Helion SA All rights reserved. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Helion SA dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Helion SA nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Helion SA ul. Kościuszki 1c, 44-100 Gliwice tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/kotakc Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Przedmowa Wst(cid:218)p Podzi(cid:218)kowania O ksi(cid:200)(cid:285)ce O autorach Spis tre(cid:258)ci 11 13 15 17 21 1.4. Filozofia j(cid:218)zyka Kotlin Pragmatyzm Zwi(cid:218)z(cid:239)o(cid:258)(cid:202) Przedsmak Kotlina 1.1. 1.2. Najwa(cid:285)niejsze cechy j(cid:218)zyka Kotlin 1.2.1. Docelowe platformy: serwery, Android i wszystko, gdzie jest Java Statyczne typowanie danych 1.2.2. 1.2.3. Programowanie funkcyjne i obiektowe 1.2.4. Bezp(cid:239)atne i otwarte oprogramowanie Zastosowania j(cid:218)zyka Kotlin 1.3.1. Kotlin na serwerach 1.3.2. Kotlin w Androidzie CZ(cid:125)(cid:165)(cid:109) I WPROWADZENIE DO J(cid:125)ZYKA KOTLIN......................................... 23 25 Rozdzia(cid:239) 1. Kotlin: co to jest i po co? 25 26 26 27 28 29 30 30 31 32 32 33 34 35 35 36 36 37 37 37 37 38 39 39 40 40 42 43 1.4.1. 1.4.2. 1.4.3. Bezpiecze(cid:241)stwo 1.4.4. Kompatybilno(cid:258)(cid:202) 1.5. Narz(cid:218)dzia j(cid:218)zyka Kotlin 1.5.1. Kompilator kodu 1.5.2. Wtyczki dla IntelliJ IDAE i Android Studio 1.5.3. 1.5.4. Wtyczka dla Eclipse 1.5.5. 1.5.6. Konwerter Java-Kotlin Podsumowanie Podstawowe elementy: funkcje i zmienne 2.1.1. Witaj, (cid:258)wiecie! 2.1.2. 2.1.3. 2.1.4. Funkcje Zmienne Proste formatowanie ci(cid:200)gów znaków: szablony Rozdzia(cid:239) 2. Podstawy j(cid:218)zyka Kotlin Interaktywna pow(cid:239)oka Internetowy „plac zabaw” 1.3. 1.6. 2.1. Poleć książkęKup książkę 4 Spis tre(cid:258)ci 2.2. Klasy i w(cid:239)a(cid:258)ciwo(cid:258)ci 2.2.1. W(cid:239)a(cid:258)ciwo(cid:258)ci 2.2.2. W(cid:239)asne metody dost(cid:218)powe 2.2.3. Uk(cid:239)ad kodu (cid:283)ród(cid:239)owego: katalogi i pakiety 2.3. Kodowanie i dokonywanie wyborów: klasa wyliczeniowa i wyra(cid:285)enie when Inteligentne rzutowanie: po(cid:239)(cid:200)czenie sprawdzania i rzutowania typów 2.3.1. Deklarowanie klasy wyliczeniowej 2.3.2. Wyra(cid:285)enie when i klasy wyliczeniowe 2.3.3. Wyra(cid:285)enie when i dowolne obiekty 2.3.4. Wyra(cid:285)enie when bez argumentów 2.3.5. 2.3.6. Refaktoryzacja kodu: zamiana if na when 2.3.7. Bloki kodu w odga(cid:239)(cid:218)zieniach wyra(cid:285)e(cid:241) if i when Iteracje: p(cid:218)tle while i for 2.4.1. 2.4.2. 2.4.3. 2.4.4. P(cid:218)tla while Iteracje liczb: zakresy i post(cid:218)py Iterowanie elementów map Sprawdzanie przynale(cid:285)no(cid:258)ci do zakresu i kolekcji za pomoc(cid:200) s(cid:239)owa in 2.4. 2.5. Wyj(cid:200)tki w Kotlinie Instrukcje try, catch i finally S(cid:239)owo kluczowe try jako wyra(cid:285)enie 2.5.1. 2.5.2. Podsumowanie 2.6. Rozdzia(cid:239) 3. Definiowanie i wywo(cid:239)ywanie funkcji 3.1. Tworzenie kolekcji 3.2. (cid:146)atwiejsze wywo(cid:239)ywanie funkcji 3.2.1. Nazwane argumenty 3.2.2. Domy(cid:258)lne warto(cid:258)ci argumentów 3.2.3. Koniec ze statycznymi klasami pomocniczymi, czyli funkcje i w(cid:239)a(cid:258)ciwo(cid:258)ci najwy(cid:285)szego poziomu 3.3. Dodawanie elementów do zewn(cid:218)trznych klas: funkcje i w(cid:239)a(cid:258)ciwo(cid:258)ci rozszerzaj(cid:200)ce 44 45 47 48 49 49 50 51 52 53 55 56 57 57 57 59 60 61 62 63 64 65 66 67 68 68 3.4. Funkcje pomocnicze jako rozszerzenia Importowanie klas a funkcje rozszerzaj(cid:200)ce 70 72 73 3.3.1. 74 3.3.2. Wywo(cid:239)ywanie funkcji rozszerzaj(cid:200)cych w kodzie Java 74 3.3.3. 75 3.3.4. Nienadpisywalno(cid:258)(cid:202) funkcji rozszerzaj(cid:200)cych 3.3.5. W(cid:239)a(cid:258)ciwo(cid:258)ci rozszerzaj(cid:200)ce 76 Przetwarzanie kolekcji: funkcjonalno(cid:258)(cid:202) varargs, wywo(cid:239)ania infix i obs(cid:239)uga bibliotek 77 78 3.4.1. Rozbudowa interfejsu API kolekcji Java 3.4.2. Deklarowanie funkcji o dowolnej liczbie argumentów 78 79 3.4.3. Dzia(cid:239)ania w parach: wywo(cid:239)ania infix i deklaracje destrukturyzuj(cid:200)ce 80 81 81 83 84 86 3.5.1. Dzielenie ci(cid:200)gów znaków 3.5.2. Wyra(cid:285)enia regularne i potrójne cudzys(cid:239)owy 3.5.3. Potrójne cudzys(cid:239)owy i wielowierszowe ci(cid:200)gi znaków 3.6. Wyg(cid:239)adzanie kodu: lokalne funkcje i rozszerzenia 3.7. Podsumowanie 3.5. Operacje na ci(cid:200)gach znaków i wyra(cid:285)eniach regularnych Poleć książkęKup książkę Spis tre(cid:258)ci 5 Rozdzia(cid:239) 4. Klasy, obiekty i interfejsy 4.1. Definiowanie hierarchii klas Interfejsy w Kotlinie 4.1.1. 4.1.2. Modyfikatory open, final (domy(cid:258)lny) i abstract 4.1.3. Modyfikatory widoczno(cid:258)ci, domy(cid:258)lny public 4.1.4. Klasy wewn(cid:218)trzne i zagnie(cid:285)d(cid:285)one (domy(cid:258)lnie) 4.1.5. Klasy zapiecz(cid:218)towane: definiowanie ograniczonych hierarchii klas 4.2. Deklarowanie klas z nietrywialnymi konstruktorami i w(cid:239)a(cid:258)ciwo(cid:258)ciami Inicjowanie klas: konstruktor g(cid:239)ówny i bloki inicjatora 4.2.1. 4.2.2. Konstruktory dodatkowe i ró(cid:285)ne sposoby inicjowania klas nadrz(cid:218)dnych 4.2.3. 4.2.4. Dost(cid:218)p do pól za pomoc(cid:200) getterów i setterów Zmienianie widoczno(cid:258)ci metody dost(cid:218)powej 4.2.5. Implementowanie w(cid:239)a(cid:258)ciwo(cid:258)ci zadeklarowanych w interfejsie 4.3. Metody generowane przez kompilator, klasy danych i delegowanie klas 4.3.1. Metody uniwersalnych obiektów 4.3.2. Klasy danych i automatyczne generowanie uniwersalnych metod 4.3.3. Delegowanie klas i s(cid:239)owo kluczowe by S(cid:239)owo kluczowe object (cid:239)(cid:200)cz(cid:200)ce deklaracj(cid:218) klasy z utworzeniem jej instancji 4.4.1. 4.4.2. Obiekty towarzysz(cid:200)ce: miejsce dla metod wytwórczych i elementów (cid:146)atwe tworzenie singletonów poprzez deklarowanie obiektów statycznych 4.4.3. Obiekty towarzysz(cid:200)ce jako zwyk(cid:239)e obiekty 4.4.4. Wyra(cid:285)enia obiektowe, czyli anonimowe klasy wewn(cid:218)trzne Podsumowanie 4.4. 4.5. Rozdzia(cid:239) 5. Wyra(cid:285)enia lambda 5.1. Wyra(cid:285)enia lambda i odwo(cid:239)ania do elementów obiektów 5.2. Lambdy i kolekcje Sk(cid:239)adnia wyra(cid:285)enia lambda 5.1.1. Wprowadzenie do wyra(cid:285)e(cid:241) lambda: bloki kodu jako argumenty funkcji 5.1.2. 5.1.3. 5.1.4. Odwo(cid:239)ania do zmiennych w bie(cid:285)(cid:200)cym kontek(cid:258)cie 5.1.5. Odwo(cid:239)ania do elementów klas Interfejsy funkcyjne do przetwarzania kolekcji 5.2.1. 5.2.2. Warunki i funkcje all(), any(), count() oraz find() w kolekcjach 5.2.3. 5.2.4. Funkcja groupBy() i konwersja listy na map(cid:218) grup Funkcja flatMap(), sp(cid:239)aszczanie struktury danych i przetwarzanie zagnie(cid:285)d(cid:285)onych kolekcji Podstawy: filtry i mapy 5.3. Leniwe operacje na kolekcjach oraz sekwencje 5.4. Po(cid:258)rednie i ko(cid:241)cowe operacje na sekwencjach Tworzenie sekwencji 5.3.1. 5.3.2. Interfejsy funkcyjne Java 5.4.1. Umieszczanie wyra(cid:285)e(cid:241) lambda w argumentach metod Java 5.4.2. Konstruktory SAM i jawna konwersja wyra(cid:285)e(cid:241) lambda na interfejsy funkcyjne 89 90 90 92 94 96 98 100 100 102 104 105 106 108 108 111 112 114 114 116 118 121 122 123 123 124 125 126 129 131 133 133 135 136 137 138 139 142 143 144 146 Poleć książkęKup książkę 6 Spis tre(cid:258)ci 5.5. Wyra(cid:285)enia lambda, odbiorniki oraz funkcje with() i apply() Funkcja with() Funkcja apply() 5.5.1. 5.5.2. Podsumowanie 5.6. 6.1. Zerowalne typy danych Znaczenie typów danych Rozdzia(cid:239) 6. System typów danych Zerowalno(cid:258)(cid:202) typów danych 6.1.1. 6.1.2. 6.1.3. Bezpieczny operator wywo(cid:239)ania „?.” 6.1.4. Operator Elvisa „?:” 6.1.5. Bezpieczne rzutowanie typów: operator „as?” 6.1.6. Asercja niezerowa „!!” 6.1.7. 6.1.8. W(cid:239)a(cid:258)ciwo(cid:258)ci inicjowane z opó(cid:283)nieniem 6.1.9. Rozszerzenia typów zerowalnych 6.1.10. Zerowalno(cid:258)(cid:202) argumentów typowanych 6.1.11. Zerowalno(cid:258)(cid:202) typów i Java Funkcja let() 6.2. Typy proste oraz inne typy podstawowe Typy proste Int, Boolean i inne Zerowalne typy proste Int?, Boolean? i inne Przekszta(cid:239)canie liczb Typy g(cid:239)ówne „Any” i „Any?” Typ Unit, odpowiednik „void” Typ Nothing, czyli „funkcja nigdy nie ko(cid:241)czy dzia(cid:239)ania” 6.2.1. 6.2.2. 6.2.3. 6.2.4. 6.2.5. 6.2.6. 6.3. Kolekcje i tablice Zerowalno(cid:258)(cid:202) typów danych i kolekcje 6.3.1. 6.3.2. Kolekcje tylko do odczytu i kolekcje mutowalne 6.3.3. Kolekcje w Kotlinie i w Javie 6.3.4. Kolekcje jako typy platformowe 6.3.5. Podsumowanie Tablice obiektów i typów prostych 6.4. 147 147 149 151 153 153 154 156 157 158 160 161 163 164 166 167 168 172 172 173 174 176 177 178 178 178 181 182 184 186 189 7.1. 7.2. Przeci(cid:200)(cid:285)anie dwuargumentowych operatorów arytmetycznych Przeci(cid:200)(cid:285)anie z(cid:239)o(cid:285)onych operatorów przypisania Przeci(cid:200)(cid:285)anie operatorów jednoargumentowych Przeci(cid:200)(cid:285)anie operatorów arytmetycznych 7.1.1. 7.1.2. 7.1.3. Przeci(cid:200)(cid:285)anie operatorów porównania 7.2.1. Operatory równo(cid:258)ci 7.2.2. CZ(cid:125)(cid:165)(cid:109) II WZBOGACANIE KOTLINA...........................................................191 193 Rozdzia(cid:239) 7. Przeci(cid:200)(cid:285)anie operatorów oraz inne konwencje 194 194 196 198 199 199 200 202 202 203 204 205 7.3.1. Dost(cid:218)p do elementu za pomoc(cid:200) indeksu, metod get() i set() 7.3.2. Konwencja operatora in 7.3.3. Metoda rangeTo() 7.3.4. Konwencja „iterator” w p(cid:218)tli loop Przeci(cid:200)(cid:285)anie operatorów nierówno(cid:258)ci: metoda compareTo() 7.3. Konwencje stosowane w kolekcjach i zakresach Poleć książkęKup książkę Spis tre(cid:258)ci 7 7.4. Deklaracje destrukturyzuj(cid:200)ce i metody komponentowe 7.4.1. Deklaracje destrukturyzuj(cid:200)ce i p(cid:218)tle 7.5. Wspó(cid:239)dzielenie metod dost(cid:218)powych i delegowanie w(cid:239)a(cid:258)ciwo(cid:258)ci Podstawy delegowania w(cid:239)a(cid:258)ciwo(cid:258)ci 7.5.1. 7.5.2. Korzystanie z delegowanych w(cid:239)a(cid:258)ciwo(cid:258)ci: inicjalizacja z opó(cid:283)nieniem i funkcja lazy Implementacja delegowanych w(cid:239)a(cid:258)ciwo(cid:258)ci Zasady translacji delegowanych w(cid:239)a(cid:258)ciwo(cid:258)ci Przechowywanie warto(cid:258)ci w(cid:239)a(cid:258)ciwo(cid:258)ci w mapie 7.5.3. 7.5.4. 7.5.5. 7.5.6. Delegowane w(cid:239)a(cid:258)ciwo(cid:258)ci w bibliotekach Podsumowanie 7.6. Rozdzia(cid:239) 8. Funkcje wysokopoziomowe: wyra(cid:285)enia lambda jako argumenty oraz wyniki 8.1. Deklarowanie funkcji wysokopoziomowych Typy funkcyjne Stosowanie typów funkcyjnych w kodzie Java 8.1.1. 8.1.2. Wywo(cid:239)ywanie funkcji podanych w argumentach 8.1.3. 8.1.4. Warto(cid:258)(cid:202) domy(cid:258)lna i warto(cid:258)(cid:202) null w argumentach typów funkcyjnych 8.1.5. 8.1.6. Usuwanie duplikatów kodu za pomoc(cid:200) wyra(cid:285)e(cid:241) lambda Funkcje zawieraj(cid:200)ce w wynikach inne funkcje 8.2. Funkcje (cid:258)ródwierszowe i wydajno(cid:258)(cid:202) wyra(cid:285)e(cid:241) lambda Zarz(cid:200)dzanie zasobami za pomoc(cid:200) (cid:258)ródwierszowych wyra(cid:285)e(cid:241) lambda 8.2.1. Wstawianie kodu funkcji 8.2.2. Ograniczenia funkcji (cid:258)ródwierszowych 8.2.3. Wstawianie operacji na kolekcjach 8.2.4. Kiedy nale(cid:285)y stosowa(cid:202) funkcje (cid:258)ródwierszowe 8.2.5. Sterowanie realizacj(cid:200) kodu w funkcjach wysokopoziomowych 8.3.1. 8.3.2. Wyj(cid:258)cie z wyra(cid:285)enia lambda: instrukcja return z etykiet(cid:200) 8.3.3. Podsumowanie Funkcje anonimowe i domy(cid:258)lne wyj(cid:258)cia lokalne Instrukcja return w wyra(cid:285)eniach lambda: wyj(cid:258)cie z nadrz(cid:218)dnej funkcji 206 207 208 209 209 211 215 215 216 218 219 220 220 221 222 223 226 227 229 230 232 233 234 234 236 236 237 239 240 241 242 243 244 245 247 8.3. 8.4. 9.2. Rozdzia(cid:239) 9. Typy generyczne 9.1. Generyczne argumenty typowane 9.1.1. Generyczne funkcje i w(cid:239)a(cid:258)ciwo(cid:258)ci 9.1.2. Deklarowanie klas generycznych 9.1.3. Ograniczenia argumentów typowanych 9.1.4. Deklarowanie niezerowalnego argumentu typowanego Typy generyczne w dzia(cid:239)aj(cid:200)cym kodzie, wymazane i urzeczowione argumenty typowane 9.2.1. 9.2.2. Deklarowanie funkcji z urzeczowionymi argumentami typowanymi 9.2.3. 9.2.4. Ograniczenia urzeczowionych argumentów typowanych 248 248 250 Zast(cid:218)powanie odwo(cid:239)a(cid:241) do klas urzeczowionymi argumentami typowanymi 252 253 Typy generyczne w dzia(cid:239)aj(cid:200)cym kodzie: sprawdzanie i rzutowanie typów Poleć książkęKup książkę 8 Spis tre(cid:258)ci 9.3. Wariancje, typy generyczne i podtypy Idea wariancji i umieszczanie warto(cid:258)ci w argumentach funkcji 9.3.1. 9.3.2. Klasy, typy i podtypy 9.3.3. Kowariancja: zachowanie zale(cid:285)no(cid:258)ci mi(cid:218)dzy podtypami 9.3.4. Kontrawariancja: odwrotna zale(cid:285)no(cid:258)(cid:202) podtypów 9.3.5. Wariancja typu w miejscu deklaracji 9.3.6. Podsumowanie Projekcja z gwiazdk(cid:200): symbol * zamiast argumentu typowanego 9.4. Rozdzia(cid:239) 10. Adnotacje i refleksja 10.1. Deklarowanie i stosowanie adnotacji 10.1.1. Stosowanie adnotacji 10.1.2. Adres adnotacji 10.1.3. Dostosowywanie procesu serializacji JSON za pomoc(cid:200) adnotacji 10.1.4. Deklarowanie adnotacji 10.1.5. Metaadnotacje: kontrolowanie procesu przetwarzania adnotacji 10.1.6. Klasy jako argumenty adnotacji 10.1.7. Klasy generyczne jako argumenty adnotacji 10.2. Refleksja: badanie obiektów w trakcie dzia(cid:239)ania kodu 10.2.1. Interfejs API refleksji w Kotlinie: interfejsy KClass, KCallable, KFunction i KProperty 10.2.2. Serializacja obiektów z wykorzystaniem refleksji 10.2.3. Dostosowywanie serializacji za pomoc(cid:200) adnotacji 10.2.4. Analiza danych JSON i deserializacja obiektów 10.2.5. Ostatni etap deserializacji: wywo(cid:239)anie metody callBy() i utworzenie obiektu za pomoc(cid:200) refleksji 10.3. Podsumowanie Rozdzia(cid:239) 11. Definiowanie j(cid:218)zyka DSL 11.1. Od interfejsu API do j(cid:218)zyka DSL Idea j(cid:218)zyków domenowych 11.1.1. 11.1.2. Wewn(cid:218)trzny j(cid:218)zyk DSL 11.1.3. Struktura j(cid:218)zyka DSL 11.1.4. Generowanie kodu HTML za pomoc(cid:200) wewn(cid:218)trznego j(cid:218)zyka DSL 11.2. Tworzenie strukturalnego interfejsu API: wyra(cid:285)enia lambda z odbiornikami w j(cid:218)zyku DSL 11.2.1. Wyra(cid:285)enie lambda z odbiornikiem i typ funkcyjny rozszerzaj(cid:200)cy 11.2.2. Wyra(cid:285)enia lambda z odbiornikami w generatorze HTML 11.2.3. Generatory w Kotlinie, abstrakcje i powtarzalny kod 11.3. Bardziej elastyczne zagnie(cid:285)d(cid:285)anie bloków kodu dzi(cid:218)ki konwencji invoke 11.3.1. Konwencja invoke, czyli obiekty wywo(cid:239)ywane tak jak funkcje 11.3.2. Konwencja invoke i typy funkcyjne 11.3.3. Konwencja invoke w j(cid:218)zyku DSL: deklarowanie zale(cid:285)no(cid:258)ci w narz(cid:218)dziu Gradle 11.4. J(cid:218)zyk DSL w praktyce 11.4.1. (cid:146)(cid:200)czenie wywo(cid:239)a(cid:241) infix i asercja should w platformach testowych 11.4.2. Rozszerzenia typów prostych i przetwarzanie dat 254 254 255 257 261 263 266 270 271 272 272 273 275 277 277 278 279 280 281 285 286 289 293 297 299 300 301 302 303 304 305 305 309 313 316 316 317 318 319 319 321 Poleć książkęKup książkę Spis tre(cid:258)ci 11.4.3. Funkcje rozszerzaj(cid:200)ce i wewn(cid:218)trzny j(cid:218)zyk DSL do obs(cid:239)ugi zapyta(cid:241) SQL 11.4.4. Biblioteka Anko i dynamiczne tworzenie interfejsu u(cid:285)ytkownika w systemie Android 11.5. Podsumowanie 9 322 325 327 DODATKI ..................................................................................................... 329 Dodatek A Kompilowanie projektów Kotlin A.1. Kompilowanie kodu Kotlin za pomoc(cid:200) narz(cid:218)dzia Gradle Skorowidz Dodatek B Dokumentowanie kodu Kotlin B.1. Umieszczanie komentarzy dokumentacyjnych B.2. Generowanie dokumentacji interfejsu API A.2. Kompilowanie kodu Kotlin za pomoc(cid:200) narz(cid:218)dzia Maven A.3. Kompilowanie kodu Kotlin za pomoc(cid:200) narz(cid:218)dzia Ant 331 331 A.1.1. Kompilowanie za pomoc(cid:200) narz(cid:218)dzia Gradle aplikacji dla systemu Android 332 A.1.2. Kompilowanie projektów wykorzystuj(cid:200)cych adnotacje 332 333 333 335 335 336 339 339 340 340 340 340 341 341 341 343 C.1. Testowanie kodu C.2. Wstrzykiwanie zale(cid:285)no(cid:258)ci C.3. Serializacja JSON C.4. Klienty HTTP C.5. Aplikacje WWW C.6. Operacje na bazach danych C.7. Narz(cid:218)dzia i struktury danych C.8. Aplikacje stacjonarne Dodatek C Ekosystem Kotlina Poleć książkęKup książkę 10 Spis tre(cid:258)ci Poleć książkęKup książkę Kotlin: co to jest i po co? Ten rozdzia(cid:225) opisuje: (cid:81) podstawy j(cid:266)zyka Kotlin, (cid:81) najwa(cid:298)niejsze cechy j(cid:266)zyka, (cid:81) tworzenie aplikacji serwerowych i aplikacji dla systemu Android, (cid:81) ró(cid:298)nice w porównaniu z innymi j(cid:266)zykami, (cid:81) tworzenie i uruchamianie kodu. Czym jest Kotlin? To nowy j(cid:218)zyk programowania przeznaczony dla platformy JVM. Jest zwi(cid:218)z(cid:239)y, pragmatyczny i ukierunkowany na wspó(cid:239)prac(cid:218) z kodem Java. Mo(cid:285)na go sto- sowa(cid:202) niemal wsz(cid:218)dzie tam, gdzie dzisiaj jest u(cid:285)ywana Java, tj. do tworzenia aplikacji serwerowych, aplikacji dla systemu Android i w wielu innych miejscach. Kod w j(cid:218)zyku Kotlin doskonale wspó(cid:239)pracuje ze wszystkimi bibliotekami i platformami j(cid:218)zyka Java i jest równie wydajny. W tym rozdziale szczegó(cid:239)owo opisujemy najwa(cid:285)niejsze cechy Kotlina. 1.1. Przedsmak Kotlina Zacznijmy od prostego kodu pokazuj(cid:200)cego, czym jest Kotlin. Kod ten definiuje klas(cid:218) Person (osoba), kolekcj(cid:218) klas, wyszukuje najstarsz(cid:200) osob(cid:218) i wy(cid:258)wietla wynik. Nawet w tym niewielkim przyk(cid:239)adzie odkryjesz wiele ciekawych cech j(cid:218)zyka. Opiszemy dok(cid:239)adniej kilka z nich, aby by(cid:239)y zrozumia(cid:239)e w dalszej cz(cid:218)(cid:258)ci ksi(cid:200)(cid:285)ki. Kod jest opisany bardzo ogólnie, nie przejmuj si(cid:218) wi(cid:218)c, je(cid:285)eli nie wszystko b(cid:218)dzie od razu zrozumia(cid:239)e. W dalszej cz(cid:218)(cid:258)ci rozdzia(cid:239)u szczegó(cid:239)owo opiszemy wszystkie zawi(cid:239)o(cid:258)ci. Poleć książkęKup książkę 26 ROZDZIA(cid:224) 1. Kotlin: co to jest i po co? Aby wypróbowa(cid:202) poni(cid:285)szy przyk(cid:239)ad, naj(cid:239)atwiej uruchomi(cid:202) go w internetowym „placu zabaw” na stronie http://try.kotl.in. Wpisz na niej kod z listingu 1.1 i uruchom, klikaj(cid:200)c przycisk Run. Listing 1.1. Przedsmak Kotlina Klasa „danych”. G(cid:225)ówna funkcja. data class Person(val name: String, val age: Int? = null) fun main(args: Array String ) { val persons = listOf(Person( Alicja ), Person( Bartek , age = 29)) val oldest = persons.maxBy { it.age ?: 0 } println( Najstarsza osoba: $oldest ) } // Najstarsza osoba: Person(name=Bartek, age=29) Typ zerowalny (Int?) i domy(cid:286)lna warto(cid:286)(cid:252) argumentu. Nazwany argument. Znakowy szablon. Wyra(cid:298)enie lambda i operator Elvisa. Automatyczne u(cid:298)ycie metody toString(). Zadeklarowa(cid:239)e(cid:258) prost(cid:200) klas(cid:218) z dwiema w(cid:239)a(cid:258)ciwo(cid:258)ciami: name (imi(cid:218)) i age (wiek). Je(cid:285)eli warto(cid:258)(cid:202) w(cid:239)a(cid:258)ciwo(cid:258)ci age nie zostanie okre(cid:258)lona, wtedy przyjmie ona domy(cid:258)ln(cid:200) warto(cid:258)(cid:202) null. Tworz(cid:200)c list(cid:218) klas, nie okre(cid:258)li(cid:239)e(cid:258) wieku Alicji, wi(cid:218)c zosta(cid:239)a u(cid:285)yta domy(cid:258)lna warto(cid:258)(cid:202). Pó(cid:283)niej u(cid:285)y(cid:239)e(cid:258) metody maxBy() do wyszukania najstarszej osoby. Wyra(cid:285)enie lambda umieszczone w argumencie tej metody ma jeden parametr o domy(cid:258)lnej nazwie it (to). Operator Elvisa (?:) zwraca warto(cid:258)(cid:202) 0, je(cid:285)eli w(cid:239)a(cid:258)ciwo(cid:258)(cid:202) age ma warto(cid:258)(cid:202) null. Poniewa(cid:285) nie okre(cid:258)li(cid:239)e(cid:258) wieku Alicji, operator u(cid:285)y(cid:239) warto(cid:258)ci 0, zatem za najstarsz(cid:200) osob(cid:218) zosta(cid:239) uznany Bartek. Podoba Ci si(cid:218) to? Czytaj wi(cid:218)c dalej i zosta(cid:241) ekspertem od Kotlina. Mamy nadziej(cid:218), (cid:285)e wkrótce taki kod b(cid:218)dziesz stosowa(cid:239) w swoich projektach, nie tylko podczas lektury tej ksi(cid:200)(cid:285)ki. 1.2. Najwa(cid:298)niejsze cechy j(cid:266)zyka Kotlin Prawdopodobnie masz ju(cid:285) wyobra(cid:285)enie, czym jest j(cid:218)zyk Kotlin. Przyjrzyjmy si(cid:218) teraz dok(cid:239)adniej jego najwa(cid:285)niejszym cechom. Najpierw sprawd(cid:283)my, jakiego rodzaju aplikacje mo(cid:285)na pisa(cid:202) w tym j(cid:218)zyku. 1.2.1. Docelowe platformy: serwery, Android i wszystko, gdzie jest Java Kotlin ma by(cid:202) przede wszystkim bardziej zwi(cid:218)z(cid:239)(cid:200), skuteczniejsz(cid:200) i bezpieczniejsz(cid:200) alter- natyw(cid:200) dla Javy. Powinien da(cid:202) si(cid:218) stosowa(cid:202) wsz(cid:218)dzie tam, gdzie jest Java, która jest nie- zwykle popularnym j(cid:218)zykiem, wykorzystywanym w szerokim spektrum (cid:258)rodowisk, od inteligentnych kart (Java Card) do najwi(cid:218)kszych centrów danych dzia(cid:239)aj(cid:200)cych w serwisach Google, Twitter, LinkedIn oraz w du(cid:285)ych firmach internetowych. W wi(cid:218)kszo(cid:258)ci powy(cid:285)- szych przypadków programi(cid:258)ci mog(cid:200) za pomoc(cid:200) j(cid:218)zyka Kotlin osi(cid:200)ga(cid:202) swoje cele, pisz(cid:200)c krótszy kod i unikaj(cid:200)c dzi(cid:218)ki temu k(cid:239)opotów. Najwi(cid:218)ksze obszary zastosowa(cid:241) j(cid:218)zyka Kotlin to: (cid:81) aplikacje serwerowe (zazwyczaj WWW), (cid:81) aplikacje przeno(cid:258)ne dla systemu Android. Poleć książkęKup książkę 1.2. Najwa(cid:285)niejsze cechy j(cid:218)zyka Kotlin 27 J(cid:218)zyk Kotlin mo(cid:285)na stosowa(cid:202) równie(cid:285) w innych sytuacjach. Na przyk(cid:239)ad mo(cid:285)na urucha- mia(cid:202) kod w systemie macOS, wykorzystuj(cid:200)c silnik Multi-OS Engine (https://software.intel. com/en-us/multi-os-engine), a za pomoc(cid:200) platform TornadoFX (https://github.com/edvin/ tornadofx) i JavaFX1 mo(cid:285)na tworzy(cid:202) aplikacje dla komputerów stacjonarnych. Ponadto, w odró(cid:285)nieniu od Javy, kod Kotlin mo(cid:285)na przekszta(cid:239)ca(cid:202) w kod JavaScript i uruchamia(cid:202) w przegl(cid:200)darce. Jednak w chwili powstawania tej ksi(cid:200)(cid:285)ki wci(cid:200)(cid:285) trwa(cid:239)o w JetBrains rozpoznawanie obs(cid:239)ugi j(cid:218)zyka JavaScript oraz tworzenie prototypu konwer- tera, dlatego temat ten nie jest opisany w tej ksi(cid:200)(cid:285)ce. Rozwa(cid:285)amy te(cid:285) przystosowanie przysz(cid:239)ych wersji j(cid:218)zyka do nowych platform. Jak widzisz, obszar zastosowania Kotlina jest bardzo szeroki. J(cid:218)zyk ten nie skupia si(cid:218) na jednej domenie ani nie próbuje rozwi(cid:200)za(cid:202) okre(cid:258)lonego problemu, z którym mierz(cid:200) si(cid:218) dzi(cid:258) programi(cid:258)ci. Wr(cid:218)cz przeciwnie, posiada wiele udoskonale(cid:241) usprawniaj(cid:200)cych realiza- cj(cid:218) zada(cid:241), które pojawiaj(cid:200) si(cid:218) w procesie tworzenia oprogramowania. Jest doskonale zintegrowany z istniej(cid:200)cymi bibliotekami do ró(cid:285)nych zastosowa(cid:241) i zagadnie(cid:241) progra- mistycznych. Przyjrzyjmy si(cid:218) teraz kluczowym cechom wyró(cid:285)niaj(cid:200)cym ten j(cid:218)zyk pro- gramowania. 1.2.2. Statyczne typowanie danych Kotlin, podobnie jak Java, jest j(cid:218)zykiem wykorzystuj(cid:200)cym statyczne typowanie danych. Oznacza to, (cid:285)e typ ka(cid:285)dego wyra(cid:285)enia jest znany na etapie kompilacji kodu, a kompila- tor sprawdza, czy istniej(cid:200) metody i pola w obiektach, do których odwo(cid:239)uje si(cid:218) kod. Tym Kotlin ró(cid:285)ni si(cid:218) od j(cid:218)zyków z dynamicznym typowaniem, takich jak Groovy i JRuby w (cid:258)rodowisku JVM. W tych j(cid:218)zykach mo(cid:285)na definiowa(cid:202) zmienne oraz funkcje przecho- wuj(cid:200)ce i zwracaj(cid:200)ce dane dowolnych typów, a tak(cid:285)e identyfikowa(cid:202) metody i pola w trak- cie dzia(cid:239)ania kodu. Dzi(cid:218)ki temu kod jest krótszy i bardziej elastyczny pod wzgl(cid:218)dem tworzenia struktur danych. Problem polega jednak na tym, (cid:285)e podczas kompilacji kodu nie s(cid:200) wykrywane pomy(cid:239)ki w nazwach identyfikatorów, co skutkuje b(cid:239)(cid:218)dnym niekiedy dzia(cid:239)aniem kodu. W Kotlinie, inaczej ni(cid:285) w Javie, nie trzeba jawnie okre(cid:258)la(cid:202) typu ka(cid:285)dej zmiennej. W wielu przypadkach typ jest okre(cid:258)lany automatycznie na podstawie kontekstu, dzi(cid:218)ki czemu mo(cid:285)na pomija(cid:202) deklaracj(cid:218) typu. Ilustruje to poni(cid:285)szy najprostszy przyk(cid:239)ad: valx = 1 Deklarowana jest tu zmienna. Poniewa(cid:285) jest ona inicjowana liczb(cid:200) ca(cid:239)kowit(cid:200), Kotlin auto- matycznie przyjmuje typ Int. Okre(cid:258)lanie przez kompilator typu danych na podstawie kon- tekstu nosi nazw(cid:218) domniemania typów. Statycznie typowany kod ma m.in. nast(cid:218)puj(cid:200)ce zalety: (cid:81) Wydajno(cid:258)(cid:202) — metody wywo(cid:239)ywane s(cid:200) szybciej, poniewa(cid:285) w trakcie dzia(cid:239)ania kodu nie trzeba wyszukiwa(cid:202) wywo(cid:239)ywanej metody. (cid:81) Niezawodno(cid:258)(cid:202) — kompilator sprawdza poprawno(cid:258)(cid:202) kodu, dzi(cid:218)ki czemu zmniejsza si(cid:218) prawdopodobie(cid:241)stwo jego awarii po uruchomieniu. 1 Patrz: JavaFX: Getting Started with JavaFX, Oracle, http://mng.bz/500y. Poleć książkęKup książkę 28 ROZDZIA(cid:224) 1. Kotlin: co to jest i po co? (cid:81) (cid:146)atwo(cid:258)(cid:202) utrzymania — praca z nieznanym kodem jest (cid:239)atwiejsza, poniewa(cid:285) wia- domo, jakiego rodzaju obiekty s(cid:200) w nim stosowane. (cid:81) Dost(cid:218)pno(cid:258)(cid:202) narz(cid:218)dzi — mo(cid:285)na korzysta(cid:202) z niezawodnej refaktoryzacji, precyzyj- nego uzupe(cid:239)niania kodu oraz innych funkcjonalno(cid:258)ci (cid:258)rodowiska IDE. Dzi(cid:218)ki domniemaniu typów zmniejsza si(cid:218) rozwlek(cid:239)o(cid:258)(cid:202) kodu, charakterystyczna dla sta- tycznego typowania, poniewa(cid:285) nie trzeba jawnie deklarowa(cid:202) wszystkich typów. Je(cid:285)eli przyjrzysz si(cid:218) specyfikacji typów w j(cid:218)zyku Kotlin, znajdziesz w niej znane poj(cid:218)cia. Klasy, interfejsy i typy generyczne s(cid:200) bardzo podobne do stosowanych w Javie. Zatem swoj(cid:200) wiedz(cid:218) o tym j(cid:218)zyku mo(cid:285)esz w du(cid:285)ej mierze przenie(cid:258)(cid:202) do Kotlina. S(cid:200) te(cid:285) nowe idee. Najwa(cid:285)niejsze z nich to typy zerowalne, dzi(cid:218)ki którym mo(cid:285)na tworzy(cid:202) stabilniejsze programy, w których ju(cid:285) na etapie kompilacji mo(cid:285)na wykrywa(cid:202) wska(cid:283)niki o warto(cid:258)ciach null. Do tych typów powrócimy w dalszej cz(cid:218)(cid:258)ci rozdzia(cid:239)u, a dok(cid:239)adniej opiszemy je w rozdziale 6. Kolejn(cid:200) nowo(cid:258)ci(cid:200) w systemie typów s(cid:200) typy funkcyjne. Aby dowiedzie(cid:202) si(cid:218), czym one s(cid:200) i jak s(cid:200) obs(cid:239)ugiwane w j(cid:218)zyku Kotlin, przypomnijmy sobie najwa(cid:285)niejsze zasady programowania funkcyjnego. 1.2.3. Programowanie funkcyjne i obiektowe Jako programista Java z pewno(cid:258)ci(cid:200) znasz kluczowe poj(cid:218)cia z dziedziny programowania obiektowego, natomiast programowanie funkcyjne mo(cid:285)e by(cid:202) dla Ciebie nowo(cid:258)ci(cid:200). Poni- (cid:285)ej wymienione s(cid:200) najwa(cid:285)niejsze terminy stosowane w programowaniu funkcyjnym: (cid:81) Funkcje pierwszej klasy — funkcje (ci(cid:200)gi operacji) traktuje si(cid:218) jak warto(cid:258)ci. Mo(cid:285)na je zapisywa(cid:202) w zmiennych, umieszcza(cid:202) w argumentach i zwraca(cid:202) w wynikach innych funkcji. (cid:81) Niezmienno(cid:258)(cid:202) — obiekty s(cid:200) niezmienne, tzn. po utworzeniu nie mo(cid:285)na zmienia(cid:202) ich stanu. (cid:81) Brak efektów ubocznych — wykorzystywane s(cid:200) czyste funkcje zwracaj(cid:200)ce te same wyniki dla tych samych warto(cid:258)ci argumentów, nie mo(cid:285)na równie(cid:285) zmienia(cid:202) stanu innych obiektów ani komunikowa(cid:202) si(cid:218) z kodem zewn(cid:218)trznym. Jakie korzy(cid:258)ci p(cid:239)yn(cid:200) z programowania funkcyjnego? Po pierwsze, kod jest zwi(cid:218)z(cid:239)y. Jest krótszy i bardziej elegancki od kodu imperatywnego, poniewa(cid:285) traktuj(cid:200)c funkcje jak war- to(cid:258)ci, lepiej wykorzystuje si(cid:218) si(cid:239)(cid:218) abstrakcji i unika duplikacji kodu. Wyobra(cid:283) sobie, (cid:285)e masz dwa podobne fragmenty kodu realizuj(cid:200)ce podobne zadania (na przyk(cid:239)ad wyszukiwanie okre(cid:258)lonych elementów kolekcji), jednak ró(cid:285)ni(cid:200)ce si(cid:218) szczegó- (cid:239)ami (np. sposobem identyfikowania elementów). W takim wypadku wspóln(cid:200) logik(cid:218) obu cz(cid:218)(cid:258)ci mo(cid:285)na (cid:239)atwo zapisa(cid:202) w postaci funkcji i umie(cid:258)ci(cid:202) j(cid:200) w argumentach dwóch innych funkcji. Argumenty s(cid:200) funkcjami, ale mo(cid:285)na je opisa(cid:202) zwi(cid:218)z(cid:239)(cid:200) sk(cid:239)adni(cid:200) w postaci funkcji anonimowych, tzw. wyra(cid:285)e(cid:241) lambda, jak ni(cid:285)ej: fun findAlicja() = findPerson { it.name == Alicja } fun findBartek() = findPerson { it.name == Bartek } Funkcja findPerson() zawiera wspólny algorytm wyszukiwania osoby. Fragment w nawiasach klamrowych opisuje osob(cid:266), któr(cid:261) chcemy znale(cid:296)(cid:252). Poleć książkęKup książkę 1.2. Najwa(cid:285)niejsze cechy j(cid:218)zyka Kotlin 29 Inn(cid:200) zalet(cid:200) kodu funkcyjnego jest bezpiecze(cid:241)stwo mi(cid:218)dzyw(cid:200)tkowe. Jednym z g(cid:239)ównych (cid:283)róde(cid:239) b(cid:239)(cid:218)dów w programach wielow(cid:200)tkowych jest modyfikowanie tych samych danych w ró(cid:285)nych w(cid:200)tkach bez odpowiedniej synchronizacji. Je(cid:285)eli natomiast stosuje si(cid:218) nie- zmienne struktury danych i czyste funkcje, mo(cid:285)na mie(cid:202) pewno(cid:258)(cid:202), (cid:285)e tego typu niebez- pieczne modyfikacje nie b(cid:218)d(cid:200) si(cid:218) zdarza(cid:202), wi(cid:218)c nie trzeba stosowa(cid:202) skomplikowanych mechanizmów synchronizacyjnych. Ponadto programowanie funkcyjne oznacza prostsze testowanie kodu. Funkcje nie- wywo(cid:239)uj(cid:200)ce efektów ubocznych mo(cid:285)na testowa(cid:202) w izolacji bez konieczno(cid:258)ci tworzenia mnóstwa kodu konfiguracyjnego implementuj(cid:200)cego otoczenie, od którego testowany kod jest uzale(cid:285)niony. Podsumowuj(cid:200)c, programowanie funkcyjne mo(cid:285)na stosowa(cid:202) w ka(cid:285)dym j(cid:218)zyku pro- gramowania, równie(cid:285) w Javie, i w du(cid:285)ej mierze jest to dobry styl. Jednak nie wszystkie j(cid:218)zyki posiadaj(cid:200) sk(cid:239)adni(cid:218) i biblioteki umo(cid:285)liwiaj(cid:200)ce (cid:239)atwe stosowanie tego stylu. Na przyk(cid:239)ad nie by(cid:239)o to mo(cid:285)liwe w wersjach starszych ni(cid:285) Java 8. Kotlin oferuje bogaty zestaw funkcjonalno(cid:258)ci umo(cid:285)liwiaj(cid:200)cych programowanie funkcyjne ju(cid:285) na starcie. S(cid:200) to mi(cid:218)dzy innymi: (cid:81) Typy funkcyjne umo(cid:285)liwiaj(cid:200)ce umieszczanie funkcji w argumentach i wynikach innych funkcji. narzutem. obiektów i kolekcji. (cid:81) Wyra(cid:285)enia lambda umo(cid:285)liwiaj(cid:200)ce umieszczanie bloków kodu z minimalnym (cid:81) Klasy danych umo(cid:285)liwiaj(cid:200)ce tworzenie zwi(cid:218)z(cid:239)ych, niezmiennych obiektów. (cid:81) Standardowa biblioteka z bogatym zestawem interfejsów API do przetwarzania Kotlin umo(cid:285)liwia programowanie funkcyjne, ale go nie narzuca. Mo(cid:285)na w nim bez dodat- kowego wysi(cid:239)ku tworzy(cid:202) zmienne obiekty i funkcje z efektami ubocznymi, je(cid:285)eli jest taka potrzeba. Oczywi(cid:258)cie korzystanie z platform opartych na hierarchii interfejsów i klas jest równie proste jak w Javie. Pisz(cid:200)c kod w j(cid:218)zyku Kotlin, mo(cid:285)na (cid:239)(cid:200)czy(cid:202) style programo- wania obiektowego i funkcyjnego oraz u(cid:285)ywa(cid:202) narz(cid:218)dzi najbardziej odpowiednich do rozwi(cid:200)zania danego problemu. 1.2.4. Bezp(cid:225)atne i otwarte oprogramowanie (cid:165)rodowisko Kotlin, obejmuj(cid:200)ce kompilator, biblioteki i narz(cid:218)dzia, jest w ca(cid:239)o(cid:258)ci otwartym oprogramowaniem do bezp(cid:239)atnego korzystania w dowolnych celach. Udost(cid:218)pniane jest w ramach licencji Apache 2, jego kod jest dost(cid:218)pny w serwisie GitHub (http://github.com/ jetbrains/kotlin), a nowi cz(cid:239)onkowie spo(cid:239)eczno(cid:258)ci s(cid:200) zawsze mile widziani. Do wyboru s(cid:200) trzy otwarte, w pe(cid:239)ni obs(cid:239)uguj(cid:200)ce j(cid:218)zyk Kotlin (cid:258)rodowiska programistyczne: IntelliJ IDEA Community Edition, Android Studio i Eclipse (oczywi(cid:258)cie IntelliJ IDEA Ulti- mate te(cid:285)). Teraz, gdy wiesz ju(cid:285), jakiego rodzaju j(cid:218)zykiem jest Kotlin, poznaj jego zalety ujaw- niaj(cid:200)ce si(cid:218) w wybranych zastosowaniach. Poleć książkęKup książkę 30 ROZDZIA(cid:224) 1. Kotlin: co to jest i po co? 1.3. Zastosowania j(cid:266)zyka Kotlin Jak wspomnia(cid:239)em wcze(cid:258)niej, dwa g(cid:239)ówne obszary zastosowa(cid:241) j(cid:218)zyka Kotlin to aplikacje serwerowe i aplikacje dla systemu Android. Przyjrzyjmy si(cid:218) teraz obu tym obszarom i sprawd(cid:283)my, dlaczego Kotlin tak dobrze si(cid:218) w nich sprawdza. 1.3.1. Kotlin na serwerach Programowanie serwerów to bardzo szeroki temat, obejmuj(cid:200)cy mi(cid:218)dzy innymi nast(cid:218)- puj(cid:200)ce zagadnienia: (cid:81) aplikacje WWW generuj(cid:200)ce kody HTML stron, (cid:81) silniki aplikacji przeno(cid:258)nych udost(cid:218)pniaj(cid:200)ce interfejs JSON API za pomoc(cid:200) pro- toko(cid:239)u HTTP, (cid:81) mikrous(cid:239)ugi komunikuj(cid:200)ce si(cid:218) ze sob(cid:200) za pomoc(cid:200) protoko(cid:239)u RPC. Od wielu lat programi(cid:258)ci tworz(cid:200) tego rodzaju aplikacje w j(cid:218)zyku Java. W efekcie powsta(cid:239)o mnóstwo platform i technologii u(cid:239)atwiaj(cid:200)cych programowanie. Zazwyczaj takie aplikacje nie s(cid:200) tworzone w odosobnieniu, od podstaw. Niemal zawsze istnieje jaki(cid:258) system, który jest rozbudowywany, ulepszany lub wymieniany, a nowy kod integrowany jest z ju(cid:285) istnie- j(cid:200)cymi elementami systemu, napisanego wiele lat wcze(cid:258)niej. Pod tym wzgl(cid:218)dem ogromn(cid:200) zalet(cid:200) Kotlina jest jego kompatybilno(cid:258)(cid:202) z istniej(cid:200)cym kodem Java. Niezale(cid:285)nie od tego, czy tworzy si(cid:218) nowy komponent, czy migruje istniej(cid:200)c(cid:200) us(cid:239)ug(cid:218), Kotlin nadaje si(cid:218) do tego celu znakomicie. Nie ma problemów z rozszerzaniem istniej(cid:200)cych klas Java ani dodawaniem adnotacji metod i w(cid:239)a(cid:258)ciwo(cid:258)ci klas. Dodatkow(cid:200) korzy(cid:258)ci(cid:200) jest bardziej zwarty, stabilny i (cid:239)atwiejszy w utrzymaniu kod. Ponadto Kotlin oferuje kilka nowych technik u(cid:239)atwiaj(cid:200)cych programowanie. Na przy- k(cid:239)ad za pomoc(cid:200) szablonów Builder mo(cid:285)na w zwi(cid:218)z(cid:239)y sposób tworzy(cid:202) dowolne obiekty graficzne przy zachowaniu pe(cid:239)nej abstrakcyjno(cid:258)ci kodu i wykorzystaniu narz(cid:218)dzi do two- rzenia jego powtarzalnych cz(cid:218)(cid:258)ci. Jednym z najprostszych przyk(cid:239)adów wykorzystania tej cechy jest biblioteka generu- j(cid:200)ca kod HTML, dzi(cid:218)ki której kod zewn(cid:218)trzny napisany w j(cid:218)zyku szablonowym mo(cid:285)na zast(cid:200)pi(cid:202) zwi(cid:218)z(cid:239)ym kodem zachowuj(cid:200)cym zgodno(cid:258)(cid:202) typów, jak ni(cid:285)ej: fun renderPersonList(persons: Collection Person ) = createHTML().table { for (person in persons) { tr { td { +person.name } td { +person.age } } } } } Mo(cid:285)na w ten sposób (cid:239)atwo (cid:239)(cid:200)czy(cid:202) funkcje reprezentuj(cid:200)ce znaczniki HTML z typowymi konstrukcjami j(cid:218)zyka Kotlin. Nie trzeba stosowa(cid:202) osobnego j(cid:218)zyka szablonowego z w(cid:239)asn(cid:200) sk(cid:239)adni(cid:200). Wystarczy zastosowa(cid:202) p(cid:218)tl(cid:218) generuj(cid:200)c(cid:200) kod HTML strony. Metody powi(cid:261)zane ze znacznikami HTML. Zwyk(cid:225)a p(cid:266)tla w j(cid:266)zyku Kotlin. Poleć książkęKup książkę 1.3. Zastosowania j(cid:218)zyka Kotlin 31 Innym obszarem, w którym stosuje si(cid:218) czyste, zwi(cid:218)z(cid:239)e j(cid:218)zyki DSL (ang. domain-spe- cific language, j(cid:218)zyk dziedzinowy), s(cid:200) platformy obs(cid:239)uguj(cid:200)ce bazy danych. Na przyk(cid:239)ad platforma Exposed (https://github.com/jetbrains/exposed) oferuje czytelny j(cid:218)zyk DSL umo(cid:285)liwiaj(cid:200)cy tworzenie i wywo(cid:239)ywanie zapyta(cid:241) SQL z pe(cid:239)nym zachowaniem kontroli typów danych. Poni(cid:285)ej przedstawiony jest przyk(cid:239)ad prostego kodu wykorzystuj(cid:200)cego t(cid:218) funkcjonalno(cid:258)(cid:202): object CountryTable : IdTable() { val name = varchar( name , 250).uniqueIndex() val iso = varchar( iso , 2).uniqueIndex() } class Country(id: EntityID) : Entity(id) { var name: String by CountryTable.name var iso: String by CountryTable.iso } val poland = Country.find { CountryTable.iso.eq( pl ) }.first() println(poland.name) Powy(cid:285)sze techniki opiszemy bardziej szczegó(cid:239)owo w podrozdziale 7.5 oraz w rozdziale 11. Utworzenie klasy odpowiadaj(cid:261)cej obiektowi w bazie danych. Baz(cid:266) mo(cid:298)na odpytywa(cid:252) bezpo(cid:286)rednio za pomoc(cid:261) kodu Kotlin. Opis tabeli w bazie danych. 1.3.2. Kotlin w Androidzie Typowa aplikacja dla urz(cid:200)dzenia przeno(cid:258)nego bardzo ró(cid:285)ni si(cid:218) od aplikacji dla kom- putera. Jest znacznie mniejsza i w ograniczonym stopniu wykorzystuje istniej(cid:200)cy kod. Ponadto zazwyczaj aplikacje przeno(cid:258)ne trzeba tworzy(cid:202) szybko i musz(cid:200) one dzia(cid:239)a(cid:202) nie- zawodnie na urz(cid:200)dzeniach bardzo ró(cid:285)nych rodzajów. Do tworzenia tego typu projektów Kotlin równie(cid:285) nadaje si(cid:218) bardzo dobrze. Struktura j(cid:218)zyka Kotlin oraz dost(cid:218)pno(cid:258)(cid:202) specjalnej wtyczki dla kompilatora powo- duj(cid:200), (cid:285)e programowanie w systemie Android jest efektywniejsze i przyjemniejsze. Naj- cz(cid:218)stsze zadania, na przyk(cid:239)ad kodowanie obs(cid:239)ugi kontrolek lub wi(cid:200)zanie elementów inter- fejsu u(cid:285)ytkownika z w(cid:239)a(cid:258)ciwo(cid:258)ciami klas, realizuje si(cid:218) za pomoc(cid:200) znacznie krótszego kodu, a czasami bez kodu w ogóle (generuje go kompilator). Biblioteka Anko (https://github.com/ kotlin/anko), równie(cid:285) opracowana przez zespó(cid:239) autorów Kotlina, jeszcze bardziej u(cid:239)atwia to zadanie, oferuj(cid:200)c adaptery przystosowane do wielu standardowych interfejsów API systemu Android. Poni(cid:285)ej znajduje si(cid:218) prosty kod wykorzystuj(cid:200)cy bibliotek(cid:218) Anko i pokazuj(cid:200)cy, co powi- nien zrobi(cid:202) programista, aby w j(cid:218)zyku Kotlin utworzy(cid:202) aplikacj(cid:218) dla systemu Android. Musi ten kod umie(cid:258)ci(cid:202) w aktywno(cid:258)ci i prosta aplikacja gotowa! verticalLayout { val name = editText() button( Powiedz: cze(cid:295)(cid:232)! ) { onClick { toast( Cze(cid:295)(cid:232), ${name.text}! ) } } } Po klikni(cid:266)ciu tego przycisku wy(cid:286)wietlane jest imi(cid:266) wpisane w polu tekstowym. Utworzenie prostego pola tekstowego. Zwarta sk(cid:225)adnia wi(cid:261)(cid:298)(cid:261)ca kod nas(cid:225)uchuj(cid:261)cy, który wy(cid:286)wietla komunikat. Poleć książkęKup książkę 32 ROZDZIA(cid:224) 1. Kotlin: co to jest i po co? Inn(cid:200) ogromn(cid:200) zalet(cid:200) j(cid:218)zyka Kotlin jest wi(cid:218)ksza stabilno(cid:258)(cid:202) tworzonych w nim aplikacji. Je(cid:285)eli masz do(cid:258)wiadczenie w pisaniu aplikacji dla systemu Android, na pewno dobrze znasz komunikat: „Niestety, aplikacja zosta(cid:239)a zatrzymana”. Komunikat ten pojawia si(cid:218) po zg(cid:239)oszeniu nieobs(cid:239)ugiwanego wyj(cid:200)tku, zazwyczaj NullPointerException. System typów w j(cid:218)zyku Kotlin, które umo(cid:285)liwiaj(cid:200) precyzyjne (cid:258)ledzenie warto(cid:258)ci null, (cid:239)agodzi problem zerowych wska(cid:283)ników. W wi(cid:218)kszo(cid:258)ci przypadków kod, który w j(cid:218)zyku Java powoduje zg(cid:239)oszenie wyj(cid:200)tku NullPointerException, w j(cid:218)zyku Kotlin w ogóle si(cid:218) nie kompiluje, dzi(cid:218)ki czemu przed udost(cid:218)pnieniem aplikacji u(cid:285)ytkownikom mo(cid:285)na b(cid:239)(cid:200)d poprawi(cid:202). Poniewa(cid:285) Kotlin jest w pe(cid:239)ni kompatybilny z Java 6, nie wyst(cid:218)puj(cid:200) problemy z inte- gracj(cid:200). Mo(cid:285)na korzysta(cid:202) ze wszystkich nowych, ciekawych funkcjonalno(cid:258)ci Kotlina, a u(cid:285)yt- kownicy b(cid:218)d(cid:200) mogli uruchamia(cid:202) aplikacje na swoich urz(cid:200)dzeniach wyposa(cid:285)onych nawet w starsze wersje systemu Android. Pod wzgl(cid:218)dem wydajno(cid:258)ci Kotlin równie(cid:285) wypada niezgorzej. Wygenerowany przez kompilator kod dzia(cid:239)a równie wydajnie jak kod Java. Biblioteka uruchomieniowa Kotlina jest bardzo ma(cid:239)a, wi(cid:218)c skompilowane pakiety aplikacyjne nie s(cid:200) du(cid:285)e. Ponadto wiele stan- dardowych bibliotek Kotlina zamienia funkcje lambda na kod procesora. Dzi(cid:218)ki temu nie s(cid:200) tworzone nowe obiekty, a dzia(cid:239)anie aplikacji nie jest wstrzymywane na czas porz(cid:200)d- kowania pami(cid:218)ci. Teraz, gdy wiesz, jaka jest przewaga Kotlina nad Jav(cid:200), poznaj jego filozofi(cid:218), odró(cid:285)- niaj(cid:200)c(cid:200) go od innych nowoczesnych j(cid:218)zyków dla (cid:258)rodowiska JVM. 1.4. Filozofia j(cid:266)zyka Kotlin O Kotlinie zwykli(cid:258)my mówi(cid:202), (cid:285)e jest to pragmatyczny, zwi(cid:218)z(cid:239)y, bezpieczny, kompatybilny j(cid:218)zyk programowania. Co konkretnie znacz(cid:200) te s(cid:239)owa? 1.4.1. Pragmatyzm Pragmatyzm oznacza prost(cid:200) cech(cid:218): Kotlin jest j(cid:218)zykiem przeznaczonym do rozwi(cid:200)zywa- nia praktycznych problemów. Jego kszta(cid:239)t wynika z wieloletniego do(cid:258)wiadczenia auto- rów w tworzeniu du(cid:285)ych systemów, a oferowane funkcjonalno(cid:258)ci zosta(cid:239)y opracowane pod k(cid:200)tem typowych przypadków, z którymi mierz(cid:200) si(cid:218) programi(cid:258)ci. Co wi(cid:218)cej, zarówno zespó(cid:239) JetBrains, jak i spo(cid:239)eczno(cid:258)(cid:202) u(cid:285)ytkowników od wielu lat korzystaj(cid:200) ze wst(cid:218)pnych wersji Kotlina i ich opinie zosta(cid:239)y uwzgl(cid:218)dnione w oficjalnej wersji. Dlatego twierdzimy, (cid:285)e Kotlin umo(cid:285)liwia rozwi(cid:200)zywanie problemów w rzeczywistych projektach. Kotlin nie jest j(cid:218)zykiem akademickim. Nie staramy si(cid:218) wzbogaca(cid:202) sztuki progra- mowania i implementowa(cid:202) innowacji informatycznych. Zamiast tego tam, gdzie jest to mo(cid:285)liwe, wykorzystujemy funkcjonalno(cid:258)ci i rozwi(cid:200)zania spotykane w innych j(cid:218)zykach, które sprawdzi(cid:239)y si(cid:218) w praktyce. Dzi(cid:218)ki temu nasz j(cid:218)zyk jest mniej skomplikowany, prostszy w opanowaniu i wykorzystuj(cid:200)cy sprawdzone koncepcje. Co wi(cid:218)cej, Kotlin nie narzuca (cid:285)adnego stylu ani zasad programowania. Rozpoczynaj(cid:200)c nauk(cid:218) tego j(cid:218)zyka, mo(cid:285)esz stosowa(cid:202) style i techniki, które znasz z Javy. W miar(cid:218) post(cid:218)pów b(cid:218)dziesz stopniowo odkrywa(cid:239) przydatne cechy Kotlina i uczy(cid:239) si(cid:218) wykorzystywa(cid:202) je w swoim kodzie, dzi(cid:218)ki czemu b(cid:218)dzie on bardziej zwi(cid:218)z(cid:239)y i funkcjonalny. Poleć książkęKup książkę 1.4. Filozofia j(cid:218)zyka Kotlin 33 Innym pragmatycznym aspektem Kotlina jest koncentracja na narz(cid:218)dziach. Dobre (cid:258)rodowisko programistyczne jest równie wa(cid:285)ne dla skutecznego programowania jak dobry j(cid:218)zyk. Dlatego marginalne traktowanie (cid:258)rodowiska IDE jest nie do przyj(cid:218)cia. W przypadku j(cid:218)zyka Kotlin wtyczka dla (cid:258)rodowiska IntelliJ IDEA by(cid:239)a rozwijana rów- nolegle z kompilatorem, a funkcjonalno(cid:258)ci j(cid:218)zyka s(cid:200) projektowane równie(cid:285) pod k(cid:200)tem narz(cid:218)dzi. (cid:165)rodowisko programistyczne odgrywa wielk(cid:200) rol(cid:218) w poznawaniu funkcjonalno(cid:258)ci Kotlina. Cz(cid:218)sto narz(cid:218)dzia automatycznie wykrywaj(cid:200) najcz(cid:218)(cid:258)ciej stosowane schematy kodo- wania, które mo(cid:285)na zast(cid:218)powa(cid:202) bardziej zwartymi konstrukcjami, i oferuj(cid:200) stosowne zmiany. Analizuj(cid:200)c sk(cid:239)adni(cid:218) sugerowan(cid:200) przez zautomatyzowane narz(cid:218)dzia, mo(cid:285)esz uczy(cid:202) si(cid:218) wykorzystywa(cid:202) nowe funkcjonalno(cid:258)ci w swoim kodzie. 1.4.2. Zwi(cid:266)z(cid:225)o(cid:286)(cid:252) Powszechnie wiadomo, (cid:285)e poznanie istniej(cid:200)cego kodu zajmuje programi(cid:258)cie wi(cid:218)cej czasu ni(cid:285) napisanie nowego. Wyobra(cid:283) sobie, (cid:285)e jeste(cid:258) cz(cid:239)onkiem zespo(cid:239)u pracuj(cid:200)cego nad ogromnym projektem i musisz zakodowa(cid:202) now(cid:200) funkcjonalno(cid:258)(cid:202) lub poprawi(cid:202) b(cid:239)(cid:200)d. Jaki jest Twój pierwszy krok? Musisz najpierw znale(cid:283)(cid:202) sekcj(cid:218) kodu, któr(cid:200) masz zmieni(cid:202). Dopiero wtedy mo(cid:285)esz poprawi(cid:202) b(cid:239)(cid:200)d. Aby okre(cid:258)li(cid:202), co powiniene(cid:258) zrobi(cid:202), musisz prze- analizowa(cid:202) mnóstwo kodu, który móg(cid:239) zosta(cid:202) napisany stosunkowo niedawno przez Twoich kolegów, ale równie dobrze du(cid:285)o wcze(cid:258)niej przez Ciebie samego lub kogo(cid:258), kto ju(cid:285) nie pracuje nad projektem. Dopiero po zrozumieniu s(cid:200)siedniego kodu jeste(cid:258) w sta- nie wprowadzi(cid:202) niezb(cid:218)dne zmiany. Im prostszy i krótszy jest kod, tym szybciej mo(cid:285)na si(cid:218) dowiedzie(cid:202), co si(cid:218) w nim dzieje. Oczywi(cid:258)cie przemy(cid:258)lana struktura i opisowe nazwy maj(cid:200) tu istotne znaczenie. Ale wa(cid:285)ny jest te(cid:285) sam j(cid:218)zyk i jego zwi(cid:218)z(cid:239)o(cid:258)(cid:202). J(cid:218)zyk jest zwi(cid:218)z(cid:239)y, je(cid:285)eli jego sk(cid:239)adnia jasno oddaje przeznaczenie kodu i nie zaciemniaj(cid:200) go dodatkowe instrukcje niezb(cid:218)dne do osi(cid:200)gni(cid:218)cia zamierzonego celu. Dok(cid:239)adamy wszelkich stara(cid:241), aby ca(cid:239)y kod Kotlin niós(cid:239) tre(cid:258)(cid:202), a nie tylko spe(cid:239)nia(cid:239) wymogi struktur programistycznych. Niektóre standardowe konstrukcje z j(cid:218)zyka Java, takie jak gettery, settery lub parametry konstruktorów powi(cid:200)zane z w(cid:239)a(cid:258)ciwo(cid:258)ciami, s(cid:200) w j(cid:218)zyku Kotlin stosowane niejawnie i nie zaciemniaj(cid:200) kodu. Niekiedy przyczyn(cid:200) niepotrzebnego wyd(cid:239)u(cid:285)enia kodu jest konieczno(cid:258)(cid:202) jawnego imple- mentowania cz(cid:218)sto wykonywanych zada(cid:241), na przyk(cid:239)ad wyszukiwania elementu w kolekcji. Podobnie jak wiele innych nowoczesnych j(cid:218)zyków, Kotlin równie(cid:285) zawiera bogat(cid:200) stan- dardow(cid:200) bibliotek(cid:218) umo(cid:285)liwiaj(cid:200)c(cid:200) zast(cid:218)powanie d(cid:239)ugich, powtarzalnych sekcji kodu gotowymi metodami z biblioteki. Dzi(cid:218)ki funkcjom lambda mo(cid:285)na w funkcjach biblio- teki (cid:239)atwo umieszcza(cid:202) ma(cid:239)e bloki kodu. W ten sposób wszystkie cz(cid:218)sto wykonywane zadania mo(cid:285)na zleca(cid:202) bibliotece i pisa(cid:202) tylko unikatowe, charakterystyczne dla danego zadania sekcje kodu. Jednak(cid:285)e przeznaczeniem j(cid:218)zyka Kotlin nie jest (cid:258)ci(cid:258)ni(cid:218)cie kodu do minimalnej liczby znaków. Na przyk(cid:239)ad mimo tego, (cid:285)e mo(cid:285)liwe jest przeci(cid:200)(cid:285)anie operatorów, nie mo(cid:285)na definiowa(cid:202) w(cid:239)asnych. Dlatego twórcy bibliotek nie mog(cid:200) zast(cid:218)powa(cid:202) nazw metod tajem- niczymi symbolami. S(cid:239)owa s(cid:200) zazwyczaj bardziej zrozumia(cid:239)e ni(cid:285) symbole i (cid:239)atwiej jest znale(cid:283)(cid:202) ich opis w dokumentacji. Poleć książkęKup książkę 34 ROZDZIA(cid:224) 1. Kotlin: co to jest i po co? Napisanie zwartego kodu zajmuje mniej czasu i, co wa(cid:285)ne, mniej czasu potrzeba na jego przeczytanie. Dzi(cid:218)ki temu programista mo(cid:285)e pracowa(cid:202) wydajniej i kodowa(cid:202) szybciej. 1.4.3. Bezpiecze(cid:276)stwo Mówi(cid:200)c, (cid:285)e j(cid:218)zyk programowania jest bezpieczny, mamy zazwyczaj na my(cid:258)li jego struk- tur(cid:218) chroni(cid:200)c(cid:200) programist(cid:218) przed pope(cid:239)nianiem okre(cid:258)lonego rodzaju b(cid:239)(cid:218)dów. Oczywi- (cid:258)cie nie jest to bezwzgl(cid:218)dnym wyznacznikiem jako(cid:258)ci j(cid:218)zyka. (cid:191)aden j(cid:218)zyk nie chroni ca(cid:239)kowicie przed b(cid:239)(cid:218)dami, a ponadto zazwyczaj taka ochrona kosztuje, poniewa(cid:285) kom- pilatorowi trzeba dostarczy(cid:202) dodatkowych informacji o operacjach, które ma wykony- wa(cid:202) program. Kompilator porównuje te informacje z wykonywanymi operacjami. Z tego powodu zawsze istnieje pewien kompromis pomi(cid:218)dzy zapewnianym poziomem bez- piecze(cid:241)stwa a nak(cid:239)adem pracy, jakiego wymaga umieszczenie w kodzie szczegó(cid:239)owych adnotacji. Naszym zamiarem by(cid:239)o zapewnienie w j(cid:218)zyku Kotlin wi(cid:218)kszego bezpiecze(cid:241)stwa ni(cid:285) w Javie, ale mniejszym kosztem. Sama maszyna JVM daje gwarancj(cid:218) bezpiecze(cid:241)stwa, na przyk(cid:239)ad zapewnia ochron(cid:218) pami(cid:218)ci, zabezpiecza przed przepe(cid:239)nieniem buforów, jak równie(cid:285) chroni przed ró(cid:285)nymi problemami wynikaj(cid:200)cymi z niew(cid:239)a(cid:258)ciwego korzy- stania z dynamicznie przydzielanej pami(cid:218)ci. Kotlin jako j(cid:218)zyk ze statycznym typowaniem przeznaczonym dla maszyny JVM zapewnia dodatkowo bezpiecze(cid:241)stwo typów danych. Odbywa si(cid:218) to jednak mniejszym kosztem ni(cid:285) w Javie, poniewa(cid:285) kompilator automa- tycznie domniemywa typy i nie trzeba ich wsz(cid:218)dzie specyfikowa(cid:202). Kotlin oferuje wi(cid:218)cej funkcjonalno(cid:258)ci umo(cid:285)liwiaj(cid:200)cych wykrywanie b(cid:239)(cid:218)dów jeszcze na etapie kompilacji kodu, a nie dopiero po jego uruchomieniu. Przede wszystkim mini- malizuje ryzyko zg(cid:239)oszenia wyj(cid:200)tku NullPointerException. System typów umo(cid:285)liwia (cid:258)le- dzenie zmiennych, które mog(cid:200) przyjmowa(cid:202) warto(cid:258)(cid:202) null, oraz tych, które nie mog(cid:200) jej przyjmowa(cid:202), i uniemo(cid:285)liwia wykonywanie na nich operacji prowadz(cid:200)cych do zg(cid:239)oszenia powy(cid:285)szego wyj(cid:200)tku. Zwi(cid:200)zany z tym dodatkowy koszt jest minimalny, poniewa(cid:285) w celu oznaczenia zerowalnej zmiennej wystarczy wpisa(cid:202) znak zapytania, jak ni(cid:285)ej: val s: String? = null val s2: String = Zmienna nie mo(cid:298)e przyjmowa(cid:252) warto(cid:286)ci null. Zmienna mo(cid:298)e przyjmowa(cid:252) warto(cid:286)(cid:252) null. Ponadto Kotlin oferuje wiele wygodnych sposobów przetwarzania zerowalnych danych, co znacznie zmniejsza ryzyko awarii aplikacji. Innym wyj(cid:200)tkiem, przed którym chroni Kotlin, jest ClassCastException. Wyj(cid:200)tek ten jest zg(cid:239)aszany podczas rzutowania typów bez uprzedniego sprawdzenia, czy jest to poprawna operacja. W Javie cz(cid:218)sto programi(cid:258)ci rezygnuj(cid:200) ze sprawdzania typu, poniewa(cid:285) jego nazwy trzeba u(cid:285)y(cid:202) dwukrotnie: najpierw w instrukcji sprawdzaj(cid:200)cej, a nast(cid:218)pnie w instrukcji rzutuj(cid:200)cej typ. Natomiast w Kotlinie sprawdzanie i rzutowanie typu reali- zuje si(cid:218) za pomoc(cid:200) jednej instrukcji. Po sprawdzeniu typu mo(cid:285)na odwo(cid:239)ywa(cid:202) si(cid:218) do elementów cz(cid:239)onkowskich bez dodatkowego rzutowania. Zatem nie ma powodu, aby rezygnowa(cid:202) ze sprawdzania typu, nie ma równie(cid:285) mo(cid:285)liwo(cid:258)ci pope(cid:239)nienia b(cid:239)(cid:218)du. Poni- (cid:285)ej przedstawiony jest przyk(cid:239)ad: Poleć książkęKup książkę 1.5. Narz(cid:218)dzia j(cid:218)zyka Kotlin 35 if (value is String) println(value.toUpperCase()) Sprawdzenie typu. U(cid:298)ycie metody wybranego typu. 1.4.4. Kompatybilno(cid:286)(cid:252) Twoje pierwsze pytanie dotycz(cid:200)ce kompatybilno(cid:258)ci zapewne brzmi: „Czy mog(cid:218) u(cid:285)ywa(cid:202) istniej(cid:200)cych bibliotek?”. W j(cid:218)zyku Kotlin odpowied(cid:283) brzmi: „Tak, oczywi(cid:258)cie”. Niezale(cid:285)nie od interfejsu API, który udost(cid:218)pnia biblioteka, mo(cid:285)na z niej korzysta(cid:202). Mo(cid:285)na wywo(cid:239)y- wa(cid:202) metody Java, rozszerza(cid:202) klasy, implementowa(cid:202) interfejsy, stosowa(cid:202) adnotacje itp. Kotlin, w odró(cid:285)nieniu od innych j(cid:218)zyków dla maszyny JVM, oferuje jeszcze wi(cid:218)ksz(cid:200) kompatybilno(cid:258)(cid:202) umo(cid:285)liwiaj(cid:200)c(cid:200) (cid:239)atwe wywo(cid:239)ywanie jego kodu w kodzie Java. Nie s(cid:200) do tego potrzebne (cid:285)adne sztuczki: klasy i metody napisane w j(cid:218)zyku Kotlin wywo(cid:239)uje si(cid:218) tak samo jak klasy i metody napisane w Javie. Daje to ogromn(cid:200) elastyczno(cid:258)(cid:202) w mieszaniu kodów Kotlin i Java. Je(cid:285)eli trzeba u(cid:285)y(cid:202) j(cid:218)zyka Kotlin w projekcie napisanym w j(cid:218)zyku Java, mo(cid:285)na za pomoc(cid:200) konwertera Java-Kotlin przekszta(cid:239)ci(cid:202) dowoln(cid:200) wybran(cid:200) klas(cid:218), a pozosta(cid:239)(cid:200) cz(cid:218)(cid:258)(cid:202) kodu skompilowa(cid:202) i uruchomi(cid:202) bez dodatkowych modyfikacji. Kon- wersja dotyczy dowolnego typu klasy. Innym obszarem kompatybilno(cid:258)ci, na którym skupia si(cid:218) Kotlin, jest jak najpe(cid:239)niejsze wykorzystanie istniej(cid:200)cych bibliotek Java. Kotlin nie ma w(cid:239)asnej kolekcji bibliotek, ponie- wa(cid:285) w ca(cid:239)o(cid:258)ci opiera si(cid:218) na standardowych bibliotekach Java i rozszerza je o dodatkowe metody, bardziej wygodne w u(cid:285)yciu (dok(cid:239)adniej ten mechanizm opisany jest w podroz- dziale 3.3). Oznacza to, (cid:285)e nie trzeba opakowywa(cid:202) ani przekszta(cid:239)ca(cid:202) klas z j(cid:218)zyka Java na Kotlin lub odwrotnie. Z bogactwa interfejsu API j(cid:218)zyka Kotlin mo(cid:285)na korzysta(cid:202) bez (cid:285)adnych dodatkowych kosztów. Narz(cid:218)dzia j(cid:218)zyka Kotlin równie(cid:285) mo(cid:285)na w pe(cid:239)ni wykorzystywa(cid:202) w projektach obej- muj(cid:200)cych dwa j(cid:218)zyki. Mo(cid:285)na kompilowa(cid:202) dowolne kombinacje plików (cid:283)ród(cid:239)owych Java i Kotlin, niezale(cid:285)nie od ich wzajemnych zale(cid:285)no(cid:258)ci. (cid:165)rodowisko programistyczne rów- nie(cid:285) obs(cid:239)uguje oba j(cid:218)zyki i umo(cid:285)liwia m.in.: (cid:81) swobodne przemieszczanie si(cid:218) pomi(cid:218)dzy plikami (cid:283)ród(cid:239)owymi Java i Kotlin, (cid:81) diagnozowanie mieszanych projektów i prze(cid:239)(cid:200)czanie si(cid:218) pomi(cid:218)dzy kodami napi- (cid:81) sanymi w obu j(cid:218)zykach, refaktorowanie metod Java oraz odpowiedni(cid:200) modyfikacj(cid:218) kodu Kotlin i odwrotnie. Mamy nadziej(cid:218), (cid:285)e przekonali(cid:258)my Ci(cid:218), aby(cid:258) wypróbowa(cid:239) j(cid:218)zyk Kotlin. Jak wi(cid:218)c zacz(cid:200)(cid:202) go u(cid:285)ywa(cid:202)? W nast(cid:218)pnej cz(cid:218)(cid:258)ci rozdzia(cid:239)u opisujemy proces kompilowania i uruchamiania kodu Kotlin za pomoc(cid:200) wiersza polece(cid:241) oraz innych narz(cid:218)dzi. 1.5. Narz(cid:266)dzia j(cid:266)zyka Kotlin Kotlin, tak jak Java, jest j(cid:218)zykiem kompilowanym. Oznacza to, (cid:285)e aby uruchomi(cid:202) kod, trzeba go najpierw skompilowa(cid:202). Przeanalizujmy teraz proces kompilacji i przyjrzyjmy si(cid:218) ró(cid:285)nym narz(cid:218)dziom, które zajmuj(cid:200) si(cid:218) tym procesem za Ciebie. Je(cid:285)eli potrzebujesz dodatkowych informacji o przygotowaniu (cid:258)rodowiska, zapoznaj si(cid:218) z sekcj(cid:200) Tutorials (podr(cid:218)czniki) na stronie Kotlina (https://kotlinlang.org/docs/tutorials). Poleć książkęKup książkę 36 ROZDZIA(cid:224) 1. Kotlin: co to jest i po co? 1.5.1. Kompilator kodu Kod (cid:283)ród(cid:239)owy Kotlin zazwyczaj zapisuje si(cid:218) w plikach z rozszerzeniem .kt. Kompilator analizuje kod (cid:283)ród(cid:239)owy i generuje pliki .class tak samo jak kompilator Java. Nast(cid:218)pnie wygenerowane pliki s(cid:200) pakowane i uruchamiane w sposób w(cid:239)a(cid:258)ciwy rodzajowi aplikacji. W najprostszym przypadku kod kompiluje si(cid:218) za pomoc(cid:200) polecenia kotlinc, a urucha- mia poleceniem java, jak ni(cid:285)ej: kotlinc plik (cid:316)ród(cid:273)owy lub katalog -include-runtime -d nazwa pliku JAR java -jar nazwa pliku JAR Rysunek 1.1 przedstawia uproszczony proces budowania aplikacji w j(cid:218)zyku Kotlin. Rysunek 1.1. Proces budowania aplikacji w j(cid:266)zyku Kotlin Kod wygenerowany za pomoc(cid:200) kompilatora Kotlin jest uzale(cid:285)niony od biblioteki uru- chomieniowej tego j(cid:218)zyka zawieraj(cid:200)cej w(cid:239)asne klasy i rozszerzenia, o które uzupe(cid:239)nia- ne s(cid:200) standardowe interfejsy API j(cid:218)zyka Java. Biblioteka uruchomieniowa musi by(cid:202) dostarczana razem z aplikacj(cid:200). W wi(cid:218)kszo(cid:258)ci przypadków b(cid:218)dziesz kompilowa(cid:239) kod za pomoc(cid:200) systemów Maven, Gradle i Ant. Kotlin jest kompatybilny ze wszystkimi wymienionymi systemami. Szcze- gó(cid:239)owe informacje na ten temat znajdziesz w dodatku A. Systemy te obs(cid:239)uguj(cid:200) równie(cid:285) projekty z mieszanym kodem. Ponadto Maven i Gradle do(cid:239)(cid:200)czaj(cid:200) bibliotek(cid:218) urucho- mieniow(cid:200) Kotlina jako zale(cid:285)no(cid:258)(cid:202) wymagan(cid:200) przez aplikacj(cid:218). 1.5.2. Wtyczki dla IntelliJ IDAE i Android Studio Wtyczka Kotlin dla (cid:258)rodowiska IntelliJ IDEA by(cid:239)a rozwijana równolegle z samym j(cid:218)zykiem. IntelliJ IDEA jest najlepiej wyposa(cid:285)onym (cid:258)rodowiskiem programistycznym dla j(cid:218)zyka Kotlin. Jest ono dojrza(cid:239)e, stabilne i oferuje pe(cid:239)ny zestaw narz(cid:218)dzi programistycznych. Wtyczka jest standardowo dost(cid:218)pna w wersjach IntelliJ IDEA 15 i nowszych, nie trzeba wi(cid:218)c wykonywa(cid:202) dodatkowych czynno(cid:258)ci, aby z niej korzysta(cid:202). Mo(cid:285)na jej u(cid:285)ywa(cid:202) w wersjach IntelliJ IDEA Community Edition i IntelliJ IDEA Ultimate. Wystarczy w oknie New Project (nowy projekt) wybra(cid:202) opcj(cid:218) Kotlin i gotowe. Poleć książkęKup książkę 1.5. Narz(cid:218)dzia j(cid:218)zyka Kotlin 37 Je(cid:285)eli korzystasz z Android Studio, musisz zainstalowa(cid:202) wtyczk(cid:218) za pomoc(cid:200) mene- d(cid:285)era wtyczek. W tym celu w oknie Settings (ustawienia) wybierz sekcj(cid:218) Plugins (wtyczki), kliknij przycisk Install JetBrains plugin (zainstaluj wtyczk(cid:218) JetBrains) i wybierz z listy pozycj(cid:218) Kotlin. 1.5.3. Interaktywna pow(cid:225)oka Aby szybko sprawdzi(cid:202) krótki kod, mo(cid:285)esz u(cid:285)y(cid:202) interaktywnej pow(cid:239)oki (tzw. REPL — ang. read-eval-print loop, p(cid:218)tla „wczytaj, wykonaj, wy(cid:258)wietl”). W tej pow(cid:239)oce mo(cid:285)na wpi- sywa(cid:202) kod Kotlin wiersz po wierszu i od razu sprawdza(cid:202) wyniki jego wykonania. Pow(cid:239)ok(cid:218) uruchamia si(cid:218), wpisuj(cid:200)c polecenie kotlinc bez argumentów lub klikaj(cid:200)c odpowiedni(cid:200) opcj(cid:218) menu w (cid:258)rodowisku IntelliJ IDEA. 1.5.4. Wtyczka dla Eclipse Je(cid:285)eli u(cid:285)ywasz (cid:258)rodowiska Eclipse, równie(cid:285) mo(cid:285)esz korzysta(cid:202) z wtyczki dla j(cid:218)zyka Kotlin. Wtyczka ta oferuje najwa(cid:285)niejsze funkcjonalno(cid:258)ci, takie jak poruszanie si(cid:218) po projekcie i uzupe(cid:239)nianie kodu. Jest dost(cid:218)pna w serwisie Eclipse Marketplace. Aby j(cid:200) zainstalo- wa(cid:202), wybierz polecenie menu Help/Eclipse Marketplace, a nast(cid:218)pnie wyszukaj na li(cid:258)cie pozycj(cid:218) Kotlin. 1.5.5. Internetowy „plac zabaw” Najprostszy sposób wypróbowania j(cid:218)zyka Kotlin nie wymaga instalacji ani konfiguracji (cid:258)rodowiska. Na stronie http://try.kotl.in dost(cid:218)pny jest „plac zabaw”, na którym mo(cid:285)na pisa(cid:202), kompilowa(cid:202) i uruchamia(cid:202) proste programy. Strona zawiera równie(cid:285) przyk(cid:239)adowe kody prezentuj(cid:200)ce mo(cid:285)liwo(cid:258)ci tego j(cid:218)zyka, mi(cid:218)dzy innymi wszystkie przyk(cid:239)ady opisane w tej ksi(cid:200)(cid:285)ce. Dost(cid:218)pne s(cid:200) te(cid:285) serie interaktywnych (cid:202)wicze(cid:241) do nauki j(cid:218)zyka. 1.5.6. Konwerter Java-Kotlin Opanowanie nowego j(cid:218)zyka programowania nigdy nie przychodzi bez wysi(cid:239)ku. Dlatego przygotowali(cid:258)my ciekawe, ma(cid:239)e narz(cid:218)dzie, dzi(cid:218)ki któremu, wykorzystuj(cid:200)c swoje do(cid:258)wiad- czenie z j(cid:218)zykiem Java, szybciej nauczysz si(cid:218) Kotlina. Tym narz(cid:218)dziem jest zautomatyzo- wany konwerter Java-Kotlin. Na pocz(cid:200)tku nauki, gdy nie b(cid:218)dziesz jeszcze zna(cid:239) dok(cid:239)adnie sk(cid:239)adni j(cid:218)zyka, konwerter pomo(cid:285)e Ci formu(cid:239)owa(cid:202) wyra(cid:285)enia. B(cid:218)dziesz móg(cid:239) pisa(cid:202) kod w Javie, zapisywa(cid:202) go w pliku i automatycznie konwertowa(cid:202) na j(cid:218)zyk Kotlin. Uzyskany kod nie zawsze b(cid:218)dzie idealnie (cid:258)cis(cid:239)y, ale b(cid:218)dzie dzia(cid:239)a(cid:239) poprawnie i pozwoli Ci robi(cid:202) post(cid:218)py w nauce. Konwerter doskonale nadaje si(cid:218) równie(cid:285) do wprowadzenia j(cid:218)zyka Kotlin do istnie- j(cid:200)cego projektu. Je(cid:285)eli b(cid:218)dziesz chcia(cid:239) utworzy(cid:202) now(cid:
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Kotlin w akcji
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: