Merge pull request #1 from adambard/master

Merge from original adambard

7 files changed, 1493 insertions, 12 deletions

diff --git a/pl-pl/bf-pl.html.markdown b/pl-pl/bf-pl.html.markdown
index 801f1a9a..09c85362 100644
--- a/pl-pl/bf-pl.html.markdown
+++ b/pl-pl/bf-pl.html.markdown
@@ -1,11 +1,15 @@
 ---
+category: language
 language: bf
+filename: learnbf-pl.bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
 translators:
     - ["Jakub Młokosiewicz", "https://github.com/hckr"]
+    - ["Mateusz Burniak", "https://github.com/matbur"]
 lang: pl-pl
+
 ---
 
 Brainfuck (pisane małymi literami, za wyjątkiem początku zdania) jest bardzo 
@@ -29,9 +33,9 @@ Oto osiem poleceń brainfucka:
 . : wyświetla wartość bieżącej komórki (w formie znaku ASCII, np. 65 = 'A')
 , : wczytuje (jeden) znak z wejścia do bieżącej komórki
     (konkretnie jego numer z tabeli ASCII)
-[ : jeśli wartość w bieżącej komórce jest rózna zero, przechodzi do
+[ : jeśli wartość w bieżącej komórce jest równa zeru, przechodzi do
     odpowiadającego ]; w przeciwnym wypdaku przechodzi do następnej instrukcji
-] : Jeśli wartość w bieżącej komórce jest rózna od zera, przechodzi do
+] : Jeśli wartość w bieżącej komórce jest równa zeru, przechodzi do
     następnej instrukcji; w przeciwnym wypdaku przechodzi do odpowiadającego [
 
 [ i ] oznaczają pętlę while. Oczywiście każda pętla rozpoczęta [
diff --git a/pl-pl/haskell-pl.html.markdown b/pl-pl/haskell-pl.html.markdown
new file mode 100644
index 00000000..236b8958
--- /dev/null
+++ b/pl-pl/haskell-pl.html.markdown
@@ -0,0 +1,449 @@
+---
+category: language
+filename: haskell-pl.hs
+language: Haskell
+contributors:
+    - ["Adit Bhargava", "http://adit.io"]
+translators:
+    - ["Remigiusz Suwalski", "https://github.com/remigiusz-suwalski"]
+lang: pl-pl
+
+---
+
+Haskell został zaprojektowany jako praktyczny, czysto funkcyjny język 
+programowania. Jest znany przede wszystkim ze względu na jego monady oraz system
+typów, ale ja lubię do niego wracać przez jego elegancję. Sprawił on, że 
+programowanie jest prawdziwą przyjemnością.
+
+```haskell
+-- Komentarze jednolinijkowe zaczynają się od dwóch myślników
+{- Komentarze wielolinijkowe należy 
+zamykać w bloki klamrami.
+-}
+
+----------------------------------------------------
+-- 1. Podstawowe typy danych oraz operatory
+----------------------------------------------------
+
+-- Mamy liczby
+3 -- 3
+
+-- Podstawowe działania działają tak, jak powinny
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+35 / 5 -- 7.0
+
+-- dzielenie domyślnie zwraca ,,dokładny'' wynik
+35 / 4 -- 8.75
+
+-- dzielenie całkowitoliczbowe
+35 `div` 4 -- 8
+
+-- wartości logiczne także są podstawowym typem danych:
+True
+False
+
+-- operacje logiczne: negacja oraz porównania
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- W powyższych przykładach, `not` jest funkcją przyjmującą jeden argument.
+-- Haskell nie potrzebuje nawiasów, by wywołać funkcję: argumenty są po prostu
+-- wypisywane jeden za drugim. Ogólnie wygląda to tak:
+-- funkcja arg1 arg2 arg3...
+-- Sekcja poświęcona funkcjom zawiera informacje, jak stworzyć własne.
+
+-- Łańcuchy znaków (stringi) i pojedyncze znaki:
+"To jest lancuch."
+'a' -- znak
+'Nie mozna laczyc apostrofow z lancuchami.' -- błąd!
+
+-- Łańcuchy można sklejać
+"Hello " ++ "world!" -- "Hello world!"
+
+-- Łańcuch jest listą własnych znaków
+['H', 'e', 'l', 'l', 'o'] -- "Hello"
+"To jest lancuch" !! 0 -- 'T'
+
+----------------------------------------------------
+-- 2. Listy oraz krotki
+----------------------------------------------------
+
+-- Wszystkie elementy listy muszą być tego samego typu.
+-- Poniższe dwie listy są identyczne:
+[1, 2, 3, 4, 5]
+[1..5]
+
+-- Zakresy są uniwersalne.
+['A'..'F'] -- "ABCDEF"
+
+-- Przy tworzeniu zakresów można określić krok.
+[0,2..10] -- [0, 2, 4, 6, 8, 10]
+[5..1] -- To nie zadziała, gdyż w Haskellu zakresy tworzone są domyślnie rosnąco
+[5,4..1] -- [5, 4, 3, 2, 1]
+
+-- indeksowanie listy od zera
+[1..10] !! 3 -- 4
+
+-- Można nawet tworzyć listy nieskończone!
+[1..] -- lista wszystkich liczb naturalnych
+
+-- Nieskończone listy mają prawo działać, ponieważ Haskell cechuje się leniwym 
+-- wartościowaniem. To oznacza, że obliczane są jedynie te elementy listy, 
+-- których istotnie potrzebujemy. Możemy poprosić o tysiączny element i 
+-- dostaniemy go:
+
+[1..] !! 999 -- 1000
+
+-- Haskell wyznaczył pierwsze tysiąc elementów listy, ale cała jej reszta 
+-- jeszcze nie istnieje! Nie zostanie obliczona ich wartość, póki nie zajdzie
+-- taka potrzeba.
+
+-- łączenie dwóch list
+[1..5] ++ [6..10]
+
+-- dodawanie pojedynczego elementu na początek listy
+0:[1..5] -- [0, 1, 2, 3, 4, 5]
+
+-- więcej operacji na listach
+head [1..5] -- 1
+tail [1..5] -- [2, 3, 4, 5]
+init [1..5] -- [1, 2, 3, 4]
+last [1..5] -- 5
+
+-- list comprehensions
+[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
+
+-- z dodatkowym warunkiem
+[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10]
+
+-- każdy element krotki może być innego typu, jednak sama krotka musi być stałej 
+-- długości. Przykładowo:
+("haskell", 1)
+
+-- dostęp do elementów pary (krotki długości 2):
+fst ("haskell", 1) -- "haskell"
+snd ("haskell", 1) -- 1
+
+----------------------------------------------------
+-- 3. Funkcje
+----------------------------------------------------
+-- Prosta funkcja przyjmująca dwa argumenty
+add a b = a + b
+
+-- Pamiętaj, że podczas stosowania ghci, interpretera Haskella, wszelkie 
+-- definicje muszą zostać poprzedzone słowem `let`, na przykład:
+-- let add a b = a + b
+
+-- Używanie funkcji:
+add 1 2 -- 3
+
+-- Nazwę funkcji można podać między dwoma argumentami, ale wtedy musi zostać
+-- otoczona grawisami:
+1 `add` 2 -- 3
+
+-- Nazwa funkcji nie musi zawierać żadnych liter, przykładem czego jest 
+-- operator dzielenia:
+(//) a b = a `div` b
+35 // 4 -- 8
+
+-- Strażnicy: prosty sposób na rozbijanie funkcji na przypadki
+fib x
+  | x < 2 = 1
+  | otherwise = fib (x - 1) + fib (x - 2)
+
+-- Dopasowanie wzorca jest podobne. Haskell sam automatycznie wybierze, która
+-- z poniższych definicji fib powinna zostać użyta:
+fib 1 = 1
+fib 2 = 2
+fib x = fib (x - 1) + fib (x - 2)
+
+-- Dopasowanie z krotkami:
+foo (x, y) = (x + 1, y + 2)
+
+-- Dopasowanie z listami. Tutaj `x` jest pierwszym elementem listy, 
+-- natomiast `xs` to jej reszta (ogon). Poniższa funkcja nakłada funkcję
+-- na każdy z elementów listy:
+myMap func [] = []
+myMap func (x:xs) = func x:(myMap func xs)
+
+-- Funkcje anonimowe tworzone są przy użyciu w-tył-ciachu, po którym następują
+-- wszystkie argumenty:
+myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
+
+-- używanie zwijania z anonimowymi funkcjami: foldl1 zwija z lewej strony,
+-- przyjmując jako wartość początkową zbieracza pierwszy element listy.
+foldl1 (\acc x -> acc + x) [1..5] -- 15
+
+----------------------------------------------------
+-- 4. Więcej funkcji
+----------------------------------------------------
+
+-- częściowe nakładanie: jeśli funkcja nie otrzyma wszystkich swoich argumentów, 
+-- zostaje cześciowo nałożona - zwraca funkcję, która przyjmuje pozostałe,
+-- brakujące argumenty.
+
+add a b = a + b
+foo = add 10 -- foo jest teraz funkcją, która przyjmuje liczbę, zwiększa ją o 10
+foo 5 -- 15
+
+-- Inny sposób na zapisanie tego samego:
+foo = (10+)
+foo 5 -- 15
+
+-- składanie funkcji:
+-- operator `.` składa wiele funkcji w jedną.
+-- Dla przykładu, foo jest funkcją, która powiększa swój argument o 10, mnoży 
+-- tak uzyskaną liczbę przez 4 i zwraca wynik:
+foo = (4*) . (10+)
+
+-- 4*(10 + 5) = 60
+foo 5 -- 60
+
+-- ustalanie kolejności
+-- Haskell posiada inny operator, `$`, który nakłada funkcję do podanego
+-- parametru. W przeciwieństwie do zwykłego lewostronnie łącznego nakładania 
+-- funkcji, którego priorytet jest najwyższy (10), operator `$` posiada
+-- priorytet 0 i jest prawostronnie łączny. Tak niski priorytet oznacza, że
+-- wyrażenie po prawej traktowane jest jako parametr funkcji po lewej
+
+-- wcześniej
+even (fib 7) -- fałsz
+
+-- równoważnie
+even $ fib 7 -- fałsz
+
+-- składanie funkcji
+even . fib $ 7 -- fałsz
+
+
+----------------------------------------------------
+-- 5. Sygnatury typów
+----------------------------------------------------
+
+-- Haskell posiada wyjątkowo silny system typów, w którym każde poprawne 
+-- wyrażenie ma swój typ.
+
+-- Kilka podstawowych typów:
+5 :: Integer
+"hello" :: String
+True :: Bool
+
+-- Funkcje też są określonego typu.
+-- `not` przyjmuje wartość logiczną i taką też zwraca:
+-- not :: Bool -> Bool
+
+-- Przykład funkcji przyjmującej dwa argumenty
+-- add :: Integer -> Integer -> Integer
+
+-- Dobrą praktyką podczas definiowania wartości jest napisanie nad nią
+-- także jej typu:
+double :: Integer -> Integer
+double x = x * 2
+
+----------------------------------------------------
+-- 6. Wyrażenia warunkowe
+----------------------------------------------------
+
+-- wyrażenie warunkowe
+haskell = if 1 == 1 then "wspaniale" else "paskudnie" -- haskell = "wspaniale"
+
+-- wyrażenie warunkowe można rozbić na wiele linii, 
+-- ale trzeba uważać na wcięcia w kodzie
+haskell = if 1 == 1
+            then "wspaniale"
+            else "paskudnie"
+
+-- rozpatrywanie przypadków: oto jak można parsować argumenty z linii poleceń:
+case args of
+  "help" -> printHelp
+  "start" -> startProgram
+  _ -> putStrLn "bad args"
+
+-- Haskell zastępuje pętle (których nie ma) rekurencyjnymi wywołaniami funkcji.
+-- map aplikuje funkcję do każdego elementu listy:
+
+map (*2) [1..5] -- [2, 4, 6, 8, 10]
+
+-- możesz zdefiniować funkcję for przy użyciu map:
+for array func = map func array
+
+-- a następnie użyć jej:
+for [0..5] $ \i -> show i
+
+-- mogliśmy użyć krótszego zapisu bez zmiany działania funkcji for:
+for [0..5] show
+
+-- Do redukcji listy służy polecenie foldl (foldr):
+-- foldl <fn> <initial value> <list>
+foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
+
+-- Jest to równoważne z:
+(2 * (2 * (2 * 4 + 1) + 2) + 3)
+
+-- foldl składa od od lewej strony, foldr od prawej
+foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
+
+-- To zaś równoważne jest:
+(2 * 1 + (2 * 2 + (2 * 3 + 4)))
+
+----------------------------------------------------
+-- 7. Typy danych
+----------------------------------------------------
+
+-- Oto jak tworzy się nowe typy danych w Haskellu:
+
+data Color = Red | Blue | Green
+
+-- Teraz można używać ich we własnych funkcjach:
+
+say :: Color -> String
+say Red = "You are Red!"
+say Blue = "You are Blue!"
+say Green =  "You are Green!"
+
+-- Twoje typy danych mogą posiadać nawet parametry:
+
+data Maybe a = Nothing | Just a
+
+-- Wszystkie poniższe są typu Maybe
+Just "hello"    -- typu `Maybe String`
+Just 1          -- typu `Maybe Int`
+Nothing         -- typu `Maybe a` for any `a`
+
+----------------------------------------------------
+-- 8. Haskell IO
+----------------------------------------------------
+
+-- Chociaż obsługa wejścia i wyjścia nie może zostać wyjaśniona przez poznaniem
+-- monad, spróbujemy zrobić to częściowo
+
+-- Wykonanie programu napisanego w Haskellu wywołuje funkcję `main` 
+-- Musi zwrócić wartość typu `IO a` dla pewnego `a`. Przykład:
+
+main :: IO ()
+main = putStrLn $ "Hello, sky! " ++ (say Blue)
+-- putStrLn has type String -> IO ()
+
+-- Najłatwiej obsłużyć wejście i wyjście, kiedy program zostanie 
+-- zaimplementowany jako funkcja String -> String. Funkcja
+--    interact :: (String -> String) -> IO ()
+-- pobiera pewien tekst, wykonuje na nim operacje, po czym wypisuje wynik.
+
+countLines :: String -> String
+countLines = show . length . lines
+
+main' = interact countLines
+
+-- Możesz myśleć o wartości typu `IO ()` jako reprezentującej ciąg czynności,
+-- które komputer ma wykonać, zupełnie niczym program komputerowy w imperatywnym
+-- języku programowania. Akcje można łączyć przy użyciu notacji `do`:
+
+sayHello :: IO ()
+sayHello = do
+   putStrLn "What is your name?"
+   name <- getLine -- this gets a line and gives it the name "name"
+   putStrLn $ "Hello, " ++ name
+
+-- Ćwiczenie: napisz własną wersję `interact`, 
+-- która czyta tylko jedną linię wejścia.
+
+-- Kod w `sayHello` nigdy się nie wykona. Jedyną akcją, która zostanie 
+-- uruchomiona, jest wartość `main`.
+-- Aby uruchomić `sayHello`, należy zastąpić poprzednią definicję `main` przez
+--   main = sayHello
+
+-- Spróbujmy lepiej zrozumieć, jak działa funkcja `getLine`, której właśnie
+-- użyliśmy. Jej typem jest
+--    getLine :: IO String
+-- Możesz myśleć o wartości typu `IO a` jako reprezentującej program, który
+-- wygeneruje wartość typu `a`, poza wszystkim innym, co jeszcze zrobi.
+-- Możemy także tworzyć własne akcje typu `IO String`:
+
+action :: IO String
+action = do
+   putStrLn "This is a line. Duh"
+   input1 <- getLine
+   input2 <- getLine
+   -- The type of the `do` statement is that of its last line.
+   -- `return` is not a keyword, but merely a function
+   return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
+
+-- Możemy użyć tego tak jak używaliśmy `getLine`:
+
+main'' = do
+    putStrLn "I will echo two lines!"
+    result <- action
+    putStrLn result
+    putStrLn "This was all, folks!"
+
+-- Typ `IO` jest przykładem monady. Sposób w jakim Haskell używa monad do 
+-- obsługi wejścia i wyjścia pozwala mu być czysto funkcyjnym językiem.
+-- Każda funkcja, która wchodzi w interakcje ze światem zewnętrznym, oznaczana
+-- jest jako `IO` w jej sygnaturze typu, co umożliwia odróżnianie funkcji
+-- czystych od zależnych od świata lub modyfikujących stan.
+
+-- To naprawdę użyteczna własność, dzięki której jesteśmy w stanie uruchamiać
+-- czyste funkcje jednocześnie.
+
+----------------------------------------------------
+-- 9. Interaktywne środowisko programowania
+----------------------------------------------------
+
+-- Aby uruchomić repl (read-eval-print loop, interaktywne środowisko), należy
+-- wpisać `ghci`. Można już programować. Do definiowania nowych wartości służy
+-- słowo kluczowe `let`:
+
+let foo = 5
+
+-- Do sprawdzania typów dowolnej wartości (wyrażenia) wykorzystuje się `:t`:
+
+> :t foo
+foo :: Integer
+
+-- Działania takie jak `+`, `:` czy `$`, są funkcjami.
+-- Przed sprawdzeniem ich typu należy otoczyć je nawiasami:
+
+> :t (:)
+(:) :: a -> [a] -> [a]
+
+-- Dodatkowych informacji dostarcza `:i`:
+
+> :i (+)
+class Num a where
+  (+) :: a -> a -> a
+  ...
+    -- Defined in ‘GHC.Num’
+infixl 6 +
+
+-- Można nawet wykonywać akcje typu `IO ()`!
+
+> sayHello
+What is your name?
+Friend!
+Hello, Friend!
+
+```
+
+Pominęliśmy wiele aspektów Haskella, wliczając w to monady. To właśnie one 
+sprawiają, że programowanie w Haskellu sprawia tyle frajdy. Na zakończenie
+pokażę Tobie implementację algorytmu quicksort w Haskellu:
+
+```haskell
+qsort [] = []
+qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
+    where lesser  = filter (< p) xs
+          greater = filter (>= p) xs
+```
+
+Haskell może zostać zainstalowany na co najmniej dwa sposoby:
+ - tradycyjnie [przy użyciu Cabala](http://www.haskell.org/platform/),
+ - nowocześnie [z pomocą Stack](https://www.stackage.org/install).
+
+Godnymi poleceniami wprowadzeniami są wspaniałe
+[Learn you a Haskell](http://learnyouahaskell.com/) albo
+[Real World Haskell](http://book.realworldhaskell.org/).
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)
diff --git a/pl-pl/json-pl.html.markdown b/pl-pl/json-pl.html.markdown
index 872455de..edd059bf 100644
--- a/pl-pl/json-pl.html.markdown
+++ b/pl-pl/json-pl.html.markdown
@@ -1,6 +1,6 @@
 ---
+category: language
 language: json
-filename: learnjson-pl.json
 contributors:
   - ["Anna Harren", "https://github.com/iirelu"]
   - ["Marco Scannadinari", "https://github.com/marcoms"]
@@ -9,6 +9,7 @@ contributors:
 translators:
   - ["Michał Mitrosz", "https://github.com/Voltinus"]
 lang: pl-pl
+filename: learnjson-pl.json
 ---
 
 JSON to bardzo prosty format wymiany danych. Jak jest napisane na [json.org](http://json.org), jest łatwy do pisania i czytania dla ludzi i do parsowania i generowania dla maszyn.
diff --git a/pl-pl/perl-pl.html.markdown b/pl-pl/perl-pl.html.markdown
index 029ca006..43d68b05 100644
--- a/pl-pl/perl-pl.html.markdown
+++ b/pl-pl/perl-pl.html.markdown
@@ -2,17 +2,20 @@
 name: perl
 category: language
 language: perl
-filename: learnperl.pl
+filename: learnperl-pl.pm
 contributors:
     - ["Korjavin Ivan", "http://github.com/korjavin"]
+    - ["Dan Book", "http://github.com/Grinnz"]
+translators:
     - ["Michał Kupczyński", "http://github.com/ukoms"]
 lang: pl-pl
+
 ---
 
-Perl 5 jest wysoce użytecznym, bogatym w wiele opcji językiem programowania
+Perl jest wysoce użytecznym, bogatym w wiele opcji językiem programowania
 z ponad 25 latami nieustannego rozwoju.
 
-Perl 5 używany jest na ponad 100 różnych platformach (od przenośnych do w
+Perl używany jest na ponad 100 różnych platformach (od przenośnych do w
 pełni stacjonarnych) i nadaje się zarówno do szybkiego prototypowania jak
 i projektów deweloperskich prowadzonych na szeroką skalę.
 
diff --git a/pl-pl/python-pl.html.markdown b/pl-pl/pythonlegacy-pl.html.markdown
index 023c3e6b..2b35ce90 100644
--- a/pl-pl/python-pl.html.markdown
+++ b/pl-pl/pythonlegacy-pl.html.markdown
@@ -1,8 +1,6 @@
 ---
-name: python
-category: language
-language: python
-filename: learnpython-pl.py
+language: Python 2 (legacy)
+filename: learnpythonlegacy-pl.py
 contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
     - ["Amin Bandali", "http://aminbandali.com"]
@@ -532,7 +530,7 @@ Czlowiek.grunt()   # => "*grunt*"
 
 # Tak importuje się moduły:
 import math
-print(math.sqrt(16))  # => 4
+print(math.sqrt(16))  # => 4.0
 
 # Można podać konkretne funkcje, np. ceil, floor z modułu math
 from math import ceil, floor
diff --git a/pl-pl/vim-pl.html.markdown b/pl-pl/vim-pl.html.markdown
index 21c8c152..8ac2df56 100644
--- a/pl-pl/vim-pl.html.markdown
+++ b/pl-pl/vim-pl.html.markdown
@@ -10,7 +10,7 @@ filename: LearnVim-pl.txt
 ---
 
 
-[Vim](www.vim.org)
+[Vim](http://www.vim.org)
 (Vi IMproved) jest klonem popularnego edytora vi dla systemów Unix. 
 Zaprojektowany z myślą o prędkości edycji i zwiększeniu produktywności jest 
 wszechobecny na systemach UNIXopodobnych. Posiada wiele skrótów klawiszowych