Atomowy Kotlin - ebook

Wprowadzenie

Książka ta jest przeznaczona zarówno dla zaangażowanych nowicjuszy, jak i dla doświadczonych programistów.

Przyjmujemy, że czytelnik jest nowicjuszem, jeśli nie ma wcześniejszego doświadczenia w programowaniu, ale powinien być „zaangażowany”, gdyż dostarczymy jedynie tyle wiedzy, ile potrzeba, aby mógł działać na tym polu samodzielnie. Po ukończeniu otrzyma solidne podstawy w programowaniu, a także w znajomości języka Kotlin.

Osoby, które są doświadczonymi programistami, powinny przejść do punktów „Podsumowanie 1” oraz „Podsumowanie 2” i kontynuować lekturę od tamtego miejsca.

Słowo „atomowy” w tytule książki odnosi się do atomów jako najmniejszych, niepodzielnych jednostek. W tej książce staramy się wprowadzać po jednej koncepcji w każdym rozdziale, zatem nie mogą być one podzielone na mniejsze fragmenty – dlatego nazywamy je atomami.

Koncepcje

Wszystkie języki programowania składają się z funkcjonalności. Używamy tych funkcjonalności, aby uzyskać pożądany rezultat. Kotlin jest efektywnym językiem – nie tylko zawiera bogaty zestaw funkcjonalności, ale dzięki niemu można je wyrazić na wiele sposobów.

Gdybyśmy zbyt szybko przekazali całą wiedzę czytelnikowi, mógłby odejść z przekonaniem, że Kotlin jest „zbyt skomplikowany”.

W tej książce staramy się uczyć tego języka w sposób dokładny i przemyślany, stosując się do następujących zasad:

1. Drobne kroki i małe zwycięstwa. Odrzucamy tyranię rozdziałów. Zamiast tego prezentujemy każdy, nawet niewielki krok jako atomową koncepcję lub po prostu atom, wyglądający jak mały rozdział. W każdym atomie staramy się przedstawić tylko jedną koncepcję. Typowy atom zawiera jeden lub więcej niewielkich, możliwych do uruchomienia fragmentów kodu oraz tworzonych przez nie wyników.

2. Bez odnośników w przód. O ile to tylko możliwe, unikamy zwrotów w rodzaju „Te funkcje zostaną wyjaśnione w późniejszym atomie”.

3. Bez odnośników do innych języków programowania. Będziemy to robić jedynie wtedy, gdy jest to niezbędne. Analogia do funkcjonalności dostępnej w języku, którego się nie rozumie, nie jest pomocna.

4. Pokazywanie, a nie opowiadanie. Zamiast słownego omawiania funkcjonalności, preferujemy używanie przykładów i wyników, czyli zamieniamy teorię w praktykę – lepiej jest gołym okiem zobaczyć np. funkcjonalność w kodzie.

5. Ćwiczenia przed teorią. Staramy się najpierw pokazywać mechanikę języka, a dopiero potem wyjaśniać, dlaczego te funkcjonalności istnieją. Jest to podejście odwrotne do „tradycyjnego” nauczania, ale często wydaje się działać lepiej.

Gdy czytelnik już pozna funkcjonalności języka, wypracuje sobie jego rozumienie. Zazwyczaj łatwiejsze jest przyswojenie pojedynczej strony kodu Kotlina niż zrozumienie równoważnego mu kodu w innym języku.

Gdzie jest indeks?

Ta książka została napisana w języku znaczników Markdown i następnie złamana za pomocą Leanpub. Niestety, ani Markdown, ani Leanpub nie obsługują indeksowania. Jednak dzięki utworzeniu możliwie małych rozdziałów (atomów), z których każdy zawiera pojedyncze zagadnienie, spis treści odgrywa rolę czegoś w rodzaju indeksu. Dodatkowo wersja eBook tej książki umożliwia elektroniczne przeszukiwanie treści.

Odsyłacze

Odsyłacz do innego atomu w książce wygląda tak: „Wprowadzenie”; w tym przypadku odsyłacz, kieruje do bieżącego atomu. W różnych formatach eBooków tworzy on hiperłącze do odpowiedniego atomu.

Formatowanie

W tej książce:

• Kursywa służy do wprowadzenia nowego pojęcia lub koncepcji, a czasem do wyróżnienia jakiegoś pomysłu.

• Czcionka o stałej szerokości oznacza słowa kluczowe programu, identyfikatory oraz nazwy plików. Przykłady kodu również używają tej czcionki, a w jej wersjach eBook także różnych kolorów wyróżniających składnię.

• W tekście opisowym nazwę funkcji zawsze uzupełniamy pustymi nawiasami, tak jak func(). Pomaga to czytelnikom rozpoznać, że patrzą na funkcję.

• Aby ułatwić czytanie eBooków na wszystkich urządzeniach i pozwolić użytkownikom zwiększyć rozmiar czcionki, szerokość listingów kodu ograniczyliśmy do 47 znaków. Czasami wymaga to kompromisów, ale wydaje się, że uzyskany rezultat jest tego wart. Aby otrzymać taką szerokość, usunęliśmy wiele spacji, które inaczej byłyby obecne w wielu stylach formatowania – w szczególności używamy wcięć o wielkości dwóch spacji, a nie standardowych czterech.

Przykładowa książka

W witrynie AtomicKotlin.com udostępniamy przykładowy fragment książki. Ta próbka obejmuje w całości dwie pierwsze części oraz kilka późniejszych atomów. Dzięki temu czytelnik może wypróbować książkę i zdecydować, czy jest dla niego odpowiednia.

Kompletna książka jest oferowana do zakupu, zarówno w formie drukowanej, jak i elektronicznej. Jeśli komuś podoba się to, co znalazł w bezpłatnej próbce, może wesprzeć nas i pomóc w dalszej pracy, płacąc za to, czego używa. Mamy nadzieję, że książka okaże się pomocna i bardzo dziękujemy za sponsorowanie naszej pracy.

W erze Internetu nie wydaje się możliwe kontrolowanie każdego elementu informacji. Elektroniczną wersję tej książki zapewne można znaleźć w wielu miejscach. Jeśli Twoja sytuacja materialna nie pozwala Ci na zakup książki już teraz i pobierzesz ją z jednego z tych miejsc, prosimy, abyś chociaż mógł podzielić się swoją wiedzą z kimś innym, np. poprzez naukę języka.

Ćwiczenia i rozwiązania

Większości atomów książki Atomowy Kotlin towarzyszy kilka niewielkich ćwiczeń. Dla poprawy opanowania materiału zalecamy rozwiązywanie tych ćwiczeń bezpośrednio po lekturze atomu. Większość z nich jest automatycznie rejestrowana przez zintegrowane środowisko programistyczne (IDE) JetBrains IntelliJ IDEA, zatem można łatwo śledzić swoje postępy i uzyskać wskazówki w razie trudności.

Pokazane dalej hiperłącza można znaleźć na stronie http://AtomicKotlin.com/exercises/.

