Java translation to Polish v1

1 files changed, 1025 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..91feaf2f
--- /dev/null
+++ b/pl-pl/java-pl.html.markdown
@@ -0,0 +1,1025 @@
+---
+language: 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.predkoscUp(3); // Zawsze używaj settera i gettera jako metod
+        trek.setCadence(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 {
+           COUNTRIES.add("DANIA");
+           COUNTRIES.add("SZWECJA");
+           COUNTRIES.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 setGear(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)
+    {
+        Dog pluto = new Dog();
+        pluto.makeSound();
+        pluto.eat();
+        pluto.printAge();
+    }
+}
+
+// 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 dzielenie {
+    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(Day.PONIEDZIALEK);
+        pierwszyDzien.opiszDzien(); // => Nie lubię poniedziałku!
+        EnumTest trzeciDzien = new EnumTest(Day.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(orbits, 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(orbits, 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)