Dodatkowe przykłady JavaSE

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/argumenty/Argumenty.java

+package alx.p01_interakcja.argumenty;
+
+/*
+Gdy uruchamiamy jakiś program w systemowym wierszu poleceń,
+możemy po jego nazwie podać dowolne napisy – argumenty programu.
+
+java alx.p01_interakcja.argumenty.Argumenty Jeden Dwa "Ala ma kota" Cztery
+*/
+
+public class Argumenty {
+	public static void main(String[] args) {
+		System.out.println("Liczba argumentów: " + args.length);
+
+		// System.out.println("Argument nr 1: " + args[1]);
+
+		for (String arg : args) {
+			System.out.println(arg);
+		}
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/konsola/A_Print.java

+package alx.p01_interakcja.konsola;
+
+import java.util.Locale;
+
+public class A_Print {
+
+    public static void main(String[] args) {
+
+        // println wypisuje coś i potem przechodzi do nast. linii
+        System.out.println("Wypisuję pierwszą linię");
+        System.out.println("Wypisuję drugą linię");
+
+        System.err.println("To jest niby błąd");
+
+        // pusty println - pusta linia
+        System.out.println();
+
+        // print - wypisuje coś i nie przechodzi do nowej linii
+        System.out.print("Ala");
+        System.out.print("Ola");
+        System.out.print("Ela");
+        System.out.println("Koniec");
+
+        int x = 50;
+        String s = "Ala";
+
+        // print, println przyjmują dowolne parametry
+        System.out.println(x);
+
+        // ale przyjmują tylko jeden parametr
+        //System.out.println("Liczba:", x);
+
+        // jeśli chcemy wypisać kilka rzeczy, to najczęściej łączy się je + . Do napisu możn a dodać także inne wartoścu (liczby, obiekty...)
+        System.out.println("Liczba: " + x);
+        System.out.println();
+
+        // W Javie dostępne jest też printf, prawie takie samo jak w C i podobnie jak % w Pythonie.
+        // Pierwszym parametrem jest wzorzec (pattern), w którym są normalne fragmenty tekstu oraz znaczniki %X,
+        // na które są wstawiane wartości podane później po przecinku.
+        // %s - string lub dowolna wartość przekonwertowana na tekst tak, jakbyśmy wypisali ją printem
+        // %d - liczba całkowita
+        // %f - liczba z ułamkiem
+        // %x - liczba szesnastkowo
+        System.out.printf("Osoba %s ma %d lat.\n", s, x);
+        double pi = Math.PI;
+        // zostaną użyte "lokale" z ustawień systemu, u mnie polskie - liczba wypisuje się z przecinkiem
+        System.out.printf("|%10s|%4d|%-4d|%04d|%6.3f|%n", s, x, x, x, pi);
+
+        // wskazuję lokale amerykańskie - liczba wypisze się z kropką
+        System.out.printf(Locale.US, "|%10s|%4d|%-4d|%04d|%6.3f|%n", s, x, x, x, pi);
+        System.out.println();
+
+        // Jeśli bardzo potrzebujemy, to na standadowe wyjście można wypisywać też dane binarne
+        System.out.write(65);
+        System.out.write(66);
+        System.out.write(67);
+        System.out.write(10);
+    }
+
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/konsola/B_SuroweWejscie1.java

+package alx.p01_interakcja.konsola;
+
+import java.io.IOException;
+
+public class B_SuroweWejscie1 {
+    public static void main(String[] args) throws IOException {
+        System.out.println("Napisz coś");
+
+        // Wczytanie jednego bajtu z wejścia - w praktyce to co odczytamy jest kodem pierwszej litery
+        int x = System.in.read();
+        System.out.println("wartość x: " + x);
+
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/konsola/B_SuroweWejscie2.java

+package alx.p01_interakcja.konsola;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+
+public class B_SuroweWejscie2 {
+    public static void main(String[] args) throws IOException {
+        System.out.println("Napisz coś");
+
+        // Można też wczytać całą porcję bajtów do tablicy
+        byte[] bajty = new byte[100];
+        int ile = System.in.read(bajty);
+
+        System.out.println("Odczytano " + ile + " bajtów.");
+        System.out.println(Arrays.toString(bajty));
+
+        // Można utworzyć napis na podstawie ciągu bajtów:
+
+        String napis = new String(bajty, 0, ile);
+        // String napis = new String(bajty, 0, ile, "utf-8");
+        System.out.println("Napisałeś: " + napis);
+
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/konsola/C_Skaner1.java

+package alx.p01_interakcja.konsola;
+
+import java.util.Scanner;
+
+public class C_Skaner1 {
+    public static void main(String[] args) {
+        // Tworzymy obiekt klasy Scanner. Ten skaner będzie czytał dane ze standardowego wejścia.
+        Scanner sc = new Scanner(System.in);
+
+        System.out.println("Napisz linię tekstu:");
+        String linia = sc.nextLine();
+        System.out.println("Napisałeś: " + linia);
+
+        System.out.println("Wpisz liczbę całkowitą:");
+        int x = sc.nextInt();
+
+        System.out.println("Wpisz liczbę z przecinkiem (!):");
+        double d = sc.nextDouble();
+
+        System.out.println("Liczby: " +x + " , " + d);
+
+        System.out.print("Wpisz dwa słowa: ");
+        String slowo1 = sc.next();
+        String slowo2 = sc.next();
+
+        System.out.println("Pierwsze: " + slowo1);
+        System.out.println("Drugie  : " + slowo2);
+
+        // Gdy teraz wczytam "linię" co tam będzie? Reszta linii wpisana za tymi dwoma słowami^
+        linia = sc.nextLine();
+        System.out.println("Linia zawiera: " + linia);
+
+        System.out.println("KONIEC");
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/konsola/C_Skaner2_LiczbaCzyNieLiczba.java

+package alx.p01_interakcja.konsola;
+
+import java.util.Scanner;
+
+public class C_Skaner2_LiczbaCzyNieLiczba {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+
+		System.out.println("Napisz coś:");
+		
+		if(sc.hasNextInt()) {
+			int liczba = sc.nextInt();
+			System.out.println("Wpisałeś int: " + liczba);
+		} else if(sc.hasNextDouble()) {
+			double liczba = sc.nextDouble();
+			System.out.println("Wpisałeś double: " + liczba);
+		} else {
+			String slowo = sc.next();
+			System.out.println("Wpisałeś tekst: " + slowo);
+		}
+		String reszta = sc.nextLine();
+		System.out.println("Reszta linii: " + reszta);
+		System.out.println("Reszta miała znaków: " + reszta.length());
+		
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/konsola/D_BufRead.java

+package alx.p01_interakcja.konsola;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+// Aby czytać wejście linia po linii, można uzyć klas Scanner (inny przykład) lub BufferedReader (tutaj).
+// Pośrednio potrzebna jest klasa InputStreamReader.
+
+// Gdybyśmy chcieli podać własne kodowane znaków (inne niż systemowe), to wtedy:
+// InputStreamReader isr = new InputStreamReader(System.in, "utf-8");
+
+public class D_BufRead {
+	public static void main(String[] args) {
+		try {
+			InputStreamReader isr = new InputStreamReader(System.in);
+			BufferedReader br = new BufferedReader(isr);
+			String wiersz;
+			while((wiersz = br.readLine()) != null) {
+				System.out.println("Napisałeś "+wiersz);
+				if("koniec".equals(wiersz))
+					break;
+			}
+			
+			System.out.println("KONIEC");
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/konsola/E_KlasaConsole.java

+package alx.p01_interakcja.konsola;
+
+import java.io.Console;
+import java.util.Arrays;
+
+public class E_KlasaConsole {
+
+	public static void main(String[] args) {
+		System.out.println("Początek (stdout)");
+		
+		Console konsola = System.console();
+		System.out.println("System.console() = " + konsola);
+		
+		if(konsola == null) return;
+		
+		String wiersz;
+		while((wiersz = konsola.readLine("> ")) != null) {
+			
+			konsola.printf("Napisałeś %s %n", wiersz);
+			if("koniec".equals(wiersz))
+				break;
+		}
+		
+		System.out.println("KONIEC");
+		
+		char[] hasło = konsola.readPassword("Podaj tajne hasło: ");
+		konsola.printf("Hasło ma długość %d %n", hasło.length);
+
+		// "zamazuję" hasło w pamięci, żeby inne programy nie mogły go odczytać
+		Arrays.fill(hasło, 'X');
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/konsola/Zakupy1.java

+package alx.p01_interakcja.konsola;
+
+/* Napisz program, który symuluje zakup jednego towaru.
+   Program pyta: Co chcesz kupić
+   Użytkownik odpowiada np.: telewizor
+   Program pyta: Ile kosztuje jedna sztuka telewizor?
+   Użytkownik odpowiada np.: 2600
+   Program pyta: Ile sztuk telewizor chcesz kupić?
+   Użytkownik odpowiada np.: 2
+   Program wypisuje: Za 2 sztuki towaru telewizor zapłacisz 5200 zł
+ */
+
+import java.util.Scanner;
+
+public class Zakupy1 {
+
+    // Cenę należy wprowadzić z przecinkiem (jeśli ustawienia językowe komputera to polski)
+    // Gdy println wypisuje wynik, wypisuje zawsze z kropką.
+
+    // Scanner i printf biorą pod uwagę ustawienia regionalne
+    // println nie bierze pod uwagę ustawień regionalnych
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        System.out.print("Co chcesz kupić? ");
+        String towar = sc.nextLine();
+        System.out.print("Ile kosztuje jedna sztuka? ");
+        double cena = sc.nextDouble();
+        System.out.print("Ile sztuk chcesz kupić? ");
+        int sztuk = sc.nextInt();
+
+        double suma = sztuk * cena;
+        System.out.println("Za " + sztuk + " sztuk towaru " + towar + " do zapłaty: " + suma);
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/konsola/Zakupy2.java

+package alx.p01_interakcja.konsola;
+
+import java.util.Scanner;
+
+public class Zakupy2 {
+
+    // W tej wersji wypisuję teksty za pomocą printf
+    // Czyli tu i wejście i wyjście działają z przecinkiem.
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        System.out.printf("Co chcesz kupić? ");
+        String towar = sc.nextLine();
+        System.out.printf("Ile kosztuje jedna sztuka towaru %s? ", towar);
+        double cena = sc.nextDouble();
+        System.out.printf("Ile sztuk towaru %s chcesz kupić? ", towar);
+        int sztuk = sc.nextInt();
+
+        double suma = sztuk * cena;
+        System.out.printf("Za %d sztuk towaru %s zapłacisz %.2f zł\n", sztuk, towar, suma);
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/konsola/Zakupy3.java

+package alx.p01_interakcja.konsola;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class Zakupy3 {
+
+    // W tej wersji na poziomie aplikacji przełączam locale na amerykańskie. Zarówno podczas wczytywania danych, jak i wypisywania printf, będą używane kropki
+
+    public static void main(String[] args) {
+        // jeszcze przed utworzeniem Scannera
+        Locale.setDefault(Locale.US);
+
+        Scanner sc = new Scanner(System.in);
+        System.out.printf("Co chcesz kupić? ");
+        String towar = sc.nextLine();
+        System.out.printf("Ile kosztuje jedna sztuka towaru %s? ", towar);
+        double cena = sc.nextDouble();
+        System.out.printf("Ile sztuk towaru %s chcesz kupić? ", towar);
+        int sztuk = sc.nextInt();
+
+        double suma = sztuk * cena;
+        System.out.printf("Za %d sztuk towaru %s zapłacisz %.2f zł\n", sztuk, towar, suma);
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/konsola/Zakupy4.java

+package alx.p01_interakcja.konsola;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class Zakupy4 {
+
+    // W tej wersji Locale zmieniam osobno dla Scannera, osobno dla printf. Nie zmieniam globalnych Locali aplikacji.
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        sc.useLocale(Locale.US);
+        System.out.printf("Co chcesz kupić? ");
+        String towar = sc.nextLine();
+        System.out.printf("Ile kosztuje jedna sztuka towaru %s? ", towar);
+        double cena = sc.nextDouble();
+        System.out.printf("Ile sztuk towaru %s chcesz kupić? ", towar);
+        int sztuk = sc.nextInt();
+
+        double suma = sztuk * cena;
+        // wersja z kropką:
+        System.out.printf(Locale.US, "Za %d sztuk towaru %s zapłacisz %.2f zł\n", sztuk, towar, suma);
+
+        // wersja z przecinkiem:
+        System.out.printf("Za %d sztuk towaru %s zapłacisz %.2f zł\n", sztuk, towar, suma);
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/konsola/Zakupy5.java

+package alx.p01_interakcja.konsola;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.Locale;
+import java.util.Scanner;
+
+public class Zakupy5 {
+
+    // W tej wersji zamiast double używamy BigDecimal, aby w pełni precyzyjnie liczyć pieniądze
+
+    public static void main(String[] args) {
+        Locale.setDefault(Locale.US);
+        // Locale.setDefault(new Locale("pl", "PL"));
+
+        Scanner sc = new Scanner(System.in);
+        System.out.printf("Co chcesz kupić? ");
+        String towar = sc.nextLine();
+        System.out.printf("Ile kosztuje jedna sztuka towaru %s? ", towar);
+        BigDecimal cena = sc.nextBigDecimal();
+        System.out.printf("Ile sztuk towaru %s chcesz kupić? ", towar);
+        BigDecimal sztuk = sc.nextBigDecimal();
+
+        // obliczenie z pełną precyzją - moze wyjść więcej liczb po przecinku
+        // BigDecimal suma = cena.multiply(sztuk);
+
+        // zaokrąglenie po wykonaniu mnożenia
+        BigDecimal suma = cena.multiply(sztuk).setScale(2, RoundingMode.HALF_UP);
+        System.out.printf("Za %d sztuk towaru %s zapłacisz %.2f zł\n", sztuk, towar, suma);
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/okna/OknoDialogowe1.java

+package alx.p01_interakcja.okna;
+
+import javax.swing.JOptionPane;
+
+/* Jednym ze sposobów komunikacji z użytkownikiem są okna dialogowe.
+   W Javie są one łatwe w użyciu (łatwiejsze niż pełnowartościowe aplikacje okienkowe),
+   korzysta się poprzez klasę JOptionPane.
+   Najważniejsze są trzy rodzaje okien dialogowych:
+   * showMessageDialog - tylko komunikat
+   * showInputDialog - pytanie i mozliwośc podania tekstowej odpowiedzi
+   * showConfirmDialog - pytanie i odpowiedź Yes/No/Cancel
+*/
+
+public class OknoDialogowe1 {
+
+	public static void main(String[] args) {
+		String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+		JOptionPane.showMessageDialog(null, "Witaj " + imie);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/okna/OknoDialogowe2.java

+package alx.p01_interakcja.okna;
+
+import javax.swing.JOptionPane;
+
+public class OknoDialogowe2 {
+
+	public static void main(String[] args) {
+		String imie = JOptionPane.showInputDialog("Jak masz na imię?");		
+		String wiekTekstowo = JOptionPane.showInputDialog("Ile masz lat, " + imie + "?");
+
+		int wiek = Integer.parseInt(wiekTekstowo);
+		
+		if(wiek >= 18) {
+			JOptionPane.showMessageDialog(null, "Witaj " + imie
+					+ ", możesz kupić piwo :)");
+		} else {
+			JOptionPane.showMessageDialog(null, "Witaj " + imie
+					+ ", dla niepełnoletnich tylko cukierki...");
+		}
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/okna/OknoDialogowe3.java

+package alx.p01_interakcja.okna;
+
+import java.awt.HeadlessException;
+
+import javax.swing.JOptionPane;
+
+public class OknoDialogowe3 {
+
+	public static void main(String[] args) {
+		
+		try {
+			String imie = JOptionPane.showInputDialog("Jak masz na imię?");		
+			String wiekTekstowo = JOptionPane.showInputDialog("Ile masz lat, " + imie + "?");
+			
+			int wiek = Integer.parseInt(wiekTekstowo);
+			
+			if(wiek >= 18) {
+				JOptionPane.showMessageDialog(null, "Witaj " + imie
+						+ ", możesz kupić piwo :)");
+			} else {
+				JOptionPane.showMessageDialog(null, "Witaj " + imie
+						+ ", dla niepełnoletnich tylko cukierki...");
+			}
+		
+		} catch(HeadlessException e) {
+			System.out.println("Brak interfejsu graficznego - nie pogadamy...");
+		} catch(NumberFormatException e) {
+			JOptionPane.showMessageDialog(null,
+					"Nieprawidłowy format liczby", "Błąd", JOptionPane.ERROR_MESSAGE);
+		} catch(Exception e) {
+			JOptionPane.showMessageDialog(null,
+					"Inny błąd " + e, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/okna/RodzajeOkien.java

+package alx.p01_interakcja.okna;
+
+import java.time.LocalDateTime;
+
+import javax.swing.JOptionPane;
+
+public class RodzajeOkien {
+
+	public static void main(String[] args) {
+		JOptionPane.showMessageDialog(null, "To jest zwykły MessageDialog");
+		JOptionPane.showMessageDialog(null, "To jest MessageDialog typu WARNING", "Uwaga", JOptionPane.WARNING_MESSAGE);
+		// są też inne typy: PLAIN_MESSAGE, INFORMATION_MESSAGE, QUESTION_MESSAGE, WARNING_MESSAGE, ERROR_MESSAGE
+
+		String cos = JOptionPane.showInputDialog("To jest inputDialog.\nNapisz coś:");
+		String data = JOptionPane.showInputDialog("To jest inputDialog z początkową wartością.", LocalDateTime.now());
+		
+		int wybor = JOptionPane.showConfirmDialog(null, "Czy chcesz " + cos + " o godzinie " + data +"?");
+		switch(wybor) {
+		case JOptionPane.YES_OPTION: JOptionPane.showMessageDialog(null, "TAK"); break;
+		case JOptionPane.NO_OPTION: JOptionPane.showMessageDialog(null, "NO"); break;
+		case JOptionPane.CANCEL_OPTION: JOptionPane.showMessageDialog(null, "Cancel"); break;
+		}
+		
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/okna/Rozmowa1.java

+package alx.p01_interakcja.okna;
+
+import javax.swing.*;
+
+public class Rozmowa1 {
+    public static void main(String[] args) {
+        String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+        JOptionPane.showMessageDialog(null, "Witaj " + imie);
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/okna/Rozmowa2.java

+package alx.p01_interakcja.okna;
+
+import javax.swing.*;
+
+public class Rozmowa2 {
+    public static void main(String[] args) {
+        String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+        JOptionPane.showMessageDialog(null, "Witaj " + imie);
+
+        // TODO zapytaj o wiek i na podstawie tej informacji napisz czy osoba jest pełnoletnia czy nie
+
+        String wiekTekstowo = JOptionPane.showInputDialog("Ile masz lat?");
+        int wiek = Integer.parseInt(wiekTekstowo);
+
+        if(wiek >= 18) {
+            JOptionPane.showMessageDialog(null, "Jesteś osobą pełnoletnią, możesz kupić piwo");
+        } else {
+            JOptionPane.showMessageDialog(null, "Jesteś osobą niepełnoletnią, nie możesz kupić piwa");
+        }
+
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/okna/Rozmowa3.java

+package alx.p01_interakcja.okna;
+
+import javax.swing.*;
+
+public class Rozmowa3 {
+    public static void main(String[] args) {
+        String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+        JOptionPane.showMessageDialog(null, "Witaj " + imie);
+
+        int wiek = Integer.parseInt(JOptionPane.showInputDialog("Ile masz lat?"));
+
+        if(wiek >= 18) {
+            JOptionPane.showMessageDialog(null, "Jesteś osobą pełnoletnią, możesz kupić piwo");
+        } else {
+            JOptionPane.showMessageDialog(null, "Jesteś osobą niepełnoletnią, nie możesz kupić piwa");
+        }
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/okna/Zakupy1_Int.java

+package alx.p01_interakcja.okna;
+
+import javax.swing.JOptionPane;
+
+/*
+Używając JOptionPane napisz taki program.
+Niech program:
+- pyta "Co chcesz kupić?"
+
+- pyta "Ile kosztuje jedna sztuka?"
+
+- pyta "Ile sztuk chcesz kupić?"
+
+- oblicza co trzeba i wypiuje przykładowo:
+"Za 3 sztuk towaru długopis zapłacisz 15 zł"
+*/
+public class Zakupy1_Int {
+
+	public static void main(String[] args) {
+		String towar = JOptionPane.showInputDialog("Co chcesz kupić?");
+		int cena = Integer.parseInt(JOptionPane.showInputDialog("Ile kosztuje jedna sztuka?"));		
+		int ilosc = Integer.parseInt(JOptionPane.showInputDialog("Ile sztuk chcesz kupić?"));		
+		
+		int doZaplaty = cena*ilosc;
+		JOptionPane.showMessageDialog(null,
+				"Za " + ilosc + " sztuk towaru " + towar + " zapłacisz " + doZaplaty + " zł");
+		
+		
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/okna/Zakupy2_Double.java

+package alx.p01_interakcja.okna;
+
+import javax.swing.JOptionPane;
+
+/*
+Używając JOptionPane napisz taki program.
+Niech program:
+- pyta "Co chcesz kupić?"
+
+- pyta "Ile kosztuje jedna sztuka?"
+
+- pyta "Ile sztuk chcesz kupić?"
+
+- oblicza co trzeba i wypiuje przykładowo:
+"Za 3 sztuk towaru długopis zapłacisz 15 zł"
+*/
+public class Zakupy2_Double {
+
+	public static void main(String[] args) {
+		String towar = JOptionPane.showInputDialog("Co chcesz kupić?");
+		double cena = Double.parseDouble(JOptionPane.showInputDialog("Ile kosztuje jedna sztuka?"));		
+		double ilosc = Double.parseDouble(JOptionPane.showInputDialog("Ile sztuk chcesz kupić?"));		
+		
+		double doZaplaty = cena*ilosc;
+		JOptionPane.showMessageDialog(null,
+				"Za " + ilosc + " sztuk towaru " + towar + " zapłacisz " + doZaplaty + " zł");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p01_interakcja/okna/Zakupy3_BigDecimal.java

+package alx.p01_interakcja.okna;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import javax.swing.JOptionPane;
+
+public class Zakupy3_BigDecimal {
+
+	public static void main(String[] args) {
+		String towar = JOptionPane.showInputDialog("Co chcesz kupić?");
+		BigDecimal cena = new BigDecimal(JOptionPane.showInputDialog("Ile kosztuje jedna sztuka?"));		
+		BigDecimal ilosc = new BigDecimal(JOptionPane.showInputDialog("Ile sztuk chcesz kupić?"));		
+		
+		BigDecimal doZaplaty = cena.multiply(ilosc).setScale(2, RoundingMode.HALF_UP);
+		JOptionPane.showMessageDialog(null,
+			"Za " + ilosc + " sztuk towaru " + towar + " zapłacisz " + doZaplaty + " zł");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p02_zmienne/Inicjalizacja.java

+package alx.p02_zmienne;
+
+public class Inicjalizacja {
+	// zmienne statyczne - inicjowane domyślnie na 0, false lub null
+	static int st;
+	
+	// zmienne instancyjne - inicjowane domyślnie na 0, false lub null
+	int inst;
+
+	public static void main(String[] args) {
+		// zmienne lokalne - nie są automatyczne inicjowane
+		int lokalna;
+		
+		System.out.println(st); // 0
+		//NK System.out.println(inst);
+
+		Inicjalizacja obiekt = new Inicjalizacja();
+		System.out.println(obiekt.inst); // 0
+
+		// błąd kompilacji - aby odczytać zmienną lokalną, musi zostać wcześniej zainicjalizowana (w taki sposób, żeby kompilator miał pewność)
+		//NK System.out.println(lokalna);
+		
+		if(st >= 0) {
+			lokalna = 13;
+			System.out.println(lokalna); // OK
+		}
+		//NK System.out.println(lokalna);
+
+		if(st >= 0) {
+			lokalna = 10;
+		} else {
+			lokalna = 20;			
+		}
+		System.out.println(lokalna); // OK
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p02_zmienne/Nazwy.java

+package alx.p02_zmienne;
+
+public class Nazwy {
+
+	public static void main(String[] args) {
+		// Nazwa nie może zaczynać się od cyfry
+		//NK String 1rstElement = "pierwszy";
+		
+		// Nazwa może zaczynać się od litery, znaku _ lub znaku $
+		String abc123 = "abc123";
+		String _123 = "qwerty";
+		String $123 = "qwertz";
+		
+		// wielkość liter ma znaczenie, to są dwie różne zmienne
+		int x = 10, X = 20;
+		
+		System.out.println(x);
+		System.out.println(X);
+		
+		// Można używać liter z różnych alfabetów
+		int żółć = 333;
+		System.out.println(żółć);
+
+		String 李 = "李";
+		System.out.println(李);
+		
+		int $a, a; // to są różne zmienne
+		
+		int $ = 444, $3 = 33, __ = 44;
+		System.out.println($);
+		System.out.println($3);
+		System.out.println(__);
+		
+// Nazwami nie mogą być słowa kluczowe ani pojedynczy znak podkreślenia
+		
+		// String int = "pomyłka";
+		String var = "okej, nawet w Javie 11";
+		
+//		String _ = "aaa";
+//		System.out.println(_);
+		
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p02_zmienne/PolaFinal.java

+package alx.p02_zmienne;
+
+public class PolaFinal {
+	// pola które są final muszą być jawnie zainicjalizowane
+	// albo w tym miejscu, albo w bloku inicjalizacyjnym, albo w konstruktorze
+	final int numer;
+	
+	public PolaFinal() {
+		numer = 0;
+	}
+
+	public PolaFinal(int nr) {
+		numer = nr;
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p02_zmienne/SlowoVar.txt

+package alx.p02_zmienne;
+
+import java.time.LocalTime;
+
+public class SlowoVar {
+
+	public static void main(String[] args) {
+		// Przykład kompiluje się od Javy 10.
+		
+		// Deklaracja zmiennej lokalnej bez podawania typu.
+		// Kompilator domyśla się typu na podstawie tego, co wpisujemy
+		var y = 100;
+		System.out.println(y);
+		y = 101; // OK
+		System.out.println(y);
+
+		// Zmienna ma jednak typ int i nie wolno wpisać wartości niezgodnego typu
+		// y = 3.14; // źle
+		// y = "Ala ma kota"; // źle
+		// System.out.println(y);
+
+		// Konstrukcja dostępna tylka dla zmiennych lokalnych, gdy początkową wartość wpisuje się od razu w miejscu deklaracji.
+		// var z;
+
+		// var nie jest słowem kluczowym i w niekolidujących miejscach można go używać jako nazwy:
+		String var = "tajemnicza zmienna";
+		System.out.println(var);
+		
+		// BTW, odpowiednikiem takich zmiennych jak w Pythonie i PHP, na które można wpisać "wszystko",
+		// w Javie jest raczej zmienna typu Object.
+		
+		Object o;
+		o = "Ala ma kota";
+		System.out.println(o.getClass().getSimpleName() + " : " + o);
+
+		o = 100 + 15;
+		System.out.println(o.getClass().getSimpleName() + " : " + o);
+		
+		o = LocalTime.now();
+		System.out.println(o.getClass().getSimpleName() + " : " + o);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p02_zmienne/Typy.java

+package alx.p02_zmienne;
+
+import java.time.LocalDate;
+
+public class Typy {
+
+    public static void main(String[] args) {
+   	 // Typy dzielą się na dwie kategorie:
+   	 // 1) typy proste
+   	 byte b = 15;
+   	 short s = 1000;
+   	 int i = 100000;
+   	 long l1 = 10, l2 = 5000000000L;
+   	 
+   	 float f = 3.14F;
+   	 double d = 3.14;
+   	 
+   	 // char to pojedynczy znak, ale jednocześnie może być traktowany jak liczba z zakresu 0-64k
+   	 char znak = 'A';
+   	 
+   	 boolean falsz = false, prawda = true, niewiem = d > 3.0;
+   	 
+   	 // typów byte i short nie opłaca sie używać, chyba że w dużych tablicach
+   	 
+   	 
+   	 // 2) typy obiektowe
+   	 Object o = new Object();
+   	 System.out.println(o);
+   	 
+   	 // klasa String - napisy
+   	 String imie = "Ala";
+   	 
+   	 // platforma Java SE definiuje ok 4 tys. klas
+   	 LocalDate data = LocalDate.now();
+   	 System.out.println(data);
+   	 System.out.println(data.getDayOfMonth());
+   	 System.out.println(data.getDayOfYear());
+   	 System.out.println();
+   	 
+   	 // programiści mogą tworzyć własne klasy
+   	 
+   	 
+   	 // w Javie również tablice są obiektami:
+   	 int[] liczby = {1,2,3,4};
+   	 System.out.println(liczby.length);
+   	 
+   	 System.out.println(liczby[1]); // 2
+   	 
+   	 // więcej na temat klas i obiektów - na trzecich zajęciach
+
+    }
+
+}
+
+

PC22-PrzetwarzanieDanych/src/alx/p02_zmienne/Zasieg1.java

+package alx.p02_zmienne;
+
+public class Zasieg1 {
+	static int x;
+
+	public static void main(String[] args) {
+		System.out.println("A: " + x);
+		x = 100;
+		System.out.println("B: " + x);
+		
+		int x = 500;
+		System.out.println("C: " + x);
+		metoda();
+		System.out.println("I: " + x);
+		
+	}
+	
+	static void metoda() {
+		// w tym miejscu nie widać lokalnych zmiennych z innych metod (np. main)
+		// a widać zmienne z poziomu klasy ("globalne")
+		System.out.println("D: " + x);
+		
+		if(x > 0) {
+			String x = "700";
+			System.out.println("E: " + x);
+		}
+		
+		System.out.println("F: " + x);
+		
+		{
+			// wolno przesłaniać zmienne klasowe za pomocą zmiennych lokalnych
+			int x = 300;
+			System.out.println("G: " + x);
+			if(true) {
+				// nie wolno przesłaniać zmiennych lokalnych
+				//NK int x = 400;	
+				// System.out.println("H: " + x);
+			}
+		}
+		
+		System.out.println("K: " + x);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p02_zmienne/Zmienne1.java

+package alx.p02_zmienne;
+
+public class Zmienne1 {
+
+	public static void main(String[] args) {
+		System.out.println("Początek programu");
+		
+		// Aby użyć zmiennej, trzeba ją zadeklarować.
+		//NK x = 15;
+		//NK System.out.println(x);
+		
+		// Deklaracja zmiennej:
+		String txt;
+		int x, innaZmienna;
+		
+		// Zmienne lokalne (czyli deklarowane wewnątrz metod)
+		// nie są automatycznie inicjowane na żadną wartość.
+		// Niezainicjowanych zmiennych lokalnych nie wolno odczytywać (błąd kompilacji).
+
+		//NK System.out.println(txt);
+		//NK System.out.println(x);
+		//NK x = 2 * x;
+		//NK x += 5;
+
+		// Instrukcja przypisania (assignment)
+		txt = "Ala";
+		x = 25;
+		
+		System.out.println(x); // OK
+		System.out.println(txt); // OK
+		x *= 2; // OK
+		
+		// ponowne przypisanie = zmiana wartości zmiennej
+		
+		txt = "Ola";
+		x = x+1;
+		System.out.println(x);
+		
+		// Zazwyczaj wartość zmiennej podaje się od razu w miejscu deklaracji (deklaracja z inicjalizacją):
+		int y = 100, z = 200;
+		String miasto = "Warszawa";
+		
+		System.out.println(y + z);
+		System.out.println(miasto);
+
+		// Typowe podejście Javy:
+		// Zmienne lokalne deklaruje się dopiero kiedy są potrzebne
+		// i od razu podaje się ich początkową wartość.
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p02_zmienne/Zmienne2.java

+package alx.p02_zmienne;
+
+public class Zmienne2 {
+
+	public static void main(String[] args) {
+		int x, y;
+		
+		x = 20;
+		System.out.println(x);
+		if(x > 10) {
+			y = 300;
+			System.out.println(y);
+		}
+
+		// kompilator widzi, ze "y może nie być zainicjowany"
+		// bo "nie wie" czy program wszedł do if-a
+		//NK System.out.println(y);
+		
+		if(x > 20) {
+			y = 1000;
+		} else {
+			y = 2000;
+		}
+		
+		System.out.println(y);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p02_zmienne/Zmienne3.java

+package alx.p02_zmienne;
+
+//NK int globalna;
+
+public class Zmienne3 {
+	// zmienna statyczna - istnieje jeden egzemplarz w pamięci
+	static int statyczna = 10;
+	
+	// zmienna instancyjna (inaczej: pole, atrybut) należy do obiektu
+	// Każdy obiekt tej klasy, w której jesteśmy, będzie posiadał taką zmienną
+	int instancyjna = 20;
+	
+
+	public static void main(String[] args) {
+		// zmienna lokalna, czyli deklarowana w obrębie metody
+		int lokalna = 30;
+		
+		metodaStatyczna(40);
+		
+		// metody instancyjnej nie da się wywołać w kontekście statycznym (np. w main)
+		// metodaInstancyjna(50);
+		
+		// Trzeba utworzyć obiekt i wywołać tę metodę na obiekcie.
+		// Tworzę obiekt, czyli "instancję"
+		Zmienne3 obiekt = new Zmienne3();
+		obiekt.metodaInstancyjna(50);
+		
+		System.out.println(statyczna);
+		System.out.println(obiekt.instancyjna);
+		
+		Zmienne3 innyObiekt = new Zmienne3();
+		innyObiekt.instancyjna = 123;
+		innyObiekt.metodaInstancyjna(33);
+	}
+	
+	
+	static void metodaStatyczna(int parametr) {
+		int lokalna = 60;
+		
+		System.out.println("metodaStatyczna:");
+		System.out.println("statyczna: " + statyczna);
+		// m "kontekście statycznym", czyli w metodzie statycznej nie ma dostępu do zmiennych instancyjnych,
+		// bo "nie wiemy w jakim obiekcie"
+		//NK System.out.println("instancyjna: " + instancyjna);
+		System.out.println("lokalna: " + lokalna);
+		System.out.println("parametr: " + parametr);
+		System.out.println();
+	}
+	
+	void metodaInstancyjna(int parametr) {
+		int lokalna = 70;
+
+		System.out.println("metodaInstancyjna:");
+		System.out.println("statyczna: " + statyczna);
+		System.out.println("instancyjna: " + instancyjna);
+		System.out.println("lokalna: " + lokalna);
+		System.out.println("parametr: " + parametr);
+		System.out.println();
+	}
+	
+	
+
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/BreakContinue_Prezentacja.java

+package alx.p03_instrukcje;
+
+import javax.swing.JOptionPane;
+
+public class BreakContinue_Prezentacja {
+
+	public static void main(String[] args) {
+		int licznik = 0;
+		
+		while(true) {
+			licznik++;
+			JOptionPane.showInternalMessageDialog(null, "Początek pętli, licznik = " + licznik);
+			int odp1 = JOptionPane.showConfirmDialog(null, "Czy zrobić break?");
+			if(odp1 == JOptionPane.YES_OPTION) {
+				break;
+				// break w pętli powoduje natychmiastowe zakończenie tej pętli i przejście do następnej instrukcji za pętlą
+			}
+			JOptionPane.showInternalMessageDialog(null, "Środek pętli. Nie było break.");
+
+			int odp2 = JOptionPane.showConfirmDialog(null, "Czy zrobić continue?");
+			if(odp2 == JOptionPane.YES_OPTION) {
+				continue;
+				// continue powoduje pominięcie reszty instrukcji w bieżącym obrocie pętli
+				// i przejście od razu na początek następnego obrotu
+			}
+			JOptionPane.showInternalMessageDialog(null, "Koniec pętli, nie było break ani continue");
+		}
+
+		JOptionPane.showInternalMessageDialog(null, "Koniec programu");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/DziwnyWhile.java

+package alx.p03_instrukcje;
+
+public class DziwnyWhile {
+
+	public static void main(String[] args) {
+		
+		int x = 1;
+		{
+			System.out.println("Ala ma kota " + x);
+			x++;
+		} while(x <= 10);
+		// To jest zwykły blok a potem pętla nieskończona
+		
+		System.out.println("Koniec");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/Label.java

+package alx.p03_instrukcje;
+
+public class Label {
+	public static void main(String[] args) {
+		label1: System.out.println("Cokolwiek");
+		label2:
+		while(true) {
+			double x = Math.random();
+			if(x > 0.5)
+				break label2;
+		}
+	
+		// goto label1;
+		// const int n = 10;
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/MartwyKod.java

+package alx.p03_instrukcje;
+
+public class MartwyKod {
+	
+	void metoda1() {
+		System.out.println("OK");
+		return;
+//		System.out.println("błąd");
+//		System.out.println("kolejna linia");
+	}
+	
+	void metoda2() throws Exception {
+		System.out.println("OK");
+		throw new Exception("katastrofa");
+//		System.out.println("błąd");
+		
+	}
+
+	public static void main(String[] args) {
+		// if(true) / if(false) NIE są traktowane jako martwy kod
+		if(false) {
+			System.out.println("Ala ma kota");
+		}
+		
+		if(true) {
+			System.out.println("AAAA");
+		} else {
+			System.out.println("BBBB");
+		}
+		
+		
+//		while(false) {
+//			System.out.println("błąd");
+//		}
+		
+		while(true) {
+			System.out.println("lkdfjg");
+		}
+		
+//		System.out.println("błąd");
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/PetlaNieskonczona.java

+package alx.p03_instrukcje;
+
+import java.time.LocalTime;
+
+public class PetlaNieskonczona {
+
+	public static void main(String[] args) {
+		int licznik = 0;
+		
+		while(true) {
+			System.out.printf("%12d : %s%n", ++licznik, LocalTime.now());
+		}
+		
+		// Kod w tym miejscu jest niepoprawny (Java go nie skompiluje), bo to jest "martwy kod".
+		// System.out.println("Koniec świata");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/Petle.java

+package alx.p03_instrukcje;
+
+public class Petle {
+
+	public static void petlaWhile() {
+		int i = 1;
+		while (i <= 5) {
+			System.out.println("w pętli: " + i);
+			i++;
+		}
+		System.out.println("za pętlą: " + i);
+	}
+
+	public static void doWhile() {
+		int i = 1;
+		do {
+			System.out.println("w pętli: " + i);
+			i++;
+		} while (i <= 5);
+		System.out.println("za pętlą: " + i);
+	}
+
+	// ominięte w main
+	public static void petlaFor() {
+		for (int i = 1; i <= 5; i++) {
+			System.out.println("w pętli " + i);
+		}
+
+		// NK System.out.println("za pętlą: " + i);
+		int i; // OK
+	}
+
+
+	public static void petlaFor2() {
+		int i;
+
+		for (i = 1; i <= 5; i++) {
+			System.out.println("w pętli " + i);
+		}
+
+		System.out.println("za pętlą: " + i); // 6
+		// NK int i;
+	}
+
+	// ominięte w main
+	public static void petlaFor3() {
+		// int i;
+
+		for (int i = 1, j = 10; i <= 5 && j < 3; i++, j = i / 10, System.out.println("z pętli " + j)) {
+			System.out.println("w pętli " + i);
+		}
+
+		// System.out.println("za pętlą: " + i);
+	}
+
+	// ominięte w main
+	// w for moga byc dowolne instrukcje
+	public static void petlaFor4(org.w3c.dom.Node node) {
+		for (org.w3c.dom.Node child = node.getFirstChild(); child != null; child = child.getNextSibling()) {
+			System.out.println(child.getTextContent());
+		}
+	}
+
+	public static void losowanie() {
+		for (;;) {
+			double x = Math.random();
+			System.out.println("Wylosowałem " + x);
+			if (x > 0.8)
+				break;
+		}
+		System.out.println("za pętlą");
+	}
+
+	public static void forEach() {
+		String[] imiona = { "Ala", "Ola", "Ela", "Ula" };
+		
+		// pozwala przeglądać zawartość tablicy, albo obiekty, które są Iterable 
+		// tzw. "for-each" albo "enhanced for loop", od Javy 5
+		for(String imie : imiona) {
+			System.out.println("Kolejna osoba to " + imie);
+		}
+
+		// Od Javy 10 można tak:
+//		for(var imie : imiona) {
+//			System.out.println("Kolejna osoba to " + imie);
+//		}
+	}
+	
+	public static void forEachEgzamin() {
+		// typowa zmyłka z egzaminu
+		int[] t = {1,2,3};
+		for (int i : t) {
+			// i oznacza WARTOŚĆ z tablicy, a nie indeks
+			// więc tu dojdzie do wyjścia poza zakres tablicy
+			System.out.println(t[i]);
+		}
+	}
+
+	public static void przerwanie() {
+		for (int i = 1; i <= 10; i++) {
+			System.out.println("i = " + i);
+			if (i % 2 == 1) {
+				System.out.println("  nieparzysta, continue");
+				continue;
+			}
+			System.out.println("  nie było continue");
+			if (i % 3 == 0) {
+				System.out.println("  podzielna przed 3, break");
+				break;
+			}
+			System.out.println("  nie było break");
+		}
+		System.out.println("za pętlą");
+	}
+
+	public static int etykiety() {
+		int suma = 0;
+		duza:
+		while(true) {
+			for(int i = 1; i < 10; i++) {
+				suma += i;
+				if (suma > 100)
+					break duza;
+			}
+		}
+		return suma;
+	}
+
+	public static void main(String[] args) {
+		etykieta:  // kompiluje się, ale nie ma jak tego użyć
+		System.out.println("while");
+		petlaWhile();
+		
+		//NK goto etykieta;
+
+		System.out.println("\ndo-while");
+		doWhile();
+
+		System.out.println("\nfor");
+		petlaFor2();
+
+		System.out.println("\nLosowanie:");
+		losowanie();
+
+		System.out.println("\nfor-each");
+		forEach();
+
+		System.out.println();
+		przerwanie();
+
+		System.out.println();
+
+		int x = etykiety();
+		System.out.println(x);
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/Przerwania.java

+package alx.p03_instrukcje;
+
+public class Przerwania {
+	static void tabliczka(int n) {
+		for (int i = 1; i <= n; i++) {
+			for (int j = 1; j <= n; j++) {
+				System.out.printf("%3d", i * j);
+
+				System.out.print(",");
+			}
+			System.out.println("#");
+		}
+		System.out.println("\n----------------\n");
+	}
+
+	static void tabliczkaBreak(int n) {
+		for (int i = 1; i <= n; i++) {
+			for (int j = 1; j <= n; j++) {
+				System.out.printf("%3d", i * j);
+				if (i + j > n)
+					break;
+				System.out.print(",");
+			}
+			System.out.println("#");
+		}
+		System.out.println("\n----------------\n");
+	}
+
+	static void tabliczkaBreakEtykieta(int n) {
+		pierwsza:
+		for (int i = 1; i <= n; i++) {
+			for (int j = 1; j <= n; j++) {
+				System.out.printf("%3d", i * j);
+				if (i + j > n)
+					break pierwsza;
+				System.out.print(",");
+			}
+			System.out.println("#");
+		}
+		System.out.println("\n----------------\n");
+	}
+
+	static void tabliczkaContinue(int n) {
+		for (int i = 1; i <= n; i++) {
+			for (int j = 1; j <= n; j++) {
+				System.out.printf("%3d", i * j);
+				if (i + j > n)
+					continue;
+				System.out.print(",");
+			}
+			System.out.println("#");
+		}
+		System.out.println("\n----------------\n");
+	}
+
+	static void tabliczkaContinueEtykieta(int n) {
+		pierwsza:
+		for (int i = 1; i <= n; i++) {
+			System.out.println(); // dodane
+			for (int j = 1; j <= n; j++) {
+				System.out.printf("%3d", i * j);
+				if (i + j > n)
+					continue pierwsza;
+				System.out.print(",");
+			}
+			System.out.println("#");
+		}
+		System.out.println("\n----------------\n");
+	}
+
+	public static void main(String[] args) {
+		tabliczka(9);
+		tabliczkaBreak(9);
+		tabliczkaBreakEtykieta(9);
+		tabliczkaContinue(9);
+		tabliczkaContinueEtykieta(9);
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/Switch1.java

+package alx.p03_instrukcje;
+
+import javax.swing.JOptionPane;
+
+public class Switch1 {
+
+	public static void main(String[] args) {
+		String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
+		int numer = Integer.parseInt(tekst);
+		
+		switch (numer) {
+		case 1:
+			System.out.println("poniedziałek");
+		case 2:
+			System.out.println("wtorek");
+		case 3:
+			System.out.println("środa");
+		case 4:
+			System.out.println("czwartek");
+		case 5:
+			System.out.println("piątek");
+			System.out.println("czyli weekendu początek");
+		case 6:
+			System.out.println("sobota");
+		case 7:
+			System.out.println("niedziela");
+		default:
+			System.out.println("niepoprawny numer dnia tygodnia");
+		}
+
+		System.out.println("Koniec programu");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/Switch2.java

+package alx.p03_instrukcje;
+
+import javax.swing.JOptionPane;
+
+public class Switch2 {
+
+	public static void main(String[] args) {
+		String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
+		int numer = Integer.parseInt(tekst);
+		
+		switch (numer) {
+		case 1:
+			System.out.println("poniedziałek");
+			break;
+		case 2:
+			System.out.println("wtorek");
+			break;
+		case 3:
+			System.out.println("środa");
+			break;
+		case 4:
+			System.out.println("czwartek");
+			break;
+		case 5:
+			System.out.println("piątek");
+			System.out.println("czyli weekendu początek");
+			break;
+		case 6:
+			System.out.println("sobota");
+			break;
+		case 7:
+			System.out.println("niedziela");
+			break;
+		default:
+			System.out.println("niepoprawny numer dnia tygodnia");
+		}
+
+		System.out.println("Koniec programu");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/Switch3.java

+package alx.p03_instrukcje;
+
+import java.util.Random;
+
+import javax.swing.JOptionPane;
+
+public class Switch3 {
+
+	public static void main(String[] args) {
+		String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
+		int numer = Integer.parseInt(tekst);
+
+		final int SOBOTA = 6; // stała
+		// final int SOBOTA = new Random().nextInt(10);
+		
+		switch (numer) {
+		case 3:
+			System.out.println("środa");
+			break;
+		case 1:
+			System.out.println("poniedziałek");
+			break;
+		case 2:
+			System.out.println("wtorek");
+			break;
+		default:
+			System.out.println("niepoprawny numer dnia tygodnia");
+			break;
+		case 4:
+			System.out.println("czwartek");
+			break;
+		case 2+3:
+			System.out.println("piątek");
+			break;
+		case SOBOTA:
+			System.out.println("sobota");
+			// tu nie ma break i wypisze się sobota niedziela
+		case 7:
+			System.out.println("niedziela");
+		}
+
+		System.out.println("Koniec programu");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/Switch4.java

+package alx.p03_instrukcje;
+
+import javax.swing.JOptionPane;
+
+public class Switch4 {
+
+    static String nazwaDniaTygodnia(int numer) {
+        switch (numer) {
+        case 1: return "poniedziałek";
+        case 2: return "wtorek";
+        case 3: return "środa";
+        case 4: return "czwartek";
+        case 5: return "piątek";
+        case 6: return "sobota";
+        case 7: return "niedziela";
+        default:
+            throw new IllegalArgumentException("Niepoprawny numer dnia tygodnia");
+        }
+    }
+
+    public static void main(String[] args) {
+        String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
+
+        try {
+            int numer = Integer.parseInt(tekst);
+			String nazwa = nazwaDniaTygodnia(numer);
+			System.out.println("Ten dzień to " + nazwa);
+		} catch (Exception wylapanyWyjatek) {
+			System.out.println("Wystąpił wyjątek " + wylapanyWyjatek);
+		}
+        
+        System.out.println("Koniec programu");
+    }
+
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/Switch5.java

+package alx.p03_instrukcje;
+
+public class Switch5 {
+	
+	static int ileDniMaMiesiac(String nazwa) {
+		switch(nazwa) {
+		case "styczeń" :
+		case "marzec" :
+		case "maj" :
+		case "lipiec" :
+		case "sierpień" :
+		case "październik" :
+		case "grudzień" :
+			return 31;
+		
+		case "kwiecień":
+		case "czerwiec":
+		case "wrzesień":
+		case "listopad":
+			return 30;
+			
+		case "luty":
+			return 28;
+
+//		case null się nie skompiluje
+//		case null:
+//			return 0;
+		
+		default: return 0;
+		}
+	}
+
+	public static void main(String[] args) {
+		System.out.println(ileDniMaMiesiac("styczeń"));
+		System.out.println(ileDniMaMiesiac("luty"));
+		System.out.println(ileDniMaMiesiac("listopad"));
+		System.out.println();
+		
+		// takie bajery nie działają:
+		System.out.println(ileDniMaMiesiac("Lipiec"));
+		System.out.println(ileDniMaMiesiac(" lipiec "));
+		System.out.println(ileDniMaMiesiac("*ec"));
+		System.out.println(ileDniMaMiesiac("%ec"));
+		
+		
+		System.out.println(ileDniMaMiesiac(""));
+		System.out.println(ileDniMaMiesiac(null)); // NPE
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/Switch6.java

+package alx.p03_instrukcje;
+
+public class Switch6 {
+
+	public static void main(String[] args) {
+		byte bb = 100;
+		// Wartości podawane w case muszą być zgodne z typem parametru switch-a.
+		// W przypadku liczb oznacza to także, że liczba musi mieścić się w zakresie,
+		switch(bb) {
+		case 100: System.out.println("100"); break;
+		//NK case 200: System.out.println("200"); break;
+		}
+
+		short ss = 100;
+		switch(ss) {
+		case 100: System.out.println("100"); break;
+		case 200: System.out.println("200"); break;
+		case 4000: System.out.println("4000"); break;
+		//NK case 33000: System.out.println("100"); break;
+		}
+
+		char cc = 'A';
+		switch(cc) {
+		case 'A' : System.out.println("AAA"); break;
+		case 120 : System.out.println("BBB"); break;
+//		case 10 : System.out.println("10"); break;
+		case 0xA : System.out.println("0xA"); break;
+		//NK case 65 : System.out.println("CCC"); break;
+		//NK case -1 : System.out.println("DDD"); break;
+		case 64000: System.out.println("EEE"); break;
+		//NK case 66000: System.out.println("FFF"); break;
+		}
+		
+		/*
+		long l = 27L;
+		// nie ma switch na typach long, float, double
+		switch(l) {
+		case 27L : System.out.println("long 27");
+		}
+		*/
+		
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/Switch8.java

+package alx.p03_instrukcje;
+
+public class Switch8 {
+
+	public static void main(String[] args) {
+		int x = 2;
+		
+		switch(x) {
+		// to jest po prostu operacja arytmetyczna (dokładnie "suma bitowa")
+		// nie ma to żadnego szczególnego znaczenia dla switch-a
+		// w tym konkretnym miejscu to wylicza się do wartości 3
+		case 2 | 3:
+			System.out.println("2 | 3");
+			break;
+//NK		case 3:
+//			System.out.println("3");
+		case 2: // bo to nie jest naruszenie unikalności
+			System.out.println("2");
+			break;
+		default:
+			System.out.println("default");
+		}
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/SwitchNull_Pusty.java

+package alx.p03_instrukcje;
+
+import javax.swing.JOptionPane;
+
+public class SwitchNull_Pusty {
+
+	public static void main(String[] args) {
+		String s = JOptionPane.showInputDialog("Wpisz napis");
+		System.out.println("Jestem przed switchem, napis = " + s);
+		switch(s) {
+		}
+		
+		System.out.println("Jestem za switchem");
+		// morał: przekazanie wartości null do switcha (na napisach lub na enumach)
+		// skutkuje wyjątkiem NPE
+		
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/SwitchString_Interaktywnie.java

+package alx.p03_instrukcje;
+
+import javax.swing.JOptionPane;
+
+public class SwitchString_Interaktywnie {
+
+	public static void main(String[] args) {
+		String s = JOptionPane.showInputDialog("Wpisz napis");
+		System.out.println("Jestem przed switchem, napis = " + s);
+		
+		// Wielkość liter, spacje itp.: mają znaczenie.
+		// Nie są przeprowadzane żadne "normalizacje".
+		// Nie działają żadne "wildcardy" typu * % itp.
+		
+		// Jeśli do switch przekażemy wartość null dojdzie d wyjątku NullPointerException
+		switch(s) {
+			case "Ala": System.out.println("Ala ma kota"); break;
+			case "Ola": System.out.println("Ola ma psa"); break;
+			//NK case null: System.out.println("NULL");
+			default: System.out.println("Nieznana osoba");
+		}
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p03_instrukcje/Warunki.java

+package alx.p03_instrukcje;
+
+import javax.swing.JOptionPane;
+
+public class Warunki {
+	public static void main(String[] args) {
+		String tekst = JOptionPane.showInputDialog("Podaj liczbę");
+		int liczba = Integer.parseInt(tekst);
+
+		if (liczba % 2 == 0) {
+			System.out.println("Liczba jest parzysta");
+		}
+		// nie ma else
+
+		System.out.println("To się zawsze wypisze");
+
+		if (liczba > 0) {
+			System.out.println("Liczba dodatnia");
+		} else {
+			System.out.println("Liczba nie jest dodatnia");
+			System.out.println("Czyli jest ujemna albo równa zero");
+		}
+
+		System.out.println("To się zawsze wypisze");
+
+		// Taki ciąg if / else if ... / else
+		// daje gwarację, że wykona się dokładnie jedna z gałęzi kodu
+		if (liczba > 1000) {
+			System.out.println("Liczba bardzo duża");
+		} else if (liczba > 100) {
+			System.out.println("Liczba duża");
+		} else if (liczba > 10) {
+			System.out.println("Liczba mała");
+		} else {
+			System.out.println("Liczba bardzo mała");
+		}
+
+		// nie muszę pisać klamerek jeśli jest pojedyncza instrukcja
+		if (liczba == 5)
+			System.out.println("To jest pięć");
+		else
+			System.out.println("To nie jest pięć");
+			System.out.println("i jeszcze to"); // ta instrukcja wykona się zawsze, bo ona nie należy do else
+
+		
+		// średnik za if-em (analogicznie: za else, while, for)
+		// oznacza pustą instrukcję: jeśli liczba == 0, nie rób nic
+		// AAAAAA wypisze się zawsze
+		if(liczba == 0); {
+			System.out.println("AAAAAA");
+		}
+		
+		// BBBBBB wypisze się gdy liczba nie jest równa 1
+		if(liczba == 1);
+		else System.out.println("BBBBB");
+			
+		// W Javie nie ma automatycznej konwersji liczb (ani innych rzeczy) na boolean
+//		if(liczba) {
+//			System.out.println("Nie zero");
+//		}
+//
+//		if(liczba = 0) {
+//			System.out.println("Nie zero");
+//		}
+
+		String str = "Ala ma kota";
+		if(str.isEmpty()) {
+			System.out.println("puste");
+		}
+
+		boolean logika = liczba > 100 && liczba % 3 == 0;
+		if (logika) {
+			System.out.println("Dziwny warunek jest prawdą");
+		} else {
+			System.out.println("Nieprawda");
+		}
+		
+		if(logika = false) {
+			System.out.println("Bzdura");  //nigdy się nie wypisze
+		}
+		System.out.println(logika); // zawsze będzie false, bo powyższy "if" tak naprawdę wpisuje wartośc false na zmienną, a nie sprawdza warunku
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/Bitowe1.java

+package alx.p04_operatory;
+
+public class Bitowe1 {
+
+	public static void main(String[] args) {
+		byte x = 25;
+		byte y = -25;
+		byte shift = 2;
+		
+		System.out.printf("x = %d  y = %d %n", x, y);
+		System.out.println("Bez przycinania (w zakresie int):");
+		System.out.printf("x << %d = %d %n", shift, x << shift);
+		System.out.printf("y << %d = %d %n", shift, y << shift);
+		System.out.printf("x >> %d = %d %n", shift, x >> shift);
+		System.out.printf("y >> %d = %d %n", shift, y >> shift);
+		System.out.printf("x >>> %d = %d %n", shift, x >>> shift);
+		System.out.printf("y >>> %d = %d %n", shift, y >>> shift);
+		System.out.println();
+		System.out.println("Przycięte do byte: ");
+		System.out.printf("x << %d = %d %n", shift, (byte)(x << shift));
+		System.out.printf("y << %d = %d %n", shift, (byte)(y << shift));
+		System.out.printf("x >> %d = %d %n", shift, (byte)(x >> shift));
+		System.out.printf("y >> %d = %d %n", shift, (byte)(y >> shift));
+		System.out.printf("x >>> %d = %d %n", shift, (byte)(x >>> shift));
+		System.out.printf("y >>> %d = %d %n", shift, (byte)(y >>> shift));
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/Bitowe2.java

+package alx.p04_operatory;
+
+public class Bitowe2 {
+
+	public static void main(String[] args) {
+		int x = 0b00000000000000000000000000011001;
+		int y = -x;
+		int z = 0b11111111111111111111111111100111;
+		System.out.println(x);
+		System.out.println(y);
+		System.out.println(z);
+		System.out.println();
+
+		System.out.println("<<");
+		System.out.println(x << 2);
+		System.out.println(y << 2);
+		System.out.println(z << 2);
+		System.out.println(0b11111111111111111111111110011100);  // -100
+		System.out.println();
+
+		System.out.println(">>");
+		System.out.println(x >> 2);
+		System.out.println(y >> 2);
+		System.out.println(0b11111111111111111111111111111001);
+		System.out.println();
+
+		System.out.println(">>>");
+		System.out.println(x >>> 2);
+		System.out.println(y >>> 2);
+		System.out.println(0b00111111111111111111111111111001);
+		System.out.println();
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/Leniwosc1.java

+package alx.p04_operatory;
+
+public class Leniwosc1 {
+	public static void gorliwa() {
+		// opertor "gorliwy"
+		// zawsze oblicza obie strony wyrażenia logicznego, a dopiero potem daje wynik false / true
+		if(lewy() & prawy()) {
+			System.out.println("prawda");
+		} else {
+			System.out.println("fałsz");
+		}
+	}
+
+	public static void leniwa() {
+		// operator "leniwy"
+		// jeśli lewa strona rozstrzyga o ostatecznym wyniku, to prawa strona nie jest sprawdzana
+		if(lewy() && prawy()) {
+			System.out.println("prawda");
+		} else {
+			System.out.println("fałsz");
+		}
+	}
+
+	private static boolean lewy() {
+		System.out.print("lewy ");
+		return false;
+	}
+
+	private static boolean prawy() {
+		System.out.print("prawy ");
+		return true;
+	}
+
+	public static void main(String[] args) {
+		System.out.println("wersja gorliwa");
+		gorliwa();
+		
+		System.out.println("\nwersja leniwa:");
+		leniwa();
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/Leniwosc2.java

+package alx.p04_operatory;
+
+public class Leniwosc2 {
+	public static void main(String[] args) {
+		int x = 0, y = 0;
+		
+		if(++x > 0 | y++ > 0) {
+			System.out.println("prawda");
+		} else {
+			System.out.println("fałsz");
+		}
+		System.out.println("x == " + x);
+		System.out.println("y == " + y);
+		System.out.println();
+
+		x = y = 0;
+		if(++x > 0 || y++ > 0) {
+			System.out.println("prawda");
+		} else {
+			System.out.println("fałsz");
+		}
+		System.out.println("x == " + x);
+		System.out.println("y == " + y);
+		System.out.println();
+
+		x = y = 0;
+		if(x++ > 0 || ++y > 0) {
+			System.out.println("prawda");
+		} else {
+			System.out.println("fałsz");
+		}
+		System.out.println("x == " + x);
+		System.out.println("y == " + y);
+
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/Leniwosc3.java

+package alx.p04_operatory;
+
+public class Leniwosc3 {
+	public static void main(String[] args) {
+		int x = 0, y = 0;
+		
+		if(x++ > 0 || y++ > 0) {
+			System.out.println("prawda");
+		} else {
+			System.out.println("fałsz");
+		}
+		System.out.println("x == " + x);
+		System.out.println("y == " + y);
+		System.out.println();
+
+		x = y = 0;
+		if(++x > 0 || ++y > 0) {
+			System.out.println("prawda");
+		} else {
+			System.out.println("fałsz");
+		}
+		System.out.println("x == " + x);
+		System.out.println("y == " + y);
+
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/Leniwosc4.java

+package alx.p04_operatory;
+
+public class Leniwosc4 {
+	public static void main(String[] args) {
+		// z prawdopodobieństwem 0.33 na imie wpisz nulla
+		// z prawdopodobieństwem 0.33 na imie wpisz "Ala"
+		// z prawdopodobieństwem 0.34 na imie wpisz "Tadeusz"
+		double los = Math.random();
+		String imie;
+		if(los < 0.33) {
+			imie = null;
+		} else if(los < 0.66) {
+			imie = "Ala";
+		} else {
+			imie = "Tadeusz";
+		}
+		
+		System.out.println("imie = " + imie);
+		
+//		if(imie != null & imie.length() >= 5) {
+//			System.out.println("długie imię");
+//		} else {
+//			System.out.println("null albo krótkie imię");
+//		}
+
+		// jeśli imie będzie null, to w ogóle nie przejdziemy do drugiej części sprawdzenia
+		if(imie != null && imie.length() >= 5) {
+			System.out.println("długie imię");
+		} else {
+			System.out.println("null albo krótkie imię");
+		}
+		
+		if(imie == null || imie.isEmpty()) {
+			System.out.println("Brak danych");
+		}
+
+		if(args.length >= 1 && "Ala".equalsIgnoreCase(args[0])) {
+			System.out.println("Ala ma kota");
+		}
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/Logiczne.java

+package alx.p04_operatory;
+
+import java.util.Random;
+
+public class Logiczne {
+
+	public static void main(String[] args) {
+		Random random = new Random();
+		int x = random.nextInt(1000);
+		int y = random.nextInt(1000);
+		System.out.println("Wylosowane liczby: " + x + " , " + y);
+		
+		// koniunkcja, logiczne "i"
+		// alternatywa, logiczne "lub"
+		if(x > 500 && y > 500) {
+			System.out.println("Obie liczby > 500");
+		} else {
+			System.out.println("Któraś z liczb <= 500");
+		}
+
+		if(x > 500 || y > 500) {
+			System.out.println("Co najmniej jedna z liczb > 500");
+		} else {
+			System.out.println("Obie liczby <= 500");
+		}
+		
+		// alternatywa rozłączna, "albo", technicznie "xor" (exclusive or)
+		if((x > 500) ^ (y > 500)) {
+			System.out.println("Dokładnie jedna z liczb > 500");
+		} else {
+			System.out.println("Obie liczby są > 500 albo obie liczby są <= 500");
+		}
+		
+		// ! negacja
+		if(!(x % 3 == 0)) {
+			System.out.println("Nieprawda, że liczba jest podzielna przez 3");
+		}
+		
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/OperatorWarunkowy1.java

+package alx.p04_operatory;
+
+public class OperatorWarunkowy1 {
+
+	public static void main(String[] args) {
+		int x = 10;
+
+		String s;
+		s = x > 10 ? "A" : "B";
+		System.out.println(s);
+		
+		// różwnoważne:
+		if(x > 10) {
+			s = "A";
+		} else {
+			s = "B";
+		}
+		
+		s = x > 10 ? "A" : x > 5 ? "B" : "C";
+		System.out.println(s);
+		s = x > 10 ? "A" : (x > 5 ? "B" : "C");
+		System.out.println(s);
+
+		s = x > 8 ? x < 20 ? "A" : "B" : " C";
+		System.out.println(s);
+
+		s = x > 8 ? (x < 20 ? "A" : "B") : " C";
+		System.out.println(s);
+
+		s = x > 8 ? x < 20 ? "A" : "B" : x % 2 == 0 ? "C" : " D";
+		System.out.println(s);
+		s = x > 8 ? (x < 20 ? "A" : "B") : (x % 2 == 0 ? "C" : " D");
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/OperatorWarunkowy2.java

+package alx.p04_operatory;
+
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class OperatorWarunkowy2 {
+
+	public static void main(String[] args) {
+		int[] liczby = {100, 10, 20, 150, 7, 120};
+		String wynik = IntStream.of(liczby)
+				.mapToObj(a -> a >= 100 ? "duże" : "małe")
+				.collect(Collectors.joining("; "));
+		System.out.println(wynik);
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/OperatorWarunkowy3.java

+package alx.p04_operatory;
+
+public class OperatorWarunkowy3 {
+
+	public static void main(String[] args) {
+		// ilustracja zastosowań:
+		String s = Math.random() > 0.5 ? "ala" : null;
+		
+		if(s != null && s.length() > 2) {
+			System.out.println("ok");
+		} else {
+			System.out.println("puste");
+		}
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/PlusPlus.java

+package alx.p04_operatory;
+
+public class PlusPlus {
+
+	public static void main(String[] args) {
+		int x;
+		int y;
+		
+		x = 10;
+		y = ++x;
+		System.out.println("++x    preinkrementacja");
+		System.out.println("x: " + x + "    ,    y: " + y);
+		System.out.println();
+
+		
+		x = 20;
+		y = x++;
+		System.out.println("x++    postinkrementacja");
+		System.out.println("x: " + x + "    ,    y: " + y);
+		System.out.println();
+		
+		x = 50;
+		System.out.println(x++);
+		System.out.println(++x);
+		System.out.println();
+		
+		Integer a = 100;
+		a++;
+		System.out.println(a); // a wskazuje już na inny obiekt
+		System.out.println();
+		
+		double d = 0.5;
+		System.out.println(d);
+		d++; // można inkrementować też float i double
+		System.out.println(d);
+		System.out.println();
+		
+		y = x = 100;
+		System.out.println("x: " + x + "    ,    y: " + y);
+
+		y = 33;
+		y = x += 5; // x zwiększam o 5, a to co wyjdzie, wpisuję także na y
+		System.out.println(" += 5");
+		System.out.println("x: " + x + "    ,    y: " + y);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/PlusPlus_Zastosowania.java

+package alx.p04_operatory;
+
+public class PlusPlus_Zastosowania {
+	
+	static int suma(int[] t) {
+		int suma = 0;
+		int i = 0;
+		while(i < t.length) {
+			suma += t[i++];
+		}
+		return suma;
+	}
+
+	public static void main(String[] args) {
+		int[] a = {10, 20, 30, 40};
+		System.out.println(suma(a));
+
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/Przypisania.java

+package alx.p04_operatory;
+
+public class Przypisania {
+
+	public static void main(String[] args) {
+		int x, y, z;
+		
+		z = y = x = 10;
+		System.out.printf("x=%d, y=%d, z=%d%n", x, y, z);
+		
+		x = 10;
+		y = 50;
+		z = 100;
+		z += y = x += 3;
+		System.out.printf("x=%d, y=%d, z=%d%n", x, y, z);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/ZagadkiPlusPlus.java

+package alx.p04_operatory;
+
+public class ZagadkiPlusPlus {
+
+	public static void main(String[] args) {
+		int x, y, z;
+
+		x = 1;
+		x = x++ + ++x; // 1 + 3
+		System.out.println(x);
+		
+		x = 1;
+		x = ++x + x++; // 2 + 2
+		System.out.println(x);
+		
+		y = 1;
+		y += y++;
+		// y = (y + y++)
+		// y = 1 + 1
+		System.out.println(y);
+
+		z = 1;
+		z += z++ + ++z;
+		// z = z + z++ + ++z
+		// z = 1 + 1 + 3 = 5
+		System.out.println(z);
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p04_operatory/ZastosowaniaLeniwychOperatorow.java

+package alx.p04_operatory;
+
+import javax.swing.JOptionPane;
+
+public class ZastosowaniaLeniwychOperatorow {
+
+	public static void main(String[] args) {
+		String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+
+		if(imie != null && imie.length() <= 3) {
+			JOptionPane.showMessageDialog(null, "Masz krótkie imię");
+		}
+
+		// Gdybym nie sprawdzał czy napis nie jest nullem,
+		// to w przypadku Cancel dochodziłoby do błedu NullPointerException (NPE)
+		// w momencie próby wywołania length()
+//		if (imie.length() <= 3) {
+//			JOptionPane.showMessageDialog(null, "Masz krótkie imię");
+//		}
+		
+		// Gdybym zamiast "leniwego" && użył "gorliwego" &
+		// to także doszłoby do błędu, bo Java sprawdzałaby prawą stronę warunku nawet wtedy gdy lewa jest fałszem
+//		if(imie != null & imie.length() <= 3) {
+//			JOptionPane.showMessageDialog(null, "Masz krótkie imię");
+//		}
+		
+		String jezyk = JOptionPane.showInputDialog("Jaki jest Twój ulubiony język programowania?");
+		
+		if(jezyk != null && jezyk.equals("Java")) {
+			JOptionPane.showMessageDialog(null, "Brawo");
+		} else {
+			JOptionPane.showMessageDialog(null, "Źle");
+		}
+		
+		// jeśli chodzi o tę konkretną sytuację, to pisząc w tej kolejności zapobiegamy wyjątkowi NPE
+		if("Java".equals(jezyk)) {
+			JOptionPane.showMessageDialog(null, "Brawo");
+		} else {
+			JOptionPane.showMessageDialog(null, "Źle");
+		}
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/BityIBajty.java

+package alx.p05_liczby;
+
+public class BityIBajty {
+
+	public static void main(String[] args) {
+		System.out.println("Zwiększanie bajta:");
+		byte b = 0;
+		for (int i = 1; i <= 260; i++) {
+			String bity = Integer.toBinaryString(Byte.toUnsignedInt(b));
+			bity = String.format("%8s", bity);
+			bity = bity.replace(' ', '0');
+			
+			System.out.printf("%4d  :  %s%n", b, bity);
+			b++;
+		}
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/Ciekawostki.java

+package alx.p05_liczby;
+
+public class Ciekawostki {
+
+	public static void main(String[] args) {
+		int x = 5, y = 1000000000;
+		int z = x * y;
+		System.out.println(z);
+		System.out.println(5 * 1000000000);
+		System.out.println(5L * 1000000000);
+		System.out.println(3 * 1000000000);
+		
+		// Gdy wynik obliczenia nie mieści się w zakresie dla danego typu (int lub long)
+		// dochodzi do "integer overflow". W Javie nie powoduje to błędu (w sensie wyjątku),
+		// po prostu wychodzi "przekręcony" wynik.
+		
+		System.out.println();
+		
+		double a = 3.0, b = 1.2;
+		System.out.println(a * b);
+		System.out.println(3 * 1.2);
+		
+		double oczekiwany = 3.6;
+		if(a*b == oczekiwany ) {
+			System.out.println("OK");
+		} else {
+			System.out.println("Nie OK");
+			System.out.println(3.6 - 3 * 1.2);
+		}
+		
+		System.out.println();
+		// Liczby zmiennoprzecinkowe (w Javie: float i double) działają w przybliżeniu.
+		// W pamięci są zapisany w systemie dwójkowym, a nie dziesiętnym, więc zaokrąglenia nastepują w zapisie binarnym liczby, co utrudnia zrozumienie.
+		
+		// Praktyczny morał: double nie używa się do liczenia pieniędzy.
+		// Lepszą alternatywą jest wyspecjalizowana klasa BigDecimal.
+		
+		// Liczba całkowita zapisana w kodzie zaczynając od cyfry 0, jest w systemie ósemkowym.
+		int n = 0321; // = 3*64 + 2*8 + 1*1
+		System.out.println(n);
+		System.out.println(0321);
+		//NK int m = 098;
+		
+		System.out.println();
+		
+		// Od Javy 7 między cyframi można wpisywać znaki _ , które nie zmieniają wartości
+		int i = 123_456_789;
+		System.out.println(i);
+		
+		int j = 123____4___5;
+		System.out.println(j);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/Dzielenie.java

+package alx.p05_liczby;
+
+public class Dzielenie {
+
+	public static void main(String[] args) {
+		double d = 1.25;
+		
+		int n = 5;
+		
+		// Uwaga na kolejność działań gdy miesza się inty i double
+		// Tutaj: int dzielony porzez int - wynik obcinany do liczby całkowitej
+		System.out.println(n / 3 * d);
+		
+		 // dzielenie na doublach
+		System.out.println(n * d / 3);
+		System.out.println(1.0 * n / 3 * d);
+		System.out.println((double)n / 3 * d);
+		System.out.println();
+		
+		System.out.println("Dzielenie całkowite i reszta z dzielenia:");
+		for(int i = -10; i <= 10; i++) {
+			System.out.printf("%3d / 3 = %2d      %3d %% 3 = %2d\n", i, i / 3, i, i % 3);
+		}
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/Floaty.java

+package alx.p05_liczby;
+ 
+public class Floaty {
+ 
+    public static void main(String[] args) {
+        float f = 1.0000001f;
+        
+        System.out.println(f);
+        f += 1;
+        System.out.println(f);
+        f -= 1;
+        System.out.println(f);
+        System.out.println();
+ 
+        // Zaokroglęnia nie są robione w systemie dziesiętnym, tylko dwójkowym
+        f = 1.0000003f;
+        System.out.println(f);
+        f += 1;
+        System.out.println(f);
+        f -= 1;
+        System.out.println(f);
+
+        System.out.println();
+        f = 2222222222f;
+        // System.out.println(f);
+        System.out.printf("%8.0f\n", f);
+        f += 1000;
+        System.out.printf("%8.0f\n", f);
+        f -= 10000000;
+        System.out.printf("%8.0f\n", f);
+        
+        // lepsze dla pieniędzy: BigDecimal
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/IntegerOverflow.java

+package alx.p05_liczby;
+
+public class IntegerOverflow {
+
+	public static void main(String[] args) {
+		System.out.println(2 * 1000_000_000);
+		System.out.println(3 * 1000_000_000);
+		System.out.println(5 * 1000_000_000);
+		System.out.println(3L * 1000_000_000);
+		System.out.println();
+
+        int x = 2147483646;
+
+        System.out.println(x);
+        x++;
+        System.out.println(x);
+        x++;
+        System.out.println(x);
+        x++;
+        System.out.println(x);
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/JakSprawdzicOverflow.java

+package alx.p05_liczby;
+
+import java.util.Scanner;
+
+public class JakSprawdzicOverflow {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Podaj pierwszą liczbę: ");
+		int x = sc.nextInt();
+		System.out.println("Podaj drugą liczbę: ");
+		int y = sc.nextInt();
+		
+		int iloczyn = x * y;
+		System.out.println("Wynik zwykłego mnożenia: " + iloczyn);
+
+		try {
+			int sprawdzony = Math.multiplyExact(x, y);
+			System.out.println("Wynik zabezpieczonego mnożenia: " + sprawdzony);
+		} catch (ArithmeticException e) {
+			System.out.println("Overflow");
+		}
+	}
+
+}
+
+
+// YT   "Ariane 5"
+// przerwa do 13:30

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/LiteralyLiczbowe.java

+package alx.p05_liczby;
+
+public class LiteralyLiczbowe {
+
+	public static void main(String[] args) {
+		int x;
+
+		x = 123; // format dziesiętny
+		System.out.println(x);
+
+		x = 0123; // system ósemkowy
+		//NK x = 08;  // cyfry od 0 do 7
+		System.out.println(x);
+
+		x = 0x100; // system szesnastkowy
+		System.out.println(x);
+		x = 0x7F;
+		System.out.println(x);
+
+		// system dwójkowy - od Javy 7
+		x = 0b1101;
+		System.out.println(x);
+
+		// odstępy pomiędzy cyframi - od Javy 7
+		x = 2_000_000;
+		System.out.println(x);
+		
+		//NK long l = 4000000000; // wartość nie mieszcząca się w int
+		long l = 4000000000L; // OK
+		
+		// int _1000 = 1313;
+		
+		// x = _1000;  // odwołanie do zmiennej :)
+		// x = 1000_;
+		x = 10______00; // po prostu tysiąc
+		
+		// dopuszczalne są tylko pomiędzy cyframi.
+		// nie na początku, nie na końcu, nie obok kropki ani obok litery typu i wykładnika
+		
+		x = 0x0F_FF_80_00;
+		x = 0b0011_0101;
+		
+		System.out.println(x); // 1000
+		
+		double dd = 10__00;
+		dd = 3.14; // literał liczbowy z częścią ułamkową jest typu double (a nie float)
+		dd = 1_00.0__0;
+		//dd = 100._9;
+		//dd = 100_.9;
+		
+		dd = 100.99d;
+		//dd = 100.99_f;
+		
+		// x = 0x_FF;
+
+		// NK x = 1L; // L na końcu oznacza typ long (może być duże lub małe)
+
+		l = 1L;
+		l = 1; // inta można wpisać na zmienną long
+
+		System.out.println();
+		
+		float f = 12; // int na float - OK
+		// f = 3.14;
+		// literał z ułamkiem jest typu double, a double nie można wpisać na float
+		f = 3.14F;
+		f = 1.0f;
+		f = 3f;
+		f = 1.13e2F;
+		f = (float)3.14; // kompiluje się, ale niezalecane, bo można zgubić precyzję
+		System.out.println(f);
+
+		double d = 3.14;
+		// NK f = d;
+		// na końcu double'a też można podać info o typie: D  albo d
+		d = 4.44d;
+		d = 4.445D;
+		
+		// liczba w notacji dziesiętnej razy 10 do podanej potęgi
+		d = 1.25e3;
+		System.out.println(d);
+		d = 4.44e-3;
+		System.out.println(d);
+		System.out.println();
+		
+		// liczba w notacji szestastkowej razy 2 do podanej potęgi - tak to jest przechowywane wewnętrznie!
+		d = 0x3p2; // 12
+		System.out.println(d);
+		d = 0x0.2p0; // 2/16 = 1/8 = 0.125 
+		System.out.println(d);
+		d = 0x1p-3;
+		System.out.println(d);
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/PomylonyDouble.java

+package alx.p05_liczby;
+
+public class PomylonyDouble {
+	public static void zaszachraj(int n, double arg) {
+		System.out.println("mnożenie : " + n * arg);
+
+		double suma = 0.0;
+		for (int i = 1; i <= n; i++) {
+			suma += arg;
+		}
+		System.out.println("dodawanie: " + suma);
+		System.out.println();
+	}
+
+	public static void main(String[] args) {
+		zaszachraj(1000, 0.5); // 1/2
+		zaszachraj(1000, 0.125); // 1/8
+
+		zaszachraj(1000, 0.2); // 1/5 - nieskończone rozwinięcie w systemie dwójkowym
+		zaszachraj(1000, 0.3);
+		zaszachraj(1000, 1.0 / 3.0);
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/ProcentyNaCalkowitych.java

+package alx.p05_liczby;
+
+public class ProcentyNaCalkowitych {
+
+	public static void main(String[] args) {
+			long netto = 10005;
+			long procent = 23;
+			long brutto = (netto * (100 + procent) + 50) / 100;
+			System.out.println(brutto);
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/PrzeciazanieIntLong.java

+package alx.p05_liczby;
+
+public class PrzeciazanieIntLong {
+
+	public static void main(String[] args) {
+		try {
+			System.out.println("oblicza w wersji int:");
+			System.out.println(Math.multiplyExact(5, 1000_000_000));
+		} catch (Exception e) {
+			System.out.println("wersja int: wyjątek " + e);
+		}
+		System.out.println();
+		
+		try {
+			System.out.println("oblicza w wersji long:");
+			System.out.println(Math.multiplyExact(5L, 1000_000_000L));
+		} catch (Exception e) {
+			System.out.println("wersja long: wyjątek " + e);
+		}
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/Rzutowania.java

+package alx.p05_liczby;
+
+public class Rzutowania {
+
+	// "Hierarchia" typów prostych:
+	// byte < short < int < long < float < double
+	// char < int
+	
+	public static void main(String[] args) {
+		int x = 107;
+		float f = 3.14f;
+		long l3 = 13;
+
+		// rzutowanie niejawne - na zmienną typu "szerszego" można zapisać wartość typu "węższego" (widening)
+		long l = x;
+		float f2 = l3;
+		//NK x = l;
+		//NK l = f;
+		f = l;
+		
+		// rzutowanie jawne można stosować zawsze; czasem może wiązać się z "popsuciem" wartości liczbowej
+		x = (int) l;
+		System.out.println(x);
+		
+		// można stosować jawne rzutowanie nawet gdy nie jest konieczne
+		l = x;
+		l = (long) x;
+		System.out.println(l);
+		
+		l = 4_000_000_000L;
+		x = (int) l;
+		System.out.println(x); // zmieniona wartość, ostatnie 32 bity z zapisu tej liczby
+
+		f = 100.99F;
+		x = (int)f;  // obcina do wartości całkowitej
+		System.out.println(x); // 100
+		
+		f = 4e9f; // 4 * 10^9 czyli 4mld
+		x = (int)f; // po wyjściu poza zakres przyjmuje MAXINT / MININT
+		System.out.println(x);
+		
+		// Na zmienne typu byte, short i char można wpisywać konkretne wartości całkowite, o ile kompilator widzi, że mieszczą się w zakresie
+		
+		byte b1 = 100;
+		//NK byte b2 = 200;
+
+		x = 100;
+		//NK byte b3 = x;
+		
+		final int fi = 10;
+		b1 = fi; // jeśli wartość jest "stałą" (jest final i jest znana w czasie kompilacji)
+		
+		b1 = 50;
+		//NK b1 = x; // bo "nie każdy int mieści się w byte"
+		x = b1;  // OK, bo byte mieści się w int
+		
+		//NK int i3 = 3L;
+		
+		float f3 = 3L;
+		
+		
+		byte b = 13;
+		b = 15;
+		//NK b = 130;
+		
+		x = 15;
+		//NK b = x;
+		b = (byte)x;
+		
+		//NK wezByte(88);
+		wezByte((byte)88);
+		wezByte(b);
+		System.out.println();
+		
+		System.out.println(dajByte());
+		System.out.println(dajZnak());
+		System.out.println();
+		
+		l = 5_000_000_000L;
+		x = (int)l;
+		System.out.println(x);
+		// rzutowanie liczb całkowitych - bierzemye ostatnie bity z zapisu liczby w pamięci
+		// zobaczę to samo, co w int overflow gdy mnożyłem 5 * 1000000000
+		System.out.println("5mld long   rzut na int: " + x);
+		
+		double d = 5_000_000_000.0;
+		x = (int)d;
+		System.out.println("5mld double rzut na int: " + x);
+		// rzutowanie float i double na liczbę całkowitą - bierzemy wartość, która jest najbliżej,
+		// w tym przypadku będzie to Integer.MAX_VALUE
+		
+		byte b2 = 40, b3 = 50;
+		
+		// Operacje arytmetyczne + - * / %  - są zdefiniowane dla typu int, a nie dla byte i short
+		// dlatego ich ywniki trzeba zrzutowa, aby pisać na zmienne tych typów
+		//NK byte b4 = b2 + b3;
+		byte b4 = (byte)(b2 + b3);
+		
+		// ale bez rzutowania działają ++ i +=
+		
+		System.out.println(b2);
+		b2++;
+		System.out.println(b2);
+		
+		b2 += 10;
+		System.out.println(b2);
+	}
+	
+	static byte dajByte() {
+		return 65;
+	}
+
+	/* NK
+	static byte dajByteInaczej() {
+		int x = 65;
+		return x;
+	}
+	*/
+
+	static char dajZnak() {
+		return 65;
+	}
+	
+	static void wezByte(byte bbb) {
+		System.out.println(bbb);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/Silnia.java

+package alx.p05_liczby;
+
+import java.util.Scanner;
+
+public class Silnia {
+	
+	// 1 * 2 * 3 * .... * n
+	static long silnia(int n) {
+		long wynik = 1;
+		for(int i = 2; i <= n; i++) {
+			wynik *= i;
+		}
+		
+		return wynik;
+	}
+
+	
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		
+		while(true) {
+			System.out.println("Podaj liczbę (-1 aby zakończyć)");
+			int n = sc.nextInt();
+			if(n < 0) break;
+			
+			long wynik = silnia(n);
+			System.out.println("Wynik: " + wynik);
+		}
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/SilniaNaRozneSposoby.java

+package alx.p05_liczby;
+
+import java.math.BigInteger;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+
+public class SilniaNaRozneSposoby {
+	
+	static int silniaInt(int n) {
+		int wynik = 1;
+		for(int i = 2; i <= n; i++) {
+			wynik *= i;
+		}
+		return wynik;
+	}
+
+	static long silniaFor(int n) {
+		long wynik = 1;
+		for(int i = 2; i <= n; i++) {
+			wynik *= i;
+		}
+		return wynik;
+	}
+
+	static long silniaWhile(int n) {
+		long wynik = 1;
+		
+		while(n > 1) {
+			wynik *= n;
+			n--;
+		}
+		
+		return wynik;
+	}
+	
+	static long silniaRek(int n) {
+		// rekurencja
+		
+		if(n < 2) {
+			return 1;
+		} else {
+			return n * silniaRek(n-1);
+		}
+	}
+	
+	static BigInteger silniaBig(int n) {
+		BigInteger wynik = BigInteger.ONE;
+		
+		for(int i = 2; i <= n; i++) {
+			wynik = wynik.multiply(BigInteger.valueOf(i));
+		}
+		
+		return wynik;
+	}
+	
+	static long silniaKontrolowana(int n) {
+		long wynik = 1;
+		for(int i = 2; i <= n; i++) {
+			wynik = Math.multiplyExact(wynik, i);
+		}
+		return wynik;
+	}
+	
+	static long silniaFun(int n) {
+		// też OK return LongStream.rangeClosed(1, n).reduce(1, Math::multiplyExact );
+		
+		return LongStream.rangeClosed(1L, n).reduce(1L, (wynik, i) -> wynik * i);
+	}
+	
+	static BigInteger silniaBigFun(int n) {
+		return IntStream.rangeClosed(1, n)
+			.mapToObj(BigInteger::valueOf)
+			.reduce(BigInteger.ONE, BigInteger::multiply);
+	}
+
+	public static void main(String[] args) {
+		
+		int wynik1 = silniaInt(5);
+		System.out.println(wynik1);
+		
+		System.out.println("int, for:");
+		for(int arg = 0; arg <= 50; arg++) {
+			System.out.println(arg + "! = " + silniaInt(arg));
+		}
+		System.out.println();
+
+		System.out.println("long, for:");
+		for(int arg = 0; arg <= 50; arg++) {
+			System.out.println(arg + "! = " + silniaFor(arg));
+		}
+		System.out.println();
+
+		System.out.println("long, while:");
+		for(int arg = 0; arg <= 50; arg++) {
+			System.out.println(arg + "! = " + silniaWhile(arg));
+		}
+		System.out.println();
+	
+		System.out.println("long, rekurencja:");
+		for(int arg = 0; arg <= 50; arg++) {
+			System.out.println(arg + "! = " + silniaRek(arg));
+		}
+		System.out.println();
+	
+		System.out.println("long, multiplyExact:");
+		for(int arg = 0; arg <= 50; arg++) {
+			try {
+				System.out.println(arg + "! = " + silniaKontrolowana(arg));
+			} catch(ArithmeticException e) {
+				System.out.println("OVERFLOW");
+			}
+		}
+		System.out.println();
+
+		System.out.println("BigInteger, for:");
+		for(int arg = 0; arg <= 100; arg++) {
+			System.out.println(arg + "! = " + silniaBig(arg));
+		}
+		System.out.println();
+
+				
+		System.out.println("long, reduce:");
+		for(int arg = 0; arg <= 50; arg++) {
+			System.out.println(arg + "! = " + silniaFun(arg));
+		}
+		System.out.println();
+	
+		System.out.println("BigInteger, reduce:");
+		for(int arg = 0; arg <= 100; arg++) {
+			System.out.println(arg + "! = " + silniaBigFun(arg));
+		}
+		System.out.println();
+
+	}
+
+}
+
+/* wersja w Pythonie:
+
+def silnia(n):
+    wynik = 1
+    for i in range(1, n+1):
+        wynik *= i
+    return wynik
+
+print(silnia(1))
+print(silnia(5))
+print(silnia(100))
+*/
+
+/* wersja w Haskellu:
+silnia n = foldl (*) 1 [1..n]
+
+silnia 5
+silnia 100
+*/
+

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/TestMegaSilni.java

+package alx.p05_liczby;
+
+import java.io.IOException;
+import java.math.BigInteger;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.Collections;
+
+public class TestMegaSilni {
+
+	public static void main(String[] args) {
+		System.out.println("Wyliczam silnię od 100 tys.");
+		BigInteger silnia100tys = SilniaNaRozneSposoby.silniaBig(100_000);
+		String silnia100tysTXT = silnia100tys.toString();
+		System.out.printf("Gotowe, wynik ma %d cyfr.", silnia100tysTXT.length());
+		try {
+			final String plik = "silnia_100_tys.txt";
+			Files.write(Paths.get(plik), Collections.singleton(silnia100tysTXT), Charset.defaultCharset(), StandardOpenOption.CREATE);
+			System.out.println("Zapisałem do pliku " + plik);
+		} catch (IOException e) {
+			System.out.println("Błąd zapisu do pliku");
+		}
+		System.out.println();
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/WypiszZakresy.java

+package alx.p05_liczby;
+ 
+public class WypiszZakresy {
+ 
+    public static void main(String[] args) {
+        System.out.println("byte  " + Byte.BYTES + " bajtów, od " + Byte.MIN_VALUE + " do " + Byte.MAX_VALUE);
+        System.out.println("short " + Short.BYTES + " bajtów, od " + Short.MIN_VALUE + " do " + Short.MAX_VALUE);
+        System.out.println("int   " + Integer.BYTES + " bajtów, od " +Integer.MIN_VALUE + " do " + Integer.MAX_VALUE);
+        System.out.println("long  " + Long.BYTES + " bajtów, od " +Long.MIN_VALUE + " do " + Long.MAX_VALUE);
+ 
+        System.out.println("char  " + Character.BYTES + " bajtów, od " + (int) Character.MIN_VALUE + " do " + (int) Character.MAX_VALUE);
+        System.out.println();
+        
+        // bez ograniczen: klasy BigInteger (calkowite) i BigDecimal (z ulamkiem)
+        
+        System.out.println("float  " + Float.BYTES + " bajtów, od " +Float.MIN_VALUE + " do " + Float.MAX_VALUE);
+        System.out.println("    min normal : " + Float.MIN_NORMAL);
+        System.out.println("double  " + Double.BYTES + " bajtów, od " +Double.MIN_VALUE + " do " + Double.MAX_VALUE);
+        System.out.println("    min normal : " + Double.MIN_NORMAL);
+        System.out.println();
+        
+        System.out.println("boolean : false i true");
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p05_liczby/Znaki.java

+package alx.p05_liczby;
+
+public class Znaki {
+
+	public static void main(String[] args) {
+		System.out.println("A");
+		System.out.println("A" + 5);
+
+		System.out.println('A');
+		System.out.println('A' + 5);
+		System.out.println('A' + 'B');
+		System.out.println();
+		
+		
+		char c = 65; // można wpisywać konkretną wartość int, o ile mieści się w zakresie
+		//NK char d = -1;
+		
+		int x = 65;
+		int y = 'A';
+		//NK c = x;  // ale nie int-a ze zmiennej
+		c = (char)x;
+		System.out.println(c);
+		
+		x = c;
+		System.out.println(x);
+		x = (int)c;
+		System.out.println((int)c);
+		System.out.println();
+		
+		for(char znak = 'A'; znak <= 'Z'; znak++) {
+			System.out.print(znak + " ");
+		}
+		System.out.println();
+		
+		int ącki = 'Ą';
+		System.out.println(ącki);
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/gdyby_nie_bylo_static/Geometria.java

+package alx.p06_funkcje.gdyby_nie_bylo_static;
+
+public class Geometria {
+	// W tej wersji metody geometryczne nie są static.
+	// Powoduje to konieczność utworzenia obiektu ("instancji") tej klasy, gdy ktoś chce użyć tych metod - zob. Program i Testy w tym pakiecie
+	
+	double poleKwadratu(double a) {
+		return a * a;
+	}
+	
+	double poleKola(double r) {
+		return Math.PI * Math.pow(r, 2);
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/gdyby_nie_bylo_static/TestyGeometrii.java

+package alx.p06_funkcje.gdyby_nie_bylo_static;
+
+public class TestyGeometrii {
+
+	public static void main(String[] args) {
+		// ponieważ w tej wersji metody nie są static, to aby je wywołać trzeba utworzyć obiekt
+		// System.out.println("Pole kwadratu 5 = " + Geometria.poleKwadratu(5.0));
+
+		Geometria geo = new Geometria();
+		System.out.println("Pole kwadratu 5 = " + geo.poleKwadratu(5.0));
+		System.out.println("Pole koła 5 = " + geo.poleKola(5.0));
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/importowanie/V1_BrakImportow.java

+package alx.p06_funkcje.importowanie;
+
+public class V1_BrakImportow {
+
+	public static void main(String[] args) {
+		System.out.println("Pole kwadratu 5 = " + alx.p06_funkcje.przyklady.Geometria.poleKwadratu(5.0));
+		System.out.println("Pole koła 5 = " + alx.p06_funkcje.przyklady.Geometria.poleKola(5.0));
+		System.out.println("Pole prostokąta 3×5 = " + alx.p06_funkcje.przyklady.Geometria.poleProstokata(3.0, 5.0));
+		System.out.println("100 mil = " + alx.p06_funkcje.przyklady.JednostkiMiary.mileNaKm(100) + " km");
+		System.out.println("100 km = " + alx.p06_funkcje.przyklady.JednostkiMiary.kmNaMile(100) + " mil");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/importowanie/V2_ImportKlas.java

+package alx.p06_funkcje.importowanie;
+
+import alx.p06_funkcje.przyklady.Geometria;
+import alx.p06_funkcje.przyklady.JednostkiMiary;
+
+public class V2_ImportKlas {
+
+	public static void main(String[] args) {
+		System.out.println("Pole kwadratu 5 = " + Geometria.poleKwadratu(5.0));
+		System.out.println("Pole koła 5 = " + Geometria.poleKola(5.0));
+		System.out.println("Pole prostokąta 3×5 = " + Geometria.poleProstokata(3.0, 5.0));
+		System.out.println("100 mil = " + JednostkiMiary.mileNaKm(100) + " km");
+		System.out.println("100 km = " + JednostkiMiary.kmNaMile(100) + " mil");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/importowanie/V3_ImportGwiazdka.java

+package alx.p06_funkcje.importowanie;
+
+import alx.p06_funkcje.przyklady.*;
+
+// Import wszystkich klas publicznych z podanego pakietu.
+// Jeśli w programie użyjemy nazwy, która znajduje się w różnych pakietach, to mamy konfokt nazw i to się skompiluje.
+// Podczas ustalania skąd się wzięła jakaś nazwa kompilator stosuje taką kolejność:
+// 1) Klasy zaimportowane wprost (jak w v2)
+// 2) Klasy z bieżącego pakietu
+// 3) Klasy zaimportowane z * , wśród nich klasy z pakietu java.lang oraz klasy z pakietu domyślnego (którego nie należy używać)
+public class V3_ImportGwiazdka {
+
+	public static void main(String[] args) {
+		System.out.println("Pole kwadratu 5 = " + Geometria.poleKwadratu(5.0));
+		System.out.println("Pole koła 5 = " + Geometria.poleKola(5.0));
+		System.out.println("Pole prostokąta 3×5 = " + Geometria.poleProstokata(3.0, 5.0));
+		System.out.println("100 mil = " + JednostkiMiary.mileNaKm(100) + " km");
+		System.out.println("100 km = " + JednostkiMiary.kmNaMile(100) + " mil");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/importowanie/V4_ImportStatic.java

+package alx.p06_funkcje.importowanie;
+
+import static alx.p06_funkcje.przyklady.Geometria.poleKola;
+import static alx.p06_funkcje.przyklady.Geometria.poleKwadratu;
+import static alx.p06_funkcje.przyklady.Geometria.poleProstokata;
+import static alx.p06_funkcje.przyklady.JednostkiMiary.kmNaMile;
+import static alx.p06_funkcje.przyklady.JednostkiMiary.mileNaKm;
+
+public class V4_ImportStatic {
+
+	public static void main(String[] args) {
+		System.out.println("Pole kwadratu 5 = " + poleKwadratu(5.0));
+		System.out.println("Pole koła 5 = " + poleKola(5.0));
+		System.out.println("Pole prostokąta 3×5 = " + poleProstokata(3.0, 5.0));
+		System.out.println("100 mil = " + mileNaKm(100) + " km");
+		System.out.println("100 km = " + kmNaMile(100) + " mil");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/importowanie/V5_ImportStaticGwiazdka.java

+package alx.p06_funkcje.importowanie;
+
+import static alx.p06_funkcje.przyklady.Geometria.*;
+import static alx.p06_funkcje.przyklady.JednostkiMiary.*;
+
+//NK import static alx.p06_funkcje.przyklady.*.*;
+
+public class V5_ImportStaticGwiazdka {
+
+	public static void main(String[] args) {
+		System.out.println("Pole kwadratu 5 = " + poleKwadratu(5.0));
+		System.out.println("Pole koła 5 = " + poleKola(5.0));
+		System.out.println("Pole prostokąta 3×5 = " + poleProstokata(3.0, 5.0));
+		System.out.println("100 mil = " + mileNaKm(100) + " km");
+		System.out.println("100 km = " + kmNaMile(100) + " mil");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/przyklady/FunkcjeZWarunkami.java

+package alx.p06_funkcje.przyklady;
+
+import java.util.Random;
+
+public class FunkcjeZWarunkami {
+	// Funkcje, które zwracają wyniki za pomocą return, mogą posiadać bardziej złożoną treść,
+	// np. używać if-ów, switch-ów, pętli...
+	// return nie musi być wtedy ostatnią instrukcją, może występować w kilku miejscach,
+	// a kompilator będzie sprawdzał "czy w każdej sytuacji na pewno funkcja zwróci jakiś wynik"
+	
+	static int wieksza(int x, int y) {
+		if(x > y) {
+			return x;
+		} else {
+			return y;
+		}
+	}
+	
+	// jeszcze bardziej zwięzła wersja, z wykorzystaniem wyrażenia warunkowego ?:
+	static int wieksza_v2(int x, int y) {
+		return x > y ? x : y;
+	}
+
+	public static void main(String[] args) {
+		Random random = new Random();
+		int x = random.nextInt(10);
+		int y = random.nextInt(10);
+		
+		System.out.println(" x = " + x);
+		System.out.println(" y = " + y);
+		
+		int wieksza = wieksza(x, y);
+		System.out.println("większą z nich jest: " + wieksza);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/przyklady/Geometria.java

+package alx.p06_funkcje.przyklady;
+
+import java.util.Scanner;
+
+public class Geometria {
+	private Geometria() {
+		// aby nikt nie tworzył instancji tej klasy, bo to jest "utility class"
+	}
+
+	public static double poleKwadratu(double a) {
+		return a * a;  // ew. Math.pow(a, 2)
+	}
+	
+	public static double poleKola(double r) {
+		//JOptionPane.showMessageDialog(null, "Właśnie zabieram się za obliczanie pola koła o promieniu " + r);
+		return Math.PI * Math.pow(r, 2);
+	}
+	
+	public static double poleProstokata(double a, double b) {
+		return a * b;
+	}
+	
+	public static double obwodKwadratu(double a) {
+		return 4*a;
+	}
+
+	public static double obwodProstokata(double a, double b) {
+		return 2*a + 2*b;
+	}
+
+	public static double obwodKola(double r) {
+		return 2 * Math.PI * r;
+	}
+
+	// W tej wersji main jest w tej samej klasie, co definicje funkcji,
+	// dzięki temu można łatwo te funkcje (statyczne) wywoływać.
+	// Ale dla przejrzystości kodu lepiej funkcje definiować w jednej klasie, a program (main) pisać w innej - zob. ProgramGeometryczny)
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.print("Podaj pierwszą liczbę: ");
+		double x = sc.nextDouble();
+
+		System.out.print("Podaj drugą liczbę: ");
+		double y = sc.nextDouble();
+		
+		double wynik;
+		wynik = poleKwadratu(x);
+		System.out.println("Pole kwadratu o boku " + x + " wynosi " + wynik);
+		wynik = poleKwadratu(y);
+		System.out.println("Pole kwadratu o boku " + y + " wynosi " + wynik);
+		
+		wynik = poleProstokata(x, y);
+		System.out.println("Pole prostokąta " + x + " × " + y + " wynosi " + wynik);
+		
+		wynik = poleKola(x);
+		System.out.println("Pole koła o promieniu " + x + " wynosi " + wynik);
+		wynik = poleKola(y);
+		System.out.println("Pole koła o promieniu " + y + " wynosi " + wynik);
+
+		wynik = obwodKwadratu(x);
+		System.out.println("Obwód kwadratu o boku " + x + " wynosi " + wynik);
+		wynik = obwodKwadratu(y);
+		System.out.println("Obwód kwadratu o boku " + y + " wynosi " + wynik);
+		
+		// tak też można pisać, ale po co?...
+		wynik = Geometria.obwodProstokata(x, y);
+		System.out.println("Obwód prostokąta " + x + " × " + y + " wynosi " + wynik);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/przyklady/JednostkiMiary.java

+package alx.p06_funkcje.przyklady;
+
+public class JednostkiMiary {
+	
+	public static double kmNaMile(double km) {
+		return km / 1.609344;
+	}
+	
+	public static double mileNaKm(double mile) {
+		return 1.609344 * mile;
+	}
+	
+	public static double farNaCel(double far) {
+		return 5. / 9. * (far - 32d);
+	}
+	
+	public static double celNaFar(double cel) {
+		return 32.0 + (9.0 / 5.0 * cel);  // 32 + 1.8*cel
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/przyklady/ProgramGeometryczny.java

+package alx.p06_funkcje.przyklady;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class ProgramGeometryczny {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		sc.useLocale(Locale.US);
+		
+		glownaPetla:
+		while(true) {
+			System.out.println("Wybierz figurę:\n Q - zakończ,\n K - kwadrat,\n P - prostokąt,\n O - koło");
+			String wybor = sc.nextLine().trim().toUpperCase();
+			switch(wybor) {
+				case "Q": {
+					break glownaPetla; // etykieta / label
+				}
+				case "K": {
+					System.out.print("Podaj długość boku kwadratu: ");
+					double a = sc.nextDouble();
+					double pole = Geometria.poleKwadratu(a);
+					double obwod = Geometria.obwodKwadratu(a);
+					System.out.println("Pole kwadratu wynosi: " + pole);
+					System.out.println("Obwód kwadratu wynosi: " + obwod);
+					break;
+				}
+				case "P": {
+					System.out.print("Podaj długość dwóch boków prostokąta: ");
+					double a = sc.nextDouble();
+					double b = sc.nextDouble();
+					double pole = Geometria.poleProstokata(a, b);
+					double obwod = Geometria.obwodProstokata(a, b);
+					System.out.println("Pole prostokąta wynosi: " + pole);
+					System.out.println("Obwód prostokąta wynosi: " + obwod);
+					break;
+				}
+				case "O": {
+					System.out.print("Podaj promień koła: ");
+					double r = sc.nextDouble();
+					double pole = Geometria.poleKola(r);
+					double obwod = Geometria.obwodKola(r);
+					System.out.println("Pole koła wynosi: " + pole);
+					System.out.println("Obwód koła wynosi: " + obwod);
+					break;
+				}
+				default: {
+					System.out.println("Nieznane polecenie");
+					continue glownaPetla;
+				}
+			}
+			sc.nextLine(); // żeby Scanner wczytał wszystkie pozostałości i przeszedł do nast. linii
+		}
+	}
+}
+
+/*
+użycie if zamiast switch wyglądałoby tak:
+if("K".equals(wybor)) {
+	System.out.println("Wybrano kwadrat");
+} else if("O".equals(wybor)) {
+	System.out.println("Wybrano koło");
+}
+*/

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/przyklady/TestyGeometrii.java

+package alx.p06_funkcje.przyklady;
+
+public class TestyGeometrii {
+	// Będąc w jednej klasie, można wywoływać metody zdefiniowane w innej klasie,
+	// zgodnie z ograniczeniami widoczności (private/public)
+	// Jeśli metoda nie jest prywatna, to można jej używać w tym samym pakiecie,
+	// a jeśli jest publiczna, to można używać wszędzie.
+	
+	public static void main(String[] args) {
+		System.out.println("Pole kwadratu 5 = " + Geometria.poleKwadratu(5.0));
+		System.out.println("Pole kwadratu 6.5 = " + Geometria.poleKwadratu(6.5));
+		System.out.println("Pole koła 5 = " + Geometria.poleKola(5.0));
+		System.out.println("Pole prostokąta 3×5 = " + Geometria.poleProstokata(3.0, 5.0));
+		System.out.println();
+
+		// Testy preliczania jednstek też przeniosłem do tej klasy, żeby pokazać, że w klasie JednostkiMiary może nie być main, tylko same funkcje.
+		System.out.println("100 mil = " + JednostkiMiary.mileNaKm(100) + " km");
+		System.out.println("100 km = " + JednostkiMiary.kmNaMile(100) + " mil");
+		System.out.println("160 km = " + JednostkiMiary.kmNaMile(160) + " mil");
+		System.out.println();
+
+		System.out.println("0 F = " + JednostkiMiary.farNaCel(0) + " C");
+		System.out.println("100 F = " + JednostkiMiary.farNaCel(100) + " C"); // ok 37
+		System.out.println("0 C = " + JednostkiMiary.celNaFar(0) + " F");
+		System.out.println("37 C = " + JednostkiMiary.celNaFar(37) + " F"); // ok 100
+		System.out.println("100 C = " + JednostkiMiary.celNaFar(100) + " F"); // 212 ?
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/teoria/Funkcje1_Void.java

+package alx.p06_funkcje.teoria;
+
+import java.time.LocalTime;
+
+public class Funkcje1_Void {
+
+	static void poczatek() {
+		// Funkcja typu void nie zwraca żadnego wyniku, tylko "coś robi"
+
+		System.out.println("To jest funkcja początek");
+		System.out.println("Funkcja początek kończy się");
+	}
+
+	static void nikt_mnie_nie_chce() {
+		// Jeśli funkcja nie jest wywoływana z main (bezpośrednio albo pośrednio), to
+		// jej treść się nie wykona.
+		System.out.println("To się nigdy nie wypisze");
+	}
+
+	static void ktoraGodzina() {
+		System.out.println("Godzina " + LocalTime.now());
+	}
+
+	public static void main(String[] args) {
+		System.out.println("Początek main");
+
+		poczatek(); // wywołanie / invoke
+		for (int i = 0; i < 10; i++) {
+			ktoraGodzina();
+		}
+
+		koniec();
+	}
+
+	// W Javie kolejność definicji metod (funkcji) nie ma znaczenia.
+	// Funkcja zdefiniowana wcześniej może wywoływać funkcję zdefiniowaną później.
+	static void koniec() {
+		System.out.println("Koniec");
+		System.out.print("Na koniec jest godzina: ");
+		ktoraGodzina(); // jedna funkcja może wywołać inną funkcję
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/teoria/Funkcje2_Parametry.java

+package alx.p06_funkcje.teoria;
+
+public class Funkcje2_Parametry {
+	
+	// Funkcja może mieć parametry:
+	static void zaprosNaKurs(String jezyk, int iloscDni) {
+		System.out.println("Zapraszamy na kurs języka " + jezyk + ", które będzie trwał " + iloscDni + " dni.");
+	}
+	
+	static void powtorz(String napis, int ilosc) {
+		for(int i = 1; i <= ilosc; i++) {
+			System.out.println(napis);
+		}
+	}
+	
+	public static void main(String[] args) {
+		// Wywołując funkcję sparametryzowaną musimy przekazać wartości parametrów, czyli "argumenty".
+		zaprosNaKurs("Java", 10);
+		zaprosNaKurs("Python", 10);
+		zaprosNaKurs("SQL", 4);
+		System.out.println();
+		
+		// Zadeklarowane w funkcji: parametr, paramter formalny (formal parameter)
+		// Wartość przekazywana w wywołaniu: argument, parametr aktualny / bieżący (actual parameter) 
+		
+		powtorz("Ala ma kota", 5);
+		powtorz("Ola ma psa", 3);
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/teoria/Funkcje3_Wynik.java

+package alx.p06_funkcje.teoria;
+
+public class Funkcje3_Wynik {
+	
+	// Funkcja może zwrócić wynik:
+	static int liczba() {
+		return 13;
+	}
+	
+	static int dodaj(int x, int y) {
+		return x + y;
+	}
+
+	static String napis() {
+		return "Hello world";
+	}
+	
+	static String powitanie(String imie) {
+		return "Witaj " + imie + ", miło Cię poznać";
+	}
+	
+	// Funkcja może zawierać wiele instrukcji return w różnych miejscach. Np. w zależości od warunku zwróć jedno lub drugie.
+	// Kompilator Javy sprawdza jednak, czy funkcja zwraca wynik w każdej sytuacji.
+	static int roznicaBezwzgledna(int x, int y) {
+		if(x >= y) {
+			return x - y;
+		} else {
+			return y - x;
+		}
+	}	
+	
+	public static void main(String[] args) {
+		liczba();
+		// Czy liczba 13 wypisze się na ekran? NIE
+		
+		// To, że funkcja zwraca wynik, oznacza, że np. można ten wynik zapisać na zmienną:
+		int wynik = liczba();
+		System.out.println("Funkcja zwróciła wynik " + wynik); // dopiero tutaj
+		
+
+		wynik = dodaj(13, 12);
+		System.out.println("Dodawanie zwróciło wynik " + wynik);
+		
+		String napis;
+		napis = powitanie("Ala");
+		System.out.println("Powitanie 1: " + napis);
+		napis = powitanie("Karol");
+		System.out.println("Powitanie 2: " + napis);
+		
+		String s = "Ola";
+		napis = powitanie(s);
+		System.out.println("Powitanie 2: " + napis);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p06_funkcje/teoria/Narnia.java

+package alx.p06_funkcje.teoria;
+
+public class Narnia {
+
+	public static void main(String[] args) {
+		System.out.println("Wszyscy są w domu");
+		System.out.println("Łucja chowa się w pokoju z szafą");
+		wejdzDoSzafy("Łucja");
+		System.out.println("Łucja wróciła do domu");
+		
+		wejdzDoSzafy("Łucja", "Zuzanna", "Piotr", "Edmund");
+		System.out.println("Po wyeliminowaniu czarownicy wszyscy wrócili do domu.");
+		
+		String[] kolejneOsoby = {"Ala", "Ola", "Ela"};
+		wejdzDoSzafy(kolejneOsoby);
+	}
+	
+	// varargs - zmienna liczba argumentów
+	// taki parametr z trzema kropkami może występować tylko 1, na samym końcu listy parametrów
+	// wewnątrz funkcji on jest widziany jako tablica
+	// a z zewnątrz można przekazać 1 tablicę albo wiele elementów po przecinku
+	static void wejdzDoSzafy(String... kto) {
+		System.out.println();
+		System.out.println("Do Krainy Narni weszli:");
+		for (String imie : kto) {
+			System.out.println(" * " + imie);
+		}
+		
+		System.out.println("Mają ciekawe przygody");
+		System.out.println("I w końcu wracają");
+		System.out.println();
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p11_referencje/Konto.java

+package alx.p11_referencje;
+
+public class Konto {
+    int numer;
+    int saldo;
+    Osoba wlasciciel;
+
+    public Konto(int numer, int saldo, Osoba wlasciciel) {
+        this.numer = numer;
+        this.saldo = saldo;
+        this.wlasciciel = wlasciciel;
+    }
+
+    @Override
+    public String toString() {
+        return "Konto{" +
+                "numer=" + numer +
+                ", saldo=" + saldo +
+                ", wlasciciel=" + wlasciciel +
+                '}';
+    }
+
+    public void wplata(int kwota) {
+        saldo += kwota;
+    }
+
+    public void wyplata(int kwota) {
+        saldo -= kwota;
+    }
+
+}

PC22-PrzetwarzanieDanych/src/alx/p11_referencje/Osoba.java

+package alx.p11_referencje;
+
+import java.util.Objects;
+
+public class Osoba {
+    String imie, nazwisko;
+    int wiek;
+
+    Osoba() {
+
+    }
+
+    Osoba(String imie, String nazwisko, int wiek) {
+        this.imie = imie;
+        this.nazwisko = nazwisko;
+        this.wiek = wiek;
+    }
+    // w klasie może być wiele konstruktorów, które różnią się ilością lub typem parametrów
+
+    void przedstawSie() {
+        System.out.println("Nazywam się " + imie + " " + this.nazwisko + " i mam " + wiek + " lat.");
+    }
+
+    boolean jestPelnoletnia() {
+        return wiek >= 18;
+    }
+
+    void postarzejSie() {
+        wiek++;
+    }
+
+    @Override
+    public String toString() {
+        return imie + " " + nazwisko + " (" + wiek + " lat)";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Osoba osoba = (Osoba) o;
+        return wiek == osoba.wiek &&
+                Objects.equals(imie, osoba.imie) &&
+                Objects.equals(nazwisko, osoba.nazwisko);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(imie, nazwisko, wiek);
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p11_referencje/PrzykladKonto.java

+package alx.p11_referencje;
+
+public class PrzykladKonto {
+    public static void main(String[] args) {
+        Osoba ala = new Osoba("Ala", "Kowalska", 30);
+        Konto a = new Konto(1, 1000, ala);
+
+        System.out.println(a);
+        a.wplata(300);
+        System.out.println(a);
+
+
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p11_referencje/Referencje1.java

+package alx.p11_referencje;
+
+public class Referencje1 {
+    public static void main(String[] args) {
+        Osoba ala = new Osoba("Ala", "Kowalska", 30);
+        Osoba ola = new Osoba("Ola", "Malinowska", 20);
+
+        Konto a = new Konto(1, 1000, ala);
+        Konto b = new Konto(2, 2000, ola);
+        Konto c = b;
+
+        System.out.println("a: " + a);
+        System.out.println("b: " + b);
+        System.out.println("c: " + c);
+        System.out.println();
+
+        b.wplata(40);
+        System.out.println("a: " + a);
+        System.out.println("b: " + b);
+        System.out.println("c: " + c);
+        System.out.println();
+
+        c.wplata(8);
+        System.out.println("a: " + a);
+        System.out.println("b: " + b);
+        System.out.println("c: " + c);
+        System.out.println();
+
+        b = a;
+        System.out.println("a: " + a);
+        System.out.println("b: " + b);
+        System.out.println("c: " + c);
+        System.out.println();
+
+        c = b;
+        // tracimy dowiązanie do konta nr 2
+        System.out.println("a: " + a);
+        System.out.println("b: " + b);
+        System.out.println("c: " + c);
+        System.out.println();
+
+        a = null; // null mówi, że zmienna nie wskazuje na żaden obiekt
+        System.out.println("a: " + a);
+        System.out.println("b: " + b);
+        System.out.println("c: " + c);
+        System.out.println();
+
+        c = b = a;
+        System.out.println("a: " + a);
+        System.out.println("b: " + b);
+        System.out.println("c: " + c);
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p11_referencje/Referencje2.java

+package alx.p11_referencje;
+
+public class Referencje2 {
+
+
+	static void metoda(Konto a, Konto b, int x) {
+		System.out.println("Początek metody");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("x: " + x);
+		System.out.println();
+
+		// zmiana wartości typu prostego zawsze jest lokalna; w main nadal bedzie 5000
+		x += 55;
+
+		// zmiana wewnątrz obiektu jest widoczna dla innych (innych metod, innych wątków...)
+		// w maina na końcu będzie 1024
+		a.wplata(24); // alternatywnie a.saldo += 24
+
+		// Zmiana samej zmiennej typu obiektowego (wpisanie wskaźnika do innego obiektu)
+		// jest lokalna. Inne metody / wątki tego nie zauważą.
+		// main w zmiennej b nadal będzie widział Konto nr 2 z saldem 2000.
+		b = a;
+		b.saldo += 1;
+
+		System.out.println("Koniec metody");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("x: " + x);
+		System.out.println();
+	}
+
+	public static void main(String[] args) {
+		Osoba ala = new Osoba("Ala", "Kowalska", 30);
+		Osoba ola = new Osoba("Ola", "Malinowska", 20);
+
+		Konto a = new Konto(1, 1000, ala);
+		Konto b = new Konto(2, 2000, ola);
+		int x = 5000;
+		
+		System.out.println("Początek programu");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("x: " + x);
+		System.out.println();
+		
+		metoda(a, b, x);
+		
+		System.out.println("Z powrotem w main");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("x: " + x);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p11_referencje/Referencje3.java

+package alx.p11_referencje;
+
+public class Referencje3 {
+
+	static void metoda(Konto a, Konto b, Konto c, int x) {
+		System.out.println("Początek metody");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);
+		System.out.println("x: " + x);
+		System.out.println();
+
+		x += 55;
+		b.wplata(44);
+
+		a = new Konto(a.numer, a.saldo, a.wlasciciel);
+		a.saldo = 1033;
+		a.wlasciciel.imie = "Alicja";
+		
+		System.out.println("Koniec metody");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);
+		System.out.println("x: " + x);
+		System.out.println();
+	}
+
+	public static void main(String[] args) {
+		Osoba ala = new Osoba("Ala", "Kowalska", 30);
+		Osoba ola = new Osoba("Ola", "Malinowska", 20);
+
+		Konto a = new Konto(1, 1000, ala);
+		Konto b = new Konto(2, 2000, ola);
+		Konto c = b;
+		int x = 5000;
+		
+		System.out.println("Początek programu");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);
+		System.out.println("x: " + x);
+		System.out.println();
+		
+		metoda(a, b, c, x);
+		
+		System.out.println("Z powrotem w main");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);
+		System.out.println("x: " + x);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p11_referencje/tutor/Referencje2_Wersja_Tutor.java

+package alx.p11_referencje.tutor;
+
+// Od tego miejsca (bez pakietu) skopiujcie to do
+// http://pythontutor.com/visualize.html
+
+class Osoba {
+	String imie, nazwisko;
+	int wiek;
+	Osoba() {
+	}
+    
+	Osoba(String imie, String nazwisko, int wiek) {
+    	this.imie = imie;
+    	this.nazwisko = nazwisko;
+    	this.wiek = wiek;
+	}
+
+	public String toString() {
+    	return imie + " " + nazwisko + " (" + wiek + " l)";
+	}
+}
+
+class Konto {
+	int numer;
+	int saldo;
+	Osoba wlasciciel;
+    
+	public Konto(int numer, int saldo, Osoba wlasciciel) {
+    	this.numer = numer;
+    	this.saldo = saldo;
+    	this.wlasciciel = wlasciciel;
+	}
+    
+	@Override
+	public String toString() {
+    	return "Konto nr " + numer + ", " + saldo + " PLN, wł. " + wlasciciel;
+	}
+    
+	void wplata(int kwota) {
+    	saldo += kwota;
+	}
+}
+
+public class Referencje2_Wersja_Tutor {
+    
+	static void metoda(Konto a, Konto b, Konto c, int x) {
+    	x += 14;
+    	b.wplata(24);
+   	 
+    	a = new Konto(b.numer, b.saldo, b.wlasciciel);
+    	a.saldo += 77;
+    	a.wlasciciel.imie = "Alicja";
+	}
+
+	public static void main(String[] args) {
+    	Osoba ala = new Osoba("Ala", "Kowalska", 30);
+    	Osoba ola = new Osoba("Ola", "Malinowska", 25);
+   	 
+    	Konto a = new Konto(1, 1000, ala);
+    	Konto b = new Konto(2, 2000, ola);
+    	Konto c = b;
+    	int x = 5000;
+   	 
+    	metoda(a, b, c, x);
+   	 
+    	b = null;
+    	a = b;
+	}
+}
+
+

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/konstruktory_z_nadklasy/ProblemZKonstruktorem.java

+package alx.p12_klasy_tech.a01_dziedziczenie.konstruktory_z_nadklasy;
+
+class AA {
+	// klasa posiada konstruktor(y) z parametrami, a nie posiada konstruktora bezparametrowego
+	AA(String nazwa) {
+		
+	}
+}
+
+/*
+// wówczas nie skompiluje się podklasa bez żadnego konstruktora
+class BB extends AA {
+}
+
+// ponieważ gdy nie napiszemy żadnego własnego konstruktora, automatycznie generowany jest taki:
+class CC extends AA {
+	public CC() {
+		super();
+	}
+}
+
+// nie można również w podklasach pisać własnych konstruktorów, które nie robią super:
+class DD extends AA {
+	String mojeImie;
+	DD(String imie) {
+		mojeImie = imie;
+	}
+	// ponieważ gdy nie napiszemy na początrku konstruktora super(...) ani this(...)
+	// to automatycznie wstawiane jest super()  (bez parametrów)
+}
+
+class EE extends AA {
+	EE() {
+		super("Ala");
+		// OK
+	}
+}
+
+class FF extends AA {
+	FF(String arg) {
+		super(arg);
+		// OK
+	}
+	
+	FF() {
+		this("Ola"); // wskazanie innego konstruktora z tej samej klasy
+	}
+	
+	FF(int x) {
+		// this lub super muszą być pierwszą instrukcją w konstruktorze
+		
+		// System.out.println(x); // gdybym odkomentował, to przestanie się kompilować
+		super(String.valueOf(x));
+	}
+}
+
+
+public class ProblemZKonstruktorem {
+	public static void main(String[] args) {
+		// nie ma konstruktora domyślnego - nie da się w tak prosty sposób utworzyć obiektu
+		AA a1 = new AA();
+	}
+
+}
+*/

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/nadpisywanie/ZasadyNadpisywania.java

+package alx.p12_klasy_tech.a01_dziedziczenie.nadpisywanie;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+class Nadklasa {
+	// nadklasa, z której potem będziemy dziedziczyć
+	int m01() {
+		return 34;
+	}
+	
+	Number m02() {
+		return 23;
+	}
+	
+	Nadklasa m02a() {
+		return this;
+	}
+
+	Integer m03() {
+		return 27;
+	}
+
+	String m04() {
+		return "Ala";
+	}
+
+	public String m05() {
+		return "Ala";
+	}
+
+	private String m06() {
+		return "Alicja";
+	}
+
+	public String m07(String arg) {
+		return "napis " + arg;
+	}
+	
+	public void m08() throws IOException {
+		
+	}
+
+	public void m09() throws IOException {
+		
+	}
+
+	public void m10() throws FileNotFoundException {
+		
+	}
+
+	public void m11() {
+	}
+
+	public void m12() {
+	}
+	
+	@Override
+	public Nadklasa clone() throws CloneNotSupportedException {
+		return (Nadklasa)super.clone();
+	}
+}
+
+
+class Podklasa extends Nadklasa {
+// typ wyniku musi być dokładnie taki sam (jeśli mówimy o typach prostych)
+//	long m01() {
+//		return 43;
+//	}
+	
+//	short m01() {
+//		return 43;
+//	}
+
+	int m01() {
+		return 43;
+	}
+	
+// typ wyniku można "zawęzić"/"ukonkretnić" jeśli mówimy o typie klasowym
+// jesli w nadklasie metoda zwraca coś bardziej ogólnego, to w podklasie można zwrócić coś bardziej konkretnego
+	Long m02() {
+		return 432L;
+	}
+
+	Podklasa m02a() {
+		return this;
+	}
+
+	
+//	Number m03() {
+//		return 27;
+//	}
+
+// nie mozna zmniejszyć poziomu widoczności
+//	private String m04() {
+//		return "Ala";
+//	}
+	
+	// ale można zwiększyć
+	protected String m04() {
+		return "Ala";
+	}
+
+	// zmiejszenie widczności
+//	String m05() {
+//		return "Ala";
+//	}
+
+//	protected String m05() {
+//		return "Ala";
+//	}
+
+	// tutaj nie mamy do czynienia z nadpisywaniem, bo metody prywatne nie są dziedziczone
+	// @Override
+	public int m06() throws IOException {
+		return 9;
+	}
+
+	// to też nie jest nadpisanie, tylko przeciążanie (to jest inna metoda) - może być dowolna jeśli chodzi o wynik, widocznośc i wyjątki
+	// @Override
+	int m07(int arg) throws FileNotFoundException {
+		return 10*arg;
+	}
+	
+	public void m08() {
+		
+	}
+
+	public void m09() throws FileNotFoundException {
+		//FileNotFoundException jest podklasą IOException
+	}
+
+//	public void m10() throws IOException {
+//	}
+	// dotyczy tylko wyjątków checked
+
+	public void m10() {
+	}
+
+	public void m11() throws IllegalArgumentException {
+		throw new IllegalArgumentException("bla bla");
+	}
+
+//	public void m12() throws Exception {
+//	}
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/nadpisywanie/ZastosowaniaKonkretyzacji.java

+package alx.p12_klasy_tech.a01_dziedziczenie.nadpisywanie;
+
+abstract class Zwierze {
+	Zwierze self() {
+		return this;
+	}
+}
+
+class Pies extends Zwierze {
+	Pies self() {
+		return this;
+	}
+}
+
+class Kot extends Zwierze {
+	Kot self() {
+		return this;
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/nadpisywanie_i_przeslanianie/A.java

+package alx.p12_klasy_tech.a01_dziedziczenie.nadpisywanie_i_przeslanianie;
+
+public class A {
+	static String zmienna_statyczna = "zmienna statyczna A";
+	
+	String zmienna_instancyjna = "zmienna instancyjna A";
+	
+	static String metoda_statyczna() {
+		return "metoda statyczna A";
+	}
+
+	String metoda_instancyjna() {
+		return "metoda instancyjna A";
+	}
+	
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/nadpisywanie_i_przeslanianie/B.java

+package alx.p12_klasy_tech.a01_dziedziczenie.nadpisywanie_i_przeslanianie;
+
+public class B extends A {
+	static String zmienna_statyczna = "zmienna statyczna B";
+	
+	String zmienna_instancyjna = "zmienna instancyjna B";
+	
+	static String metoda_statyczna() {
+		return "metoda statyczna B";
+	}
+
+	String metoda_instancyjna() {
+		return "metoda instancyjna B";
+	}
+	
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/nadpisywanie_i_przeslanianie/Test.java

+package alx.p12_klasy_tech.a01_dziedziczenie.nadpisywanie_i_przeslanianie;
+
+public class Test {
+
+	public static void main(String[] args) {
+		A a = new A();
+		B b = new B();
+		
+		A[] razem = {a, b};
+		
+		System.out.println("A a");
+		System.out.println(a.zmienna_statyczna);
+		System.out.println(a.zmienna_instancyjna);
+		System.out.println(a.metoda_statyczna());
+		System.out.println(a.metoda_instancyjna());
+		System.out.println();
+
+		System.out.println("B b");
+		System.out.println(b.zmienna_statyczna);
+		System.out.println(b.zmienna_instancyjna);
+		System.out.println(b.metoda_statyczna());
+		System.out.println(b.metoda_instancyjna());
+		System.out.println();
+
+		for(A e : razem) {
+			System.out.println("element typu " + e.getClass());
+			System.out.println(e.zmienna_statyczna);
+			System.out.println(e.zmienna_instancyjna);
+			System.out.println(e.metoda_statyczna());
+			System.out.println(e.metoda_instancyjna());
+			System.out.println();
+		}
+		
+		// Nadpisywanie (overriding) działa tylko dla metod instancyjnych.
+		// W przypadku zmiennych  instancyjnych i statycznych oraz oraz metod statycznych
+		// mamy do czynienia z "przesłanianiem".
+		
+		// Poza tym odwołania do rzeczy statycznych poprzez obiekt są tłumaczone w czasie kompilacji na odwołania do klas.
+		System.out.println(A.metoda_statyczna());
+		System.out.println(B.metoda_statyczna());
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/nadpisywanie_i_przeslanianie/TestOsobaStudent.java

+package alx.p12_klasy_tech.a01_dziedziczenie.nadpisywanie_i_przeslanianie;
+
+// nadpisywanie nie działa dla metod statycnzych.
+// zmień metody cenaBiletu na static i zobacz co się stanie
+class Osoba {
+	int cenaBiletu() {
+		return 6;
+	}
+}
+
+class Student extends Osoba {
+	int cenaBiletu() {
+		return 3;
+	}
+}
+
+public class TestOsobaStudent {
+
+	public static void main(String[] args) {
+		Osoba o = new Osoba();
+		Student s = new Student();
+		
+		System.out.println("Bilet normalny: " + o.cenaBiletu());
+		System.out.println("Bilet studencki: " + s.cenaBiletu());
+		System.out.println();
+		
+		sprzedajBilet(o);
+		sprzedajBilet(s);
+	}
+	
+	static void sprzedajBilet(Osoba klient) {
+		System.out.println("Klientowi klasy " + klient.getClass().getSimpleName()
+				+ " sprzedam bilet za " + klient.cenaBiletu());
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/przeslanianie/A.java

+package alx.p12_klasy_tech.a01_dziedziczenie.przeslanianie;
+
+public class A {
+	static String zmienna_statyczna = "zmienna statyczna A";
+	
+	String zmienna_instancyjna = "zmienna instancyjna A";
+	
+	static String metoda_statyczna() {
+		return "metoda statyczna A";
+	}
+
+	String metoda_instancyjna() {
+		return "metoda instancyjna A";
+	}
+	
+	void wypiszA() {
+		System.out.println(zmienna_instancyjna);
+	}
+	
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/przeslanianie/B.java

+package alx.p12_klasy_tech.a01_dziedziczenie.przeslanianie;
+
+public class B extends A {
+	static String zmienna_statyczna = "zmienna statyczna B";
+	
+	String zmienna_instancyjna = "zmienna instancyjna B";
+	
+	static String metoda_statyczna() {
+		return "metoda statyczna B";
+	}
+
+	String metoda_instancyjna() {
+		return "metoda instancyjna B";
+	}
+	
+	void wypiszB() {
+		System.out.println(zmienna_instancyjna);
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/przeslanianie/Test.java

+package alx.p12_klasy_tech.a01_dziedziczenie.przeslanianie;
+
+public class Test {
+
+	public static void main(String[] args) {
+		A a = new A();
+		B b = new B();
+		
+		A[] razem = {a, b};
+		
+		System.out.println("A a");
+		System.out.println(a.zmienna_statyczna);
+		System.out.println(a.zmienna_instancyjna);
+		System.out.println(a.metoda_statyczna());
+		System.out.println(a.metoda_instancyjna());
+		System.out.println();
+		a.wypiszA();
+		System.out.println();
+
+		System.out.println("B b");
+		System.out.println(b.zmienna_statyczna);
+		System.out.println(b.zmienna_instancyjna);
+		System.out.println(b.metoda_statyczna());
+		System.out.println(b.metoda_instancyjna());
+		System.out.println();
+		b.wypiszA();
+		b.wypiszB();
+		System.out.println();
+
+		for(A e : razem) {
+			System.out.println("element typu " + e.getClass());
+			System.out.println(e.zmienna_statyczna);
+			System.out.println(e.zmienna_instancyjna);
+			System.out.println(e.metoda_statyczna());
+			System.out.println(e.metoda_instancyjna());
+			System.out.println();
+		}
+		
+		// Nadpisywanie (overriding) działa tylko dla metod instancyjnych.
+		// W przypadku zmiennych  instancyjnych i statycznych oraz oraz metod statycznych
+		// mamy do czynienia z "przesłanianiem".
+		
+		// Poza tym odwołania do rzeczy statycznych poprzez obiekt są tłumaczone w czasie kompilacji na odwołania do klas.
+		System.out.println(A.metoda_statyczna());
+		System.out.println(B.metoda_statyczna());
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/przeslanianie/TestOsobaStudent.java

+package alx.p12_klasy_tech.a01_dziedziczenie.przeslanianie;
+
+// nadpisywanie nie działa dla metod statycnzych.
+// zmień metody cenaBiletu na static i zobacz co się stanie
+class Osoba {
+	int cenaBiletu() {
+		return 6;
+	}
+}
+
+class Student extends Osoba {
+	int cenaBiletu() {
+		return 3;
+	}
+}
+
+public class TestOsobaStudent {
+
+	public static void main(String[] args) {
+		Osoba o = new Osoba();
+		Student s = new Student();
+		
+		System.out.println("Bilet normalny: " + o.cenaBiletu());
+		System.out.println("Bilet studencki: " + s.cenaBiletu());
+		System.out.println();
+		
+		sprzedajBilet(o);
+		sprzedajBilet(s);
+	}
+	
+	static void sprzedajBilet(Osoba klient) {
+		System.out.println("Klientowi klasy " + klient.getClass().getSimpleName()
+				+ " sprzedam bilet za " + klient.cenaBiletu());
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/przeslanianie/TestOverridingu.java

+package alx.p12_klasy_tech.a01_dziedziczenie.przeslanianie;
+
+public class TestOverridingu {
+
+	public static void main(String[] args) {
+		A obiekt = new B();
+		
+		System.out.println(obiekt.zmienna_statyczna);
+		System.out.println(obiekt.zmienna_instancyjna);
+		System.out.println(obiekt.metoda_statyczna());
+		System.out.println(obiekt.metoda_instancyjna());
+		
+		// Overriding działa tylko dla metod instancyjnych. O tym która wersja metody się wykona decyduje klasa obiektu w pamięci w czasie działania programu.
+		
+		// Dla zmiennych oraz dla metod statycznych o tym co się wypisze/co zadziała decyduje typ zmiennej.
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/superthis/A.java

+package alx.p12_klasy_tech.a01_dziedziczenie.superthis;
+
+public class A {
+	public void print() {
+		System.out.println("Jestem A");
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/superthis/B.java

+package alx.p12_klasy_tech.a01_dziedziczenie.superthis;
+
+public class B extends A {
+	public void print() {
+		System.out.println("Jestem B");
+	}
+
+	public void testSuper() {
+		this.print();
+		super.print();
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/superthis/C.java

+package alx.p12_klasy_tech.a01_dziedziczenie.superthis;
+
+public class C extends B {
+	public void print() {
+		System.out.println("Jestem C");
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a01_dziedziczenie/superthis/TestSuper.java

+package alx.p12_klasy_tech.a01_dziedziczenie.superthis;
+
+public class TestSuper {
+
+	public static void main(String[] args) {
+		System.out.println("sprawdzam B");
+		B b = new B();
+		b.testSuper();
+		System.out.println();
+		
+		System.out.println("sprawdzam C");
+		C c = new C();
+		c.testSuper();
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v1/A.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v1;
+
+public class A {
+	
+	{
+		// to jest "blok inicjalizacyjny"
+		// wykonuje się podczas tworzenia każdego obiektu, przed konstruktorem
+		System.out.println("init A 1");
+	}
+	
+	A() {
+		System.out.println("A()");
+	}
+	
+	{
+		// jeśli jest wiele bloków, to wykonują się w kolejności w jakiej zostały wpisane, ale przed konstruktorem
+		System.out.println("init A 2");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v1/Test1.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v1;
+
+public class Test1 {
+
+	public static void main(String[] args) {
+		System.out.println("Początek main");
+		
+		A a = new A();
+		
+		System.out.println("Koniec main");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v1/Test2.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v1;
+
+public class Test2 {
+
+	public static void main(String[] args) {
+		System.out.println("Początek main");
+		
+		A a1 = new A();
+		A a2 = new A();
+		
+		new A();
+		
+		System.out.println("Koniec main");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v1/X.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v1;
+
+public class X {
+	
+	{ System.out.println("foo"); }
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v2/A.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v2;
+
+public class A {
+	
+	static {
+		// to jest "blok inicjalizacyjny statyczny"
+		// wykonuje się gdy klasa po raz pierwszy jest potrzebna i jest ładowana do pamięci
+		System.out.println("static A 1");
+	}
+	
+	{
+		// to jest "blok inicjalizacyjny"
+		// wykonuje się podczas tworzenia każdego obiektu, przed konstruktorem
+		System.out.println("init A 1");
+	}
+	
+	A() {
+		System.out.println("A()");
+	}
+	
+	{
+		// jeśli jest wiele bloków, to wykonują się w kolejności w jakiej zostały wpisane, ale przed konstruktorem
+		System.out.println("init A 2");
+	}
+
+	static {
+		System.out.println("static A 2");
+	}
+
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v2/SuperStatic.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v2;
+
+public class SuperStatic {
+	static {
+		System.out.println("super static");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v2/Test1.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v2;
+
+public class Test1 {
+
+	public static void main(String[] args) {
+		System.out.println("Początek main");
+		
+		A a = new A();
+		
+		System.out.println("Koniec main");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v2/Test2.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v2;
+
+public class Test2 extends SuperStatic {
+
+	public static void main(String[] args) {
+		System.out.println("Początek main");
+		
+		A a1 = new A();
+		A a2 = new A();
+		
+		new A();
+		
+		System.out.println("Koniec main");
+	}
+	
+	static {
+		System.out.println("static Test - jeszcze przed mainem");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v3/A.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v3;
+
+public class A {
+	private int x = 5;
+
+	public A() {
+		System.out.println("konstruktor A() " + ++x);
+	}
+	
+	static {
+		System.out.println("static A");
+	}
+	
+	{
+		System.out.println("init A " + ++x);
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v3/B.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v3;
+
+public class B extends A {
+	static {
+		System.out.println("static B");
+	}
+
+	public B() {
+		// System.out.println("Konstruktor B()");
+		this(44);
+		System.out.println("Konstruktor B()");
+		
+		// wywołanie this() albo super() (jeśli jest jawnie wpisane) musi być pierwszą instrukcją konstruktora
+		// a jeśli nie ma jawnego wywołania, to niejawnie wywoływane jest super() bez parametrów
+	}
+
+	{
+		System.out.println("init B 1");
+	}
+	
+	public B(int arg) {
+		super();
+		// < w tym momencie wykonają się init B
+		System.out.println("Konstruktor B(" + arg + ")");
+	}
+
+	{
+		System.out.println("init B 2");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v3/Test.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v3;
+
+public class Test {
+
+	public static void main(String[] args) {
+		
+		System.out.println("Początek main, wątek " + Thread.currentThread().getId());
+		
+		// deklaracja zmiennej nie wymusza ładowania klasy
+		B bbb = null;
+		System.out.println("mam nulla");
+		System.out.println();
+		
+//		A a = new A();	
+//		System.out.println("Obiekt a utworzony\n");
+
+		B b = new B();
+		System.out.println("Obiekt b utworzony\n");
+
+		A c = new B(13);
+		System.out.println("Obiekt c utworzony\n");
+
+		System.out.println("Koniec main");
+
+	}
+
+	static {
+		System.out.println("static Test, wątek " + Thread.currentThread().getId());
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v4/A.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v4;
+
+public class A {
+
+	A() {
+		System.out.println("A()");
+		System.out.println(" w konstruktorze x == " + x); // OK
+	}
+
+	{
+		System.out.println("init A 1");
+		// w bloku init nie wolno odczytywać zmiennych instancyjnych, które są zadeklarowane później
+		//NK System.out.println(" w init 1 x == " + x); // zle, bo zmienna jest dalej
+		// System.out.println(y);
+
+		// ale można zapisywać!!!!
+		y = 20;
+		// System.out.println(y);
+		z = 50;
+		//NK System.out.println(z);
+	}
+	
+	int x = Utils.przypisz(44);
+	int y = 10;
+	final int z;
+
+	{
+		System.out.println("init A 2");
+		System.out.println(" w init 2 x == " + x); // OK, bo zmienna była wcześniej
+		System.out.println(" w init 2 y == " + y);
+		System.out.println(" w init 2 z == " + z);
+	}
+
+	A(int i) {
+		System.out.println("A(int) " + i);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v4/Static.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v4;
+
+public class Static {
+
+	static {
+		System.out.println("static 1");
+		//NK System.out.println(" w static 1 x == " + x); // zle, bo zmienna jest dalej
+	}
+	
+	{ // blok inicjalizacyjny obiektu może odwołać się do zmiennych statycznych
+		System.out.println(x);
+	}
+	
+	static int x = Utils.przypisz(33);
+
+	static {
+		System.out.println("static 2");
+		System.out.println(" w static 2 x == " + x); // OK, bo zmienna była wcześniej
+	}
+
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v4/StaticObejscie.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v4;
+
+public class StaticObejscie {
+	
+	static {
+		System.out.println("static 1");
+		// System.out.println(" w static 1 x == " + x);
+		System.out.println(" w static 1 x == " + getX()); // tu jest 0
+	}
+	
+	final static int x = Utils.przypisz(33);
+
+	static {
+		System.out.println("static 2");
+		System.out.println(" w static 2 x == " + getX()); // tu jest 33
+	}
+
+	static int getX() {
+		return x;
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v4/StaticObejscie2.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v4;
+
+public class StaticObejscie2 {
+	
+	static {
+		System.out.println("static 1");
+		x = 55;
+		System.out.println(" w static 1 x == " + getX()); // tu jest 55
+	}
+	
+	static int x = Utils.przypisz(33);
+
+	static {
+		System.out.println("static 2");
+		System.out.println(" w static 2 x == " + getX()); // a tu 33
+	}
+
+	static int getX() {
+		return x;
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v4/TestA.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v4;
+
+public class TestA {
+
+	public static void main(String[] args) {
+		System.out.println("Tworzę pierwszy obiekt...");
+		A a = new A();
+
+		System.out.println();
+		System.out.println("Tworzę drugi obiekt...");
+		new A(15);
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v4/TestStatic.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v4;
+
+public class TestStatic {
+
+	public static void main(String[] args) {
+		System.out.println("początek");
+		
+		Static zmienna = new Static();
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v4/TestStaticObejscie.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v4;
+
+public class TestStaticObejscie {
+
+	public static void main(String[] args) {
+		System.out.println("początek");
+		
+		StaticObejscie zmienna = new StaticObejscie();
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v4/TestStaticObejscie2.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v4;
+
+public class TestStaticObejscie2 {
+
+	public static void main(String[] args) {
+		System.out.println("początek");
+		
+		StaticObejscie2 zmienna = new StaticObejscie2();
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/v4/Utils.java

+package alx.p12_klasy_tech.a02_inicjalizacja.v4;
+
+public class Utils {
+	public static int przypisz(int x) {
+		System.out.println("przypisuję " + x);
+		return x;
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/zmienne/A.java

+package alx.p12_klasy_tech.a02_inicjalizacja.zmienne;
+
+public class A {
+	char c;
+	int a;
+	double d;
+	boolean bool;
+	String s;
+	Integer i;
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a02_inicjalizacja/zmienne/TestA.java

+package alx.p12_klasy_tech.a02_inicjalizacja.zmienne;
+
+public class TestA {
+
+	public static void main(String[] args) {
+		A obiekt = new A();
+		
+		System.out.println(obiekt.a);
+		System.out.println(obiekt.bool);
+		System.out.println(obiekt.c);
+		System.out.println((int)obiekt.c);
+		System.out.println(obiekt.d);
+		System.out.println(obiekt.s);
+		System.out.println(obiekt.i);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a03_statyczne/A.java

+package alx.p12_klasy_tech.a03_statyczne;
+
+public class A {
+	int instancyjna = 100;
+	static int statyczna = 200;
+	
+	static void statyczna() {
+		System.out.println(statyczna);
+		//NK System.out.println(instancyjna); // bo "nie wiemy z jakiego obiektu"
+		System.out.println(new A().instancyjna);
+		
+		//NK instancyjna();
+	}
+
+	void instancyjna() {
+		System.out.println(statyczna);
+		System.out.println(A.statyczna);
+		System.out.println(this.statyczna); // brzydko, ale się kompiluje
+		
+		System.out.println(instancyjna);
+		System.out.println(this.instancyjna);
+		
+		statyczna(); // OK
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a03_statyczne/Test1.java

+package alx.p12_klasy_tech.a03_statyczne;
+
+public class Test1 {
+
+	public static void main(String[] args) {
+		A a1 = new A();
+		A a2 = new A();
+				
+		a1.instancyjna = 1;
+		a2.instancyjna = 2;
+		a1.statyczna  = 11;
+		a2.statyczna  = 12;
+
+		System.out.println(a1.instancyjna);
+		System.out.println(a2.instancyjna);
+		System.out.println(a1.statyczna);
+		System.out.println(a2.statyczna);
+		System.out.println();
+		System.out.println(A.statyczna);
+		System.out.println();
+		System.out.println("--------");
+		System.out.println();
+		
+		//NK A.instancyjna();
+		a1.instancyjna();
+		
+		A.statyczna();
+		a1.statyczna();
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a03_statyczne/Test2.java

+package alx.p12_klasy_tech.a03_statyczne;
+
+public class Test2 {
+
+	public static void main(String[] args) {
+		A a1 = new A();
+		A a2 = new A();
+		
+		System.out.println(a1.instancyjna);
+		System.out.println(a2.instancyjna);
+		System.out.println(a1.statyczna);
+		System.out.println(a2.statyczna);
+		System.out.println();
+		
+		System.out.println("++");
+		System.out.println(++a1.instancyjna);
+		System.out.println(++a2.instancyjna);
+		System.out.println();
+		System.out.println(++a1.statyczna);
+		System.out.println(++a2.statyczna);
+		System.out.println(++A.statyczna);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a03_statyczne/Test3.java

+package alx.p12_klasy_tech.a03_statyczne;
+
+public class Test3 {
+
+	public static void main(String[] args) {
+		A a = new A();
+		
+		//NK A.instancyjna();
+		a.instancyjna();
+		
+		A.statyczna();
+		a.statyczna();
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a04_widocznosc/InnaKlasa.java

+package alx.p12_klasy_tech.a04_widocznosc;
+
+public class InnaKlasa {
+	public void metoda2(Klasa inny) {
+		//NK System.out.println(inny.prywatne);
+		System.out.println(inny.domyslne);
+		System.out.println(inny.chronione);
+		System.out.println(inny.publiczne);
+	}
+	
+	public static void main(String[] args) {
+		Klasa obiekt = new Klasa();
+		//NK System.out.println(obiekt.prywatne);
+		System.out.println(obiekt.domyslne);
+		System.out.println(obiekt.chronione);
+		System.out.println(obiekt.publiczne);
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a04_widocznosc/Klasa.java

+package alx.p12_klasy_tech.a04_widocznosc;
+
+public class Klasa {
+	private    int prywatne = 1;
+	           int domyslne = 2;
+	protected  int chronione = 3;
+	public     int publiczne = 4;
+
+	public void metoda() {
+		System.out.println(this.prywatne);
+		System.out.println(prywatne);
+		System.out.println(domyslne);
+		System.out.println(chronione);
+		System.out.println(publiczne);		
+	}
+
+	public void metoda2(Klasa inny) {
+		System.out.println(inny.prywatne);
+		System.out.println(inny.domyslne);
+		System.out.println(inny.chronione);
+		System.out.println(inny.publiczne);		
+		inny.prywatne = 101;
+	}
+
+	public static void main(String[] args) {
+		// Tutaj nie ma dostępu, bo jesteśmy w kontekście statycznym - poziomy widoczności nie mają nic do rzeczy.
+        //NK System.out.println(prywatne);
+        //NK System.out.println(publiczne);
+            
+		Klasa obiekt = new Klasa();
+		System.out.println(obiekt.prywatne);
+		System.out.println(obiekt.domyslne);
+		System.out.println(obiekt.chronione);
+		System.out.println(obiekt.publiczne);
+		
+		obiekt.metoda();
+		Klasa innyObiekt = new Klasa();
+		innyObiekt.prywatne = 19;
+		obiekt.metoda2(innyObiekt);
+		System.out.println(innyObiekt.prywatne);
+	}
+}
+

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a04_widocznosc/KlasaZaawansowana.java

+package alx.p12_klasy_tech.a04_widocznosc;
+
+public class KlasaZaawansowana {
+	private int prywatne = 1;
+	int domyslne = 2;
+	protected int chronione = 3;
+	public int publiczne = 4;
+
+	public void metoda() {
+		System.out.println(this.prywatne);
+		System.out.println(prywatne);
+		System.out.println(domyslne);
+		System.out.println(chronione);
+		System.out.println(publiczne);
+
+//OK Nested1 zagn = this.new Nested1();
+		Nested1 zagn = new Nested1();
+	}
+
+	public void metoda2(KlasaZaawansowana inny) {
+		System.out.println(inny.prywatne);
+		System.out.println(inny.domyslne);
+		System.out.println(inny.chronione);
+		System.out.println(inny.publiczne);
+		inny.prywatne = 101;
+	}
+
+	public static void main(String[] args) {
+//NK System.out.println(prywatne);
+//NK System.out.println(publiczne);
+
+		KlasaZaawansowana obiekt = new KlasaZaawansowana();
+		System.out.println(obiekt.prywatne);
+		System.out.println(obiekt.domyslne);
+		System.out.println(obiekt.chronione);
+		System.out.println(obiekt.publiczne);
+
+		obiekt.metoda();
+		KlasaZaawansowana innyObiekt = new KlasaZaawansowana();
+		innyObiekt.prywatne = 19;
+		obiekt.metoda2(innyObiekt);
+		System.out.println(innyObiekt.prywatne);
+
+		Nested1 zagniezdzony = obiekt.new Nested1();
+		zagniezdzony.metodaX();
+
+		Nested1 zagniezdzony1 = new KlasaZaawansowana().new Nested1();
+		zagniezdzony1.metodaX();
+
+		Nested2 zagniezdzony2 = new Nested2();
+		zagniezdzony2.metodaX();
+	}
+
+	class Nested1 {
+// klasa zagnieżdżona instancyjna
+		public void metodaX() {
+			System.out.println(prywatne);
+			System.out.println(domyslne);
+			System.out.println(chronione);
+			System.out.println(publiczne);
+		}
+	}
+
+	static class Nested2 {
+// klasa zagnieżdżona statyczna
+		public void metodaX() {
+			// bo nie jestesmy w zadnym obiekcie = jestesmy w kontekscie statycznym
+			// NK System.out.println(prywatne);
+			// NK System.out.println(domyslne);
+			// NK System.out.println(chronione);
+			// NK System.out.println(publiczne);
+		}
+
+		public void metodaY(KlasaZaawansowana inny) {
+			System.out.println(inny.prywatne);
+			System.out.println(inny.domyslne);
+			System.out.println(inny.chronione);
+			System.out.println(inny.publiczne);
+		}
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a04_widocznosc/inny_pakiet/KlasaWInnymPakiecie.java

+package alx.p12_klasy_tech.a04_widocznosc.inny_pakiet;
+
+import alx.p12_klasy_tech.a04_widocznosc.Klasa;
+
+public class KlasaWInnymPakiecie {
+	public void metoda2(Klasa inny) {
+		//NK System.out.println(inny.prywatne);
+		//NK System.out.println(inny.domyslne);
+		//NK System.out.println(inny.chronione);
+		System.out.println(inny.publiczne);
+	}
+	
+	public static void main(String[] args) {
+		Klasa obiekt = new Klasa();
+		//NK System.out.println(obiekt.prywatne);
+		//NK System.out.println(obiekt.domyslne);
+		//NK System.out.println(obiekt.chronione);
+		System.out.println(obiekt.publiczne);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a04_widocznosc/inny_pakiet/Podklasa.java

+package alx.p12_klasy_tech.a04_widocznosc.inny_pakiet;
+
+import alx.p12_klasy_tech.a04_widocznosc.Klasa;
+
+public class Podklasa extends Klasa {
+
+	public void metoda() {
+		//NK System.out.println(prywatne);
+		//NK System.out.println(this.prywatne);
+		//NK System.out.println(domyslne);
+		System.out.println(chronione);
+		System.out.println(this.chronione);
+		System.out.println(publiczne);		
+		
+		//NK ((Klasa)this).chronione = 44;
+		((Klasa)this).publiczne = 45;
+	}
+	
+	public void metoda2(Klasa inny) {
+		//NK System.out.println(inny.prywatne);
+		//NK System.out.println(inny.domyslne);
+		//NK System.out.println(inny.chronione);
+		System.out.println(inny.publiczne);
+
+		// Gdyby Osoba miała pole protected pesel, to:
+		// Osoba ma dostęp do peselu innej osoby
+		// Student ma dostęp do peselu innego studenta
+		// Student nie ma dostępu do peselu osoby
+	}
+
+	public void metoda3(Podklasa inny) {
+		//NK System.out.println(inny.prywatne);
+		//NK System.out.println(inny.domyslne);
+		System.out.println(inny.chronione);
+		System.out.println(inny.publiczne);
+	}
+
+	public static void main(String[] args) {
+		Klasa obiekt = new Klasa();
+		//NK System.out.println(obiekt.prywatne);
+		//NK System.out.println(obiekt.domyslne);
+		//NK System.out.println(obiekt.chronione);
+		System.out.println(obiekt.publiczne);
+
+		Podklasa obiekt2 = new Podklasa();
+		//NK System.out.println(obiekt2.prywatne);
+		//NK System.out.println(obiekt2.domyslne);
+		System.out.println(obiekt2.chronione);
+		System.out.println(obiekt2.publiczne);
+
+		Klasa obiekt3 = new Podklasa();
+		//NK System.out.println(obiekt3.prywatne);
+		//NK System.out.println(obiekt3.domyslne);
+		//NK System.out.println(obiekt3.chronione);
+		System.out.println(obiekt3.publiczne);
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a01_podstawy/Przeciazanie1.java

+package alx.p12_klasy_tech.a05_przeciazanie.a01_podstawy;
+
+public class Przeciazanie1 {
+	
+	// w jednej klasie można mieć wiele metod o tej samej nazwie
+	// pod warunkiem, że te metody różnią się listą typów parametrów
+	void print() {
+		System.out.println("print()");
+	}
+	
+	void print(String arg) {
+		System.out.println("print(String) " + arg);
+	}
+
+	void print(int arg) {
+		System.out.println("print(int) " + arg);
+	}
+
+	void print(int arg1, int arg2) {
+		System.out.println("print(int, int) " + arg1 + " " + arg2);
+	}
+
+	// nawet tak subtelne różnice typu sa wystarczające
+	void print(long arg1, int arg2) {
+		System.out.println("print(long, int) " + arg1 + " " + arg2);
+	}
+
+	void print(int arg1, long arg2) {
+		System.out.println("print(int, long) " + arg1 + " " + arg2);
+	}
+
+	void print(long arg1, long arg2) {
+		System.out.println("print(long, long) " + arg1 + " " + arg2);
+	}
+
+	void print(Integer arg1, int arg2) {
+		System.out.println("print(Integer, int) " + arg1 + " " + arg2);
+	}
+
+	// nie wystarczają natomiast:
+// 1) nazwy parametrów
+//	void print(int x, int y) {
+//		System.out.println("x y");
+//	}
+
+// 2) typ wynikowy
+//	int print(int arg1, int arg2) {
+//	}
+//
+//	String print(int arg1, int arg2) {
+//	}
+	
+
+	public static void main(String[] args) {
+		new Przeciazanie1().run();
+	}
+
+	private void run() {
+		print();
+		print(13);
+		print(13, 15);
+		print(22L, 1);
+		print("Ala");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a02_liczby/Liczby1.java

+package alx.p12_klasy_tech.a05_przeciazanie.a02_liczby;
+
+public class Liczby1 {
+	
+	static void m(int arg) {
+		System.out.println("int " + arg);
+	}
+
+	static void m(double arg) {
+		System.out.println("double " + arg);
+	}
+
+	static void m(String arg) {
+		System.out.println("String " + arg);
+	}
+	
+	public static void main(String[] args) {
+		m(5);
+		
+		byte b = 4;
+		// widening - parametr typu "węższego" może zostać przekazany do metody oczekującej typu "szerszego"
+		m(b);
+		
+		m('A');
+		
+		long l = 1;
+		m(l);
+		m(14L);
+		
+		m(3.14);
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a02_liczby/Liczby2.java

+package alx.p12_klasy_tech.a05_przeciazanie.a02_liczby;
+
+public class Liczby2 {
+	
+	static void m(int arg) {
+		System.out.println("int " + arg);
+	}
+
+	static void m(Integer arg) {
+		System.out.println("Integer " + arg);
+	}
+	
+	static void m(Double arg) {
+		System.out.println("Double " + arg);
+	}
+	
+	public static void main(String[] args) {
+		m(5);
+		m('A');
+
+		int i = 3;
+		m(i);
+		
+		Integer ii = 15;
+		m(ii);
+		m((Integer)i);
+		
+		double d = 3.14;
+		// autoboxing
+		m(d);
+
+		long l = 44L;
+		// nie działa taka kombinacja: najpierw widening, a potem autoboxing
+		//NK m(l);
+
+		m((double)l);
+		
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a02_liczby/Liczby3.java

+package alx.p12_klasy_tech.a05_przeciazanie.a02_liczby;
+
+public class Liczby3 {
+	
+	static void m(double arg) {
+		System.out.println("double " + arg);
+	}
+	
+	public static void main(String[] args) {
+		m(5);
+		
+		m(3.14);
+		
+		Double dd = 4.44;
+		// unboxing
+		m(dd);
+		
+		Long ll = 4L;
+		
+		// działa taka kombinacja: najpierw unboxing, a potem widening
+		m(ll);
+		
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a02_liczby/Liczby4.java

+package alx.p12_klasy_tech.a05_przeciazanie.a02_liczby;
+
+public class Liczby4 {
+    static void m(int x, long y) {
+        System.out.println("Ala ma kota");
+    }
+
+    static void m(long x, int y) {
+        System.out.println("Ola ma psa");
+    }
+
+    public static void main(String[] args) {
+        //NK m(13, 14);
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a02_liczby/ListaLiczb.java

+package alx.p12_klasy_tech.a05_przeciazanie.a02_liczby;
+
+import java.util.ArrayList;
+
+public class ListaLiczb {
+
+	public static void main(String[] args) {
+		ArrayList<Integer> lista = new ArrayList<>();
+		
+		System.out.println(lista);
+		
+		lista.add(10);
+		lista.add(30);
+		lista.add(40);
+		System.out.println(lista);
+		
+		lista.add(1, 20);
+		System.out.println(lista);
+		
+		// usuń spod podanego indeksu
+		Integer coUsunieto = lista.remove(1);
+		
+		// usuń element 40
+		boolean czyUsunieto = lista.remove((Integer)40);
+		
+		// Przykładowo na egzaminie moga napisać:
+		// a to się nie skompiluje, bo ta wersja remove nie zwraca boolean
+		int i = 13;
+//NK	if(lista.remove(i)) {
+//			
+//		}
+
+		// teraz OK - ta wersja remove zwraca boolean
+		Integer ii = 33;
+		if(lista.remove(ii)) {
+			
+		}
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a03_overloading_overriding/BiletUlgowy1.java

+package alx.p12_klasy_tech.a05_przeciazanie.a03_overloading_overriding;
+
+// Historia: mamy klasy Osoba i Student. Metoda cenaBiletu ma zwrócić cenę biletu w zależności od rodzaju klienta.
+// Wydawać by się mogło, że elegancko będzie zrobić przeciążanie. Ale...
+
+public class BiletUlgowy1 {
+	private static class Osoba {
+		
+	}
+	
+	private static class Student extends Osoba {
+		
+	}
+	
+	private static class KasaBiletowa {
+		int cenaBiletu(Osoba klient) {
+			return 50;
+		}
+
+		int cenaBiletu(Student klient) {
+			return 25;
+		}
+	}
+	
+	public static void main(String[] args) {
+		KasaBiletowa kasa = new KasaBiletowa();
+		
+		Osoba osoba = new Osoba();
+		Student student = new Student();
+		
+		System.out.println(kasa.cenaBiletu(osoba)); // 50
+		System.out.println(kasa.cenaBiletu(student)); // 25
+		System.out.println();
+		
+		Osoba[] osoby = {
+			new Osoba(),
+			new Student(),
+		};
+		for (Osoba o : osoby) {
+			System.out.println(o.getClass().getSimpleName()
+					+ " dostaje bilet w cenie "
+					+ kasa.cenaBiletu(o));
+		}
+		// Przeciążanie działa w czasie kompilacji, w oparciu o zadeklarowany typ zmiennej, a nie typ obiektu w pamięci.
+		// W tym przypadku wszyscy dostaną bilety za 50 zł.
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a03_overloading_overriding/BiletUlgowy2.java

+package alx.p12_klasy_tech.a05_przeciazanie.a03_overloading_overriding;
+
+// Klasy Osoba i Student posiadają metodę mówiącą czy posiada zniżkę, ale podaną jako metoda statyczna.
+// To też nie działa, bo dla metod statycznych nie działa nadpisywanie!
+
+public class BiletUlgowy2 {
+	private static class Osoba {
+		public static boolean czyMaZnizke() {
+			return false;
+		}
+	}
+
+	private static class Student extends Osoba {
+		public static boolean czyMaZnizke() {
+			return true;
+		}
+	}
+
+	private static class KasaBiletowa {
+		int cenaBiletu(Osoba klient) {
+			// tu zawsze wywołamy metod z klasy Osoba, tak jakby wołać Osoba.czyMaZnizke()
+			if(klient.czyMaZnizke()) {
+				return 25;
+			}
+			return 50;
+		}
+	}
+	
+	public static void main(String[] args) {
+		
+		KasaBiletowa kasa = new KasaBiletowa();
+		
+		Osoba osoba = new Osoba();
+		Student student = new Student();
+		
+		// niby OK
+		System.out.println(osoba.czyMaZnizke());
+		System.out.println(student.czyMaZnizke());
+		System.out.println();
+		
+		System.out.println(kasa.cenaBiletu(osoba)); // 50
+		System.out.println(kasa.cenaBiletu(student)); // 50
+		System.out.println();
+		
+		Osoba[] osoby = {
+			new Osoba(),
+			new Student(),
+		};
+		for (Osoba o : osoby) {
+			System.out.println(o.getClass().getSimpleName()
+					+ " dostaje bilet w cenie "
+					+ kasa.cenaBiletu(o));
+		}
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a03_overloading_overriding/BiletUlgowy3.java

+package alx.p12_klasy_tech.a05_przeciazanie.a03_overloading_overriding;
+
+// Ta wersja poprawna, informacja czy osoba ma zniżkę jest podawana w metodzie instancyjnej, która jest nadpisywana w podklasie.
+// Nieintuicyjne (nieżyciowe?... :) ) jest to, że osoba sama deklaruje czy ma zniżkę...
+// Nawet patrząc z punktu widzenia dobrych/złych praktyk programistycznych nie podoba mi się to,
+// że aby działał klasa KasaBiletowa muskmy dodawać nową metodę do klas Osoba i Student.
+// Nadpisywanie (overriding) działa w czasie wykonania (runtime) i bierze pod uwagę faktyczną klase obiektu w pamięciu.
+
+public class BiletUlgowy3 {
+	private static class Osoba {
+		public boolean czyMaZnizke() {
+			return false;
+		}
+	}
+	
+	private static class Student extends Osoba {
+		@Override
+		public boolean czyMaZnizke() {
+			return true;
+		}
+	}
+	
+	private static class KasaBiletowa {
+		int cenaBiletu(Osoba klient) {
+			if(klient.czyMaZnizke()) {
+				return 25;
+			}
+			return 50;
+		}
+	}
+	
+	public static void main(String[] args) {
+		
+		KasaBiletowa kasa = new KasaBiletowa();
+		
+		Osoba osoba = new Osoba();
+		Student student = new Student();
+		
+		// OK
+		System.out.println(osoba.czyMaZnizke());
+		System.out.println(student.czyMaZnizke());
+		System.out.println();
+
+		System.out.println(kasa.cenaBiletu(osoba)); // 50
+		System.out.println(kasa.cenaBiletu(student)); // 25
+		System.out.println();
+		
+		Osoba[] osoby = {
+			new Osoba(),
+			new Student(),
+		};
+		for (Osoba o : osoby) {
+			System.out.println(o.getClass().getSimpleName()
+					+ " dostaje bilet w cenie "
+					+ kasa.cenaBiletu(o));
+		}
+		
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a03_overloading_overriding/BiletUlgowy4.java

+package alx.p12_klasy_tech.a05_przeciazanie.a03_overloading_overriding;
+
+
+// W tej wersji jawnie sprawdzamy typ obiektu.
+// Działa poprawnie i okazuje się być najbardziej sensownym rozwiązaniem.
+
+public class BiletUlgowy4 {
+	private static class Osoba {
+		
+	}
+
+	private static class Student extends Osoba {
+		
+	}
+
+	private static class KasaBiletowa {
+		int cenaBiletu(Osoba klient) {
+			if(klient instanceof Student) {
+				return 25;
+			}
+			return 50;
+		}
+	}
+
+	public static void main(String[] args) {
+		KasaBiletowa kasa = new KasaBiletowa();
+		
+		Osoba osoba = new Osoba();
+		Student student = new Student();
+		
+		System.out.println(kasa.cenaBiletu(osoba)); // 50
+		System.out.println(kasa.cenaBiletu(student)); // 25
+		System.out.println();
+		
+		Osoba[] osoby = {
+			new Osoba(),
+			new Student(),
+		};
+		for (Osoba o : osoby) {
+			System.out.println(o.getClass().getSimpleName()
+					+ " dostaje bilet w cenie "
+					+ kasa.cenaBiletu(o));
+		}
+		
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a03_overloading_overriding/BiletUlgowy5.java

+package alx.p12_klasy_tech.a05_przeciazanie.a03_overloading_overriding;
+
+// Tutaj stosuję jeszcze tzw. marker interface, czyli interfejs mówiący, że niektóre klasy mają jakąś cechę
+
+public class BiletUlgowy5 {
+	private static interface MaZnizke {}
+	
+	private static class Osoba {
+		
+	}
+
+	private static class Student extends Osoba implements MaZnizke {
+		
+	}
+	
+	private static class Pies implements MaZnizke {
+		
+	}
+
+	private static class KasaBiletowa {
+		int cenaBiletu(Osoba klient) {
+			if(klient instanceof MaZnizke) {
+				return 25;
+			}
+			return 50;
+		}
+	}
+
+	public static void main(String[] args) {
+		KasaBiletowa kasa = new KasaBiletowa();
+		
+		Osoba osoba = new Osoba();
+		Student student = new Student();
+		
+		System.out.println(kasa.cenaBiletu(osoba)); // 50
+		System.out.println(kasa.cenaBiletu(student)); // 25
+		System.out.println();
+		
+		Osoba[] osoby = {
+			new Osoba(),
+			new Student(),
+		};
+		for (Osoba o : osoby) {
+			System.out.println(o.getClass().getSimpleName()
+					+ " dostaje bilet w cenie "
+					+ kasa.cenaBiletu(o));
+		}
+		
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a03_overloading_overriding/Nadklasa.java

+package alx.p12_klasy_tech.a05_przeciazanie.a03_overloading_overriding;
+
+public class Nadklasa {
+
+	public void print(Number arg) {
+		System.out.println("Nadklasa Number " + arg);
+	}
+	
+	// nie ma metody od Byte
+	
+	public void print(Integer arg) {
+		System.out.println("Nadklasa Integer " + arg);
+	}
+	
+	public static void main(String[] args) {
+		Nadklasa obiekt = new Nadklasa();
+		obiekt.print(5);
+		
+		Byte bb = 3;
+		obiekt.print(bb);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a03_overloading_overriding/Podklasa.java

+package alx.p12_klasy_tech.a05_przeciazanie.a03_overloading_overriding;
+
+public class Podklasa extends Nadklasa {
+	public void print(Number arg) {
+		System.out.println("Podklasa Number " + arg + " obiekt jest klasy " + arg.getClass().getSimpleName());
+	}
+	
+	public void print(Byte arg) {
+		System.out.println("Podklasa Byte " + arg);
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a03_overloading_overriding/TestNadPod.java

+package alx.p12_klasy_tech.a05_przeciazanie.a03_overloading_overriding;
+
+public class TestNadPod {
+
+	public static void main(String[] args) {
+		Integer ii = 7;
+		Byte bb = 5;
+		Number n = ii;
+		
+		Podklasa pod = new Podklasa();
+		pod.print(ii);
+		pod.print(bb);
+		pod.print(n);
+		System.out.println();
+		
+		Nadklasa nad = pod;
+		nad.print(ii);
+		nad.print(bb);
+		nad.print(n);
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a07_varargs/Varargs1.java

+package alx.p12_klasy_tech.a05_przeciazanie.a07_varargs;
+
+import java.util.Arrays;
+
+public class Varargs1 {
+
+	static void test(String... slowa) {
+		// parametr wewnątrz metody jest widziany jako tablica
+		System.out.println(slowa.getClass());
+		System.out.println(slowa.length + " " + Arrays.toString(slowa));
+		System.out.println();
+	}
+	
+	static int sum(int... liczby) {
+		int suma = 0;
+		for (int x : liczby) {
+			suma += x;
+		}
+		return suma;
+	}
+	
+	
+	//Mając metodę String..., nie można już definiować metody String[] o tej samej nazwie
+	
+//	static void test(String[] tab) {
+//	}
+	
+	
+	
+	/* Parametr z wielokropkiem może być tylko jeden, na samym końcu.
+	 Te wersje się nie kompilują:
+	 
+	void p(String... args, int... ints) {
+		
+	}
+
+	void q(int x, int... ints, int y) {
+		
+	}
+	*/
+	
+	// deklaracje są poprawne, niejednoznaczna będzie próba wywołania
+	static void test(int a, int... reszta) {
+		// OK
+	}
+
+	static void test(int a, int b, int... reszta) {
+		// OK
+	}
+
+	
+	public static void main(String[] args) {
+		test();
+		test("Ala");
+		test("Ala", "Ola", "Ela");
+		
+		System.out.println();
+		
+		System.out.println(sum(1,3,5,7));
+		System.out.println(sum());
+		System.out.println();
+		
+		// do takiej metody można też przekazać prawdziwą tablicę
+		
+		String[] miasta = {"Warszawa", "Kraków", "Łódź"};
+		test(miasta);
+		int[] t = new int[100];
+		Arrays.fill(t, 7);
+		System.out.println(sum(t));
+		
+		//NK test(1,2,3);
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a07_varargs/Varargs2.java

+package alx.p12_klasy_tech.a05_przeciazanie.a07_varargs;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class Varargs2 {
+	
+	public static void m(String... slowa) {
+		// slowa jest typu String[]
+		
+		System.out.println("start");
+		System.out.println(slowa.length); // NPE jeśli przekazano null-a
+		for(String slowo : slowa) {
+			System.out.println("kolejne slowo: " + slowo);
+		}
+		System.out.println();
+	}
+	
+//	public static void m(String[] slowa) {
+	//	nie może być jednoczesnie metody String...   i String[]		
+//	}
+
+	public static void main(String[] args) {
+		
+		m();
+		m("ala");
+		m("ola", "ala", "ela");
+		m(null, "ola", "ala", null);
+		m(null, null); // tablica String[] zawierająca dwa nulle
+		//NPE m(null);  // bo kompilator "myśli" że null jako tablica i w pętli for-each nastepuje NPE
+		m((String)null);  // a teraz jednak tablica zawierająca nulla
+		
+		String[] tablica = {"ola", "ala", "ela"};
+		m(tablica);
+		
+		m(new String[] {"jeden", "dwa"});
+		
+		//NK m({"jeden", "dwa"});
+		
+		List<String> lista1 = Arrays.asList(tablica);
+		List<String> lista2 = Arrays.asList("ala", "ola", "ela");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p12_klasy_tech/a05_przeciazanie/a07_varargs/Varargs3.java

+package alx.p12_klasy_tech.a05_przeciazanie.a07_varargs;
+
+import java.util.Arrays;
+
+public class Varargs3 {
+
+	public static void m(String... slowa) {
+		System.out.println("start");
+		for(String slowo : slowa) {
+			System.out.println("kolejne slowo: " + slowo);
+		}
+		System.out.println("koniec\n");
+		// slowa[0] = "55";
+	}
+
+// można zadeklarować metodę, która przyjmuje normalne parametry, a tylko ostatni jest parametrem typu vararg
+// w praktyce takie dwie metody jak ta i powyższa prowadziłyby do konfliktu w momencie wywołania
+//	public static void m(String arg, String... slowa) {
+//		System.out.println("start");
+//		for(String slowo : slowa) {
+//			System.out.println("kolejne slowo: " + slowo);
+//		}
+//		System.out.println("koniec\n");
+//	}
+
+	public static void m(Object slowo) {
+		System.out.println("pojedynczy obiekt "+ slowo);
+		System.out.println();
+	}
+
+	public static void m(String slowo, String slowo2) {
+		System.out.println("dwa slowa");
+		System.out.println();
+	}
+
+	public static int m(int... liczby) {
+		int suma = 0;
+		for(int i = 0; i < liczby.length; i++) {
+			suma += liczby[i];
+			liczby[i]++;
+		}
+		
+		return suma;
+	}
+
+	public static void main(String[] args) {
+		//NK m();  // niejednoznaczne
+		m("ala");
+		m("ala", "ola");
+		m("ola", "ala", "ela");
+		m(null, "ola", "ala", null);
+		
+		String[] tablica = {"ola", "ala", "ela"};
+		m(tablica);
+		
+		System.out.println(m(1,3,5,7,9));
+		
+		int[] ti = {10,20,30};
+		System.out.println(Arrays.toString(ti));
+		System.out.println(m(ti));
+		System.out.println(Arrays.toString(ti));
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v1_brak_enkapsulacji/Konto.java

+package alx.p13_enkapsulacja.v1_brak_enkapsulacji;
+
+public class Konto {
+	int numer;
+	int saldo;
+	Osoba wlasciciel;
+
+	public Konto(int numer, int saldo, Osoba wlasciciel) {
+		this.numer = numer;
+		this.saldo = saldo;
+		this.wlasciciel = wlasciciel;
+	}
+
+	@Override
+	public String toString() {
+		return "Konto nr " + numer + ", saldo: " + saldo + ", wł: " + wlasciciel;
+	}
+
+	// Brak kontroli nad tym co się dzieje z saldem.
+	// Da się ustawić niepoprawne saldo.
+	// Gdybym zapragnął dodać rejestrowanie historii zmiana, nie byłbym w stanie zapanować nad wszystkimi odwołaniami do zmiennej saldo.
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v1_brak_enkapsulacji/Osoba.java

+package alx.p13_enkapsulacja.v1_brak_enkapsulacji;
+
+public class Osoba {
+	String imie, nazwisko;
+	int wiek;
+	
+	Osoba() {
+	}
+	
+	Osoba(String imie, String nazwisko, int wiek) {
+		this.imie = imie;
+		this.nazwisko = nazwisko;
+		this.wiek = wiek;
+	}
+	
+	void przedstawSie() {
+		System.out.println("Nazywam się " + imie + " " + nazwisko + " i mam " + wiek + " lat.");
+	}
+	
+	public String toString() {
+		return imie + " " + nazwisko + " (" + wiek + " lat)";
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v1_brak_enkapsulacji/Program.java

+package alx.p13_enkapsulacja.v1_brak_enkapsulacji;
+
+import java.util.stream.DoubleStream;
+
+public class Program {
+
+	public static void main(String[] args) {
+		// Gdy klasy nie stosują zasad enkapsulacji, to programy mogą bezpośrednio używać zmiennych z tych klas:
+		
+		Student student = new Student("Ada", "Nowak", 22, "biologia", 2);
+		
+		System.out.println(student.imie);
+		student.imie = "Adam";
+		
+		student.dodajOcene(3.5);
+		student.dodajOcene(4.5);
+		
+		// Programy mogą zakładać, że zmienna oceny jest typu tablica
+		// wtedy po ewentualnej zmianie na listę - programy przestaną się kompilować
+		double[] oceny = student.oceny;
+		
+		// Nie zawsze ten dostęp jest celowym "psuciem", czasami inny programista korzysta z naszej zmiennej z dobrymi intencjami.
+		// Ten kod nie robi nic złego, ale kompiluje się tylko przy założeniu, że student.oceny jest tablicą double[]
+		System.out.println("średnia wyliczona streamem: " + DoubleStream.of(student.oceny).sum() / student.iloscOcen);
+
+
+		// Są też jednak zagrożenia...
+		// Dostęp do tablicy jest też groźny, bo program może modyfikować zawartość
+		for (int i = 0; i < oceny.length; i++) {
+			oceny[i] += 1;
+		}
+		
+
+		Konto konto = new Konto(1, 1000, student);
+		// można w szczególności wpisać "bez żadnego uzasadnienia" saldo w koncie
+		konto.saldo = 5000;
+		
+		konto.saldo += 10000;
+		
+		// możemy doprowadzić do ujemnego saldo - nie ma żadnej kontroli
+		konto.saldo -= 40000;
+		
+		System.out.println(konto);
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v1_brak_enkapsulacji/Sklep.java

+package alx.p13_enkapsulacja.v1_brak_enkapsulacji;
+
+public class Sklep {
+
+	public void sprzedajPiwo(Osoba klient) {
+		if(klient.wiek >= 18) {
+			System.out.println("Osoba " + klient.imie + " " + klient.nazwisko + " kupuje piwo.");
+		} else {
+			System.out.println("Niepełnoletnia " + klient.imie + " nie może kupić piwa");
+		}
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v1_brak_enkapsulacji/Student.java

+package alx.p13_enkapsulacja.v1_brak_enkapsulacji;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Student extends Osoba {
+	String kierunek;
+	int rok;
+	double[] oceny = new double[10];
+	// Teraz zmiana typu zmiennej, zmiana "wewnętrznej reprezentacji", spowoduje, że inne klasy w projekcie przestaną się kompilować.
+	// List<Double> oceny = new ArrayList<>();
+	int iloscOcen = 0;
+	
+	Student() {
+		
+	}
+	
+	public Student(String imie, String nazwisko, int wiek, String kierunek, int rok) {
+		super(imie, nazwisko, wiek);
+		this.kierunek = kierunek;
+		this.rok = rok;
+	}
+	
+	void dodajOcene(double ocena) {
+		oceny[iloscOcen++] = ocena;
+	}
+
+	double sredniaOcen() {
+		double suma = 0.0;
+		for (int i = 0; i < iloscOcen; i++) {
+			suma += oceny[i];
+		}
+		return suma / iloscOcen;
+	}
+
+	void przedstawSie() {
+		System.out.println("Hej tu " + imie + " " + nazwisko + ", jestem studentem " + rok + " roku kierunku " + kierunek);
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v3_przed_zmiana/Konto.java

+package alx.p13_enkapsulacja.v3_przed_zmiana;
+
+public class Konto {
+	private int numer;
+	private int saldo;
+	private Osoba wlasciciel;
+
+	public Konto(int numer, int saldo, Osoba wlasciciel) {
+		this.numer = numer;
+		this.saldo = saldo;
+		this.wlasciciel = wlasciciel;
+	}
+
+	public int getNumer() {
+		return numer;
+	}
+
+	public int getSaldo() {
+		return saldo;
+	}
+
+	public Osoba getWlasciciel() {
+		return wlasciciel;
+	}
+
+	public void setWlasciciel(Osoba wlasciciel) {
+		this.wlasciciel = wlasciciel;
+	}
+
+	public String toString() {
+		return "Konto nr " + numer + ", saldo: " + saldo + ", wł: " + wlasciciel;
+	}
+	
+	// Jedynymi sposobami modyfikacji salda są metody wplata i wyplata.
+	// Żadna inna klasa w projekcie, choćby było 1000 klas, nie modyfikuje salda z pominięciem tych metod.
+	
+	// na razie bez zabezpieczeń
+	public void wplata(int kwota) {
+		saldo += kwota;
+	}
+	
+	public void wyplata(int kwota) {
+		saldo -= kwota;
+	}
+	
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v3_przed_zmiana/Osoba.java

+package alx.p13_enkapsulacja.v3_przed_zmiana;
+
+import java.time.LocalDate;
+import java.time.Period;
+
+public class Osoba {
+	private String imie, nazwisko;
+	private LocalDate dataUrodzenia;
+	
+	public Osoba() {
+	}
+	
+	public Osoba(String imie, String nazwisko, LocalDate dataUrodzenia) {
+		this.imie = imie;
+		this.nazwisko = nazwisko;
+		this.setDataUrodzenia(dataUrodzenia);
+	}
+
+	public String getImie() {
+		return imie;
+	}
+
+	public void setImie(String imie) {
+		this.imie = imie;
+	}
+
+	public String getNazwisko() {
+		return nazwisko;
+	}
+
+	public void setNazwisko(String nazwisko) {
+		this.nazwisko = nazwisko;
+	}
+
+
+	public LocalDate getDataUrodzenia() {
+		return dataUrodzenia;
+	}
+
+	public void setDataUrodzenia(LocalDate dataUrodzenia) {
+		this.dataUrodzenia = dataUrodzenia;
+	}
+	
+	public int getWiek() {
+		Period period = Period.between(dataUrodzenia, LocalDate.now());
+		return period.getYears();
+	}
+
+	public void przedstawSie() {
+		System.out.println("Nazywam się " + imie + " " + nazwisko + " i mam " + getWiek() + " lat.");
+	}
+	
+	public String toString() {
+		return imie + " " + nazwisko + " (" + getWiek() + " lat)";
+	}
+	
+	public boolean jestPelnoletnia() {
+		return getWiek() >= 18;
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v3_przed_zmiana/Program.java

+package alx.p13_enkapsulacja.v3_przed_zmiana;
+
+import java.time.LocalDate;
+
+public class Program {
+
+	public static void main(String[] args) {
+		Student student = new Student("Ada", "Nowak", LocalDate.of(1999, 9, 19), "biologia", 3);
+		System.out.println(student.getImie());
+		student.setImie("Adam");
+		
+		// Teraz program nie ma jak dostać się do tablicy ocen
+		// double[] oceny = student.oceny;
+		
+		student.dodajOcene(4.0);
+		student.dodajOcene(5.0);
+		student.dodajOcene(4.0);
+		System.out.println(student.sredniaOcen());
+		
+
+		Konto konto = new Konto(1, 1000, student);
+
+		// Teraz żadna inna klasa nie będzie mogła "bez uzasadnienia" modyfikować salda;.
+		// Musi użyć jednej z "operacji biznesowych".
+		// konto.saldo = 5000;
+		// konto.saldo -= 40000;
+		
+		konto.wplata(5000);
+		System.out.println(konto);
+
+		// na razie też możemy doprowadzić do ujemnego salda
+		konto.wyplata(40000);
+		System.out.println(konto);
+		
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v3_przed_zmiana/ProgramBankowy.java

+package alx.p13_enkapsulacja.v3_przed_zmiana;
+
+import java.time.LocalDate;
+import java.util.Scanner;
+
+public class ProgramBankowy {
+
+    public static void main(String[] args) {
+   	 @SuppressWarnings("resource")
+   	 Scanner sc = new Scanner(System.in);
+
+   	 Osoba ala = new Osoba("Ala", "Kowalska", LocalDate.of(1991, 3, 4));
+   	 
+   	 System.out.print("Podaj początkową kwotę: ");
+   	 int kwota = sc.nextInt();
+   	 sc.nextLine(); // wymuszenie przejścia do nowej linii
+   	 
+   	 Konto konto = new Konto(1, kwota, ala);
+   	 
+   	 System.out.println(konto);
+
+   	 petla:
+   	 while(true) {
+   		 try {
+   			 System.out.println("Co chcesz zrobić?  W - wpłata, Y - wypłata, K - koniec");
+   			 String wybor = sc.nextLine().toUpperCase();
+   			 switch(wybor) {
+   				 case "K":
+   					 break petla;
+   				 
+   				 case "W":
+   					 System.out.print("Podaj kwotę wpłaty: ");
+   					 kwota = sc.nextInt();
+   					 sc.nextLine();
+   					 konto.wplata(kwota);
+   					 System.out.println("Pieniądze zostały wpłacone");
+   					 break;
+   				 case "Y":
+   					 System.out.print("Podaj kwotę wypłaty: ");
+   					 kwota = sc.nextInt();
+   					 sc.nextLine();
+   					 konto.wyplata(kwota);
+   					 
+   					 // ta linia wykona się tylko jeśli nie było wyjątku:
+   					 System.out.println("Pieniądze zostały wypłacone");
+   					 break;
+   			 }
+   		 } catch(Exception e) {
+   			 System.out.println("Inny błąd: " + e);
+   		 }
+   		 System.out.println();
+   		 System.out.println(konto);
+   		 System.out.println();
+   	 }
+   	 
+    }
+
+}
+
+
+

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v3_przed_zmiana/Sklep.java

+package alx.p13_enkapsulacja.v3_przed_zmiana;
+
+public class Sklep {
+
+	public void sprzedajPiwo(Osoba klient) {
+		if(klient.jestPelnoletnia()) {
+			System.out.println("Osoba " + klient.getImie() + " " + klient.getNazwisko() + " kupuje piwo.");
+		} else {
+			System.out.println("Niepełnoletnia " + klient.getImie() + " nie może kupić piwa");
+		}
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v3_przed_zmiana/Student.java

+package alx.p13_enkapsulacja.v3_przed_zmiana;
+
+import java.time.LocalDate;
+import java.util.Arrays;
+
+public class Student extends Osoba {
+	private String kierunek;
+	private int rok;
+	
+	// Ukrywamy szczegóły implementacji - klient nie musi wiedzieć, w jaki sposób przechowujemy oceny studenta ("to nasza prywatna sprawa")
+	// Żadna inna klasa nie może odwoływać się bezpośrednio do tej tablicy.
+	private double[] oceny = new double[10];
+	private int iloscOcen = 0;
+	
+	public Student() {
+		
+	}
+	
+	public Student(String imie, String nazwisko, LocalDate dataUrodzenia, String kierunek, int rok) {
+		super(imie, nazwisko, dataUrodzenia);
+		this.kierunek = kierunek;
+		this.rok = rok;
+	}
+	
+	public String getKierunek() {
+		return kierunek;
+	}
+
+	public void setKierunek(String kierunek) {
+		this.kierunek = kierunek;
+	}
+
+	public int getRok() {
+		return rok;
+	}
+
+	public void setRok(int rok) {
+		this.rok = rok;
+	}
+
+	public void dodajOcene(double ocena) {
+		if(iloscOcen == oceny.length) {
+			oceny = Arrays.copyOf(oceny, oceny.length*2); // mniej więcej coś takiego robi ArrayList oraz StringBuilder
+		}
+		oceny[iloscOcen++] = ocena;
+	}
+
+	public double sredniaOcen() {
+		double suma = 0.0;
+		for (int i = 0; i < iloscOcen; i++) {
+			suma += oceny[i];
+		}
+		return suma / iloscOcen;
+	}
+
+	public void przedstawSie() {
+		System.out.println("Hej tu " + getImie() + " " + getNazwisko() + ", jestem studentem " + rok + " roku kierunku " + kierunek);
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v4_po_zmianie/BrakSrodkow.java

+package alx.p13_enkapsulacja.v4_po_zmianie;
+
+public class BrakSrodkow extends Exception {
+    public BrakSrodkow() {
+    }
+
+    public BrakSrodkow(String message) {
+        super(message);
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v4_po_zmianie/Konto.java

+package alx.p13_enkapsulacja.v4_po_zmianie;
+
+public class Konto {
+	private final int numer;
+	private int saldo;
+	private Osoba wlasciciel;
+
+	public Konto(int numer, int saldo, Osoba wlasciciel) {
+		if(saldo < 0) {
+			throw new IllegalArgumentException("Saldo nie może być ujemne");
+		}
+		if(wlasciciel == null) {
+			throw new IllegalArgumentException("Właściciel null");
+		}
+		this.numer = numer;
+		this.saldo = saldo;
+		this.wlasciciel = wlasciciel;
+	}
+
+	public int getNumer() {
+		return numer;
+	}
+
+	public int getSaldo() {
+		return saldo;
+	}
+
+	public Osoba getWlasciciel() {
+		return wlasciciel;
+	}
+
+	public void setWlasciciel(Osoba wlasciciel) {
+		this.wlasciciel = wlasciciel;
+	}
+
+	public String toString() {
+		return "Konto nr " + numer + ", saldo: " + saldo + ", wł: " + wlasciciel;
+	}
+	
+	// Jedynymi sposobami modyfikacji salda są metody wplata i wyplata.
+	// Żadna inna klasa w projekcie, choćby było 1000 klas, nie modyfikuje salda z pominięciem tych metod.
+	
+	public void wplata(int kwota) {
+		if(kwota <= 0) {
+			throw new IllegalArgumentException("Ujemna kwota we wplata");
+		}
+		saldo += kwota; // bezpieczniej byłoby saldo = Math.addExact(saldo, kwota)
+	}
+	
+	public void wyplata(int kwota) throws BrakSrodkow {
+		if(kwota <= 0) {
+			throw new IllegalArgumentException("Ujemna kwota we wplata");
+		}
+		if(kwota > saldo) {
+			throw new BrakSrodkow("Brak środków na koncie nr " + numer);
+		}
+		saldo -= kwota;
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v4_po_zmianie/Osoba.java

+package alx.p13_enkapsulacja.v4_po_zmianie;
+
+import java.time.LocalDate;
+import java.time.Period;
+
+public class Osoba {
+	private String imie, nazwisko;
+	private LocalDate dataUrodzenia;
+	
+	public Osoba() {
+	}
+	
+	public Osoba(String imie, String nazwisko, LocalDate dataUrodzenia) {
+		this.imie = imie;
+		this.nazwisko = nazwisko;
+		this.setDataUrodzenia(dataUrodzenia);
+	}
+
+	public String getImie() {
+		return imie;
+	}
+
+	public void setImie(String imie) {
+		this.imie = imie;
+	}
+
+	public String getNazwisko() {
+		return nazwisko;
+	}
+
+	public void setNazwisko(String nazwisko) {
+		this.nazwisko = nazwisko;
+	}
+
+
+	public LocalDate getDataUrodzenia() {
+		return dataUrodzenia;
+	}
+
+	public void setDataUrodzenia(LocalDate dataUrodzenia) {
+		this.dataUrodzenia = dataUrodzenia;
+	}
+	
+	public int getWiek() {
+		Period period = Period.between(dataUrodzenia, LocalDate.now());
+		return period.getYears();
+	}
+
+	public void przedstawSie() {
+		System.out.println("Nazywam się " + imie + " " + nazwisko + " i mam " + getWiek() + " lat.");
+	}
+	
+	public String toString() {
+		return imie + " " + nazwisko + " (" + getWiek() + " lat)";
+	}
+	
+	public boolean jestPelnoletnia() {
+		return getWiek() >= 18;
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v4_po_zmianie/Program.java

+package alx.p13_enkapsulacja.v4_po_zmianie;
+
+import java.time.LocalDate;
+
+public class Program {
+
+	public static void main(String[] args) {
+		Student student = new Student("Ada", "Nowak", LocalDate.of(1999, 9, 19), "biologia", 3);
+		System.out.println(student.getImie());
+		student.setImie("Adam");
+		
+		// Teraz program nie ma jak dostać się do tablicy ocen
+		// double[] oceny = student.oceny;
+		
+		student.dodajOcene(4.0);
+		student.dodajOcene(5.0);
+		student.dodajOcene(4.0);
+		System.out.println(student.sredniaOcen());
+		
+
+		Konto konto = new Konto(1, 1000, student);
+
+		// Teraz żadna inna klasa nie będzie mogła "bez uzasadnienia" modyfikować salda;.
+		// Musi użyć jednej z "operacji biznesowych".
+		// konto.saldo = 5000;
+		// konto.saldo -= 40000;
+		
+		konto.wplata(5000);
+		System.out.println(konto);
+
+		try {
+			konto.wyplata(40000);
+			System.out.println("Wypłata się powiodła");
+		} catch (BrakSrodkow e) {
+			System.out.println("Wypłata nieudana z powodu " + e);
+		}
+		System.out.println(konto);
+		
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v4_po_zmianie/ProgramBankowy.java

+package alx.p13_enkapsulacja.v4_po_zmianie;
+
+import java.time.LocalDate;
+import java.util.Scanner;
+
+public class ProgramBankowy {
+
+    public static void main(String[] args) {
+		@SuppressWarnings("resource")
+		Scanner sc = new Scanner(System.in);
+
+		Osoba ala = new Osoba("Ala", "Kowalska", LocalDate.of(1991, 3, 4));
+
+		System.out.print("Podaj początkową kwotę: ");
+		int kwota = sc.nextInt();
+		sc.nextLine(); // wymuszenie przejścia do nowej linii
+
+		Konto konto = new Konto(1, kwota, ala);
+
+		System.out.println(konto);
+
+		petla:
+		while(true) {
+			try {
+				System.out.println("Co chcesz zrobić?  W - wpłata, Y - wypłata, K - koniec");
+				String wybor = sc.nextLine().toUpperCase();
+				switch(wybor) {
+					case "K":
+						break petla; // przejście do Koniec programu
+
+					case "W":
+						System.out.print("Podaj kwotę wpłaty: ");
+						kwota = sc.nextInt();
+						sc.nextLine();
+						konto.wplata(kwota);
+						System.out.println("Pieniądze zostały wpłacone");
+						break;
+					case "Y":
+						System.out.print("Podaj kwotę wypłaty: ");
+						kwota = sc.nextInt();
+						sc.nextLine();
+						konto.wyplata(kwota);
+
+						// ta linia wykona się tylko jeśli nie było wyjątku:
+						System.out.println("Pieniądze zostały wypłacone");
+						break;
+					default:
+						System.out.println("Nieznane polecenie");
+					 	continue petla; // Przejście do Co chcesz zrobić
+				}
+			} catch(IllegalArgumentException e) {
+				System.out.println("Niepoprawny argument: " + e);
+			} catch(BrakSrodkow e) {
+				System.out.println(e.getMessage());
+			} catch(Exception e) {
+				System.out.println("Inny błąd: " + e);
+			}
+			System.out.println();
+			System.out.println(konto);
+			System.out.println();
+   	 	}
+		System.out.println("Koniec programu");
+    }
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v4_po_zmianie/Sklep.java

+package alx.p13_enkapsulacja.v4_po_zmianie;
+
+public class Sklep {
+
+	public void sprzedajPiwo(Osoba klient) {
+		if(klient.jestPelnoletnia()) {
+			System.out.println("Osoba " + klient.getImie() + " " + klient.getNazwisko() + " kupuje piwo.");
+		} else {
+			System.out.println("Niepełnoletnia " + klient.getImie() + " nie może kupić piwa");
+		}
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p13_enkapsulacja/v4_po_zmianie/Student.java

+package alx.p13_enkapsulacja.v4_po_zmianie;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.DoubleStream;
+
+public class Student extends Osoba {
+	private String kierunek;
+	private int rok;
+	
+	// Ukrywamy szczegóły implementacji - klient nie musi wiedzieć, w jaki sposób przechowujemy oceny studenta ("to nasza prywatna sprawa")
+	// Żadna inna klasa nie może odwoływać się bezpośrednio do tej tablicy.
+	private List<Double> oceny = new ArrayList<>();
+
+	public Student() {
+		
+	}
+	
+	public Student(String imie, String nazwisko, LocalDate dataUrodzenia, String kierunek, int rok) {
+		super(imie, nazwisko, dataUrodzenia);
+		this.kierunek = kierunek;
+		this.rok = rok;
+	}
+	
+	public String getKierunek() {
+		return kierunek;
+	}
+
+	public void setKierunek(String kierunek) {
+		this.kierunek = kierunek;
+	}
+
+	public int getRok() {
+		return rok;
+	}
+
+	public void setRok(int rok) {
+		this.rok = rok;
+	}
+
+	public void dodajOcene(double ocena) {
+		oceny.add(ocena);
+	}
+
+	public double sredniaOcen() {
+		return oceny.stream().mapToDouble(x->x).average().orElse(0.0);
+	}
+
+	public void przedstawSie() {
+		System.out.println("Hej tu " + getImie() + " " + getNazwisko() + ", jestem studentem " + rok + " roku kierunku " + kierunek);
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/DzialanieWyjatkow.java

+package alx.p14_wyjatki;
+
+import java.io.IOException;
+
+public class DzialanieWyjatkow {
+	
+	static int metoda(String arg) throws IOException {
+		System.out.println("Początek metody, arg = " + arg);
+		
+		try {
+			int dlugosc = arg.length();
+			System.out.println("length() = " + dlugosc);
+			
+			int wynik = 10 / dlugosc;
+			
+			System.out.println("Znak numer 2 to " + arg.charAt(2));
+			
+			switch(arg) {
+			case "NULL" :
+				NullPointerException wyjatek = new NullPointerException("Moje NPE");
+				throw wyjatek;
+				
+			case "ERROR" :
+				long[] t = new long[2000_000_000];
+				//throw new OutOfMemoryError("Na niby");
+				break;
+				
+			case "IOEXC" :
+				throw new IOException("Na niby");		
+
+			case "RETURN" :
+				System.out.println("Przerywam metodę return");
+				return 8;		
+			case "EXIT" :
+				System.out.println("Przerywam program EXIT");
+				System.exit(0);
+			}
+			
+			System.out.println("Koniec metody, zwracam " + wynik);		
+			return wynik;
+		} finally {
+			System.out.println("FINALLY w metodzie");
+		}
+	}
+	
+
+	public static void main(String[] args) throws IOException {
+		System.out.println("Początek main");
+		
+		try {
+			int x = -1;
+			x = metoda("ala");
+			//x = metoda(null);
+			//x = metoda("");
+			//x = metoda("As");
+			//x = metoda("NULL");
+			//x = metoda("ERROR");
+			//x = metoda("RETURN");	
+			//x = metoda("EXIT");
+			
+			System.out.println("Metoda się wykonała, wynik to " + x);
+			
+			if(x > 2) {
+				System.out.println("Przerywam maina");
+				return;
+			}
+			System.out.println("Przed catchami");
+			
+		} catch (NullPointerException e) {
+			System.out.println("Wyłapałem wyjątek NPE " + e.getMessage());
+		} catch (Exception e) {
+			System.out.println("Wyłapałem inny wyjątek " + e.getClass().getSimpleName() + " " + e.getMessage());
+
+//		} catch (Error e) {
+//			System.out.println("Wyłapałem ERROR " + e.getClass().getSimpleName() + " " + e.getMessage());
+//		} catch (Throwable e) {
+//			System.out.println("Wyłapałem coś " + e.getClass().getSimpleName() + " " + e.getMessage());
+		} finally {
+			System.out.println("FINALLY w main");
+		}
+		
+		System.out.println("Koniec main");
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/KiedyTrzebaLapac.java

+package alx.p14_wyjatki;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+
+public class KiedyTrzebaLapac {
+
+	public static void main(String[] args) {
+		String s = "123";
+		
+		// tutaj może dojść do błędu NumberFormatException
+		// nie ma błędu kompilacji - ten wyjątek należy do kategorii "unchecked"
+		int x = Integer.parseInt(s);
+		System.out.println(x);
+		
+		// operacje dotyczące plików mogą kończyć się wyjątkiem IOException
+		// tym razem musimy te wyjątki jawnie obsłużyć - za pomocą try-catch albo throws
+		// bo IOException jest wyjątkiem z kategorii "checked"
+		try {
+			FileInputStream in = new FileInputStream("plik.txt");
+			int bajt;
+			while((bajt = in.read()) != -1) {
+				System.out.println("kolejny bajt: " + bajt);
+			}
+			in.close();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/Konto.java

+package alx.p14_wyjatki;
+
+class BrakSrodkow extends Exception {
+
+}
+
+class Konto {
+	public void wyplata(int kasa) throws BrakSrodkow {
+		// usunięcie throws spowoduje błąd kompilacji w uzytkowniku
+	}
+}
+
+class Uzytkownik {
+	public static void main(String[] args) {
+		Konto k = new Konto();
+		
+		try {
+			k.wyplata(400);
+			System.out.println("jest kasa");
+			
+		} catch (BrakSrodkow e) {
+			System.out.println("nie ma kasy");
+		}
+	}
+}
+

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/ProsteDzialanieWyjatkow.java

+package alx.p14_wyjatki;
+
+public class ProsteDzialanieWyjatkow {
+	
+	static void metoda(String arg) {
+		try {
+			System.out.println("Początek metody: " + arg);
+			int x = arg.length();
+			System.out.println("Długość napisu: " + x);
+			if(x == 1) {
+				return; // przerwanie metody
+			}
+			
+			int y = 10 / x;
+			System.out.println("Wynik dzielenia: " + y);
+		} finally {
+			System.out.println("FINALLY w metodzie");
+		}
+	}
+
+	public static void main(String[] args) {
+		
+		try {
+			//metoda("Ala ma kota");
+			 metoda(null);
+			// metoda("");
+			// metoda("A");
+			System.out.println("Przed catch");
+		} catch(NullPointerException e) {
+			System.out.println("Był wyjątek NPE");
+		} finally {
+			System.out.println("FINALLY w main");
+		}
+		
+		System.out.println("Koniec programu");
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/ProsteDzialanieWyjatkow_BezCatch.java

+package alx.p14_wyjatki;
+
+public class ProsteDzialanieWyjatkow_BezCatch {
+	
+	static void metoda(String arg) {
+		System.out.println("Początek metody: " + arg);
+		int x = arg.length();
+		System.out.println("Długość napisu: " + x);
+		if(x == 1) {
+			return; // przerwanie metody
+		}
+		
+		int y = 10 / x;
+		System.out.println("Wynik dzielenia: " + y);
+	}
+
+	public static void main(String[] args) {
+		metoda("Ala ma kota");
+		// metoda(null);
+		// metoda("");
+		// metoda("A");
+		System.out.println("Przed catch");
+		
+		System.out.println("Koniec programu");
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/ZasadyWyjatkow1.java

+package alx.p14_wyjatki;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Scanner;
+
+public class ZasadyWyjatkow1 {
+
+	public static void main(String[] args) {
+		
+//		 try {
+//			 System.out.println("Ala ma kota");
+//			 File f = new File("plik.txt");
+//			 // tu na pewno nie ma IOException
+//		  
+//		 } catch (IOException e) {
+//			 // nie kompiluje się - ale to dotyczy tylko wyjątków "checked"
+//			 System.out.println("wyjątek którego nie ma prawa być");
+//		 }
+		
+		try {
+			
+		} catch(NullPointerException e) {
+			// RuntimeExceptiony można zawsze próbować łapać
+			System.out.println("NPE którego nie było");
+		}
+		
+		try {
+			
+		} catch(Exception e) {
+			// exception i Throwable można łapać zawsze, bo one obejmują w sobie RuntimeException i Error
+		}
+		
+		try {
+			Scanner sc = new Scanner(new File("ala.txt"));
+			// konstruktor Scanner() deklaruje FileNotFoundException
+			// można łapać IOException, bo to jest nadklasa
+			
+			sc.close();
+		} catch(IOException e) {
+			System.out.println("IOEx");
+		}
+
+		// przykład "try-with-resources"
+		try(Scanner sc = new Scanner(new File("ala.txt"))) {
+			
+			String linia = sc.nextLine();
+			System.out.println(linia);
+
+			// nie trzeba pisać close, a Java i tak zamknie plik
+		} catch(IOException e) {
+			System.out.println("IOEx");
+		}
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/ZasadyWyjatkow2.java

+package alx.p14_wyjatki;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Scanner;
+
+public class ZasadyWyjatkow2 {
+
+	public static void main(String[] args) {
+	
+//		try {
+//			System.out.println();
+//		} catch(Exception e) {
+//			System.out.println("E");
+//		} catch(RuntimeException e) {
+//			// "martwy catch", bo Exception już ten przypadek obejmowało
+//			System.out.println("RE");
+//		}
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/ZasadyWyjatkow3.java

+package alx.p14_wyjatki;
+
+public class ZasadyWyjatkow3 {
+
+	public static void main(String[] args) {
+	
+		try {
+			System.out.println();
+		} catch(ArithmeticException | NullPointerException | NumberFormatException e) {
+			// zmienna e jest typu, który jest najbliższą wspólną nadklasą wszystkich klas wymienionych w catch
+			RuntimeException e2 = e;
+			
+			System.out.println("multicatch złapał " + e.getMessage());
+		}
+
+// pewniak na egzaminie: multi-catch, w którym coś się nie zgadza
+//		try {
+//			System.out.println();
+//		} catch(NumberFormatException | IllegalArgumentException e) {
+//			// nie kompiluje sie bo NumberFormatException jest podklasą IllegalArgumentException
+//			System.out.println("multicatch złapał " + e.getMessage());
+//		}
+//
+//		try {
+//			System.out.println();
+//		} catch(Exception | NullPointerException e) {
+//			// nie można wymieniać tych klas, które są spokrewnione "w linii prostej"
+//			System.out.println("multicatch złapał " + e.getMessage());
+//		}
+
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/ZasadyWyjatkow4.java

+package alx.p14_wyjatki;
+
+public class ZasadyWyjatkow4 {
+	// temat "rethrow" - ponownego wyrzucania złapanego wyjątku
+
+	static void test1() {
+		try {
+			throw new RuntimeException();
+			
+		} catch(RuntimeException e) {
+			System.out.println(e);
+			throw e;
+		} catch(Exception e) {
+			// ten catch nie wyłapie wyjątku wyrzuconego we wcześniejszym catchu
+			System.out.println(e);
+		}
+	}
+	
+	static void test2() {
+		try {
+			throw new RuntimeException();
+		} catch(Exception e) {
+			System.out.println(e);
+			throw e;
+			// Kompilator wie, że wyrzucany jest RuntimeException
+			// i nie każe go deklarować / obsługiwać
+		}
+	}
+
+	static void test3() {
+		try {
+			java.sql.Connection c = java.sql.DriverManager
+					.getConnection("jdbc:postgresql://localhost//baza");
+			
+		} catch(java.sql.SQLException e) {
+			throw new RuntimeException(e);
+			// wyrzucanie opakowanego wyjątku - jako RuntimeException nie wymaga deklaracji
+		}
+	}
+	
+	static void test4() {
+		try {
+			try {
+				System.out.println("A");
+				throw new RuntimeException("X");
+				//NK System.out.println("B"); // martwy kod
+			} catch(Exception e) {
+				System.out.println("C " + e);
+				throw e;
+			} catch(Throwable t) {
+				System.out.println("D " + t);
+				throw t;
+			} finally {
+				System.out.println("E");
+			}
+		} catch(Exception e) {
+			System.out.println("F " + e);
+			throw e;
+		} finally {
+			System.out.println("G");
+		}
+	}
+	
+	static void test5() {
+		// throw new Exception(); // trzeba by deklarować
+		
+		// throw new RuntimeException(); // nie trzeba deklarować
+		
+		try {
+			throw new RuntimeException();
+			// throw new Exception();  // gdytby było to, to trzeba dekalrować throws Exception
+		} catch (Exception e) {
+			System.out.println("wyłapałem " + e + " i rzucam dalej");
+			throw e;
+			// mimo że zmienna e jest typu Exception, nie muszę deklarować tego wyrzucenia w metodzie,
+			// bo kompilator widzi, że e to może być najwyżej RuntimeException
+		}
+	}
+	
+
+	public static void main(String[] args) {
+		test4();
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/zasoby/UzycieZasobu0.java

+package alx.p14_wyjatki.zasoby;
+
+public class UzycieZasobu0 {
+
+	public static void main(String[] args) {
+		System.out.println("początek maina");
+		
+		try(Zasob z = new Zasob()) {
+			System.out.println("po try");
+			z.dzialaj();
+			System.out.println("koniec try");
+		}
+
+		System.out.println("koniec main");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/zasoby/UzycieZasobu1.java

+package alx.p14_wyjatki.zasoby;
+
+public class UzycieZasobu1 {
+
+	public static void main(String[] args) {
+		System.out.println("początek maina");
+		
+		try(Zasob z = new Zasob()) {
+			System.out.println("po try");
+			z.dzialaj();
+			System.out.println("koniec try");
+		} finally {
+			System.out.println("finally");
+		}
+
+		System.out.println("koniec main");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/zasoby/UzycieZasobu2.java

+package alx.p14_wyjatki.zasoby;
+
+public class UzycieZasobu2 {
+
+	public static void main(String[] args) {
+		System.out.println("początek maina");
+		
+		try(Zasob z = new Zasob()) {
+			System.out.println("po try");
+			z.przerwij();
+			System.out.println("koniec try");
+		} finally {
+			System.out.println("finally");
+		}
+
+		System.out.println("koniec main");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/zasoby/UzycieZasobu3.java

+package alx.p14_wyjatki.zasoby;
+
+public class UzycieZasobu3 {
+
+	public static void main(String[] args) {
+		System.out.println("początek maina");
+		
+		try(Zasob z = new Zasob()) {
+			System.out.println("po try");
+			z.przerwij();
+			System.out.println("koniec try");
+			
+			// close wykona się przed catchem
+			
+		} catch(RuntimeException e) {
+			System.out.println("catch");
+		} finally {
+			System.out.println("finally");
+		}
+
+		System.out.println("koniec main");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/zasoby/UzycieZasobu5.java

+package alx.p14_wyjatki.zasoby;
+
+public class UzycieZasobu5 {
+
+	public static void main(String[] args) {
+		System.out.println("początek maina");
+		
+		try(Zasob z = new Zasob(true)) {
+			System.out.println("po try");
+			z.dzialaj();
+			System.out.println("koniec try");
+			// w close nastąpi wyjątek
+			
+		} finally {
+			System.out.println("finally");
+		}
+
+		System.out.println("koniec main");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/zasoby/UzycieZasobu6.java

+package alx.p14_wyjatki.zasoby;
+
+public class UzycieZasobu6 {
+
+	public static void main(String[] args) {
+		System.out.println("początek maina");
+		
+		try(Zasob z = new Zasob()) {
+			z.wyjatekWClose = true;
+			System.out.println("po try");
+			z.dzialaj();
+			System.out.println("koniec try");
+			// w close nastąpi wyjątek
+		} catch(RuntimeException e) {
+			// wyłapany wyjątek z close
+			System.out.println("catch, e = " + e);
+			
+		} finally {
+			System.out.println("finally");
+		}
+
+		System.out.println("koniec main");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/zasoby/UzycieZasobu7.java

+package alx.p14_wyjatki.zasoby;
+
+public class UzycieZasobu7 {
+
+	public static void main(String[] args) {
+		System.out.println("początek maina");
+		
+		try(Zasob z = new Zasob(true)) {
+			System.out.println("po try");
+			z.przerwij();
+			// przerwij wyrzuci wyjątek
+			// a close także wyrzuci wyjątek
+
+			System.out.println("koniec try");
+		} catch(RuntimeException e) {
+			// wyjątekiem bezpośrednio wyłapanym jest ten z treści
+			// ale do niego dołączony jest wyjątek z close() (suppressed)
+			System.out.println("catch, e = " + e);
+			Throwable[] suppressed = e.getSuppressed();
+			System.out.println("Wyjątki suppressed:");
+			for (Throwable th : suppressed) {
+				System.out.println(" * " + th);
+			}
+			
+		} finally {
+			System.out.println("finally");
+		}
+
+		System.out.println("koniec main");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p14_wyjatki/zasoby/Zasob.java

+package alx.p14_wyjatki.zasoby;
+
+// java.lang.AutoClosable - od Javy 7 - klasa implementować ten interfejs, aby działała w try()
+// java.io.Closeable - od Javy 5 - używany w klasach związanych z IO
+// w Javie 7 dopisano, że java.io.Closeable extends java.lang.AutoClosable
+
+public class Zasob implements AutoCloseable {
+	boolean wyjatekWClose = false;
+	
+	public Zasob() {
+		System.out.println("Zasob()");
+	}
+
+	public Zasob(boolean wyjatekNaKoniec) {
+		this.wyjatekWClose = wyjatekNaKoniec;
+		System.out.println("Zasob("+wyjatekNaKoniec+")");
+	}
+
+	
+	@Override
+	public void close() {
+		System.out.println("close()");
+		if(wyjatekWClose) {
+			System.out.println("Teraz close wyrzuci wyjątek IllegalState...");
+			throw new IllegalStateException("wyjątek z close()");
+		}
+	}
+
+	public void dzialaj() {
+		System.out.println("dzialaj()");
+	}
+
+	public void przerwij() {
+		System.out.println("zaraz wyrzucę wyjątek");
+		throw new RuntimeException("przerwanie");
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p15_abstrakcyjne/APodstawy.java

+package alx.p15_abstrakcyjne;
+
+
+abstract class A1 {
+	// klasa abstrakcyjna może być zupełnie pusta
+}
+
+abstract class A2 {
+	// jak każda klasa może mieć pola, konstruktory, normalne metody, zmienne i metody statyczne
+	private int licznik;
+	
+	String halo() {
+		return "halo halo";
+	}
+	
+	// dodatkowo może posiadać metody abstrakcyjne, czyli pozbawione treści
+	abstract String abstrakcyjna(int a, int b);
+
+	// nie klamerki, tylko średnik
+	//NK abstract String aaa(int a, int b) { }
+
+	// metoda abstract nie może być private ani final
+	//NK private abstract String bbb();
+
+	//NK final abstract String ccc();
+}
+
+// gdy tworzymy podklasę klasy abstrakcyjnej, to albo ona też jest abstrakcyjna
+abstract class A3 extends A2 {
+	
+}
+
+// albo musi uzupełnić implementacje wszystkich metod, które "wyżej" były abstrakcyjne
+class A4 extends A2 {
+	String abstrakcyjna(int a, int b) {
+		return a + " " + b;
+	}
+}
+
+
+public class APodstawy {
+
+	public static void main(String[] args) {
+		// Nie można utoworzyć instancji tej klasy:
+		//NK A1 a1 = new A1();
+		
+		A2 a4 = new A4();
+		System.out.println(a4.abstrakcyjna(5, 7));
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v1/Implementacja.java

+package alx.p16_interfejsy.v1;
+
+import javax.swing.JButton;
+
+public class Implementacja implements Interfejs {
+
+	public void wypisz() {
+		// w klasie, która implementuje interfejs, jest bezpośredni dostęp do stałych deklarowanych w interfejsie
+		System.out.println("aaa " + NAZWA);
+		System.out.println("aaa " + NAZWA);
+	}
+
+	public double oblicz(double arg1, double arg2) {
+		return arg1 + arg2;
+	}
+
+	public void p() {
+		System.out.println("ppp");
+		
+	}
+
+	public static void main(String[] args) {
+		Implementacja obiekt = new Implementacja();
+		obiekt.wypisz();
+		// klasa "dziedziczy" stałe z interfejsu, który implementuje
+		System.out.println(NAZWA);
+		System.out.println(obiekt.NAZWA);
+		System.out.println(NAZWA);
+		System.out.println(NAZWA);
+		// NAZWA = "Javatech";
+		
+		// przykład zastosowania:
+		JButton button = new JButton();
+		button.setHorizontalAlignment(JButton.CENTER);
+		// CENTER pochodzi z interfejsu SwingConstants
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v1/ImplementacjaAbstrakcyjna.java

+package alx.p16_interfejsy.v1;
+
+public abstract class ImplementacjaAbstrakcyjna implements Interfejs {
+
+	// Klasa abstrakcyjna nie musi implementować wszystkich metod z interfejsu
+	
+	// Ale jeśli implementuje albo deklaruje bez implementacji jakąś metodę z interfejsu,
+	// musi zachować zgodność z interfejsem
+
+	// Przykładowo ta deklaracja ma typ wynikowy niezgodny z interfejsem
+	//NK public abstract String oblicz(double arg1, double arg2);
+	
+	// ale jeśli nie zaimplementuję tej metody, to klasa się skompiluje, bo jest abstrakcyjna
+	
+	public abstract void wypisz();
+	
+	
+	public void mojaMetoda() {
+		System.out.println("jeste klasą abstrakcyjną");
+	}
+	
+	protected abstract int abstrakcyjna();
+	
+	public void p() {
+		System.out.println("papapa");
+	}
+	
+
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v1/Interfejs.java

+package alx.p16_interfejsy.v1;
+
+/* Tradycyjne spojrzenie na to czym jest interfejs:
+   * lista metod "do zaimplementowania"
+   * zawiera sygnatury metod, bez ich implementacji
+   * pełni rolę "kontraktu", z którym mogą być zgodne niektóre klasy
+   * 
+   * od Javy 8: interfejs może zawierać implementacje niektórych metod, oraz metody statyczne
+ */
+
+public interface Interfejs {
+	// Interfejsy mogą zawierać:
+	// 1) metody
+	// Do każdej metody niejawnie dopisywane są modyfikatory:
+	// public abstract
+	// Z tego wynika, że w klasach, które implementują interfejsy, te metody muszą być public
+	void wypisz();
+	
+	public double oblicz(double arg1, double arg2);
+	
+	public abstract void p();
+	
+	//NK protected void m();
+	//NK private void m();
+	//NK final void n();
+	
+	
+	// 2) zmienne
+	int x = 5;
+	// do każdej rzeczy wyglądającej jak zmienna dopisywane są:
+	// public static final
+	// W praktyce używa się do zapisywania stałych
+	
+	public static final String NAZWA = "ALX";
+	
+	// trzeba podać wartość
+	//NK double y;
+	
+	/* W interfejsach NIE MA statycznych bloków inicjalizacyjnych:
+	static {
+		y = 44;
+	}
+	*/
+
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v1/NieStala.java

+package alx.p16_interfejsy.v1;
+
+import java.time.LocalTime;
+
+public interface NieStala {
+	// Tak naprawdę to nie jest stała, bo wartośc będzie ustalana od nowa przy każdym uruchomieniu programu
+	public static final int SEK = LocalTime.now().getSecond();
+
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v1/PodklasaAbstrakcyjnej.java

+package alx.p16_interfejsy.v1;
+
+public class PodklasaAbstrakcyjnej extends ImplementacjaAbstrakcyjna {
+	// Konkretna klasa rozszerzająca abstrakcyjną musi zaimplementować
+	// wszystkie metody wprowadzone nie tylko przez tę klasę, ale także przez interfejs.
+
+	public double oblicz(double arg1, double arg2) {
+		return 0;
+	}
+
+
+	public void wypisz() {
+		
+	}
+
+	protected int abstrakcyjna() {
+		return 13;
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v1/TestNieStala.java

+package alx.p16_interfejsy.v1;
+
+public class TestNieStala {
+
+	public static void main(String[] args) {
+		System.out.println(NieStala.SEK);
+
+	}
+
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v2/Implementacja1.java

+package alx.p16_interfejsy.v2;
+
+public class Implementacja1 implements Interfejs {
+
+	// implementacja musi zdefiniować te metody, które nie miały implementacji w interfejsie
+	// a może zaimplementować (nadpisać) metody default (niekoniecznie wszystkie)
+	
+	public int wartosc() {
+		return 1313;
+	}
+	
+	public void nowaMetoda() {
+		// będą w implementacji interfejsu można odwoływać się do stałych
+		System.out.println(NAZWA);
+		
+		// nie można odwoływać się w ten sposób do metod statycznych
+		//NK powtorz(this, 5);
+	}
+
+	
+	public static void main(String[] args) {
+		Implementacja1 obiekt = new Implementacja1();
+		
+		obiekt.wypisz(); // zadziała defaultowe wypisz z interfejsu, ale w środku wartosc 1313
+		
+		obiekt.nowaMetoda();
+		
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v2/Implementacja2.java

+package alx.p16_interfejsy.v2;
+
+public class Implementacja2 implements Interfejs {
+	@Override // implementacja metody z interfejsu też moze być oznaczona @Override
+	public int wartosc() {
+		return 1313;
+	}
+
+	// istnieje możliwość nadpisania defaultowej metody
+	@Override // jak dla klas: opcjonalne, dodatkowe zabezpieczenie
+	public String tytul() {
+		return "Nowa wartość";
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v2/InnyInterfejs.java

+package alx.p16_interfejsy.v2;
+
+public interface InnyInterfejs {
+	default void wypisz() {
+		System.out.println("A ja jestem z innego interfejsu");
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v2/Interfejs.java

+package alx.p16_interfejsy.v2;
+
+public interface Interfejs {
+	String NAZWA = "ALX";
+	
+	int wartosc();
+	
+	// Od Javy 8 interfejsy mogą zawierać metody z implementacjami
+	// 1) "domyślne" implementacje metod instancyjnych
+	default void wypisz() {
+		System.out.println("defaultowe wypisz z wartością " + wartosc());
+		// odwoływanie się w tym miejscu do metody, która jeszcze nie implementacji, to jest wzorzec projektowy "template method"
+	}
+	
+	default String tytul() {
+		return "Warszawa";
+	}
+
+	// słowo default jest wymagane
+//	void n() {
+//		System.out.println("cokolwiek");
+//	}
+	
+	// default w pewnym sensie unieważnia abstract
+	// to jest niepoprawne składniowo:
+//	abstract default void m() {
+//		System.out.println("cokolwiek");
+//	}
+	
+	// metoda default nie może być final. Inaczej mówiąc klasa zawsze ma możliwość nadpisania tej domyślnej implementacji.
+//	final default String k() {
+//		return "Warszawa";
+//	}
+	
+	// 2) metody statyczne
+	public static void powtorz(Interfejs obiekt, int n) {
+		for(int i = 1; i <= n; i++) {
+			obiekt.wypisz();
+		}
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v2/WielodziedziczenieInterfejs.java

+package alx.p16_interfejsy.v2;
+
+/* Interfejs może rozszerzać wiele interfejsów.
+ * Jeśli istnieją domyślne implementacje, to trzeba je nadpisać.
+ */
+
+public interface WielodziedziczenieInterfejs extends Interfejs, InnyInterfejs {
+	default void wypisz() {
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v2/WielodziedziczenieKlasa.java

+package alx.p16_interfejsy.v2;
+
+/* Klasa może implementować wiele interfejsów.
+ * W Javie 8 oznacza to, że:
+ * - musi zaimplementować wszystkie niezaimplementowane metody z tych interfejsów,
+ * - nie musi implementować tych metod, które występują tylko w jednym z interfejsów
+ *   i mają tam implementację domyślną,
+ * - ale musi jawnie zaimplementować te metody, które występują w więcej niż jednym interfejsie
+ *   (obojętnie czy gdzieś mają implementację domyślną, czy kilka implementacji, czy żadnej).
+ */
+
+public class WielodziedziczenieKlasa implements Interfejs, InnyInterfejs {
+	// Muszę zaimplementować, bo nie było implementacji domyślnej.
+	public int wartosc() {
+		return 123;
+	}
+
+	// Muszę zaimplementować, bo metoda występowała w obu interfejsach.
+	public void wypisz() {
+		// Nowa składnia od Javy 8:
+		// możliwość wskazania instniejącej implementacji z interfejsu
+		Interfejs.super.wypisz();
+		System.out.println("a kuku");
+		InnyInterfejs.super.wypisz();
+	}
+	
+	// Tutaj przykładowo nie implementujemy metody tytuł - bo już ma domyślną implementację
+	
+	public static void main(String[] args) {
+		new WielodziedziczenieKlasa().wypisz();
+	}
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v3/AAA.java

+package alx.p16_interfejsy.v3;
+
+public interface AAA {
+	
+	String metoda();
+
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v3/BBB.java

+package alx.p16_interfejsy.v3;
+
+public interface BBB {
+	
+	int metoda();
+
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v3/ImplementacjaObu.java

+package alx.p16_interfejsy.v3;
+
+
+//  public class ImplementacjaObu implements AAA, BBB {
+//  
+//  public String metoda() { return null; }
+//  public int metoda() { return 11; }
+//  
+//  }
+  
+ 
\ No newline at end of file

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v4/AAA.java

+package alx.p16_interfejsy.v4;
+
+public interface AAA {
+	
+	String stala = "Ala ma kota"; // public static final - nawet jak nie piszemy
+
+	default String x() {
+		return "AAA";
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v4/BBB.java

+package alx.p16_interfejsy.v4;
+
+public interface BBB {
+
+	static String x() {
+		return "BBB";
+	}
+	
+}

PC22-PrzetwarzanieDanych/src/alx/p16_interfejsy/v4/Test.java

+package alx.p16_interfejsy.v4;
+
+import javax.swing.JButton;
+import javax.swing.SwingConstants;
+
+public class Test implements AAA, BBB {
+
+	public static void main(String[] args) {
+		// to jest metoda z interfejsu AAA - metoda domyślna
+		Test t = new Test();
+		System.out.println(t.x());
+
+		// metody statyczne z interfejsów nie są dziedziczone przez klasy
+		// Test.x();
+		System.out.println(BBB.x()); // metodę statyczną trzeba wywołać poprzez nazwę interfejsu
+		
+		// natomiast zmienne (czyli stałe) są
+		System.out.println(stala);
+		System.out.println(stala);
+		
+		JButton guzik = new JButton("OK");
+		guzik.setHorizontalAlignment(JButton.CENTER);
+		// stała CENTER jest dziedziczona przez JButton z interfejsu SwingConstants
+		guzik.setHorizontalAlignment(SwingConstants.CENTER);
+	}
+}