Aby móc rozwiązywać ćwiczenia, należy zainstalować IntelliJ IDEA wraz z wtyczką Edu Tools, zgodnie z poniższymi tutorialami:

1. Instalowanie IntelliJ IDEA oraz wtyczki EduTools.

2. Otwarcie kursu Atomic Kotlin i rozwiązywanie ćwiczeń.

W ramach kursu można znaleźć rozwiązania wszystkich ćwiczeń. Jeśli ktoś nie będzie w stanie wykonać któregoś z nich, może tam poszukać wskazówek bądź spróbować zerknąć do rozwiązania. Nadal jednak zalecamy samodzielność.

Jeśli pojawią się jakieś problemy przy konfigurowaniu i uruchamianiu kursu, należy przeczytać dokument The Troubleshooting Guide. Jeżeli to nie rozwiąże problemu, prosimy o kontakt z zespołem wsparcia, zgodnie z informacjami zawartymi w przewodniku.

W przypadku odkrycia błędu w zawartości kursu (na przykład gdy test do zadania zwraca niewłaściwy wynik), prosimy użyć naszego mechanizmu śledzenia problemów, aby zgłosić go za pośrednictwem wstępnie wypełnionego formularza. Warto zauważyć, że konieczne będzie zalogowanie się w YouTrack. Doceniamy czas, jaki poświęcają nasi czytelnicy, aby pomóc w ulepszeniu kursu.

Seminaria

Informacje na temat seminariów na żywo i innych narzędzi edukacyjnych można znaleźć w witrynie AtomicKotlin.com.

Konferencje

Bruce organizuje konferencje Open-Spaces, takie jak Winter Tech Forum. Warto dołączyć do listy mailingowej na stronie AtomicKotlin.com, aby otrzymywać bieżące informacje o naszych działaniach i miejscach, w których prowadzimy wykłady.

Wspieranie nas

To był wielki projekt. Stworzenie tej książki i towarzyszących jej materiałów pomocniczych zajęło wiele czasu i wymagało sporego wysiłku. Jeśli komuś spodobała się nasza praca i chciałby znaleźć więcej podobnych rzeczy, prosimy o okazanie wsparcia:

• Blogowanie, tweetowanie itp. oraz opowiadanie przyjaciołom. Takie wysiłki marketingowe działają u samych podstaw, zatem cokolwiek zrobisz, będzie pomocne.

• Zakup książki w wersji eBook lub drukowanej w witrynie AtomicKotlin.com.

• Sprawdzenie AtomicKotlin.com pod kątem innych pomocniczych produktów i zdarzeń.

O nas

Bruce Eckel jest autorem wielokrotnie nagradzanych książek Thinking in Java oraz Think ing in C++, a także wielu innych książek na temat programowania komputerów, w tym Atomic Scala. Przedstawił setki prezentacji i wykładów na całym świecie, a także organizuje alternatywne konferencje i wydarzenia, takie jak Winter Tech Forum i szkolenia dla programistów. Bruce uzyskał BS z fizyki stosowanej oraz MS z inżynierii komputerowej. Jego blog jest dostępny pod adresem www.BruceEckel.com, zaś jego firma MindView LLC zajmuje się konsultacjami, szkoleniami i konferencjami.

Svetlana Isakova zaczynała jako członek zespołu tworzącego kompilator Kotlina, a obecnie jest propagatorem JetBrains wśród programistów. Uczy języka Kotlin i występuje na konferencjach na całym świecie, a ponadto jest współautorką książki Kotlin in Action.

Podziękowania

• Dla zespołu projektowego Kotlina i innych współautorów.

• Dla programistów Leanpub, dzięki którym opublikowanie tej książki było dużo łatwiejsze.

Dedykacje

Ku pamięci mojego ukochanego ojca – E. Wayne’a Eckela (1.04.1924 – 23.11.2016). Jako pierwszy pokazałeś mi świat maszyn, narzędzi i projektowania.

Ku pamięci mojego ojca – Sergeya Lvovicha Isakova, który odszedł tak wcześnie i którego stale nam brak.

O okładce

Daniel Will-Harris zaprojektował okładkę, bazując na logu Kotlina.Dlaczego Kotlin?

Przedstawimy teraz przegląd historycznego rozwoju języków programowania, aby czytelnik mógł się zorientować, gdzie Kotlin się znajduje i kto może chcieć się go nauczyć. Ten atom wprowadza kilka zagadnień, które mogą się początkowo wydawać zbyt skomplikowane dla nowicjuszy. W takiej sytuacji czytelnik może spokojnie pominąć ten atom i powrócić do niego później, gdy przeczyta więcej rozdziałów.

Programy muszą być pisane tak, aby ludzie mogli je czytać,
a tylko czasami powstają dla maszyn, aby mogły je wykonywać.
– Harold Abelson, Struktura i interpretacja
programów komputerowych

Projektowanie języków programowania przeszło długą drogę ewolucji, od zapewniania wymagań maszyny, po obsługiwanie potrzeb programisty.

Język programowania jest tworzony przez projektanta języka i implementowany jako jeden lub więcej programów, które pełnią funkcje narzędzi umożliwiających posługiwanie się tym językiem. Osoba implementująca te narzędzia to zazwyczaj projektant języka, przynajmniej początkowo.

Wczesne języki skupiały się na ograniczeniach sprzętowych. W miarę jak komputery stawały się coraz silniejsze, nowsze języki przesuwały się w stronę bardziej wyrafinowanego programowania, z naciskiem na niezawodność. Te języki wybierają funkcjonalności na podstawie psychologii programowania.

Każdy język programowania jest efektem zbioru eksperymentów. Historycznie rzecz biorąc, projekt języka programowania był efektem domysłów i przypuszczeń na temat tego, co może zapewnić większą produktywność programistów. Niektóre z tych eksperymentów zakończyły się niepowodzeniem, inne były średnio udane, a niektóre odniosły wielki sukces.

W każdym nowym języku uczymy się poprzez eksperymenty. Niektóre języki są nakierowane na rozwiązywanie problemów, które z kolei okazują się być raczej incydentalne niż kluczowe, albo też zmiany środowiska (szybsze procesory, mniejsza cena pamięci, nowe rozumienie programowania i języków) sprawiają, że problemy te okazują się mniej ważne bądź wręcz nieistotne. Jeśli te idee staną się przestarzałe, a język nie będzie ewoluował, jego używanie zaniknie.

Pierwsi programiści pracowali bezpośrednio z liczbami reprezentującymi instrukcje maszynowe. Takie podejście powodowało liczne błędy, zatem powstał język asemblera, zastępujący liczby mnemonicznymi kodami operacji – słowami, które programistom łatwiej było zapamiętać i czytać, niezależnie od innych pomocnych narzędzi. Nadal jednak była zależność jeden do jednego pomiędzy instrukcjami języka asemblera a instrukcjami maszynowymi, a programiści musieli napisać każdy wiersz kodu asemblera. Dodatkowo każdy procesor komputerowy używał własnego, odmiennego języka asemblera.

