summaryrefslogtreecommitdiffhomepage
path: root/pl-pl
diff options
context:
space:
mode:
Diffstat (limited to 'pl-pl')
-rw-r--r--pl-pl/java-pl.html.markdown1026
1 files changed, 1026 insertions, 0 deletions
diff --git a/pl-pl/java-pl.html.markdown b/pl-pl/java-pl.html.markdown
new file mode 100644
index 00000000..0da449c5
--- /dev/null
+++ b/pl-pl/java-pl.html.markdown
@@ -0,0 +1,1026 @@
+---
+language: java
+filename: LearnJavaPl.java
+contributors:
+ - ["Jake Prather", "https://github.com/JakeHP"]
+ - ["Jakukyo Friel", "https://weakish.github.io"]
+ - ["Madison Dickson", "https://github.com/mix3d"]
+ - ["Simon Morgan", "https://sjm.io/"]
+ - ["Zachary Ferguson", "https://github.com/zfergus2"]
+ - ["Cameron Schermerhorn", "https://github.com/cschermerhorn"]
+ - ["Rachel Stiyer", "https://github.com/rstiyer"]
+ - ["Michael Dähnert", "https://github.com/JaXt0r"]
+ - ["Rob Rose", "https://github.com/RobRoseKnows"]
+ - ["Sean Nam", "https://github.com/seannam"]
+ - ["Shawn M. Hanes", "https://github.com/smhanes15"]
+filename: LearnJava.java
+translators:
+ - ["Jacek Wachowiak", "https://github.com/jacekwachowiak"]
+lang: pl-pl
+---
+
+Java jest współbieżnym, opartym na klasach, obiektowym językiem programowania
+ogólnego zastosowania.
+[Tu znajdziesz więcej informacji po angielsku.]
+(https://docs.oracle.com/javase/tutorial/java/)
+
+```java
+// Pojedyncze komentarze oznaczamy //
+
+/*
+Komentarze wieloliniowe wyglądają tak
+*/
+
+/**
+ * Komentarze JavaDoc wygladają w ten sposób. Używane są do opisu klas lub
+ * różnych właściwości klas.
+ * Główne właściwości:
+ *
+ * @author Imię i nazwisko (i kontakt np. email) autora.
+ * @version Aktualna wersja programu.
+ * @since Kiedy ta część programu została dodana.
+ * @param Służy do opisu parametrów metody.
+ * @return Służy do opisu zwracanej wartości.
+ * @deprecated Służy do oznaczenia nieaktualnego lub niezalecanego kodu.
+ * @see Linki do innej cześci dokumentacji.
+*/
+
+// Import klasy ArrayList z paczki java.util
+import java.util.ArrayList;
+// Import wszystkich klas z paczki java.security
+import java.security.*;
+
+public class LearnJava {
+
+ // Aby móc uruchomić program w języku java musi on mieć główną metodę jako
+ // punkt wejścia.
+ public static void main(String[] args) {
+
+ ///////////////////////////////////////
+ // Operacje wejścia/wyjścia (input/output)
+ ///////////////////////////////////////
+
+ /*
+ * Wyjście
+ */
+
+ // System.out.println() służy do wyświetlania linii tekstu.
+ System.out.println("Hello World!");
+ System.out.println(
+ "Integer: " + 10 +
+ " Double: " + 3.14 +
+ " Boolean: " + true);
+
+ // Aby wyświetlić bez nowej linii użyj System.out.print().
+ System.out.print("Hello ");
+ System.out.print("World");
+
+ // System.out.printf() służy do łatwego formatowania wyświetlanego elementu.
+ System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
+
+ /*
+ * Wejście
+ */
+
+ // Scanner służy do wczytywania danych
+ // niezbędny jest import java.util.Scanner;
+ Scanner scanner = new Scanner(System.in);
+
+ // zczytaj string (tekst)
+ String name = scanner.next();
+
+ // zczytaj zmienną typu bajt
+ byte numByte = scanner.nextByte();
+
+ // zczytaj zmienną typu integer - liczba całkowita
+ int numInt = scanner.nextInt();
+
+ // zczytaj zmienną typu float - liczba zmiennoprzecinkowa
+ float numFloat = scanner.nextFloat();
+
+ // zczytaj zmienna typu double -liczba zmiennoprzecinkowa
+ double numDouble = scanner.nextDouble();
+
+ // zczytaj zmienną typu boolowskiego -
+ boolean bool = scanner.nextBoolean();
+
+ ///////////////////////////////////////
+ // Zmienne
+ ///////////////////////////////////////
+
+ /*
+ * Deklaracja zmiennych
+ */
+ // Zmienną deklaruje się poprzez <rodzaj> <nazwa>
+ int fooInt;
+ // Dozwolona jest deklaracja wielu zmiennych tego samego typu na raz
+ // rodzaj <nazwa1>, <nazwa2>, <nazwa3>
+ int fooInt1, fooInt2, fooInt3;
+
+ /*
+ * Inicjalizacja zmiennych
+ */
+
+ // Zmienną inicjalizuje się poprzez <rodzaj> <nazwa> = <wartość>
+ int barInt = 1;
+ // Możliwe jest zainicjalizowanie wielu zmiennych tego samego typu tą samą wartością
+ // rodzaj <nazwa1>, <nazwa2>, <nazwa3>
+ // <nazwa1> = <nazwa2> = <nazwa3> = <wartość>
+ int barInt1, barInt2, barInt3;
+ barInt1 = barInt2 = barInt3 = 1;
+
+ /*
+ * Rodzaje zmiennych
+ */
+ // Bajt - 8-bitowa, zawierająca ujemne wartości zmienna w dwójkowym
+ // systemie pozycyjnym
+ // (-128 <= byte <= 127)
+ byte fooByte = 100;
+
+ // Jeśli chcemy zinterpretować bajt jako zmienną typu unsigned integer
+ // - liczbę całkowitą z wartościami ujemnymi ta operacja może pomóc:
+ int unsignedIntLessThan256 = 0xff & fooByte;
+ // jako kontrast operacja zmiany typu która może zwrócić wartość ujemną.
+ int signedInt = (int) fooByte;
+
+ // Short - 16-bitowa, zawierająca ujemne wartości zmienna w dwójkowym
+ // systemie pozycyjnym (-32,768 <= short <= 32,767)
+ short fooShort = 10000;
+
+ // Integer - 32-bitowa, zawierająca ujemne wartości zmienna w dwójkowym systemie pozycyjnym
+ // (-2,147,483,648 <= int <= 2,147,483,647)
+ int bazInt = 1;
+
+ // Long - 64-bitowa, zawierająca ujemne wartości zmienna w dwójkowym
+ // systemie pozycyjnym
+ // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+ long fooLong = 100000L;
+ // L jest używane do zaznaczenia, że wartość zmiennej jest typu Long;
+ // bez L wszystko inne będzie traktowane z założenia jako integer.
+
+ // Uwaga: byte, short, int and long zawierają ujemne wartości.
+ // Nie istnieją odpowiedniki z jedynie pozytywnymi wartościami.
+ // Jedynie char jest 16-bitowym typem zmiennej, który akceptuje tylko
+ // wartości nieujemne.
+
+ // Float - 32-bitowy typ zmiennoprzecinkowy zgodnie z IEEE 754
+ // Floating Point 2^-149 <= float <= (2-2^-23) * 2^127
+ float fooFloat = 234.5f;
+ // f or F jest używane aby zaznaczyć, że dana zmienna jest typu float;
+ // w przeciwnym razie będzie ona traktowana jako double.
+
+ // Double - 64-bitowy typ zmiennoprzecinkowy zgodnie z IEEE 754
+ // Floating Point 2^-1074 <= x <= (2-2^-52) * 2^1023
+ double fooDouble = 123.4;
+
+ // Typ boolowski - true/prawda & false/fałsz
+ boolean fooBoolean = true;
+ boolean barBoolean = false;
+
+ // Char - pojedynczy 16-bitowy symbol Unicode
+ char fooChar = 'A';
+
+ // zmienne zadeklarowane z użyciem final nie mogą być edytowane,
+ final int HOURS_I_WORK_PER_WEEK = 9001;
+ // ale możliwa jest późniejsza inicjalizacja.
+ final double E;
+ E = 2.71828;
+
+ // BigInteger - Nieedytowalny typ zmiennej o nieograniczonej długości
+ // dla liczb całkowitych
+ //
+ // BigInteger jest typem zmiennej, który pozwala na operacje na liczbach całkowitych dłuższych niż 64 bity.
+ // Liczby są przechowywane jako tablica bajtów
+ // i modyfikowane za pomocą funkcji wbudowanych w BigInteger
+ //
+ // BigInteger może być zainicjalizowany za pomocą tablicy bajtów lub jako string.
+ BigInteger fooBigInteger = new BigInteger(fooByteArray);
+
+ // BigDecimal - Nieedytowalny typ zmiennej o nieograniczonej długości dla
+ // liczb zmiennoprzecinkowych
+ //
+ // BigDecimal zaiwera 2 części: typ integer o arbitralnej precyzji bez skalowania
+ // oraz 32-bitową skalę
+ //
+ // BigDecimal pozwala programiście na całkowitą kontrolę zaokrąglenia dziesiętnego.
+ // Zalecane jest używanie BigDecimal z wartościami walut.
+ // oraz tam, gdzie absolutna dokładność jest niezbędna.
+ //
+ // BigDecimal można zainicjalizowac używając int, long, double or String
+ // a także inicjalizując nieprzeskalowaną wartość (BigInteger) i skalę (int).
+ BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
+
+ // Uwaga na konstruktor, który przyjmuje float lub double jako, że
+ // niedokładność float/double będzie przeniesiona do BigDecimal.
+ // Zalecane jest uzywanie konstruktora typu String gdy konieczne jest
+ // uzyskanie absolutnej precyzji.
+ BigDecimal tenCents = new BigDecimal("0.1");
+
+ // String - zmienna tekstowa
+ String fooString = "Tutaj jest mój string!";
+
+ // \n jest symbolem karetki, która rozpoczyna nową linę
+ String barString = "Wyświetlanie w nowej linii?\nNie ma problemu!";
+ // \t jest symbolem tabulatora, który dodaje odstęp.
+ String bazString = "Chesz dodać tabulator?\tBez problemu!";
+ System.out.println(fooString);
+ System.out.println(barString);
+ System.out.println(bazString);
+
+ // Budowanie Stringów
+ // #1 - za pomocą operatora dodawania
+ // To jest podstawowy sposób (zoptymalizowany)
+ String plusConcatenated = "Stringi mogą " + "być łączone " + "operatorem +.";
+ System.out.println(plusConcatenated);
+ // Wyjście: Stringi będą połączone operatorem +.
+
+ // #2 - za pomocą StringBuilder
+ // Ten sposób nie tworzy żadnych pośrednich stringów, jedynie zachowuje
+ // części i wiąże je po kolei gdy wywołane jest toString().
+ // Wskazówka: Ta klasa nie jest bezpieczna z punktu widzenia wątków.
+ // Bezpieczną alternatywą jest (wiążąca się ze spadkiem wydajności)
+ // StringBuffer.
+ StringBuilder builderConcatenated = new StringBuilder();
+ builderConcatenated.append("Możesz ");
+ builderConcatenated.append("użyć ");
+ builderConcatenated.append("klasy StringBuilder.");
+ System.out.println(builderConcatenated.toString()); // dopiero tutaj
+ //budowany jest string
+ // Wyjście: Używany jest StringBuilder.
+
+ // StringBuilder jest wydajny, gdy połączony string nie jest używany aż do końcowego przetworzenia.
+ StringBuilder stringBuilder = new StringBuilder();
+ String inefficientString = "";
+ for (int i = 0 ; i < 10; i++) {
+ stringBuilder.append(i).append(" ");
+ inefficientString += i + " ";
+ }
+ System.out.println(inefficientString);
+ System.out.println(stringBuilder.toString());
+ // inefficientString wymaga dużo więcej pracy przy stworzeniu ponieważ
+ // tworzy string przy każdej iteracji.
+ // Proste łączenie za pomocą + jest kompilowane do StringBuilder i
+ // toString(). Unikaj łączenia stringów w pętlach.
+
+ // #3 - za pomocą String formatter
+ // Inna możliwość, szybka i czytelna.
+ String.format("%s wolisz %s.", "A może", "String.format()");
+ // Wyjście: Być może wolisz String.format().
+
+ // Tablice
+ // Rozmiar tablicy musi być określony przy stworzeniu.
+ // Podane poniżej sposoby są dozwolone prz deklaracji tablicy
+ // <rodzaj>[] <nazwa> = new <rodzaj>[<rozmiar>];
+ // <rodzaj> <nazwa>[] = new <rodzaj>[<rozmiar>];
+ int[] intArray = new int[10];
+ String[] stringArray = new String[1];
+ boolean boolArray[] = new boolean[100];
+
+ // Inny sposób deklaracji i inicjalizacji tablicy
+ int[] y = {9000, 1000, 1337};
+ String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
+ boolean bools[] = {true, false, false};
+
+ // Indeksowanie tablicy - dostęp do elementów
+ System.out.println("intArray @ 0: " + intArray[0]);
+
+ // Tablice zaczynają się z indeksem 0 i są edytowalne.
+ intArray[1] = 1;
+ System.out.println("intArray @ 1: " + intArray[1]); // => 1
+
+ // Inny typ zmiennej, z którymi warto się zapoznać
+ // ArrayLists - Tablice z większą funkcjonalnością
+ // i zmiennym rozmiarem.
+ // LinkedLists - Dwustronnie połączone listy. Wszystkie operacje
+ // na listach zaimpllementowane.
+ // Maps - Mapy zawierające klucz i wartość. Mapa jest interfejsem
+ // i nie może zostać zainicjalizowana.
+ // Rodzaj klucza i wartości dla mapy musi zostać określony
+ // przy inicjalizacji implementującej mapę klasy
+ // Każdy klucz przypisany jest do tylko jednej wartości,
+ // każdy klucz może wystąpić tylko raz (brak duplikatów).
+ // HashMaps - Używa tablicy hashów do implementacji interfejsu mapy
+ // Pozwala to na użycie podstawowych operacji, jak
+ // get i insert, które pozostają niezmiennie wydajne
+ // czasowo nawet dla dużych zestawów danych
+ // TreeMap - Mapa posortowana przez klucze. Każda modyfikacja
+ // utrzymuje sortowanie, zdefiniowane przez komparator
+ // dodany przy inicjalizacji lub porównanie każdego obiektu
+ // jeśli zaimplementowany jest interfejs Comparable.
+ // Niepowodzenie kluczy wimplemntacji Comparable połączone
+ // z niepowodzeniem dostarczenia komparatora spowoduje
+ // ClassCastExceptions.
+ // Dodawanie i usuwanie kosztuje O(log(n)) czasu,
+ // zalecane jest nieużywanie tego typu jeżeli sortowanie
+ // nie jest przydatne.
+
+ ///////////////////////////////////////
+ // Operatory
+ ///////////////////////////////////////
+ System.out.println("\n->Operatory");
+
+ int i1 = 1, i2 = 2; // Skrót dla wielokrotnych deklaracji
+
+ // Arytmetyka jest prosta
+ System.out.println("1+2 = " + (i1 + i2)); // => 3
+ System.out.println("2-1 = " + (i2 - i1)); // => 1
+ System.out.println("2*1 = " + (i2 * i1)); // => 2
+ System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int zwraca int)
+ System.out.println("1/2.0 = " + (i1 / (double)i2)); // => 0.5
+
+ // Modulo
+ System.out.println("11%3 = "+(11 % 3)); // => 2
+
+ // Porównania
+ System.out.println("3 == 2? " + (3 == 2)); // => false
+ System.out.println("3 != 2? " + (3 != 2)); // => true
+ System.out.println("3 > 2? " + (3 > 2)); // => true
+ System.out.println("3 < 2? " + (3 < 2)); // => false
+ System.out.println("2 <= 2? " + (2 <= 2)); // => true
+ System.out.println("2 >= 2? " + (2 >= 2)); // => true
+
+ // Operacje boolowskie
+ System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false
+ System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true
+ System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true
+
+ // Operacje na bitach!
+ /*
+ ~ Odwrócenie bitów
+ << Przesunięcie w lewo
+ >> Przesunięcie w prawo, arytmetyczne/dla wartości ujemnych -signed
+ >>> Przesunięcie w prawo, logiczne/dla wartości dodatnich - unsigned
+ & Bitowe AND
+ ^ Bitowe XOR
+ | Bitowe OR
+ */
+
+ // Operatory inkrementacji
+ int i = 0;
+ System.out.println("\n->In/De-krementacja");
+ // Operatory ++ i -- zwiększają lub zmniejszają o 1 daną wartość.
+ // Jeżeli używane są przed zmienną, wykonywane są przed powrotem zmiennej.
+ // Użyte po zmiennej najpierw zwracają zmienną a następnie dokonują
+ // zmiany wartości.
+ System.out.println(i++); // i = 1, wyświetli 0 (post-increment)
+ System.out.println(++i); // i = 2, wyświetli 2 (pre-increment)
+ System.out.println(i--); // i = 1, wyświetli 2 (post-decrement)
+ System.out.println(--i); // i = 0, wyświetli 0 (pre-decrement)
+
+ ///////////////////////////////////////
+ // Przepływ sterowania
+ ///////////////////////////////////////
+ System.out.println("\n->Przepływ sterowania");
+
+ // Instrukcja if wygląda jak w c
+ int j = 10;
+ if (j == 10) {
+ System.out.println("Wyświetlam się");
+ } else if (j > 10) {
+ System.out.println("A ja nie");
+ } else {
+ System.out.println("Ja też nie");
+ }
+
+ // Pętla while
+ int fooWhile = 0;
+ while(fooWhile < 100) {
+ System.out.println(fooWhile);
+ // Licznik jest zwiększany
+ // Iteruje 100 razy, fooWhile 0,1,2...99
+ fooWhile++;
+ }
+ System.out.println("Wartość fooWhile: " + fooWhile);
+
+ // Pętla do while
+ int fooDoWhile = 0;
+ do {
+ System.out.println(fooDoWhile);
+ // Licznik jest zwiększany
+ // Iteruje 99 razy, fooDoWhile 0->99
+ fooDoWhile++;
+ } while(fooDoWhile < 100);
+ System.out.println("Wartość fooDoWhile: " + fooDoWhile);
+
+ // Pętla for
+ // struktura pętli for => for(<początek>; <warunek>; <krok>)
+ for (int fooFor = 0; fooFor < 10; fooFor++) {
+ System.out.println(fooFor);
+ // Iteruje 10 razy, fooFor 0->9
+ }
+ System.out.println("Wartość fooFor: " + fooFor);
+
+ // Wyjście z zagnieżdżonej, oznaczonej pętli for
+ outer:
+ for (int i = 0; i < 10; i++) {
+ for (int j = 0; j < 10; j++) {
+ if (i == 5 && j ==5) {
+ break outer;
+ // wychodzi z zewnętrznej pętli zamiast jednynie z aktualnej z
+ // powodu oznaczenia
+ }
+ }
+ }
+
+ // Pętla for each
+ // Pętla for each może iterować tablice jak i obiekty
+ // które implementują interfejs Iterable.
+ int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+ // Struktura for each => for (<element> : <obiekt iterowany>)
+ // należy rozumieć jako: dla każdego elementu w obiekcie iterowanym
+ // uwaga: typ zdefiniowango elementu musi się zgadzać z typem w
+ //obiekcie iterowanym.
+ for (int bar : fooList) {
+ System.out.println(bar);
+ //Iteruje 9 razy i wyświetla 1-9 w nowych liniach
+ }
+
+ // Switch Case
+ // Switch (przełącznik) działa z zmiennymi typu byte, short, char, int.
+ // Działa również z enumeratorami (zobacz typ Enum),
+ // klasą String, i kilkoma specjalnymi klasami które zawierają typy
+ // podstawowe: Character, Byte, Short, and Integer.
+ // Z wersją Java 7 i wyższymi możliwe jest użycie typu String.
+ // Uwagga: Pamiętaj, że nie dodając "break" na końcu danego case
+ // spowoduje przejście do następnego (jeżeli spełniony jest warunek).
+ int month = 3;
+ String monthString;
+ switch (month) {
+ case 1: monthString = "Styczeń";
+ break;
+ case 2: monthString = "Luty";
+ break;
+ case 3: monthString = "Marzec";
+ break;
+ default: monthString = "Inny miesiąc";
+ break;
+ }
+ System.out.println("Wynik Switch Case : " + monthString);
+
+
+ // Try-with-resources (Java 7+)
+ // Try-catch-finally działa zgodnie z oczekiwaniami jednakże w Java 7+
+ // dodatkowo jest dostępny try-with-resources statement.
+ // Try-with-resources upraszcza try-catch-finally automatycznie
+ // usuwając zasoby.
+
+ // Aby użyć try-with-resources, użyj instancji klasy
+ // w części "try". Klasa musi implementować java.lang.AutoCloseable.
+ try (BufferedReader br = new BufferedReader(new FileReader("foo.txt"))) {
+ // Tutaj możesz spróbować wywołac wyjątek.
+ System.out.println(br.readLine());
+ // W Java 7 zasoby będą zawsze usuwane nawet jeśli nastąpi wyjątek.
+ } catch (Exception ex) {
+ // Zasób będzie usunięty zanim wykona się catch.
+ System.out.println("readLine() nie powiódł się.");
+ }
+ // Nie ma potrzeby używać sekcji "finally", jako że BufferedReader
+ // został już zamknięty. Ten sposób może zostać użyty aby uniknąć
+ // pewnych wartości brzegowych gdzie "finally" nie zostałoby wywołane
+ // Więcej na ten temat po angielsku:
+ // https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html
+
+
+ // Skrócone instrukcje warunkowe
+ // Dozwolone jest użycie operatora '?' aby szybko sprawdzić warunek
+ // logiczny. Rozumiane jest to jako "Jeśli (warunek) jest spełniony, użyj
+ // <pierwszej wartości>, inaczej, użyj <drugiej wartości>"
+ int foo = 5;
+ String bar = (foo < 10) ? "A" : "B";
+ System.out.println("bar : " + bar); // Wyśwletli "bar : A", poineważ
+ // warunke jest spełniony.
+ // Lub prościej
+ System.out.println("bar : " + (foo < 10 ? "A" : "B"));
+
+
+ ////////////////////////////////////////
+ // Konwersja typów danych
+ ////////////////////////////////////////
+
+ // Konwersja danych
+
+ // Konwersja String do Integer
+ Integer.parseInt("123");//zwraca zmienna typu Integer o wartości "123"
+
+ // Konwersja Integer do String
+ Integer.toString(123);//zwraca zmienną typu String o wartości 123
+
+ // Inne konwersje możesz sprawdzić dla klas:
+ // Double
+ // Long
+ // String
+
+ ///////////////////////////////////////
+ // Klasy i funkcje
+ ///////////////////////////////////////
+
+ System.out.println("\n->Klasy & Funkcje");
+
+ // (definicja klasy Rower nieco niżej)
+
+ // Użyj new aby zainstancjonować klasę
+ Rower trek = new Rower();
+
+ // Wywoływanie metod klasy
+ trek.predkoscZwieksz(3); // Zawsze używaj settera i gettera jako metod
+ trek.setPedalowanie(100);
+
+ // toString zwraca reprezentację typu String tego obiektu.
+ System.out.println("trek info: " + trek.toString());
+
+ // Inicjalizacja za pomocą podwójnego nawiasu
+ // Język Java nie zawiera możliwości stworzenia statycznej kolekcji
+ // Dlatego zwykle odbywa się to w ten sposób:
+ private static final Set<String> KRAJE = new HashSet<String>();
+ static {
+ KRAJE.add("DANIA");
+ KRAJE.add("SZWECJA");
+ KRAJE.add("FINLANDIA");
+ }
+
+ // Jest jednak sprytny sposób aby łatwiej osiągnąc ten sam efekt
+ // używając czegoś nazywanego Double Brace Initialization -
+ // inicjalizacja za pomocą podwójnego nawiasu.
+ private static final Set<String> KRAJE = new HashSet<String>() {{
+ add("DANIA");
+ add("SZWECJA");
+ add("FINLANDIA");
+ }}
+
+ // Pierwszy nawias tworzy nową klasę AnonymousInnerClass,
+ // drugi deklaruje instancję bloku inicjalizacji. Blok ten
+ // jest wywoływany gdy wewnętrzna, anonimowa klasa jest tworzona.
+ // Dany sposób działa nie tylko dla kolekcji, ale również dla
+ // wszystkich nie-finalnych klas.
+
+ } // Koniec metody main
+} // Koniec klasy LearnJava
+
+// Możesz zawrzeć inne, niepubliczne, zewnętrzne klasy w pliku .java,
+// jednak nie jest to zalecane. Zalecane jest dzielenie klas na osobne pliki.
+
+// Składnia deklaracji klasy:
+// <public/private/protected> class <nazwa klasy> {
+// // pola danych, konstruktory, funkcje.
+// // w jężyku Java funkcje są wywoływane jako metody.
+// }
+
+class Rower {
+
+ // Zmienne klasy
+ public int pedalowanie; // Public: Dostępne wszędzie
+ private int predkosc; // Private: Dostępne tylko w klasie
+ protected int przerzutka; // Protected: Dostępne w klasie i podklasach
+ String nazwa; // domyślnie: Dostępne tlyko w danej paczce
+ static String nazwaKlasy; // Zmienna statyczna
+
+ // Blok statyczny
+ // Java nie posiada implemntacji konstruktorów staycznych, ale
+ // posiada blok stayczny, który może być użyty aby zainicjalizować
+ // statyczne zmienne klasy
+ // Ten blok będzie wywołane gdy klasa jest ładowana.
+ static {
+ nazwaKlasy = "Rower";
+ }
+
+ // Konstruktory służą do stworzenia instancji klas
+ // Too jest konstruktor
+ public Rower() {
+ // Możesz wywołać także inny konstruktor:
+ // this(1, 50, 5, "Bontrager");
+ przerzutka = 1;
+ pedalowanie = 50;
+ predkosc = 5;
+ nazwa = "Bontrager";
+ }
+ // To jest konstruktor, który przyjmuje argumenty
+ public Rower(int poczatkowePedalowanie, int poczatkowaPredkosc, int początkowaPrzerzutka,
+ String nazwa) {
+ this.przerzutka = początkowaPrzerzutka;
+ this.pedalowanie = poczatkowePedalowanie;
+ this.predkosc = poczatkowaPredkosc;
+ this.nazwa = nazwa;
+ }
+
+ // Składnia metod:
+ // <public/private/protected> <zwracany rodzaj> <nazwa funkcji>(<argumenty>)
+
+ // Klasy często implementują metody getter i setter dla danych wewnątrz
+
+ // Składnia deklaracji metody:
+ // <dostępność> <zwracany rodzaj> <nawa metody>(<argumenty>)
+ public int getPedalowanie() {
+ return pedalowanie;
+ }
+
+ // metody void nie wymagają słowa kluczowego return, nic nie zwracają
+ public void setPedalowanie(int newValue) {
+ pedalowanie = newValue;
+ }
+ public void setPrzerzutka(int newValue) {
+ przerzutka = newValue;
+ }
+ public void predkoscZwieksz(int inkrement) {
+ predkosc += inkrement;
+ }
+ public void predkoscZmniejsz(int dekrement) {
+ predkosc -= dekrement;
+ }
+ public void nadajNazwe(String nowaNazwa) {
+ nazwa = nowaNazwa;
+ }
+ public String zwrocNazwe() {
+ return nazwa;
+ }
+
+ // Metoda do wyświetlenia wartości atrybutów danego obiektu.
+ @Override // Dziedziczy z klasy obiektu.
+ public String toString() {
+ return "przerzutka: " + przerzutka + " pedalowanie: " + pedalowanie + " predkosc: " + predkosc +
+ " nazwa: " + nazwa;
+ }
+} // koniec klasy Rower
+
+// PennyFarthing jest podklasą klasy Rower
+class PennyFarthing extends Rower {
+ // (Penny Farthing to rower z wielkim przednim kołem.
+ // Nie ma przerzutek.)
+
+ public PennyFarthing(int poczatkowePedalowanie, int poczatkowaPredkosc) {
+ // Wywołanie kostruktora klasy z której dziedziczymy za pomocą super
+ super(poczatkowePedalowanie, poczatkowaPredkosc, 0, "PennyFarthing");
+ }
+
+ // Używamy annotacji @annotation przy przeciążaniu metod.
+ // Aby dowiedzieć się więcej o annotacjach przydatne jest przejrzenie
+ // (w języku angielskim):
+ // http://docs.oracle.com/javase/tutorial/java/annotations/
+ @Override
+ public void setPrzerzutka(int przerzutka) {
+ this.przerzutka = 0;
+ }
+}
+
+// Rzutowanie
+// Jako, że klasa PennyFarthing dziedziczy z klasy Rower, możemy uznać, że
+// instancja PennyFarthing jest typu Rower i napisać :
+// Rower rower = new PennyFarthing();
+// Dana operacja jest rzutowaniem obiektu, gdzie jego domyślna klasa jest inna niż docelowa.
+// Więcej szczegółów i przykładów oraz ciekawych konceptów (po angielsku):
+// https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+// Interfejsy
+// Składnia deklaracji interfejsu
+// <dostępność> interface <nazwa interfejsu> extends <super-interfaces> {
+// // Zmienne typu constant
+// // Deklaracje metod
+// }
+
+// Przykład - Jedzenie:
+public interface Jadalne {
+ public void jedz(); // Każda klasa która implemetuje ten interfejs musi
+ // implementować tę metodę.
+}
+
+public interface Przetrawialne {
+ public void przetrawiaj();
+ // Wraz z Java 8, interfejsy mogą mieć metodę domyślną.
+ public default void defaultMethod() {
+ System.out.println("Hej z metody domyślnej ...");
+ }
+}
+
+// Teraz stworzymy klasę, która zaimplementuje oba interfejsy.
+public class Owoc implements Jadalne, Przetrawialne {
+ @Override
+ public void jedz() {
+ // ...
+ }
+
+ @Override
+ public void przetrawiaj() {
+ // ...
+ }
+}
+
+// W Javie możesz dziedziczyć jedynie z jednej klasy, jednak implementować
+// wiele interfejsów. Na przykład:
+public class Przyklad extends Przodek implements Interfejs1,
+ Interfejs2 {
+ @Override
+ public void Interfejs1Metoda() {
+ }
+
+ @Override
+ public void Interfejs2Metoda() {
+ }
+
+}
+
+// Klasy abstrakcyjne
+
+// Składnia deklaracji klasy abstrakcyjnej
+// <dostępność> abstract class <nawa klasy abstrakcyjnej> extends
+// <superklasy, z których dziedziczy> {
+// // Zmienne i stałe
+// // Deklaracje metod
+// }
+
+// Klasy abstrakcyjne nie mogą posiadać instancji.
+// Klasy abstrakcyjne mogą definiować metody abstrakcyjne.
+// Metody abstrakcyjne nie mają ciała funkcji i są oznaczone jako abstrakcyjne.
+// Nieabstrakcyjne klasy-dzieci muszą przeciążać wszystkie abstrakcyjne metody
+// superklasy.
+// Klasy abstrakcyjne są użyteczne gdy wymagana jest powtarzalna logika działania,
+// jednak należy zaauważyć, że jako, że wymagają dziedziczenia, łamią
+// zasadę "Composition over inheritance". Rozważ inne podejścia używając
+// kompozycji. https://en.wikipedia.org/wiki/Composition_over_inheritance
+
+public abstract class Zwierze
+{
+ private int wiek;
+
+ public abstract void dajGlos();
+
+ // Metody mogą mieć ciało
+ public void jedz()
+ {
+ System.out.println("Jestem zwierzeciem i jem.");
+ // Uwaga: Możliwy jest dostęp do zmiennych prywatnych.
+ wiek = 30;
+ }
+
+ public void wyswietlWiek()
+ {
+ System.out.println(wiek);
+ }
+
+ // Klasy abstrakcyjne mogą mieć metodę główną.
+ public static void main(String[] args)
+ {
+ System.out.println("Jestem abstrakcyjna");
+ }
+}
+
+class Pies extends Zwierze
+{
+ // Musimy przeciążyć wszystkie abstrakcyjne metody z klasy abstrakcyjnej
+ @Override
+ public void dajGlos()
+ {
+ System.out.println("Hau");
+ // wiek = 30; ==> BLAD! wiek jest typu private dla Zwierze
+ }
+
+ // NOTE: Wystąpi błąd jeżeli użyto annotacji @Override jako, że Java
+ // nie pozwala na przeciążanie metod statycznych.
+ // Występuje tutaj METHOD HIDING - ukrywanie metod.
+ // Więcej w poście na SO: http://stackoverflow.com/questions/16313649/
+ public static void main(String[] args)
+ {
+ Pies pluto = new Pies();
+ pluto.dajGLos();
+ pluto.jedz();
+ pluto.wyswietlWiek();
+ }
+}
+
+// Klasy finalne
+
+// Składnia deklaracji klasy finalnej
+// <dostępność> final <nazwa klasy finalnej> {
+// // Zmienne i stałe
+// // Deklaracje Metody
+// }
+
+// Klasy finalne są klasami, które nie mogą być użyte do dziedziczenia, są więc
+// z założenia ostatnim elementem dziedziczenia. W ten sposób są przeciwnością
+// klas abstrakcyjnych, które z założenia muszą być dziedziczone.
+public final class TygrysSzablozebny extends Zwierze
+{
+ // Nadal musimy przeciążyć metody abstrakcyjne klasy abstrakcyjnej Zwierze
+ @Override
+ public void dajGlos()
+ {
+ System.out.println("Roar");
+ }
+}
+
+// Metody finalne
+public abstract class Ssak
+{
+ // Składnia metody finalnej:
+ // <dostępność> final <zwracany rodzaj> <nazwa funkcji>(<argumenty>)
+
+ // Metody finalne, jak klasy finalne nie mogą być przeciążane
+ // i są w ten sposób ostatecznymi implementacjami danej metody.
+ public final boolean jestStalocieplny()
+ {
+ return true;
+ }
+}
+
+// Enumeratory
+//
+// Enumerator jest specjalnym tyme danej, która pozwala zmiennej na bycie
+// zestawem wcześniej zdefiniowanych stałych. Zmienna musi być równa jednej z
+// wartości wcześniej zdefiniowanych. Jako, że są to stałe, nazwy pól typu enum
+// są pisane wielkimi literami. W języku Java typ enum definiujemy przez użycie
+// słowa enum. Na przykład aby zdefiniować dni tygodnia:
+public enum Dzien {
+ PONIEDZIALEK, WTOREK, SRODA, CZWARTEK,
+ PIATEK, SOBOTA, NIEDZIELA
+}
+
+// We can use our enum Day like that:
+public class EnumTest {
+ // Zmienna typu enum
+ Dzien dzien;
+
+ public EnumTest(Dzien dzien) {
+ this.dzien = dzien;
+ }
+
+ public void opiszDzien() {
+ switch (dzien) {
+ case PONIEDZIALEK:
+ System.out.println("Nie lubię poniedziałku!");
+ break;
+ case PIATEK:
+ System.out.println("Piątki są dużo lepsze.");
+ break;
+ case SOBOTA:
+ case NIEDZIELA:
+ System.out.println("Weekendy są najlepsze.");
+ break;
+ default:
+ System.out.println("Środek tygodnia jest taki sobie.");
+ break;
+ }
+ }
+
+ public static void main(String[] args) {
+ EnumTest pierwszyDzien = new EnumTest(Dzien.PONIEDZIALEK);
+ pierwszyDzien.opiszDzien(); // => Nie lubię poniedziałku!
+ EnumTest trzeciDzien = new EnumTest(Dzien.SRODA);
+ trzeciDzien.opiszDzien(); // => Środek tygodnia jest taki sobie.
+ }
+}
+
+// Typ enum jest bardziej wszechstronny niż powyższa demostracja.
+// Ciało typu enum może zawierać metody i inne pola.
+// Rzuć okiem na (angielski) https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+
+// Wprowadzenie do wyrażeń lambda
+//
+// Nowe w Javie 8 są wyrażenia lambda. Lambdy znajdujemy zwykle w funkcyjnych
+// językach programowania, co oznacza, że są metodami, które potrafią być
+// stowrzone bez klasy i przekazywane jak gdyby były obiektem oraz wykonywane
+// gdy zajdzie potrzeba.
+//
+// Ostatnia uwaga - lambdy muszą implementować funcjonalny interfejs.
+// Interfels funkcjonalny to taki, który ma jedynie jedną zadeklarowaną metodę
+// abstrakcyjną, ale może mieć dowolną ilość domyślnych metod. Wyrażenia lambda
+// mogą być używane jako instancje tego interfejsu. Każdy inteferjs, który
+// spełnia wymagania jest traktowany jako funkcjonalny. Więcej o interfejsach
+// znajdziesz powyżej, w odpowiedniej sekcji.
+//
+import java.util.Map;
+import java.util.HashMap;
+import java.util.function.*;
+import java.security.SecureRandom;
+
+public class Lambdas {
+ public static void main(String[] args) {
+ // Składnia deklaracji lambdy:
+ // <zero lub więcej parametrów> -> <ciało wyrażenia lub blok instrukcji>
+
+ // Poniżej w przykładzie użyjemy tablicy z hashowaniem.
+ Map<String, String> planety = new HashMap<>();
+ planety.put("Merkury", "87.969");
+ planety.put("Wenus", "224.7");
+ planety.put("Ziemia", "365.2564");
+ planety.put("Mars", "687");
+ planety.put("Jowisz", "4,332.59");
+ planety.put("Saturn", "10,759");
+ planety.put("Uran", "30,688.5");
+ planety.put("Neptun", "60,182");
+
+ // Lambda z zerową liczbą parametrów używając funkcjonalnego interfejsu
+ // Supplier z java.util.function.Supplier. Faktyczną lambdą jest częśc
+ // po numPlanets =.
+ Supplier<String> numPlanety = () -> Integer.toString(planety.size());
+ System.out.format("Liczba planet: %s\n\n", numPlanety.get());
+
+ // Lambda z jednym parametrem używająca funkcjonalnego interfejsu
+ // Consumer z java.util.function.Consumer.planety jest mapą, która
+ // wimplementuje Collection jak i Iterable. Użyty forEach pochodzi z
+ // Iterable i jest użyty w lambdzie na każdym elemencie kolekcji
+ // Domyślna implementacja forEach wygląda tak:
+ /*
+ for (T t : this)
+ action.accept(t);
+ */
+
+ // Faktyczna lambda jest parametrem przekazywanym do forEach.
+ planety.keySet().forEach((p) -> System.out.format("%s\n", p));
+
+ // Jeżeli przekazujemy tyklo pojedynczy argumentpowyższy zapis możemy
+ // przekształcić do (zauważ brak nawiasów dookoła p):
+ planety.keySet().forEach(p -> System.out.format("%s\n", p));
+
+ // Śledząc powyższe widzimy, że planety jest typu HashMap, a keySet()
+ // zwraca zestaw kluczy, forEach stosuje o każdego elementu lambdę:
+ // (parameter p) -> System.out.format("%s\n", p). Za każdym razem
+ // element jest uznawany jako "konsumowany" i wyrażenie (wyrażenia)
+ // w lambdzie są wykonywane. Pamiętaj, że ciało lambdy to część po
+ // symbolu ->.
+
+ // Powyższy przykład bez użycia lambdy wyglądałby tradycyjnie tak:
+ for (String planeta : planety.keySet()) {
+ System.out.format("%s\n", planeta);
+ }
+
+ // Poniższy przykład różni się od powyższego sposobem implementacji
+ // forEach: forEach użyty w klasie HashMap implementuje intefejs Map.
+ // Poniższy forEach przyjmuje BiConsumer, który ogólnie ujmując jest
+ // wymyślnym sposobem stwierdzenia, że zajmuje się zestawem par
+ // klucz-wartość Key -> Value dla każdego klucza. Ta domyślna
+ // implementacja działa jak:
+ /*
+ for (Map.Entry<K, V> entry : map.entrySet())
+ action.accept(entry.getKey(), entry.getValue());
+ */
+
+ // Faktyczna lambda jest parametrem przekazywanym do forEach.
+ String orbity = "%s okrąża Słońce w %s dni.\n";
+ planety.forEach((K, V) -> System.out.format(orbity, K, V));
+
+ // Powyższe bez użycia lambdy wyglądałoby tradycyjnie tak:
+ for (String planet : planety.keySet()) {
+ System.out.format(orbity, planet, planety.get(planet));
+ }
+
+ // Lub jeżeli postępujemy zgodnie ze specyfikacją domyślnej implementacji:
+ for (Map.Entry<String, String> planeta : planety.entrySet()) {
+ System.out.format(orbity, planeta.getKey(), planeta.getValue());
+ }
+
+ // Podane przykłady pokrywają jedynie podstawowe zastosowanie wyrażeń
+ // lambda. Być może wydają się one niezbyt przydatne, jednak należy
+ // pamiętać, że lambdy można stworzyć jako obiekty, które nastepnie mogą
+ // zostać przekazane jako parametry do innych metod.
+ }
+}
+```
+
+## Dalsze materiały
+
+Linki zamieszczone poniżej służą pomocą w zrozumieniu wybranego tematu, w razie braku rozwiązania wyszukanie w Google zwykle służy pomocą
+
+**Oficjalne poradniki Oracle po angielsku**:
+
+* [Tutorial w Javie od Sun / Oracle](https://docs.oracle.com/javase/tutorial/index.html)
+
+* [Modyfikacje poziomu dostępu w Java](https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Koncepty programowania obiektowego](https://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+ * [Dziedziczenie](https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+ * [Polimorfizm](https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+ * [Abstrakcja](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Wyjątki](https://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Interfejsy](https://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Uogólnianie](https://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Konwencja kodu Java](https://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
+
+* Nowości z Java 8:
+ * [Funkcje Lambda (programowanie funkcyjne)](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html)
+ * [Data y czas API (java.time package)](http://www.oracle.com/technetwork/articles/java/jf14-date-time-2125367.html)
+
+**Kursy po polsku**
+
+* [PJWSTK - Podstawy programowania w języku Java](http://edu.pjwstk.edu.pl/wyklady/ppj/scb/)
+
+* [PJWSTK - Programowanie obiektowe w języku Java](http://edu.pjwstk.edu.pl/wyklady/poj/scb/)
+
+**Tutoriale i ćwiczenia online po angielsku**
+
+* [Learneroo.com - Learn Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+* [Codewars - Java Katas](https://www.codewars.com/?language=java)
+
+**Książki po angielsku**:
+
+* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
+
+* [Thinking in Java](http://www.mindview.net/Books/TIJ/)
+
+* [Objects First with Java](https://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
+
+* [Java The Complete Reference](https://www.amazon.com/gp/product/0071606300)