różne gotowe przykłady

src/main/java/alx/p00_hello/Hello.java

+package alx.p00_hello;
+
+public class Hello {
+    public static void main(String[] args) {
+        System.out.println("Hello world");
+        System.out.println("Zmiana, aby sprawdzić git-a");
+    }
+}

src/main/java/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);
+		}
+	}
+}

src/main/java/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);
+    }
+
+}

src/main/java/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);
+
+    }
+}

src/main/java/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);
+
+    }
+}

src/main/java/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");
+    }
+}

src/main/java/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());
+		
+	}
+
+}

src/main/java/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();
+		}
+	}
+}

src/main/java/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');
+	}
+}

src/main/java/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);
+    }
+}

src/main/java/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);
+    }
+}

src/main/java/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);
+    }
+}

src/main/java/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);
+    }
+}

src/main/java/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);
+    }
+}

src/main/java/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);
+	}
+
+}

src/main/java/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...");
+		}
+	}
+
+}

src/main/java/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);
+		}
+	}
+
+}

src/main/java/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;
+		}
+		
+	}
+
+}

src/main/java/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);
+    }
+}

src/main/java/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");
+        }
+
+    }
+}

src/main/java/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");
+        }
+    }
+}

src/main/java/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ł");
+		
+		
+	}
+
+}

src/main/java/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ł");
+	}
+
+}

src/main/java/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ł");
+	}
+
+}

src/main/java/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
+	}
+
+}

src/main/java/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(_);
+		
+	}
+
+}

src/main/java/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;
+	}
+}

src/main/java/alx/p02_zmienne/SlowoVar.java

+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);
+	}
+
+}

src/main/java/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
+
+    }
+
+}
+
+

src/main/java/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);
+	}
+
+}

src/main/java/alx/p02_zmienne/Zmienne1.java

+package alx.p02_zmienne;
+
+public class Zmienne1 {
+
+	public static void main(String[] args) {
+		// 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ść.
+	}
+
+}

src/main/java/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);
+	}
+
+}

src/main/java/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();
+	}
+	
+	
+
+}

src/main/java/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");
+	}
+
+}

src/main/java/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");
+	}
+
+}

src/main/java/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;
+	}
+}

src/main/java/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");
+	}
+}

src/main/java/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");
+	}
+
+}

src/main/java/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);
+	}
+}

src/main/java/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);
+	}
+}

src/main/java/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");
+	}
+
+}

src/main/java/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");
+	}
+
+}

src/main/java/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");
+	}
+
+}

src/main/java/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");
+    }
+
+}

src/main/java/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
+
+	}
+
+}

src/main/java/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");
+		}
+		*/
+		
+	}
+}

src/main/java/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");
+		}
+
+	}
+
+}

src/main/java/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
+		
+	}
+
+}

src/main/java/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");
+		}
+	}
+
+}

src/main/java/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
+	}
+}

src/main/java/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));
+
+	}
+
+}

src/main/java/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();
+	}
+
+}

src/main/java/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();
+	}
+}

src/main/java/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);
+
+	}
+	
+}

src/main/java/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);
+
+	}
+	
+}

src/main/java/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");
+		}
+	}
+	
+}

src/main/java/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");
+		}
+		
+	}
+
+}

src/main/java/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");
+	}
+}

src/main/java/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);
+	}
+}

src/main/java/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");
+		}
+
+	}
+
+}

src/main/java/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);
+	}
+
+}

src/main/java/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));
+
+	}
+}

src/main/java/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);
+	}
+
+}

src/main/java/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);
+	}
+}

src/main/java/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");
+		}
+	}
+
+}

src/main/java/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++;
+		}
+	}
+}

src/main/java/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);
+	}
+
+}

src/main/java/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);
+		}
+
+	}
+
+}

src/main/java/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
+    }
+}

src/main/java/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);
+	}
+}

src/main/java/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

src/main/java/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);
+	}
+}

src/main/java/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);
+	}
+}

src/main/java/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);
+
+	}
+
+}

src/main/java/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);
+		}
+	}
+
+}

src/main/java/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);
+	}
+
+}

src/main/java/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);
+		}
+
+	}
+
+}

src/main/java/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
+*/
+

src/main/java/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();
+	}
+}

src/main/java/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");
+    }
+}

src/main/java/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);
+	}
+}

src/main/java/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);
+	}
+	
+}

src/main/java/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));
+	}
+
+}

src/main/java/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");
+	}
+
+}

src/main/java/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");
+	}
+
+}

src/main/java/alx/p06_funkcje/importowanie/V3_ImportGwiazdka.java

+package alx.p06_funkcje.importowanie;
+
+import alx.p06_funkcje.przyklady.*;
+
+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");
+	}
+
+}

src/main/java/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");
+	}
+
+}

src/main/java/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");
+	}
+
+}

src/main/java/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);
+	}
+
+}

src/main/java/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);
+		
+		wynik = obwodProstokata(x, y);
+		System.out.println("Obwód prostokąta " + x + " × " + y + " wynosi " + wynik);
+	}
+
+}

src/main/java/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
+	}
+
+}

src/main/java/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");
+}
+*/

src/main/java/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 ?
+	}
+
+}

src/main/java/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ę
+	}
+
+}

src/main/java/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);
+
+	}
+
+}

src/main/java/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);
+	}
+
+}

src/main/java/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.");
+	}
+	
+	// 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();
+	}
+
+}