Tworzenie programów w asemblerze jest zbyt kosztowne. Języki wyższego poziomu pomagają rozwiązać ten problem, tworząc dodatkowe poziomy abstrakcji ponad niskopoziomowymi językami asemblera.

Kompilatory i interpretery

Kotlin jest językiem kompilowanym, a nie interpretowanym. Instrukcje języka interpretowanego są wykonywane bezpośrednio przez oddzielny program nazywany interpreterem. W przeciwieństwie do tego kod źródłowy języka kompilowanego jest przekształcany na inną reprezentację, która jest uruchamiana jako samodzielny program albo bezpośrednio w sprzętowym procesorze, albo w maszynie wirtualnej, która emuluje procesor:

Takie języki jak C, C++, Go i Rust są kompilowane do kodu maszynowego, który działa bezpośrednio w sprzętowym procesorze (central processing unit – CPU). Języki takie jak Java i Kotlin są kompilowane do kodu bajtowego (bytecode), który jest formatem warstwy pośredniej i nie jest uruchamiany wprost na procesorze sprzętowym, ale w maszynie wirtualnej, która jest programem wykonującym instrukcje kodu bajtowego. Wersja JVM języka Kotlin działa w Java Virtual Machine (JVM).

Ważną korzyścią stosowania maszyny wirtualnej jest przenośność. Ten sam kod bajtowy może działać na każdym komputerze, który dysponuje odpowiednią maszyną wirtualną. Maszyny wirtualne mogą być optymalizowane pod kątem konkretnego sprzętu i w celu rozwiązywania problemów z prędkością działania. JVM zawiera w sobie efekty wielu lat takich optymalizacji i jest implementowana na bardzo wielu platformach sprzętowych.

W czasie kompilacji kod jest sprawdzany przez kompilator w celu identyfikowania błędów czasu kompilacji. (IntelliJ IDEA i inne środowiska programistyczne wyróżniają takie błędy podczas wprowadzania kodu, dzięki czemu można szybko wykrywać i poprawiać dowolne problemy). Jeśli nie pojawią się błędy czasu kompilacji, kod źródłowy zostanie skompilowany do kodu bajtowego.

