From b4f232a7f0623358c926d2b0f4136d5d502824f0 Mon Sep 17 00:00:00 2001 From: Kamil Duda Date: Sat, 3 Nov 2018 14:52:07 +0100 Subject: [PATCH] Update Polish translation for classes Add tut:fail validation Remove tut check Fix typos Make more readable Update _pl/tour/classes.md Co-Authored-By: kamilduda Update _pl/tour/classes.md Co-Authored-By: kamilduda --- _pl/tour/classes.md | 112 +++++++++++++++++++++++++++++++++++++------- 1 file changed, 95 insertions(+), 17 deletions(-) diff --git a/_pl/tour/classes.md b/_pl/tour/classes.md index 24a69c466c..94ce2e3ebb 100644 --- a/_pl/tour/classes.md +++ b/_pl/tour/classes.md @@ -6,49 +6,127 @@ discourse: false partof: scala-tour -num: 3 +num: 4 language: pl next-page: traits previous-page: unified-types --- -Klasy w Scali określają schemat obiektów podczas wykonania programu. Oto przykład definicji klasy `Point`: +Klasy w Scali są wzorcami do tworzenia obiektów. +Klasy mogą zawierać metody, wartości, zmienne, typy, obiekty, cechy i klasy; wszystkie one są nazywane składnikami klasy (_class members_). +Typy, obiekty i cechy zostaną omówione w dalszej części przewodnika. + +## Definiowanie klasy + +Minimalna definicja klasy składa się ze słowa kluczowego `class` oraz jej identyfikatora. +Nazwy klas powinny zaczynać się z wielkiej litery. + +```tut +class User + +val user1 = new User +``` + +Do tworzenia nowych instancji klasy służy słowo kluczowe `new`. +Ponieważ żaden konstruktor nie został zdefiniowany, klasa `User` posiada konstruktor domyślny, który nie przyjmuje żadnych parametrów. +Zazwyczaj jednak definiujemy konstruktor i ciało klasy. +Poniższy przykład przedstawia definicję klasy służącej do reprezentowania punktu. ```tut class Point(var x: Int, var y: Int) { + def move(dx: Int, dy: Int): Unit = { x = x + dx y = y + dy } + override def toString: String = - "(" + x + ", " + y + ")" + s"($x, $y)" } + +val point1 = new Point(2, 3) +point1.x // 2 +println(point1) // wyświetla (2, 3) +``` + +Klasa `Point` ma cztery składniki: zmienne `x` i `y` oraz metody `move` i `toString`. +W przeciwieństwie do innych języków programowania, główny konstruktor zawiera się w sygnaturze klasy: `(var x: Int, var y: Int)`. +Metoda `move` przyjmuje jako parametry dwie liczby całkowite i zwraca wartość `()` typu `Unit`, która nie niesie ze sobą żadnych informacji. +Odpowiada to słowu kluczowemu `void` w językach Java - podobnych. +Metoda `toString` nie przyjmuje żadnych parametrów, ale zwraca wartość typu `String`. +Ponieważ `toString` nadpisuje metodę `toString` zdefiniowaną w [`AnyRef`](unified-types.html), jest ona dodatkowo oznaczona słowem kluczowym `override`. + +## Konstruktory + +Konstruktory mogą zawierać parametry opcjonalne - wystarczy dostarczyć wartość domyślną dla takiego parametru. + +```tut +class Point(var x: Int = 0, var y: Int = 0) + +val origin = new Point // x i y są mają wartość 0 +val point1 = new Point(1) +println(point1.x) // wyświetla 1 + ``` -Klasy w Scali są sparametryzowane poprzez argumenty konstruktora. Powyższy kod wymaga podania dwóch argumentów konstruktora: `x` i `y`. Oba parametry są widoczne w zasięgu ciała klasy. +W tej wersji klasy `Point`, `x` oraz `y` mają domyślną wartość `0` - dlatego nie jest wymagane przekazanie żadnych parametrów. +Jednak z powodu tego, że konstruktor jest ewaluowany od lewej do prawej strony, jeżeli chcesz przekazać parametr tylko do argumentu `y`, musisz określić nazwę tego parametru. + +``` +class Point(var x: Int = 0, var y: Int = 0) +val point2 = new Point(y = 2) +println(point2.y) // wyświetla 2 +``` -Klasa `Point` zawiera także dwie metody: `move` i `toString`. `move` pobiera dwa argumenty w postaci liczb całkowitych, ale nie zwraca żadnej wartości (zwracany typ `Unit` odpowiada `void` w językach takich jak Java). Z drugiej strony `toString` nie wymaga żadnych parametrów, ale zwraca łańcuch znaków typu `String`. Ponieważ `toString` przesłania predefiniowaną metodę `toString`, jest ona oznaczona słowem kluczowym `override`. +Jest to również dobra praktyka, która zwiększa przejrzystość kodu. -Należy dodać, że w Scali nie jest wymagane podanie słowa kluczowego `return` w celu zwrócenia wartości. Dzięki temu, że każdy blok kodu w Scali jest wyrażeniem, wartością zwracaną przez metodę jest ostatnie wyrażenie w ciele metody. Dodatkowo proste wyrażenia, takie jak zaprezentowane na przykładzie implementacji `toString` nie wymagają podania klamer, zatem można je umieścić bezpośrednio po definicji metody. +## Prywatne składniki oraz składnia getterów i setterów -Instancje klasy można tworzyć w następujący sposób: +Domyślnie wszystkie składniki klasy są publiczne. +Aby ukryć je przed zewnętrznymi klientami (wszystkim co jest poza daną klasą), należy użyć słowa kluczowego `private`. ```tut -object Classes { - def main(args: Array[String]) { - val pt = new Point(1, 2) - println(pt) - pt.move(10, 10) - println(pt) +class Point { + private var _x = 0 + private var _y = 0 + private val bound = 100 + + def x = _x + def x_= (newValue: Int): Unit = { + if (newValue < bound) _x = newValue else printWarning } + + def y = _y + def y_= (newValue: Int): Unit = { + if (newValue < bound) _y = newValue else printWarning + } + + private def printWarning = println("UWAGA: wartość poza przedziałem") } + +val point1 = new Point +point1.x = 99 +point1.y = 101 // wyświetla ostrzeżenie ``` -Program definiuje wykonywalną aplikację w postaci [obiektu singleton](singleton-objects.html) z główną metodą `main`. Metoda `main` tworzy nową instancję typu `Point` i zapisuje ją do wartości `pt`. Istotną rzeczą jest to, że wartości zdefiniowane z użyciem słowa kluczowego `val` różnią się od zmiennych określonych przez `var` (jak w klasie `Point` powyżej) tym, że nie dopuszczają aktualizacji ich wartości. +W powyższym przykładnie klasy `Point` dane przechowywane są w prywatnych zmiennych `_x` i `_y`. +Publiczne metody `def x` i `def y` istnieją w celu uzyskania dostępu do prywatnych danych - są to gettery. +Metody `def x_=` i `def y_=` (settery) służą do walidacji oraz ustawiania wartości zmiennych `_x` i `_y`. +Zwróć uwagę na specyficzną składnię dla setterów: posiadają one `_=` dołączone do nazwy, dopiero w dalszej kolejności zdefiniowane są ich parametry. + +Parametry głównego konstruktora oznaczone przez `val` i `var` są publiczne. +Ponieważ `val` jest niezmienne, poniższy kod nie jest prawidłowy + +``` +class Point(val x: Int, val y: Int) +val point = new Point(1, 2) +point.x = 3 // <-- nie kompiluje się +``` -Wynik działania programu: +Parametry konstruktora __nie__ zawierające `val` lub `var` są prywatne - widoczne jedynie we wnętrzu klasy. ``` -(1, 2) -(11, 12) +class Point(x: Int, y: Int) +val point = new Point(1, 2) +point.x // <-- nie kompiluje się ```