From 7a2822f323b660898ce0442fb88b27094f18bfa1 Mon Sep 17 00:00:00 2001 From: Kamil Duda Date: Fri, 26 Oct 2018 18:53:52 +0200 Subject: [PATCH] Update Polish translation for tour of scala MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fix numbers of eng mixin and tuples pages Add Polish introduction page Add Polish "basics" page Remove outof tags Make Polish "tuples" page visible Rewrite Polish "unified-types" page Remove tut fail assertion Remove redundant lines Remove tut from code example - should contain error Fix broken links Apply review suggestion Fix typo "powyższeego" --- _pl/tour/basics.md | 343 +++++++++++++++++++++++++++- _pl/tour/mixin-class-composition.md | 2 +- _pl/tour/tour-of-scala.md | 69 ++++-- _pl/tour/tuples.md | 7 +- _pl/tour/unified-types.md | 97 ++++++-- _tour/mixin-class-composition.md | 2 +- _tour/tuples.md | 5 +- 7 files changed, 475 insertions(+), 50 deletions(-) diff --git a/_pl/tour/basics.md b/_pl/tour/basics.md index 9ca6062b48..befaad3e5b 100644 --- a/_pl/tour/basics.md +++ b/_pl/tour/basics.md @@ -1,9 +1,350 @@ --- layout: tour -title: Basics +title: Podstawy discourse: false partof: scala-tour + +num: 2 language: pl +next-page: unified-types +previous-page: tour-of-scala --- + +Na tej stronie omówimy podstawy języka Scala. + +## Uruchamianie Scali w przeglądarce + +Dzięki ScalaFiddle możesz uruchomić Scalę w swojej przeglądarce. + +1. Przejdź do [https://scalafiddle.io](https://scalafiddle.io). +2. Wklej kod `println("Hello, world!")` w polu po lewej stronie. +3. Naciśnij przycisk "Run". W panelu po prawej stronie pojawi się wynik działania programu. + +Jest to prosta i niewymagająca żadnej instalacji metoda do eksperymentowania z kodem w Scali. + +Wiele przykładów kodu w tym przewodniku jest również zintegrowana ze ScalaFiddle, +dzięki czemu można je wypróbować wciskając po prostu przycisk "Run". + +## Wyrażenia + +Wyrażenia są rezultatem ewaluacji fragmentów kodu. + +``` +1 + 1 +``` + +Wyniki wyrażeń można wyświetlić za pomocą funkcji `println`. + +{% scalafiddle %} +```tut +println(1) // 1 +println(1 + 1) // 2 +println("Hello!") // Hello! +println("Hello," + " world!") // Hello, world! +``` +{% endscalafiddle %} + +### Wartości + +Rezultaty wyrażeń mogą zostać nazwane za pomocą słowa kluczowego `val`. + +```tut +val x = 1 + 1 +println(x) // 2 +``` + +Nazwane wyniki, tak jak `x` w ww. przykładzie, to wartości. +Odniesienie się do wartości nie powoduje jej ponownego obliczenia. + +Wartości nie można przypisać ponownie. + +```tut:fail +x = 3 // Nie kompiluje się. +``` + +Typy wartości mogą być wywnioskowane przez kompilator, ale można również wyraźnie określić type: + +```tut +val x: Int = 1 + 1 +``` + +Zauważ, że deklaracja `Int` pojawia po identyfikatorze `x`, potrzebny jest rówmież dwukropek `:`. + +### Zmienne + +Zmienne są podobne do wartości, ale z tym wyjątkiem, że można je ponownie przypisywać. +Zmienną można zdefiniować używając słowa kluczowego `var`. + +{% scalafiddle %} +```tut +var x = 1 + 1 +x = 3 // Kompiluje się, ponieważ "x" jest zdefiniowane z użyciem "var". +println(x * x) // 9 +``` +{% endscalafiddle %} + +Tak jak przy wartościach, można wyraźnie zdefiniować żądany typ: + +```tut +var x: Int = 1 + 1 +``` + +## Wyrażenia blokowe + +Wyrażenia mogą być łączone poprzez zamknięcie ich w nawiasie klamrowym`{}`. +Taką konstrukcję nazywamy blokiem. +Wynikiem całego bloku kodu jest wynik ostatniego wyrażenia w tym bloku. + +{% scalafiddle %} +```tut +println({ + val x = 1 + 1 + x + 1 +}) // 3 +``` +{% endscalafiddle %} + +## Funkcje + +Funkcje to wyrażenia, które przyjmują pewne parametry. + +Poniżej zdefiniowana jest funkcja anonimowa (nieposiadająca nazwy), która zwraca liczbę całkowitą przekazaną jako parametr, zwiększoną o 1. + +```tut +(x: Int) => x + 1 +``` + +Po lewej stronie od `=>` znajduje się lista parametrów. +Po prawej stronie - wyrażenie wykorzystujące te parametry. + +Funkcje można również nazywać. + +{% scalafiddle %} +```tut +val addOne = (x: Int) => x + 1 +println(addOne(1)) // 2 +``` +{% endscalafiddle %} + +Funkcje mogą przyjmować wiele parametrów. + +{% scalafiddle %} +```tut +val add = (x: Int, y: Int) => x + y +println(add(1, 2)) // 3 +``` +{% endscalafiddle %} + +Mogą też wcale nie mieć parametrow. + +{% scalafiddle %} +```tut +val getTheAnswer = () => 42 +println(getTheAnswer()) // 42 +``` +{% endscalafiddle %} + +## Metody + +Metody wyglądają i zachowują się bardzo podobnie jak funkcje, jednak jest między nimi kilka kluczowych różnic. + +Metody są definiowane z użyciem słowa kluczowego `def`. +Po `def` następuje nazwa metody, lista parametrów, zwracany typ i ciało metody. + +{% scalafiddle %} +```tut +def add(x: Int, y: Int): Int = x + y +println(add(1, 2)) // 3 +``` +{% endscalafiddle %} + +Zauważ, że zwracany typ jest zadeklarowany _po_ liście parametrów i dwukropku `: Int`. + +Metody mogą mieć wiele list parametrów. + +{% scalafiddle %} +```tut +def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier +println(addThenMultiply(1, 2)(3)) // 9 +``` +{% endscalafiddle %} + +Mogą również wcale ich nie posiadać. + +{% scalafiddle %} +```tut +def name: String = System.getProperty("user.name") +println("Hello, " + name + "!") +``` +{% endscalafiddle %} + +Od funkcji odróżnia je jeszcze kilka innych rzeczy, ale na razie możesz o nich myśleć jak o bardzo podobnych do funkcji. + +Metody mogą zawierać również wyrażenia wielowierszowe. + +```tut +def getSquareString(input: Double): String = { + val square = input * input + square.toString +} +``` + +Ostatnie wyrażenie w ciele metody jest wartością, jaką zwraca cała metoda. +Scala posiada słowo kluczowe `return`, ale jest ono wykorzystywane bardzo rzadko. + +## Klasy + +Klasy są definiowane za pomocą słowa kluczowego `class`, po którym następuje nazwa klasy i parametry konstruktora. + +{% scalafiddle %} +```tut +class Greeter(prefix: String, suffix: String) { + def greet(name: String): Unit = + println(prefix + name + suffix) +} +``` + +Metoda `greet` zwraca typ `Unit` - oznacza to, że nie ma nic znaczącego do zwrócenia. +`Unit` jest używany podobnie jak `void` w językach Java i C. +Różnica polega na tym, że w Scali każde wyrażenie musi zwracać jakąś wartosć, tak naprawdę istnieje [obiekt singleton](singleton-objects.html) typu `Unit` - nie niesie on ze sobą żadnej znaczącej informacji. + +Nowe instancje klasy tworzy się za pomocą słowa kluczowego `new`. + +```tut +val greeter = new Greeter("Hello, ", "!") +greeter.greet("Scala developer") // Hello, Scala developer! +``` +{% endscalafiddle %} + +Klasy zostaną szerzej omówione w [dalszej części](classes.html) tego przewodnika. + +## Klasy przypadku (case classes) + +W Scali istnieje spacjalny typ klasy - klasa "przypadku" (case class). +Klasy przypadku są domyślnie niezmienne i porównywane przez wartości. +Klasy te można definiować używająć słów kluczowych `case class`. + +{% scalafiddle %} +```tut +case class Point(x: Int, y: Int) +``` + +Do utworzenia nowej instacji klasy przypadku nie jest konieczne używanie słowa kluczowego `new`. + +```tut +val point = Point(1, 2) +val anotherPoint = Point(1, 2) +val yetAnotherPoint = Point(2, 2) +``` + +Są one porównywane przez wartości - _nie_ przez referencje. + +```tut +if (point == anotherPoint) { + println(point + " i " + anotherPoint + " są jednakowe.") +} else { + println(point + " i " + anotherPoint + " są inne.") +} // Point(1,2) i Point(1,2) są jednakowe. + +if (point == yetAnotherPoint) { + println(point + " i " + yetAnotherPoint + " są jednakowe.") +} else { + println(point + " i " + yetAnotherPoint + " są inne.") +} // Point(1,2) i Point(2,2) są inne. +``` +{% endscalafiddle %} + +Klasy przypadków to dużo szerszy temat, do zapoznania z którym bardzo zachęcamy. Jesteśmy pewni, że Ci się spodoba! +Jest on dokładnie omówiony w [późniejszym rozdziale](case-classes.html). + +## Obiekty + +Obiekty to pojedyncze wystąpienia ich definicji. +Można o nich myśleć jak o instancjach ich własnych klas - singletonach. + +Objekty definiuje się z użyciem słowa kluczowego `object`. + +{% scalafiddle %} +```tut +object IdFactory { + private var counter = 0 + def create(): Int = { + counter += 1 + counter + } +} +``` + +Aby uzyskać dostęp do obiektu używa się jego nazwy. + +```tut +val newId: Int = IdFactory.create() +println(newId) // 1 +val newerId: Int = IdFactory.create() +println(newerId) // 2 +``` +{% endscalafiddle %} + +Obiekty zostaną szerzej omówione [później](singleton-objects.html). + +## Cechy (traits) + +Cechy to typy zawierające pewne pola i metody. +Wiele cech może być łączonych. + +Cechę (trait) można zdefiniować używając słowa kluczowego `trait`. + +```tut +trait Greeter { + def greet(name: String): Unit +} +``` + +Cechy mogą zawierać domyślną implementację. + +{% scalafiddle %} +```tut +trait Greeter { + def greet(name: String): Unit = + println("Hello, " + name + "!") +} +``` + +Cechy można rozszerzać używając słowa kluczowego `extends` i nadpisać implementację z użyciem `override`. + +```tut +class DefaultGreeter extends Greeter + +class CustomizableGreeter(prefix: String, postfix: String) extends Greeter { + override def greet(name: String): Unit = { + println(prefix + name + postfix) + } +} + +val greeter = new DefaultGreeter() +greeter.greet("Scala developer") // Hello, Scala developer! + +val customGreeter = new CustomizableGreeter("How are you, ", "?") +customGreeter.greet("Scala developer") // How are you, Scala developer? +``` +{% endscalafiddle %} + +W tym przykładzie `DefaultGreeter` rozszerza tylko jedną cechę (trait), ale równie dobrze może rozszerzać ich wiele. + +Cechy zostały dokładniej opisane w jednym z [kolejnych](traits.html) rozdziałów. + +## Metoda Main + +Metoda `main` to punkt wejścia do programu. +Maszyna Wirtalna Javy (Java Virtual Machine / JVM) wymaga, aby metoda ta nazywała się "main" i posiadała jeden arguemnt - tablicę ciągów znaków. + +Z użyciem obiektu można zdefiniować metodę `main` w następujący sposób: + +```tut +object Main { + def main(args: Array[String]): Unit = + println("Hello, Scala developer!") +} +``` diff --git a/_pl/tour/mixin-class-composition.md b/_pl/tour/mixin-class-composition.md index 6e411a989e..125dc207ec 100644 --- a/_pl/tour/mixin-class-composition.md +++ b/_pl/tour/mixin-class-composition.md @@ -6,7 +6,7 @@ discourse: false partof: scala-tour -num: 5 +num: 6 language: pl next-page: higher-order-functions previous-page: tuples diff --git a/_pl/tour/tour-of-scala.md b/_pl/tour/tour-of-scala.md index ee1a1b9338..ba50e3dc47 100644 --- a/_pl/tour/tour-of-scala.md +++ b/_pl/tour/tour-of-scala.md @@ -7,41 +7,68 @@ discourse: false partof: scala-tour num: 1 -outof: 33 language: pl -next-page: unified-types +next-page: basics --- -Scala jest nowoczesnym, wieloparadygmatowym językiem programowania zaprojektowanym do wyrażania powszechnych wzorców programistycznych w zwięzłym, eleganckim i bezpiecznie typowanym stylu. Scala płynnie integruje ze sobą cechy języków funkcyjnych i zorientowanych obiektowo. +## Witaj +Ten przewodnik składa się z drobnych wprowadzeń do najczęściej używanych funkcjonalności języka Scala. + +Jest to jedynie krótkie wprowadzenie, a nie pełny samouczek. +Jeżeli szukasz tego drugiego, rozważ jedną z [książek](/books.html) lub [inne zasoby](/learn.html). + +## Czym jest Scala? +Scala jest nowoczesnym, wieloparadygmatowym językiem programowania zaprojektowanym do wyrażania powszechnych wzorców programistycznych w zwięzłym, eleganckim i bezpiecznie typowanym stylu. +Scala płynnie integruje ze sobą cechy języków funkcyjnych i zorientowanych obiektowo. ## Scala jest zorientowana obiektowo ## -Scala jest czysto obiektowym językiem w tym sensie, że każda [wartość jest obiektem](unified-types.html). Typy oraz zachowania obiektów są opisane przez [klasy](classes.html) oraz [cechy](traits.html). Klasy są rozszerzane przez podtypowanie i elastyczny mechanizm [kompozycji domieszek](mixin-class-composition.html) jako zastępnik dla wielodziedziczenia. +Scala jest czysto obiektowym językiem w tym sensie, że każda [wartość jest obiektem](unified-types.html). +Typy oraz zachowania obiektów są opisane przez [klasy](classes.html) oraz [cechy](traits.html). +Klasy są rozszerzane przez podtypowanie i elastyczny mechanizm [kompozycji domieszek](mixin-class-composition.html) jako zastępstwo dla wielodziedziczenia. ## Scala jest funkcyjna ## -Scala jest też funkcyjnym językiem w tym sensie, że [każda funkcja jest wartością](unified-types.html). Scala dostarcza lekką składnię do definiowana funkcji anonimowych, wspiera [funkcje wyższego rzędu](higher-order-functions.html), pozwala funkcjom, by były [zagnieżdżone](nested-functions.html), a także umożliwia [rozwijanie funkcji](multiple-parameter-lists.html). [Klasy przypadków](case-classes.html) oraz wbudowane wsparcie dla [dopasowania wzorców](pattern-matching.html) wprowadzają do Scali mechanizm typów algebraicznych stosowany w wielu funkcyjnych językach programowania. [Obiekty singleton](singleton-objects.html) są wygodną metodą grupowania funkcji, które nie należą do żadnej klasy. +Scala jest też funkcyjnym językiem w tym sensie, że [każda funkcja jest wartością](unified-types.html). +Scala dostarcza [lekką składnię](basics.html#funkcje) do definiowana funkcji anonimowych, wspiera [funkcje wyższego rzędu](higher-order-functions.html), pozwala funkcjom, by były [zagnieżdżone](nested-functions.html), a także umożliwia [rozwijanie funkcji](multiple-parameter-lists.html). +[Klasy przypadków (case class)](case-classes.html) oraz wbudowane wsparcie dla [dopasowania wzorców (pattern matching)](pattern-matching.html) wprowadzają do Scali mechanizm typów algebraicznych stosowany w wielu funkcyjnych językach programowania. [Obiekty singleton](singleton-objects.html) są wygodną metodą grupowania funkcji, które nie należą do żadnej klasy. -Ponadto mechanizm dopasowania wzorca w naturalny sposób rozszerza się do obsługi przetwarzania danych w formacie XML z pomocą [wzorców sekwencji ignorujących prawą stronę](regular-expression-patterns.html), z wykorzystaniem rozszerzeń [obiektów ekstraktorów](extractor-objects.html). W tym kontekście instrukcje for są użyteczne w formułowaniu zapytań. Ta funkcjonalność sprawia, że Scala jest idealnym językiem do tworzenia aplikacji takich jak usługi sieciowe. +Ponadto, mechanizm dopasowania wzorców w naturalny sposób rozszerza się do obsługi [przetwarzania danych w formacie XML](https://github.com/scala/scala-xml/wiki/XML-Processing) z pomocą [wzorców sekwencji ignorujących prawą stronę](regular-expression-patterns.html), z wykorzystaniem rozszerzeń [obiektów ekstraktorów](extractor-objects.html). +W tym kontekście [wyrażenia for](for-comprehensions.html) są użyteczne w formułowaniu zapytań. +Te i inne funkcjonalności sprawiają, że Scala jest idealnym językiem do tworzenia aplikacji takich jak usługi sieciowe. ## Scala jest statycznie typowana ## -Scala posiada ekspresywny system typów zapewniający, że abstrakcje są używane w sposób zgodny oraz bezpieczny. W szczególności system typów wspiera: +Scala posiada ekspresywny system typów, który zapewnia, że abstrakcje są używane w bezpieczny i należyty sposób. +W szczególności system typów wspiera: -* [klasy generyczne](generic-classes.html) -* [adnotacje wariancji](variances.html) -* [górne](upper-type-bounds.html) oraz [dolne](lower-type-bounds.html) ograniczenia typów -* [klasy zagnieżdżone](inner-classes.html) i [typy abstrakcyjne](abstract-types.html) jako elementy obiektów -* [typy złożone](compound-types.html) -* [jawnie typowane samoreferencje](self-types.html) -* [parametry domniemane](implicit-parameters.html) i [konwersje niejawne](implicit-conversions.html) -* [metody polimorficzne](polymorphic-methods.html) +* [klasy generyczne](generic-classes.html), +* [adnotacje wariancji](variances.html), +* [górne](upper-type-bounds.html) oraz [dolne](lower-type-bounds.html) ograniczenia typów, +* [klasy zagnieżdżone](inner-classes.html) i [typy abstrakcyjne](abstract-types.html) jako elementy obiektów, +* [typy złożone](compound-types.html), +* [jawnie typowane samoreferencje](self-types.html), +* [parametry domniemane](implicit-parameters.html) i [konwersje niejawne](implicit-conversions.html), +* [metody polimorficzne](polymorphic-methods.html). -[Mechanizm lokalnej inferencji typów](type-inference.html) sprawia, że nie jest konieczne podawanie nadmiarowych informacji o typach w programie. W połączeniu te funkcje języka pozwalają na bezpiecznie typowane ponowne wykorzystanie programistycznych abstrakcji. +[Mechanizm lokalnej inferencji typów](type-inference.html) sprawia, że nie jest konieczne podawanie nadmiarowych informacji o typach w programie. +Wszystkie te funkcje języka pozwalają na bezpieczne ponowne użycie programistycznych abstrakcji oraz rozwijanie oprogramowania z bezpieczeństwem dla typów. ## Scala jest rozszerzalna ## -W praktyce rozwiązania specyficzne dla domeny wymagają odpowiednich rozszerzeń języka. Scala dostarcza unikalne mechanizmy, dzięki którym można łatwo dodawać nowe konstrukcje do języka w postaci bibliotek: +W praktyce rozwiązania specyficzne dla domeny często wymagają odpowiednich, również specyficznych domenowo, rozszerzeń języka. +Scala dostarcza unikalne mechanizmy, dzięki którym można łatwo dodawać nowe konstrukcje do języka w postaci bibliotek. + +W większości przypadków można to uzyskać bez potrzeby używania technik meta-programowania takich jak np. makra. +Oto kilka przykładów: + +* [Klasy domniemane](http://docs.scala-lang.org/overviews/core/implicit-classes.html) pozwalają na rozszerzanie już istniejących klas o nowe metody, +* [Interpolacja łańcuchów znaków](/overviews/core/string-interpolation.html) jest rozszerzalna o niestandardowe interpolatory użytkownika. + +## Scala współdziała z językami JVM +Scala jest zaprojektowana tak, aby jak najlepiej współpracować z popularnym środowiskiem uruchomieniowym Java Runtime Environment (JRE). +W szczególności interakcja z językiem Java jest tak płynna, jak tylko jest to możliwe. +Nowsze funkcje języka Java takie jak interfejsy funkcyjne (SAM), [funkcje anonimowe (lambda)](higher-order-functions.html), [adnotacje](annotations.html) oraz [typy generyczne](generic-classes.html) posiadają swoje bezpośrednie odwzorowania w języku Scala. -* każda metoda może być używana jako [operator infiksowy lub prefiksowy](operators.html) -* [domknięcia są konstruowane automatycznie zależnie od wymaganego typu](automatic-closures.html) +Unikalne dla Scali funkcje, które nie mają odwzorowania w Javie, jak na przykład [domyślne wartości parametrów](default-parameter-values.html) oraz [parametry nazwane](named-arguments.html), są kompilowane tak, aby zachować jak największą zgodność z Javą. +Scala posiada taki sam model kompilacji (oddzielna kompilacja, dynamiczne ładowanie klas) jak Java, dzięki czemu umożliwa korzystanie z tysięcy już istniejących, wysokiej klasy bibliotek. -Powyższe mechanizmy pozwalają na definicję nowych rodzajów wyrażeń bez potrzeby rozszerzania składni języka czy też wykorzystywania meta-programowania w postaci makr. +## Do dzieła! -Scala jest zaprojektowana tak, aby współpracować dobrze ze środowiskiem uruchomieniowym JRE oraz językiem Java. Funkcje Javy takie jak [adnotacje](annotations.html) oraz typy generyczne posiadają swoje bezpośrednie odwzorowanie w Scali. Unikalne funkcje Scali, jak na przykład [domyślne wartości parametrów](default-parameter-values.html) oraz [nazwane parametry](named-arguments.html), są kompilowane tak, aby zachować jak największą zgodność z Javą. Scala ma także taki sam model kompilacji (oddzielna kompilacja, dynamiczne ładowanie klas), dzięki czemu umożliwia korzystanie z całego ekosystemu Javy. +Przejdź do [kolejnej strony](basics.html) aby dowiedzieć się więcej. diff --git a/_pl/tour/tuples.md b/_pl/tour/tuples.md index d6516a89e6..81272485e8 100644 --- a/_pl/tour/tuples.md +++ b/_pl/tour/tuples.md @@ -2,10 +2,11 @@ layout: tour title: Tuples -discourse: true +discourse: false partof: scala-tour -num: + +num: 5 language: pl next-page: mixin-class-composition previous-page: traits @@ -13,4 +14,4 @@ previous-page: traits --- (this section of the tour has not been translated yet. pull request -with translation welcome!) \ No newline at end of file +with translation welcome!) diff --git a/_pl/tour/unified-types.md b/_pl/tour/unified-types.md index 103647d8e7..6f57412bb7 100644 --- a/_pl/tour/unified-types.md +++ b/_pl/tour/unified-types.md @@ -6,44 +6,101 @@ discourse: false partof: scala-tour -num: 2 +num: 3 language: pl next-page: classes -previous-page: tour-of-scala +previous-page: basics --- -W przeciwieństwie do Javy wszystkie wartości w Scali są obiektami (wliczając w to wartości numeryczne i funkcje). Ponieważ Scala bazuje na klasach, wszystkie wartości są instancjami klasy. Można zatem powiedzieć, że Scala posiada zunifikowany system typów. Poniższy diagram ilustruje hierarchię klas Scali: +W Scali wszystkie wartości mają określony typ, włączając w to wartości numeryczne i funkcje. +Poniższy diagram ilustruje podzbiór hirarchii typów. -![Scala Type Hierarchy]({{ site.baseurl }}/resources/images/classhierarchy.img_assist_custom.png) +Scala Type Hierarchy -## Hierarchia Klas Scali ## +## Hierarchia Typów Scali ## -Klasa bazowa dla wszystkich klas `scala.Any` posiada dwie bezpośrednie klasy pochodne: `scala.AnyVal` oraz `scala.AnyRef`, które reprezentują dwie różne rodziny klas: klasy wartości oraz klasy referencji. Klasy wartości są predefiniowane i odpowiadają one typom prymitywnym z języków takich jak Java. Wszystkie inne klasy definiują typy referencyjne. Klasy zdefiniowane przez użytkownika są domyślnie typami referencyjnymi, tzn. są one zawsze podtypem klasy `scala.AnyRef`. W kontekście maszyny wirtualnej Javy `scala.AnyRef` odpowiada typowi `java.lang.Object`. Powyższy diagram ilustruje także konwersje implicit pomiędzy klasami wartości. +Typem bazowym dla wszystkich klas jest `Any`, jest on też nazywany typem górnym (top type). +Definiuje on uniwersalne metody takie jak `equals`, `hashCode` oraz `toString`. +`Any` posiada dwa bezpośrednie podtypy: `AnyVal` i `AnyRef`. -Poniższy przykład pokazuje, że liczby, znaki, wartości logiczne oraz funkcje są obiektami: +`AnyVal` reprezentuje typy wartości. +Żaden z tych typów nie może przyjąć wartości `null`. +Istnieje dziewięć predefiniowanych typów wartości: `Double`, `Float`, `Long`, `Int`, `Short`, `Byte`, `Char`, `Unit` oraz `Boolean`. +`Unit` to typ wartości, która nie niesie ze sobą żadnej znaczącej informacji. +Istnieje dokładnie jedna instancja typu `Unit` i jest zdefiniowana dosłownie jako: `()`. +Wszystkie funkcje muszą coś zwracać, dlatego w niektórych przypadkach trzeba użyć `Unit` do oznaczenia zwracanego typu. +`AnyRef` reprezentuje typy referencyjne. +Przez referencje mamy w tym przypadku na myśli wskaźniki do innych obiektów. +Wszystkie typy niebędące wartościami są zdefiniowane jako typy referencyjne. +Każdy typ zdefiniowany przez użytkownika jest podtypem `AnyRef`. +Jeżeli Scala użyta jest w kontekście środowiska uruchomieniowego Javy, to `AnyRef` odnosi się do `java.lang.Object`. +Poniższy przykład pokazuje, że łańcuchy znakowe, liczby całkowite, znaki, wartości logiczne oraz funkcje są obiektami tak samo jak każdy inny obiekt: + +{% scalafiddle %} ```tut -object UnifiedTypes extends App { - val fun: Int => Int = _ + 1 // deklaracja funkcji - val set = new scala.collection.mutable.LinkedHashSet[Any] - set += "To jest łańcuch znaków" // dodaj łańcuch znaków - set += 732 // dodaj liczbę - set += 'c' // dodaj znak - set += true // dodaj wartość logiczną - set += fun _ // dodaj funkcję - set foreach println -} +val list: List[Any] = List( + "Łancuch znaków", + 732, // liczba całkowita + 'c', // znak + true, // wartość Boolowska + () => "funkcja anonimowa zwracająca łańcuch znaków" +) + +list.foreach(element => println(element)) ``` +{% endscalafiddle %} -Program deklaruje aplikację `UnifiedTypes` w postaci [obiektu singleton](singleton-objects.html) rozszerzającego klasę `App`. Aplikacja definiuje zmienną lokalną `set` odwołującą się do instancji klasy `LinkedHashSet[Any]`, która reprezentuje zbiór obiektów dowolnego typu (`Any`). Ostatecznie program wypisuje wszystkie elementy tego zbioru. +Program deklaruje wartość `list` typu `List[Any]`. +Lista jest zainicjowana elementami różnego typu, ale będącymi podtypami `scala.Any` - dlatego można je umieścić na tej liście. -Wynik działania programu: +Wynik działania powyższego programu: ``` -To jest łańcuch znaków +Łancuch znaków 732 c true ``` + +## Rzutowanie typów + +Typy wartości mogą być rzutowane w następujący sposób: + +Scala Type Hierarchy + +Dla przykładu: + +```tut +val x: Long = 987654321 +val y: Float = x // 9.8765434E8 (w tym wypadku tracimy część precyzji) + +val face: Char = '☺' +val number: Int = face // 9786 +``` + +Rzutowanie jest jednokierunkowe, następujący kod nie zadziała: + +``` +val x: Long = 987654321 +val y: Float = x // 9.8765434E8 +val z: Long = y // Błąd: Does not conform +``` + +Możliwe jest też rzutowanie referencji typu jego podtyp. +Zostanie to dokładniej omówione w kolejnych rozdziałach. + +## Typy Nothing oraz Null + +`Nothing` jest podtypem wszystkich typów, istnieje na samym dole hierarchii i jest nazywany typem dolnym (bottom type). +Nie istnieje żadna wartość typu `Nothing`. +Częstym przykładem użycia jest zasygnalizowanie stanów nieoznaczonych np. wyrzucony wyjątek, wyjście z programu, +nieskończona pętla (ściślej mówiąc - jest to typ wyrażenia które nie ewaluuje na żadną wartość lub metoda, która nie zwraca wyniku). + +`Null` jest podtypem wszystkich typów referencyjnych (wszystkich podtypów `AnyRef`). +Ma pojedynczą wartosć identyfikowaną przez słowo kluczowe `null`. +`Null` przydaje się głównie do współpracy z innymi językami platformy JVM i nie powinien być praktycznie nigdy używany +w kodzie w jęzku Scala. +W dalszej części przewodnika omówimy alternatywy dla `null`. diff --git a/_tour/mixin-class-composition.md b/_tour/mixin-class-composition.md index 18a0bcbb38..35a87dc664 100644 --- a/_tour/mixin-class-composition.md +++ b/_tour/mixin-class-composition.md @@ -6,7 +6,7 @@ discourse: true partof: scala-tour -num: 6 +num: 7 next-page: higher-order-functions previous-page: tuples prerequisite-knowledge: inheritance, traits, abstract-classes, unified-types diff --git a/_tour/tuples.md b/_tour/tuples.md index 7db0aac4dd..a7b59e7e08 100644 --- a/_tour/tuples.md +++ b/_tour/tuples.md @@ -6,7 +6,7 @@ discourse: true partof: scala-tour -num: +num: 6 next-page: mixin-class-composition previous-page: traits topics: tuples @@ -92,5 +92,4 @@ for ((a, b) <- numPairs) { The value () of type Unit is conceptually the same as the value () of type Tuple0. There can only be one value of this type since it has no elements. -Users may sometimes find hard to chose between Tuples and case classes. As a rule, case classes are preferred choice if elements -carry more meaning. \ No newline at end of file +Users may sometimes find hard to chose between Tuples and case classes. As a rule, case classes are preferred choice if elements carry more meaning.