Błędu czasu wykonania (runtime error) nie można wykryć podczas kompilacji, zatem ujawnia się on dopiero po uruchomieniu programu. Typowo błędy czasu wykonania są trudniejsze do wykrycia, a ich naprawa bardziej kosztowna. Statycznie typowane języki, takie jak Kotlin, pozwalają na wykrywanie w czasie kompilacji tak wielu błędów, jak to możliwe, podczas gdy języki dynamiczne wykonują testy bezpieczeństwa dopiero podczas uruchamiania (niektóre dynamiczne języki nie mogą sobie pozwolić na wykonywanie ich w takiej ilości.

Języki, które wywarły wpływ na Kotlin

Idee i funkcjonalności występujące w Kotlinie wywodzą się z wielu języków, a na nie miały wpływ jeszcze wcześniejsze. Przydatne jest poznanie historii języków programowania, aby uzyskać lepszą perspektywę tego, jak dotarliśmy do języka Kotlin. Języki opisane w tym punkcie zostały wybrane ze względu na wpływ, jaki miały na języki następujące po nich. Wszystkie z nich ostatecznie inspirowały projektantów Kotlina, czasami jako przykłady czegoś, czego nie należy robić.

FORTRAN: FORmula TRANslation (1957)

Zaprojektowany pod kątem zastosowań naukowych i inżynierskich – Fortran – miał na celu ułatwienie kodowana równań. Dopracowane i przetestowane biblioteki Fortranu są nadal w użyciu, ale zazwyczaj zostały „opakowane”, aby możliwe było ich wywoływanie z innych języków.

LISP: LISt Processor (1958)

Zamiast być specyficznym dla zastosowania, LISP ucieleśniał podstawowe koncepcje programowania; był pierwszym językiem informatyków i pierwszym językiem funkcyjnym (programowanie funkcyjne będziemy poznawać w tej książce). Ceną za tę wszechstronność i elastyczność była wydajność: LISP był zbyt kosztowny, aby go używać na wczesnych maszynach i dopiero w ostatnich dziesięcioleciach komputery stały się dostatecznie szybkie, aby zapewnić ponowne odrodzenie się tego języka. Na przykład edytor GNU Emacs jest w całości napisany w LISP i można go rozszerzać przy użyciu LISP.

ALGOL: ALGOrithmic Language (1958)

Jest zdecydowanie najbardziej wpływowy spośród języków pochodzących z lat 50. XX w., gdyż wprowadzono w nim składnię, która przetrwała do dziś w wielu późniejszych językach. Przykładowo język C i jego pochodne są językami „podobnymi do ALGOLa”.

COBOL: COmmon Business-Oriented Language (1959)

Zaprojektowany do przetwarzania danych biznesowych, finansowych i administracyjnych. Ma składnię przypominającą zwykły język angielski i został pomyślany jako samodokumentujący się i łatwy w odczytywaniu. Choć te zamiary w ogólności się nie powiodły – COBOL jest znany z błędów powodowanych przez źle umieszczoną kropkę – Department Obrony Stanów Zjednoczonych wymusił jego szerokie stosowanie na komputerach klasy mainframe i dziś nadal istnieją działające (i wymagające utrzymywania) systemy napisane w tym języku.

BASIC: Beginners’ All-purpose Symbolic Instruction Code (1964)

BASIC był jedną z pierwszych prób sprawienia, by programowanie stało się dostępne dla wszystkich. Choć ten cel został osiągnięty, jego funkcjonalność i składnia są bardzo ograniczone, zatem był jedynie częściowo pomocny dla osób, które potrzebowały nauczyć się bardziej wyrafinowanych języków. Zasadniczo jest on interpretowany, co oznacza, że trzeba uruchamiać oryginalny kod programu. Mimo to wiele użytecznych programów zostało napisanych w języku BASIC, w szczególności język skryptowy dla produktów Microsoft Office. BASIC można nawet traktować jako pierwszy „otwarty” język programowania, gdyż różni ludzie stworzyli jego liczne odmiany.

Simula 67, oryginalny język obiektowy (1967)

Symulacja typowo obejmuje wiele „obiektów” oddziałujących na siebie nawzajem. Różne obiekty mają różne charakterystyki i zachowania. Języki, które istniały w tym czasie, były skrajnie niewygodne do wykorzystania w symulacjach, zatem opracowano język Simula (kolejny język „podobny do ALGOLa”) w celu zapewnienia bezpośredniego wsparcia dla tworzenia obiektów symulacji. Okazało się, że te pomysły są również przydatne w programowaniu ogólnego stosowania i taka jest geneza języków obiektowych (Object-Oriented – OO).

Pascal (1970)

Pascal pozwolił zwiększyć szybkość kompilacji poprzez narzucenie na język takich ograniczeń, aby możliwe było jego zaimplementowanie jako kompilatora jednoprzebiegowego. Język wymuszał na programiście używanie określonej struktury kodu i narzucał trochę dziwne i mniej zrozumiale ograniczenia na organizację programu. W miarę jak procesory stawały się szybsze, pamięć tańsza, a technologia kompilatorów lepsza, wpływ tych ograniczeń stawał się zbyt kosztowny.

Jedna z implementacji Pascala, Turbo Pascal firmy Borland, początkowo działała na komputerach systemu CP/M, po czym została przeniesiona na wczesne wersje MS-DOS (prekursora systemu Windows), później ewoluując do postaci języka Delphi dla Windows. Dzięki umieszczaniu wszystkiego w pamięci Turbo Pascal kompilował kod z ogromną prędkością, nawet na bardzo słabych maszynach, poprawiając komfort pracy programistów. Jego twórca, Anders Hejlsberg, później dołączył do pracy nad projektowaniem języków C# oraz TypeScript.

Niklaus Wirth, wynalazca Pascala, stworzył jeszcze kolejne języki: Modula, Modula-2 oraz Oberon. Zgodnie z nazwą Modula koncentruje się na dzieleniu programów na moduły, co pozwala na lepsze uporządkowanie i szybszą kompilację. Większość nowoczesnych języków wspiera oddzielne kompilowanie i jakąś formę systemu modułów.

C (1972)

Pomimo rosnącej liczby języków wysokiego poziomu programiści nadal pisali programy w języku asemblera. Często jest to nazywane programowaniem systemowym, gdyż jest wykonywane na poziomie samego systemu operacyjnego, ale do tej kategorii należy również tworzenie systemów wbudowanych dla dedykowanych urządzeń fizycznych. Jest to nie tylko żmudne i kosztowne (Bruce rozpoczął swoją karierę od napisania języka asemblera dla systemów wbudowanych), ale również nie jest przenośne – język asemblera może działać tylko na tym procesorze, dla którego został napisany. Język C został zaprojektowany jako „język asemblera wyższego poziomu”, który jest nadal tak dostatecznie blisko sprzętu, że rzadko zachodzi potrzeba pisania kodu asemblera. Co ważniejsze jednak, program napisany w C działa na dowolnym procesorze, dla którego istnieje kompilator C. Język C oddzielił program od procesora, co rozwiązywało wielki i kosztowny problem. W rezultacie programiści, którzy dotychczas pracowali w asemblerze, mogli być znacznie bardziej produktywni, pracując w C. Ten język okazał się tak skuteczny, że najnowsze języki (przede wszystkim Go oraz Rust) nadal podejmują próby zastąpienia go w programowaniu systemowym.

Smalltalk (1972)

Zaprojektowany od początku jako w pełni obiektowy, Smalltalk stanowił znaczący krok w przód programowania obiektowego i teorii języków, będąc platformą dla eksperymentów i demonstrowania błyskawicznego tworzenia aplikacji. Został jednak utworzony w czasach, gdy języki nadal były czyjąś własnością i cena startowa systemu Smalltalk mogła być liczona w tysiącach. Był to język interpretowany, zatem do uruchamiania programów potrzebne było środowisko Smalltalk. Jego otwarte implementacje nie pojawiły się aż do chwili, gdy świat programistyczny nie ruszył dalej. Programiści Smalltalk wnieśli znaczącą wiedzę, z której skorzystały późniejsze języki obiektowe, takie jak C++ i Java.

C++: Lepsze C z obiektami (1983)

Bjarne Stroustrup stworzył język C++, gdyż potrzebował lepszego C i chciał uzyskać wsparcie dla konstrukcji obiektowych, które poznał przy posługiwaniu się językiem Simula-67. Bruce był członkiem komitetu standaryzacyjnego C++ przez pierwszych osiem lat jego istnienia i napisał trzy książki na temat tego języka, w tym Thinking in C++ (Helion, 2002).

Fundamentalną zasadą C++ była wsteczna kompatybilność z C, tak by kod napisany w C mógł zostać skompilowany w C++ zasadniczo bez żadnych zmian. Zapewniło to łatwą ścieżkę migracji – programiści mogli nadal programować w C, uzyskiwać korzyści związane z C++ i powoli eksperymentować z funkcjonalnościami C++, nadal zachowując produktywność. Większość krytyki dotyczącej C++ można w istocie sprowadzić do wymogu wstecznej zgodności z C.

Jednym z głównych problemów C było zagadnienie zarządzania pamięcią. Programista musiał najpierw uzyskać przydział pamięci, potem wykonać operację używającą tej pamięci, a następnie zwolnić tę pamięć. Pominięcie (zapomnienie)ostatniego etapu nazywane jest wyciekiem pamięci i może prowadzić do zużycia całej jej dostępnej, a następnie awarii procesu. Wstępna wersja C++ wprowadziła pewne innowacje w tym zakresie, wraz z konstruktorami zapewniającymi właściwe zainicjowanie. W późniejszych wersjach języka pojawiły się znaczące usprawnienia w dziedzinie zarządzania pamięcią.

Python: przyjazny i elastyczny (1990)

Projektant języka Python, Guido Van Rossum, stworzył to narzędzie, opierając się na inspirującej koncepcji „programowania dla każdego”. Jego opiekuńcze podejście do społeczności Pythona zapewniło jej opinię najbardziej przyjaznej i pomocnej społeczności w świecie programistycznym. Python był jednym z pierwszych języków o otwartych źródłach, co doprowadziło do jego implementacji, praktycznie na każdej istniejącej platformie, w tym na systemach wbudowanych i w uczeniu maszynowym. Dynamizm i łatwość użycia języka sprawia, że jest to idealny wybór dla automatyzowania niewielkich, powtarzalnych zadań, ale jego funkcjonalności pozwalają również na tworzenie obszernych, złożonych programów.

Python jest prawdziwie „oddolnym” językiem; nigdy nie był promowany przez żadną firmę, a jego fani prezentują postawę polegającą na tym, że nigdy nie wymuszają używania języka, ale po prostu pomagają nauczyć się go każdemu, kto tego zechce. Język stale się rozwija, a w ostatnich latach jego popularność ogromnie wzrosła.

Być może Python jest pierwszym językiem głównego nurtu, który łączy w sobie programowanie funkcyjne z obiektowym. Wyprzedził język Java, jeśli chodzi o automatyczne zarządzanie pamięcią przy użyciu mechanizmów sprzątających (garbage collection) – w typowych sytuacjach nigdy nie ma potrzeby samodzielnego alokowania ani zwalniania pamięci – oraz zdolność uruchamiania programów na wielu platformach.

Haskell: czysto funkcyjne programowanie (1990)

Inspirowany językiem Miranda (1985), językiem należącym do konkretnej firmy, Haskell powstał jako otwarty standard dla badań programowania czysto funkcyjnego, choć był również używany do utworzenia konkretnych produktów. Składnia i pomysły pochodzące z Haskella miały wpływ na wiele późniejszych języków, w tym na Kotlina.

Java: maszyny wirtualne i sprzątanie pamięci (1995)

James Gosling i jego zespół otrzymali zadanie napisania kodu dla dekodera telewizyjnego. Zdecydowali, że nie użyją języka C++ i zamiast utworzenia dekodera, stworzyli język Java. Firma Sun Microsystems zapewniła niespotykane wsparcie marketingowe wolnemu językowi (co w tym czasie było nadal nowatorską koncepcją) w dążeniu do uzyskania dominacji w rozwijającym się świecie Internetu.

To niewielkie okno czasowe dominowania w Internecie wywierało wielką presję na projektowanie języka Java, co doprowadziło do znaczącej liczby niedociągnięć (książka Thinking in Java wyjaśnia te wady, dzięki czemu czytelnicy są przygotowani na radzenie sobie z nimi). Brian Goetz z firmy Oracle, obecnie główny projektant Javy, dokonał znaczących i zaskakujących usprawnień w języku, pomimo odziedziczonych ograniczeń. Choć Java osiągnęła znaczący sukces, jednym z ważnych celów projektowych języka Kotlin jest wyeliminowanie wad języka Java, aby zapewnić większą produktywność programistów.

Sukces Javy wynikał z dwóch innowacyjnych cech: maszyny wirtualnej oraz odśmiecania pamięci (garbage collection). Były one dostępne w innych językach – dla przykładu LISP, Smalltalk oraz Python dysponują mechanizmem sprzątania pamięci, zaś UCSD Pascal działa w maszynie wirtualnej – ale nigdy nie były uważane za praktyczne podejście dla języków głównego nurtu. Java zmieniła to i właśnie dzięki temu programiści stali się znacząco bardziej produktywni.

Maszyna wirtualna jest warstwą pośrednią pomiędzy językiem a sprzętem. Język nie musi generować kodu maszynowego dla konkretnego procesora, jedynie wygenerować język pośredni (kod bajtowy), który działa w maszynie wirtualnej. Wymaga ona dodatkowej mocy obliczeniowej i przed pojawieniem się Javy uważano, że jest niepraktyczna. Java Virtual Machine (JVM) pozwoliła zrealizować slogan reklamowy Javy „napisz raz, uruchamiaj wszędzie”. Dodatkowo można łatwo tworzyć kod w innych językach, wybierając JVM jako środowisko docelowe; przykłady obejmują Groovy – podobny do Javy język skryptowy, oraz Clojure – odmianę języka LISP.

Odśmiecanie pamięci rozwiązuje problem dotyczący sytuacji, gdy zapomnimy o zwolnieniu pamięci, lub takich, gdy trudno jest ustalić, czy dany fragment pamięci jest jeszcze używany, czy nie. Wiele projektów zostało znacząco opóźnionych lub wręcz anulowanych z powodu wycieków pamięci. Choć mechanizmy sprzątania pamięci występują w niektórych wcześniejszych językach, uważano, że tworzą one nieakceptowalne, nadmiarowe obciążenie, dopóki Java nie zademonstrowała praktyczności tego podejścia.

JavaScript: Java tylko w nazwie (1995)

Oryginalne przeglądarki internetowe po prostu kopiowały i wyświetlały strony z serwera. W miarę rozpowszechniania przeglądarek stawały się one nową platformą programistyczną, która potrzebowała wsparcia własnego języka. Tym językiem chciała być Java, ale była zbyt nieporęczna dla tego zadania. JavaScript powstał jako LiveScript, wbudowany w NetScape Navigator, jedną z pierwszych przeglądarek Web. Zmiana nazwy na JavaScript była jedynie chwytem marketingowym ze strony NetScape, gdyż język ten wykazuje tylko nieznaczne podobieństwo do Javy.

W miarę rozwoju sieci Web JavaScript stał się niebywale ważnym językiem. Jednak zachowanie JavaScriptu było tak nieprzewidywalne, że Douglas Crockford napisał książkę pod ironicznym tytułem JavaScript – mocne strony (Helion, 2011, tyt. oryg. JavaScript, the Good Parts), w której demonstrował wszystkie problemy związane z tym językiem, tak by programiści mogli ich unikać. Późniejsze ulepszenia dokonane przez komitet ECMAScript sprawiły, że JavaScript stał się niezrozumiały dla oryginalnego programisty JavaScript. Obecnie jest uznawany za stabilny i dojrzały język.

Web assembly – WASM zostały wyprowadzone z JavaScript jako rodzaj kodu bajtowego dla przeglądarek Web. Często działają znacznie szybciej niż JavaScript i można je generować z innych języków. W chwili pisania tych słów zespół Kotlina pracuje nad dodaniem WASM jako miejsca docelowego.

C#: Java dla .NET (2000)

C# został zaprojektowany w celu zapewnienia pewnych ważnych możliwości języka Java na platformie .NET (Windows), zarazem uwalniając projektantów od ograniczenia związanego z trzymaniem się języka Java. Rezultat tych starań zawiera liczne ulepszenia względem języka Java. Dla przykładu w C# wypracowano koncepcję funkcji rozszerzających (extension functions), które są intensywnie używane w Kotlinie. C# stał się również znacząco bardziej funkcyjny niż Java. Wiele cech C# bezpośrednio wpłynęło na projekt języka Kotlin.

Scala: Skalowalność (2003)

Martin Odersky utworzył język Scala z myślą o uruchamianiu na maszynie wirtualnej Java: aby wykorzystać pracę już wykonaną nad JVM, zapewnić interakcję z programami napisanymi w Javie, a być może w nadziei zastąpienia Javy. Jako badacz, Odersky i jego zespół używali języka Scala jako platformy eksperymentowania z funkcjonalnościami języków, szczególnie tymi, które nie zostały włączone do Javy.

Eksperymenty te były bardzo pouczające i wiele z nich znalazło swoje odzwierciedlenie w Kotlinie, zazwyczaj w zmodyfikowanej formie. Na przykład zdolność do przedefiniowania operatorów, takich jak +, do wykorzystania w specjalnych przypadkach, nosi nazwę przeciążania operatorów. Ta możliwość została włączona w C++, ale nie w Javę. Scala dodała przeciążanie operatorów, ale również pozwala tworzyć nowe operatory poprzez kombinację dowolnej sekwencji znaków. To jednak często tworzy mylący, nieczytelny kod. Kotlin zawiera ograniczone możliwości przeciążania operatorów, ale przeciążać możemy tylko te operatory, które już istnieją.

Scala jest ponadto hybrydą obiektowo-funkcyjną, podobnie jak Python, ale ze skupieniem na czyste funkcje i ścisłe obiekty. Pomogło to twórcom Kotlina w dokonaniu wyboru, że ten język również ma być hybrydą obiektowo-funkcyjną.

Podobnie jak Scala, Kotlin działa na JVM, ale zapewnia znacznie łatwiejszą interakcję z programami napisanymi w Javie, niż robi to Scala. Dodatkowo Kotlin może generować kod dla JavaScript w Android OS oraz kod natywny dla innych platform.

Książka Atomowy Kotlin wyewoluowała z koncepcji i materiału zawartego w Atomic Scala.

Groovy: Dynamiczny język JVM (2007)

Języki dynamiczne należą do pociągających, gdyż są bardziej interaktywne i zwięzłe od języków statycznych. Podejmowano wiele prób uzyskania bardziej dynamicznych sposobów programowania na platformie JVM, w tym Jython (Python) oraz Clojure (dialekt języka Lisp). Groovy był pierwszym z tych języków, który zdobył szeroką akceptację.

Na pierwszy rzut oka Groovy wydaje się wyczyszczoną wersją Javy, zapewniającą przyjemniejsze wrażenia programistyczne. Większość kodu w języku Java będzie działać w Groovy bez żadnych zmian, zatem programiści Javy mogą szybko uzyskać produktywność, dopiero później ucząc się bardziej zaawansowanych funkcjonalności, które zapewniają znaczące korzyści względem Javy.

Występujące w języku Kotlin operatory ?. oraz ?:, które zajmują się problemem pustki (ang. emptiness), po raz pierwszy pojawiły się w języku Groovy.

Istnieje wiele cech Groovy, które można zauważyć w Kotlinie. Niektóre z tych funkcjonalności występują również w innych językach, co zapewne było dodatkowym przyczynkiem dla dołączenia ich do Kotlina.

Dlaczego Kotlin? (wprowadzony w roku 2011, wersja 1.0: 2016)

Podobnie jak C++, początkowo miał być „lepszym C”, Kotlin wstępnie był nakierowany na zostanie „lepszą Javą”. Od tego momentu stopniowo wyewoluował daleko poza ten cel. Pragmatycznie wybiera tylko najbardziej udane i pomocne cechy innych języków programowania – gdy te funkcjonalności zostały już przetestowane w praktyce i wykazały swoją szczególną wartość.

Tym samym ktoś, kto przychodzi z innego języka programowania, może rozpoznać w Kotlinie pewne cechy tamtego języka. Tak właśnie powinno być: Kotlin maksymalizuje produktywność dzięki wykorzystaniu sprawdzonych koncepcji.

Czytelność

Czytelność jest głównym celem projektu języka. Składnia Kotlina jest zwięzła – w większości scenariuszy nie jest wymagany żaden ceremoniał, ale nadal można w nim wyrazić złożone idee.

Narzędzia

Kotlin wywodzi się z JetBrains, firmy, która specjalizuje się w tworzeniu narzędzi dla programistów. Oferuje najwyższej klasy wsparcie narzędzi, a wiele cech języka zostało zaprojektowanych z myślą o narzędziach.

Wiele paradygmatów

Kotlin wspiera wiele paradygmatów programowania, które zostaną przedstawione w tej książce:

• Programowanie imperatywne

• Programowanie funkcyjne

• Programowanie obiektowe

Wieloplatformowość

Kod źródłowy w języku Kotlin można skompilować na różne platformy docelowe:

• JVM. Kod źródłowy kompiluje się do kodu bajtowego JVM (pliki .class), który może zostać uruchomiony na dowolnej maszynie wirtualnej Java (JVM).

• Android. System Android zawiera własny mechanizm wykonawczy o nazwie ART (jego poprzednik nosił nazwę Dalvik). Kod źródłowy w języku Kotlin można skompilować do postaci Dalvik Executable Format (pliki .dex).

• JavaScript, co umożliwia działanie wewnątrz przeglądarki.

• Natywne pliki binarne dzięki generowaniu kodu maszynowego dla określonych platform i procesorów.

Książka ta skupia się na samym języku, wykorzystując JVM jako jedyną platformę docelową. Gdy już poznamy język, będziemy mogli stosować Kotlin w różnych aplikacjach i platformach docelowych.

Dwie cechy Kotlina

W tym atomie nie zakładamy, że czytelnik jest programistą, przez co trudniejsze jest wyjaśnienie większości cech, dzięki którym język Kotlin ma przewagę nad alternatywami. Istnieją jednak dwa zagadnienia, które mają wielki wpływ i które można wyjaśnić w tak wczesnym momencie: współdziałanie z Javą oraz problem wskazywania „braku wartości”.

Współdziałanie z Javą bez wysiłku

Aby być „lepszym C”, język C++ musi być wstecznie kompatybilny ze składnią języka C, jednak Kotlin nie potrzebuje wstecznej kompatybilności ze składnią Javy – musi jedynie współdziałać z JVM. Pozwoliło to projektantom Kotlina stworzyć znacznie czystszą i bardziej efektywną składnię, bez wizualnego szumu i komplikacji, które zaciemniają kod Javy.

Aby Kotlin był „lepszą Java”, wrażenia z posługiwania się nim muszą być przyjemne i pozbawione zgrzytów, zatem Kotlin umożliwia bezwysiłkową integrację z istniejącymi projektami tworzonymi w Javie. Można napisać drobny fragment funkcjonalności w Kotlinie i wsunąć go w środek istniejącego kodu Javy. Kod ten nie będzie nawet wiedzieć, że znajduje się tu kawałek napisany w Kotlinie – będzie to wyglądać, jak kolejny fragment kodu Javy.

Firmy często badają nowy język, budując samodzielny program w tym języku. W idealnym wariancie taki program jest przydatny, ale nie jest kluczowy, zatem jeśli projekt ten zawiedzie, można go zakończyć przy minimalnych stratach. Jednak nie każda firma chce poświęcać zasoby na tego rodzaju eksperymentowanie. Dzięki temu, że Kotlin pozwala na gładką integrację z istniejącym systemem napisanym w Javie (i korzysta z testów dla tego systemu), wypróbowanie Kotlina w celu przekonania się, czy jest to dobry wybór, jest bardzo tanie lub wręcz darmowe.

Dodatkowo JetBrains, firma, która tworzy Kotlin, udostępnia IntelliJ IDEA w wersji „Community” (bezpłatnej), która zawiera wsparcie zarówno języka Java, jak i Kotlin, wraz z możliwością łatwej integracji obu języków. Dostępne jest nawet narzędzie przyjmujące kod Java i dokonujące przepisania go (prawie) na Kotlin.

Interoperacyjność z językiem Java omówiona jest w dodatku B.

Reprezentowanie pustki

Szczególnie korzystną funkcjonalnością języka Kotlin jest jego rozwiązanie dla szczególnie wymagającego problemu programistycznego.

Co można zrobić, jeśli ktoś poda nam słownik i każe wyszukać w nim słowo, które nie istnieje? Możemy zapewnić uzyskanie wyników, tworząc definicje dla nieznanych słów. Bardziej użyteczne podejście to po prostu stwierdzenie „Nie istnieje definicja dla tego słowa”. Demonstruje to znaczący problem programistyczny: Jak możemy oznaczyć „brak wartości” dla fragmentu pamięci, która nie została zainicjowana, albo dla wyniku jakiejś operacji?

Pojęcie referencji null (null reference) zostało wynalezione na potrzeby języka ALGOL przez Tony’ego Hoare’a, który później nazwał je „pomyłką za miliard dolarów”. Po pierwsze, było to zbyt proste – niekiedy nie wystarcza nam informacja, że pokój jest pusty; możemy potrzebować się dowiedzieć na przykład, dlaczego tak jest. To prowadzi do kolejnego problemu: implementacji. Ze względu na wydajność była to typowo specjalna wartość, która mieściła się w niewielkiej ilości pamięci, ale w czym miałaby być lepsza od pamięci już alokowanej dla tej informacji?

Oryginalny język C nie inicjuje automatycznie pamięci, co powodowało liczne problemy. C++ usprawnił sytuację, wypełniając nowo alokowaną pamięć samymi zerami. Tym samym, jeśli wartość numeryczna nie została zainicjowana, była po prostu równa zero. Nie wydaje się to takie złe, ale pozwalało niezainicjowanym wartościom po cichu wślizgnąć się poprzez szczeliny (nowsze kompilatory C i C++ często zgłoszą ostrzeżenia o takich sytuacjach). Co gorsza, jeśli tym fragmentem pamięci był wskaźnik – używany do oznaczania („wskazywania”) innego miejsca w pamięci – wskaźnik null kierowałby nas do lokalizacji zero w pamięci, co niemal na pewno nie jest tym, co chcemy otrzymać.

Język Java blokuje dostęp do niezainicjowanych wartości, raportując takie błędy w trakcie działania programu. Choć pozwala to odkryć niezainicjowane wartości, nie rozwiązuje to problemu, gdyż jedynym sposobem weryfikacji, że nasz program nie ulegnie awarii, jest jego uruchomienie. W kodzie Javy mogą być całe roje takich błędów i programiści marnują mnóstwo czasu na ich wyszukiwanie.

Kotlin rozwiązuje problem, powstrzymując operacje mogące prowadzić do błędów null w czasie kompilacji, zanim program będzie mógł zostać uruchomiony. Jest to cecha języka najbardziej doceniana przez programistów Javy, którzy przechodzą do Kotlina. Ta jedna funkcjonalność może zminimalizować lub wyeliminować błędy null w Javie.

Bogactwo korzyści

Te dwie cechy, które byliśmy w stanie wyjaśnić w tym miejscu (bez wymagania większej wiedzy programistycznej), stanowią wielką różnicę, niezależnie od tego, czy ktoś jest już programistą Javy, czy nie. Jeśli Kotlin jest naszym pierwszym językiem i trafimy do projektu, który wymaga udziału większej liczby programistów, znacznie łatwiej będzie zwerbować do tego projektu jednego z wielu istniejących programistów Javy.

Kotlin ma jeszcze wiele innych zalet, których nie możemy wyjaśnić, dopóki czytelnik nie nauczy się więcej o programowaniu. Temu właśnie służy reszta tej książki.

Języki są często wybierane z powodu emocji, a nie rozumowania… Staram się uczynić Kotlin językiem, który jest kochany z konkretnego powodu.
– Andrey Breslav, wiodący projektant języka KotlinHello, world!

Podstawową składnię języków programowania najczęściej demonstruje się za pomocą programu „Hello, world!”

Program ten opracujemy w kilku krokach, aby czytelnik zrozumiał jego poszczególne części. Na początek zbadajmy pusty program, który w ogóle nic nie robi:

// HelloWorld/EmptyProgram.kt

fun main() {

// Tu będzie kod programu...

}

Przykład rozpoczyna się komentarzem, który jest tekstem objaśniającym, ignorowanym przez Kotlin. // (dwa ukośniki) zaczynają komentarz, który biegnie do końca bieżącego wiersza:

// Jednowierszowy komentarz

Kotlin ignoruje // i wszystko, co następuje po tych znakach aż do końca wiersza. W kolejnym wierszu znowu zaczyna zwracać uwagę.

Pierwszy wiersz każdego przykładu zawartego w tej książce jest komentarzem rozpoczynającym się nazwą podkatalogu, zawierającego plik kodu źródłowego (w tym przypadku jest to HelloWorld), po którym następuje nazwa pliku: EmptyProgram.kt. Nazwa podkatalogu z przykładami dla każdego atomu pasuje do nazwy tego atomu.

Słowa kluczowe to słowa zarezerwowane przez język i mające specjalne znaczenie. Jednym z nich jest słowo fun, które jest skrótem od function. Funkcja (function) jest fragmentem kodu, który można wykonać poprzez użycie nazwy tej funkcji (w tej książce poświęcimy funkcjom naprawdę dużo czasu). Nazwa funkcji następuje po słowie kluczowym fun, zatem w tym przypadku jest to main() (w tekście opisowym nazwy funkcji zawsze będziemy uzupełniać parą nawiasów).

main() w rzeczywistości jest specjalną nazwą funkcji; sygnalizuje „punkt wejściowy” programu w języku Kotlin. Program w Kotlinie może zawierać wiele funkcji o wielu różnych nazwach, ale to main() jest tą funkcją, która jest wywoływana automatycznie przy uruchamianiu programu.

Lista parametrów znajduje się za nazwą funkcji i jest ujęta w nawiasy. W tym przypadku nie przekazujemy niczego do funkcji main(), zatem lista parametrów jest pusta.

Ciało funkcji następuje po liście parametrów. Rozpoczyna się otwierającym nawiasem klamrowym ({) i kończy zamykającym nawiasem klamrowym (}). Ciało funkcji zawiera instrukcje i wyrażenia. Instrukcja powoduje wystąpienie jakiegoś efektu, zaś wyrażenie zwraca wynik.

EmptyProgram.kt nie zawiera w ciele funkcji żadnych instrukcji ani wyrażeń, jedynie komentarz.

Spowodujemy teraz, że program wyświetli tekst „Hello, world!”, dodając wiersz do ciała funkcji main():

// HelloWorld/HelloWorld.kt

fun main() {

println("Hello, world!")

}

/* Output:

Hello, world!

*/

Wiersz wyświetlający powitanie rozpoczyna się println(). Podobnie jak main(), println() jest funkcją. Wiersz ten wywołuje funkcję, która wykonuje swoje ciało. Podajemy nazwę funkcji, uzupełnioną nawiasami zawierającymi jeden lub więcej parametrów. W tej książce, ilekroć odwołujemy się do funkcji w tekście opisowym, dodajemy nawiasy po nazwie, dla przypomnienia, że chodzi nam o funkcję. W tym przypadku napiszemy println().

println() przyjmuje pojedynczy parametr, którym jest łańcuch (typ String). Parametr typu String definiujemy, umieszczając znaki tekstu pomiędzy znakami cudzysłowu.

println() przenosi kursor do następnego wiersza po wyświetleniu parametru, zatem następne dane wyjściowe programu pojawią się w kolejnym wierszu. Moglibyśmy zamiast tego użyć funkcji print(), która pozostawia kursor w tym samym wierszu.

W odróżnieniu od niektórych innych języków, w Kotlinie nie ma potrzeby sygnalizowania końca wyrażenia za pomocą średnika. Jest to konieczne jedynie wtedy, gdy umieszczamy więcej niż jedno wyrażenie w pojedynczym wierszu (czego nie zalecamy).

W niektórych przykładach w tej książce będziemy pokazywać na końcu listingu, wewnątrz komentarza wielowierszowego, wyjście (output) programu/funkcji. Komentarz wielowierszowy rozpoczyna się od sekwencji /* (ukośnik, po którym następuje gwiazdka) i biegnie dalej – włącznie z podziałami wierszy (które nazywamy nowymi liniami – newlines) – aż do wystąpienia sekwencji */ (gwiazdka uzupełniona przez ukośnik), która kończy komentarz:

/* Wielowierszowy komentarz

Nie zwraca uwagi

na podziały wiersza */

Możliwe jest dodanie kodu w tym samym wierszu po */ zamykających komentarz, ale może to być mylące, zatem zazwyczaj się tego nie robi.

Komentarze dodają informacje, które nie są oczywiste (nie wynikają wprost z czytanego kodu). Jeśli jedynie powtarzają to, co mówi sam kod, stają się irytujące i ludzie zaczynają je ignorować. Przy zmianach w kodzie programiści często zapominają o aktualizowaniu komentarzy, zatem dobrą praktyką jest rozważne i oszczędne stosowanie komentarzy, głównie dla wyróżniania trudniejszych aspektów naszego kodu.

Ćwiczenia i rozwiązania można znaleźć na stronie www.AtomicKotlin.com.Typy danych

Dane mogą mieć różne typy.

Aby rozwiązać problem arytmetyczny, napiszemy wyrażenie:

5.9 + 6

Wiemy, że dodawanie liczb tworzy inną liczbę. Kotlin również to wie. Wiemy także, że jedna z nich jest liczbą ułamkową (5.9), co w Kotlinie nazwiemy Double, a druga jest liczbą całkowitą (6), co Kotlin nazywa Int. Wiemy wreszcie, że wynik jest liczbą ułamkową.

Typ (nazywany również typem danych) informuje Kotlin, jak zamierzamy używać tych danych. Udostępnia zbiór danych, spośród których wyrażenie może przybierać wartości. Definiuje operacje, które można wykonywać na danych, znaczenie tych danych, a także to, jak można przechowywać wartości tego typu.

Kotlin używa typów do weryfikowania, że nasze wyrażenia są poprawne. W przypadku wyrażenia powyżej Kotlin utworzy nową wartość typu Double do przechowania wyniku.

Kotlin próbuje dostosować się do naszych potrzeb. Jeśli jednak zażądamy wykonania czegoś, co łamie reguły, wygeneruje komunikat o błędzie. Dla przykładu spróbujmy dodać do siebie łańcuch tekstowy (String) oraz liczbę:

// DataTypes/StringPlusNumber.kt

fun main() {

println"Sall" + 5.9)

}

/* Output:

Sally5.9

*/

Typy informują Kotlin, jak należy ich poprawnie używać. W tym przypadku reguły typów mówią Kotlinowi, jak dodać liczbę do łańcucha: złączając obie wartości i tworząc nowy String dla przechowania wyniku.

Spróbujmy teraz pomnożyć dane typu String oraz Double, zamieniając + w przykładzie StringPlusNumber.kt na *:“”

"Sally" * 5.9

Połączenie typów w taki sposób nie ma żadnego sensu dla języka Kotlin, zatem otrzymamy błąd.

W atomie „var oraz val” zapisywaliśmy kilka typów. Kotlin ustalił za nas, jakie są to typy, opierając się na ich użyciu. Takie zachowanie nosi nazwę wnioskowania o typie (type inference).

Możemy jednak być bardziej dosłowni i jawnie określić typ:

val identifier: Type = initialization

Zaczynamy od słowa kluczowego val albo var, po którym następuje identyfikator, dwukropek, określenie typu, znak = i, na koniec wartość inicjująca. Tak więc zamiast pisać:

val n = 1

var p = 1.2

możemy powiedzieć:

val n: Int = 1

var p: Double = 1.2

W tym przykładzie informujemy Kotlin, że n jest typu Int, a p jest typu Double, zamiast pozwalać mu wywnioskować typ.

Oto kilka podstawowych typów języka Kotlin:

// DataTypes/Types.kt

fun main() {

val whole: Int = 11 //

val fractional: Double = 1.4 //

val trueOrFalse: Boolean = true //

val words: String = "Wartość" //

val character: Char = 'z' //

val lines: String = """Potrójne cudzysłowy

pozwalają umieścić w łańcuchu

wiele wierszy""" //

println(whole)

println(fractional)

println(trueOrFalse)

println(words)

println(character)

println(lines)

}

/* Output:

11

1.4

true

Wartość

z

Potrójne cudzysłowy

pozwalają umieścić w łańcuchu

wiele wierszy

*/

• Typ danych Int to liczba całkowita (ang. integer), co oznacza, że może przechowywać tylko liczby całkowite (nie ułamki).

• Do przechowywania liczb ułamkowych używamy typu Double.

• Typ Boolean (logiczny) może przechowywać tylko dwie wartości specjalne: true (prawda) oraz false (fałsz).

• Typ String (łańcuch) przechowuje sekwencję znaków. Wartość można przypisać, ujmując łańcuch znaków w znaki podwójnego cudzysłowu.

• Typ Char (character) może przechować pojedynczy znak.

• Jeśli mamy dłuższy tekst obejmujący wiele wierszy i/lub znaków specjalnych, można go obramować trzema podwójnymi cudzysłowami (tzw. potrójnie cytowany łańcuch – triple-quoted String).

Kotlin używa wnioskowania o typach do ustalania znaczenia mieszanek typów. Na przykład przy połączeniu Int z Double, w trakcie dodawania Kotlin, rozstrzyga się, jaki jest typ wynikowej wartości:

// DataTypes/Inference.kt

fun main() {

val n = 1 + 1.2 println(n)

}

/* Output:

2.2

*/

Gdy dodajemy wartości typu Int do Double z wykorzystaniem wnioskowania typu, Kotlin ustala, że wynikowa wartość n ma typ Double i gwarantuje, że spełnia ona wszystkie reguły dotyczące liczb tego typu.

Wnioskowanie typów w Kotlinie jest częścią strategii wykonywania pracy w zastępstwie programisty. Jeśli pominiemy deklarację typu, Kotlin zazwyczaj zdoła go wywnioskować.

Ćwiczenia i rozwiązania można znaleźć na stronie www.AtomicKotlin.com.