pętle i porządki w pakietach

src/main/java/gotowe/p01_okna_dialogowe/RodzajeOkien.java

+package gotowe.p01_okna_dialogowe;
+
+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());
+    	// Rozbudowana wersja showInputDialog pozwala wybrać wartość z rozwijanej listy
+    	// Należy przekazać tablicę wartości do wyboru
+    	String[] opcje = {"wiosna", "lato", "jesień", "zima"};
+    	String poraRoku = (String)JOptionPane.showInputDialog(null, "Którą porę roku lubisz najbardziej?",
+    			"Pytanie", JOptionPane.QUESTION_MESSAGE, null, opcje, "jesień");
+    	
+    	int pora2 = JOptionPane.showOptionDialog(null, "A której pory nie lubisz?",
+    			"Pytanie 2", 0, JOptionPane.QUESTION_MESSAGE, null, opcje, "zima");
+    	// dostajemy numer wybranej opcji, od 0
+    	
+    	int wybor = JOptionPane.showConfirmDialog(null, "Czy chcesz " + cos + " o godzinie " + data + "?");
+    	switch(wybor) {
+	    	case JOptionPane.YES_OPTION ->
+	        	JOptionPane.showMessageDialog(null, "TAK");
+	    	case JOptionPane.NO_OPTION ->
+	        	JOptionPane.showMessageDialog(null, "NO");
+	    	case JOptionPane.CANCEL_OPTION ->
+	        	JOptionPane.showMessageDialog(null, "Cancel");
+	        default ->
+	            JOptionPane.showMessageDialog(null, "Inna wartość: " + wybor);
+	            // zamknięcie okna daje wynik -1 czyli CLOSED_OPTION
+    	}
+	}
+
+}

src/main/java/gotowe/p01_okna_dialogowe/Rozmowa1.java

+package gotowe.p01_okna_dialogowe;
+
+import javax.swing.JOptionPane;
+
+public class Rozmowa1 {
+
+	public static void main(String[] args) {
+		String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+		String miasto = JOptionPane.showInputDialog("Z jakiego miasta jesteś?");
+		JOptionPane.showMessageDialog(null, "Witaj " + imie + " z miasta " + miasto);
+	}
+
+}
+
+// uruchamianie w Eclipse: Ctrl + F11
\ No newline at end of file

src/main/java/gotowe/p01_okna_dialogowe/Rozmowa2.java

+package gotowe.p01_okna_dialogowe;
+
+import javax.swing.JOptionPane;
+
+public class Rozmowa2 {
+
+	public static void main(String[] args) {
+		String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+		String miasto = JOptionPane.showInputDialog("Z jakiego miasta jesteś?");
+		JOptionPane.showMessageDialog(null, "Witaj " + imie + " z miasta " + miasto);
+		
+		int wiek = Integer.parseInt(JOptionPane.showInputDialog("Ile masz lat?"));
+		
+		if(wiek >= 18) {
+			JOptionPane.showMessageDialog(null, "Możesz kupić piwo");
+		} else {
+			JOptionPane.showMessageDialog(null, "Nie możesz kupić piwa, bo masz tylko " + wiek + " lat.");			
+		}
+	}
+
+}

src/main/java/gotowe/p01_okna_dialogowe/Zakupy1.java

+package gotowe.p01_okna_dialogowe;
+
+import javax.swing.JOptionPane;
+
+public class Zakupy1 {
+
+	public static void main(String[] args) {
+		String nazwa = JOptionPane.showInputDialog("Podaj nazwę towaru");
+		double cena = Double.parseDouble(JOptionPane.showInputDialog("Podaj cenę towaru"));
+		int ile = Integer.parseInt(JOptionPane.showInputDialog("Ile sztuk kupujesz?"));
+		
+		JOptionPane.showMessageDialog(null, "Za " + ile + " sztuk towaru " + nazwa + " zapłacisz " + ile*cena);
+	}
+
+}

src/main/java/gotowe/p01_okna_dialogowe/Zakupy2.java

+package gotowe.p01_okna_dialogowe;
+
+import javax.swing.JOptionPane;
+
+public class Zakupy2 {
+
+	public static void main(String[] args) {
+		String nazwa = JOptionPane.showInputDialog("Podaj nazwę towaru");
+		double cena = Double.parseDouble(JOptionPane.showInputDialog("Podaj cenę towaru"));
+		int ile = Integer.parseInt(JOptionPane.showInputDialog("Ile sztuk kupujesz?"));
+		
+		// Pierwszy sposób, aby poradzić sobie z niedokładnościami obliczeń double:
+		// Zaokrąglanie podczas wypisywania.
+		// Na tekstową konsolę można wypisać System.out.printf
+		// Tutaj użyjemy String.format, aby uzyskać napis do wyświetlenia w oknie
+		
+		JOptionPane.showMessageDialog(null, String.format("Za %d sztuk towaru %s zapłacisz %.2f", ile, nazwa, ile*cena));
+		
+		// wersje, które wypisują w ten sposób na stadardowe wyjście (obie nazwy działają tak samo):
+//		System.out.format("Za %d sztuk towaru %s zapłacisz %.2f%n", ile, nazwa, ile*cena);
+//		System.out.printf("Za %d sztuk towaru %s zapłacisz %.2f%n", ile, nazwa, ile*cena);
+		
+	}
+
+}

src/main/java/gotowe/p01_okna_dialogowe/Zakupy3.java

+package gotowe.p01_okna_dialogowe;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+import javax.swing.JOptionPane;
+
+public class Zakupy3 {
+	// Drugi sposób, aby poradzić sobie z niedokładnościami obliczeń double:
+	// Używamy klasy BigDecimal, która zapewnia dokładne obliczenia z ułamkami dziesiętnymi.
+	// Operacje trzeba zapisywać słownie...
+
+	public static void main(String[] args) {
+		String nazwa = JOptionPane.showInputDialog("Podaj nazwę towaru");
+		BigDecimal cena = new BigDecimal(JOptionPane.showInputDialog("Podaj cenę towaru"));
+		BigDecimal ile = new BigDecimal(JOptionPane.showInputDialog("Ile towaru kupujesz?"));
+		// BigDecimal kwota = ile.multiply(cena);
+		BigDecimal kwota = ile.multiply(cena).setScale(2, RoundingMode.HALF_UP);
+
+		JOptionPane.showMessageDialog(null, String.format("Za %s sztuk towaru %s zapłacisz %s", ile, nazwa, kwota));
+	}
+
+}

src/main/java/gotowe/p01_okna_dialogowe/Zgadywanka1.java

+package gotowe.p01_okna_dialogowe;
+
+import java.util.Random;
+
+import javax.swing.JOptionPane;
+
+public class Zgadywanka1 {
+
+	public static void main(String[] args) {
+		Random random = new Random();
+		
+		int x = random.nextInt(1, 11);
+		int y = random.nextInt(1, 11);
+		
+		int odp = Integer.parseInt(JOptionPane.showInputDialog("Ile to jest " + x + " razy " + y + "?"));
+		if(odp == x * y) {
+			JOptionPane.showMessageDialog(null, "Gratulacje, poprawna odpowiedz");
+		} else {
+			JOptionPane.showMessageDialog(null, "Źle, wróć do szkoły!", "Alarm", JOptionPane.ERROR_MESSAGE);			
+		}
+	}
+
+}

src/main/java/gotowe/p02_zmienne_i_typy/DeklaracjeZmiennych.java

+package gotowe.p02_zmienne_i_typy;
+
+public class DeklaracjeZmiennych {
+
+	public static void main(String[] args) {
+		// Nie wolno używać zmiennych, które nie są zadelarowane
+		// x = 123;
+		// System.out.println(x);
+		
+		// Sama deklaracja wygląda tak:
+		int x;
+		// teraz do takiej zmiennej mógłbym już wpisać wartość, ale nie mogę jej jeszcze czytać, bo jest niezainicjowana:
+		// System.out.println(x);
+		
+		// Przypisanie wartości do zmiennej
+		x = 345;
+		System.out.println(x);
+
+		// Wartość zmiennej można zmienić (o ile ta zmienna nie jest "final")
+		x++; // zwiększenie liczby o 1
+		System.out.println(x);
+		
+		x += 5; // zmiana względem poprzedniej wartości
+		System.out.println(x);
+		
+		// wpisanie zupełnie innej wartości
+		x = 200 * 4;
+		System.out.println(x);
+		System.out.println();
+		
+		int y;
+		if(x > 100) {
+			y = 333;
+			System.out.println(y); // tutaj OK
+		}
+		// Kompilator myśli: "Gdyby program nie wszedł do if-a, to zmienna y nie byłaby zainicjowana".
+		// I dlatego w tym miejscu jest zgłaszany błąd kompilacji.
+		// System.out.println(y);
+		
+		if(x > 200) {
+			y = 444;
+		} else {
+			y = 555;
+		}
+		// Ale teraz y na pewo ma jakąś wartość, więc ta linia jest OK:
+		System.out.println(y);
+		
+		// W praktyce najczęściej deklarując zmienną od razu wpisuje się jej początkową wartość:
+		double z = 321.123;
+		System.out.println(z);
+		
+		// Wpisując inną wartość do już istniejącej zmiennej, nie podajemy jej typu:
+		// double z = 321.123;
+		// int x = 5432;
+		x = 5432;
+		System.out.println(x);
+	}
+
+}

src/main/java/gotowe/p02_zmienne_i_typy/Losowanie.java

+package gotowe.p02_zmienne_i_typy;
+
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class Losowanie {
+
+	public static void main(String[] args) {
+		// tworzymy obiekt Random - "generator liczb pseudolosowych"
+		Random random = new Random();
+		
+		double d = random.nextDouble();
+		// liczba z zakresu [0.0 , 1.0)
+		System.out.println("double: " + d);
+
+		// losowy int z całego zakresu intów (orientacyjnie od -2mld do +2mld)
+		int x = random.nextInt();
+		
+		// int z zakresu od 0 do limit-1, czyli tu od 0 do 99
+		int y = random.nextInt(100);
+		
+		// int z zakresu od 500 włącznie do 1000 wyłączając, czyli od 500 do 999
+		// dostępne od niedawna, od Java 17
+		int z = random.nextInt(500, 1000);
+
+		System.out.println(x + " " + y + " " + z);
+	}
+
+}

src/main/java/gotowe/p02_zmienne_i_typy/PrzegladTypow.java

+package gotowe.p02_zmienne_i_typy;
+
+import java.time.LocalDateTime;
+
+public class PrzegladTypow {
+
+	public static void main(String[] args) {
+		// 8 typów prostych:
+		// liczby calkowite: byte, short, int, long
+		byte b = 100;
+		short s = 1000;
+		int i = 23;
+		long l = 333;
+		System.out.println(b * s * i * l);
+		
+		// 2 typy dla liczb z ułamkiem. liczby "zmiennopozycyjne" / "zmiennoprzeconkowe" (floating point)
+		float f = 3.14F;
+		double d = 123.456;
+		System.out.println(f * d);
+		System.out.println();
+		
+		// char - pojedynczy znak, ale patrząc technicznie, to jest liczba 16-bitowa, która może być kodem znaku
+		char c = 'A';
+		System.out.println(c);
+		System.out.println(c+1); // kodem litery A jest 65
+		c++;
+		// teraz jednak "przesuwamy znak" o jedną pozycję do przodu
+		System.out.println(c);
+		
+		boolean warunek = true;
+		System.out.println(warunek);
+		warunek = f < 3;
+		System.out.println(warunek);
+		// przy okazji dwa sposoby umieszczania egzotycznych znaków w napisach:
+		if(warunek) {
+			System.out.println("\u03C0 jest małe");
+		} else {
+			System.out.println("π jest duże");
+		}
+		System.out.println();
+		
+		// Typy obiektowe: klasa, interfejs, enum, rekord oraz tablice
+		// Sama Java definiuje ich kilka tysięcy, a programiści mogą tworzyć własne
+		String napis = "Ala ma kota";
+		System.out.println(napis);
+		System.out.println(napis.toUpperCase());
+		
+		LocalDateTime czas = LocalDateTime.now();
+		System.out.println(czas);
+		System.out.println("Godzina " + czas.getHour() + " minut " + czas.getMinute());
+		// itd, jest tego bardzo dużo
+	}
+
+}

src/main/java/gotowe/p03_skaner/ObliczPowierzchnie.java

+package gotowe.p03_skaner;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class ObliczPowierzchnie {
+	/* Za pomocą Scannera program wczytuje wymiary pomieszczenia: długość i szerokość w metrach.
+	 * Na tej podstawie oblicza powierzchnię tego pomieszczenia.
+	 * Można też obliczyć obwód.
+	 */
+	
+	public static void main(String[] args) {
+		// Locale.setDefault(Locale.US);
+		
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Podaj wymiary pomieszczenia w metrach.");
+		System.out.print("długość: ");
+		double a = sc.nextDouble();
+		System.out.print("szerokość: ");
+		double b = sc.nextDouble();
+
+		double pole = a*b;
+		double obwod = 2*a + 2*b;
+		// System.out.println("Pole wynosi " + pole + " m² a obwód " + obwod + " m");
+		System.out.printf("Pole wynosi %.3f m² a obwód %.3f m%n", pole, obwod);
+	}
+
+}

src/main/java/gotowe/p03_skaner/Skaner1.java

+package gotowe.p03_skaner;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class Skaner1 {
+
+	public static void main(String[] args) {
+		// Deklaruję zmienną scanner typu Scanner
+		// i wpisuję do niej nowy obiekt klasy Scanner.
+		// Ten skaner będzie czytał dane ze standardowego wejścia (System.in)
+		Scanner scanner = new Scanner(System.in);
+		// Gdy zmieniemy ustawienia na amerykańskie, to liczby będzie trzeba wpisywać z kropką.
+		// scanner.useLocale(Locale.US);
+		// Jeśli tego nie zrobimy, to wszystko zależy od ustawień językowych komputera. Jeśli są PL, to wpisujemy liczby z przecinkiem
+		
+		System.out.println("Wpisz linię tekstu:");
+		String linia = scanner.nextLine();
+		System.out.println("linia: " + linia);
+		
+		System.out.println("Napisz kilka słów:");
+		String slowo1 = scanner.next();
+		String slowo2 = scanner.next();
+		// Po wczytaniu pojedynczych słów lub liczb, warto wykonać nextLine,
+		// aby wczytać wszystkie pozostałe znaki do końca linii - w ten sposób "oczyszczamy wejście"
+		String reszta = scanner.nextLine();
+		System.out.println("Pierwsze słowo: " + slowo1);
+		System.out.println("Drugie słowo: " + slowo2);
+		System.out.println("Reszta linii: " + reszta);
+		
+		System.out.print("Podaj liczbę całkowitą: ");
+		int x = scanner.nextInt();
+		System.out.println("x = " + x);
+
+		System.out.print("Podaj liczbę z ułamkiem: ");
+		double d = scanner.nextDouble();
+		System.out.println("d = " + d);
+		System.out.println("iloczyn tych liczb: " + x*d);
+		
+		// można też long, BigDecimal, a nawet boolean
+
+		// Zamykanie skanera, który czyta stdin, nie jest konieczne,
+		// ale napiszemy tu close, aby Eclipse nie pokazywał warninga.
+		scanner.close();
+	}
+
+}

src/main/java/gotowe/p03_skaner/StandardoweWejscie.java

+package gotowe.p03_skaner;
+
+import java.io.IOException;
+
+public class StandardoweWejscie {
+
+	public static void main(String[] args) throws IOException {
+		// standardowe wyjście (stdout)
+		System.out.println("Normalny output");
+		
+		// wyjście błędów (stderr)
+		System.err.println("Wyjście błędów");
+		
+		System.out.println("Napisz kawałek tekstu:");
+		
+		// standardowe wejście
+		int x = System.in.read();
+		System.out.println("pierwszy bajt: " + x);
+
+		x = System.in.read();
+		System.out.println("drugi bajt: " + x);
+
+	}
+
+}

src/main/java/gotowe/p03_skaner/StandardoweWejscie2.java

+package gotowe.p03_skaner;
+
+import java.io.IOException;
+import java.util.Arrays;
+
+public class StandardoweWejscie2 {
+    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);
+    }
+}
+
+// System.in pozwala czytać surowe dane w postaci pojedynczych bajtów lub tablicy bajtów.
+// Jest to niewygodne. Przydałaby nam się operacja czytania całej linii tekstu albo całych słów, albo liczb zapisanych dziesiętnie...
+
+// W paktyce korzysta się z tego za pośrednictwem klasy Scanner (lub ewentualnie BufferedReader).
+

src/main/java/gotowe/p03_skaner/bledy.txt

+Wyjście błędów

src/main/java/gotowe/p03_skaner/normalne_wyjscie.txt

+Normalny output

src/main/java/gotowe/p04_if/Bagaz1.java

+package gotowe.p04_if;
+
+import java.util.Scanner;
+
+/* Program czyta od użytkownika 3 liczby: wymiary walizki w cm
+ * i sprawdza czy walizka mieści się w limitach wymiaru.
+ * Warunki:
+ * - żaden wymiar nie może przekraczać 50 cm
+ * - objętość nie może przekraczać 50_000 cm³
+ */
+public class Bagaz1 {
+    /* W tej wersji:
+     * - wszystkie warunki sprawdza są w jednym if, program nie informuje konkretnie dlaczego odrzucił
+     * - sprawdzamy warunek "pozytywny", czyli piszemy kiedy jest dobrze; spójnikiem jest &&
+     */
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		System.out.println("Podaj trzy liczby - wymiary walizki w cm:");
+		double a = scanner.nextDouble();
+		double b = scanner.nextDouble();
+		double c = scanner.nextDouble();
+		
+		if(a <= 50 && b <= 50 && c <= 50 && a*b*c <= 50_000) {
+			System.out.println("Bagaż mieści się w wymaganiach");
+		} else {
+			System.out.println("Bagaż za duży");
+		}
+		
+	}
+
+}

src/main/java/gotowe/p04_if/Bagaz2.java

+package gotowe.p04_if;
+
+import java.util.Scanner;
+
+public class Bagaz2 {
+    /* W tej wersji:
+     * - wszystkie warunki sprawdza są w jednym if, program nie informuje konkretnie dlaczego odrzucił
+     * - sprawdzamy warunek "negatywny", czyli piszemy kiedy jest źle; spójnikiem jest &&
+     */
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		System.out.println("Podaj trzy liczby - wymiary walizki w cm:");
+		double a = scanner.nextDouble();
+		double b = scanner.nextDouble();
+		double c = scanner.nextDouble();
+		
+		if(a > 50 || b > 50 || c > 50 || a*b*c > 50_000) {
+			System.out.println("Bagaż za duży");
+		} else {
+			System.out.println("Bagaż mieści się w wymaganiach");
+		}
+	}
+
+}

src/main/java/gotowe/p04_if/Bagaz3.java

+package gotowe.p04_if;
+
+import java.util.Scanner;
+
+public class Bagaz3 {
+    /* W tej wersji:
+     * - rozbijamy warunki do oddzielnych if-ów, aby program napisał dlaczego bagaż został odrzucony
+     * - ważne jednak, aby program ostatecznie potwierdził akceptację bagażu, lub napisał jednoznacznie, że odrzuca
+     * - program wypisuje tylko pierwszą przyczynę odrzucenia
+     * - sprawdzanie warunków pozytywnych prowadzi tutaj do powstania kodu wielokrotnie zagnieżdżonego
+     *   (if w ifie i kolejnym ifie...)
+     *   "else jest daleko od swojego if-a"
+     */
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		System.out.println("Podaj trzy liczby - wymiary walizki w cm:");
+		System.out.print("długość: ");
+		double a = scanner.nextDouble();
+		System.out.print("szerokość: ");
+		double b = scanner.nextDouble();
+		System.out.print("wysokość: ");
+		double c = scanner.nextDouble();
+		double obj = a*b*c;
+		
+		if(a <= 50) {
+			if (b <= 50) {
+				if (c <= 50) {
+					if (obj <= 50_000) {
+						System.out.println("Bagaż mieści się w wymaganiach");
+					} else {
+						System.out.println("Zbyt duża objętość");
+					}
+				} else {
+					System.out.println("Zbyt duża wysokość");
+				}
+			} else {
+				System.out.println("Zbyt duża szerokość");
+			}
+		} else {
+			System.out.println("Zbyt duża długość");
+		}
+		
+	}
+
+}

src/main/java/gotowe/p04_if/Bagaz4.java

+package gotowe.p04_if;
+
+import java.util.Scanner;
+
+public class Bagaz4 {
+    /* W tej wersji:
+     * - rozbijamy warunki do oddzielnych if-ów, aby program napisał dlaczego bagaż został odrzucony
+     * - program wypisuje tylko pierwszą przyczynę odrzucenia
+     * - dzięki sprawdzaniu warunków negatywnych, możemy zastosować schemat else-if
+     *   i napisać to na zasadzie: sprawdź czy jest źle z 1. powodu, czy z 2. powodu itd.
+     *   a jeśli nie było żadnego problemu, to na samym końcu jest wykonana operacja w przypadku braku błędów
+     */
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		System.out.println("Podaj trzy liczby - wymiary walizki w cm:");
+		System.out.print("długość: ");
+		double a = scanner.nextDouble();
+		System.out.print("szerokość: ");
+		double b = scanner.nextDouble();
+		System.out.print("wysokość: ");
+		double c = scanner.nextDouble();
+		double obj = a*b*c;
+		
+		if(a > 50) {
+			System.out.println("Zbyt duża długość");
+		} else if(b > 50) {
+			System.out.println("Zbyt duża szerokość");
+		} else if(c > 50) {
+			System.out.println("Zbyt duża wysokość");
+		} else if(obj > 50_000) {
+			System.out.println("Zbyt duża objętość");
+		} else {
+			System.out.println("Bagaż mieści się w wymaganiach");
+		}
+	}
+
+}

src/main/java/gotowe/p04_if/Bagaz5.java

+package gotowe.p04_if;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class Bagaz5 {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		System.out.println("Podaj trzy liczby - wymiary walizki w cm:");
+		System.out.print("długość: ");
+		double a = scanner.nextDouble();
+		System.out.print("szerokość: ");
+		double b = scanner.nextDouble();
+		System.out.print("wysokość: ");
+		double c = scanner.nextDouble();
+		double obj = a*b*c;
+		
+		List<String> bledy = new ArrayList<>();
+		
+		if(a > 50) {
+			bledy.add("Zbyt duża długość");
+		} 
+		if(b > 50) {
+			bledy.add("Zbyt duża szerokość");
+		}
+		if(c > 50) {
+			bledy.add("Zbyt duża wysokość");
+		} 
+		if(obj > 50_000) {
+			bledy.add("Zbyt duża objętość");
+		}
+		
+		if(bledy.isEmpty()) {
+			System.out.println("Bagaż mieści się w wymaganiach");
+		} else {
+			System.out.println("Bagaż odrzucony. Znalezione problemy:");
+			for (String blad : bledy) {
+				System.out.println(blad);
+			}
+		}
+	}
+
+}

src/main/java/gotowe/p04_if/SpojnikiLogiczne.java

+package gotowe.p04_if;
+
+import java.util.Random;
+
+public class SpojnikiLogiczne {
+
+	public static void main(String[] args) {
+		Random random = new Random();
+		int x = random.nextInt(20);
+		int y = random.nextInt(20);
+		System.out.println("x = " + x + " , y = " + y);
+		
+		// && - koniunkcja, "i", "and"
+		// warunek jest prawdziwy tylko gdy obie części są prawdziwe
+		if(x >= 10 && y >= 10) {
+			System.out.println("AAA obie liczby są dwucyfrowe");
+		} else {
+			System.out.println("BBB nieprawda, że obie na raz są dwucyfrowe");			
+		}
+		
+		// || - alternatywa, "lub", "or"
+		// warunek jest prawdziwy gdy co najmniej jedna część jest prawdziwa
+		if(x >= 10 || y >= 10) {
+			System.out.println("CCC któraś z liczb jest dwucyfrowa");
+		} else {
+			System.out.println("DDD obie liczby są jednocyfrowe");			
+		}
+		
+		// Istnieje też ^ - to jest alternatywa rozłączna, tzw. "xor",
+		// Jest prawdą, gdy dokładnie jedna z części jest prawdą.
+		// Inaczej mówiąc ^ sprawdza czy warunki składowe dają różne wyniki.
+		// W praktyce nieużywane
+		if(x >= 10 ^ y >= 10) {
+			System.out.println("EEE tylko jedna z liczb jest dwucyfrowa");
+		} else {
+			System.out.println("FFF warunki są jednakowe dla obu liczb");
+		}
+	}
+
+}

src/main/java/gotowe/p04_if/SprawdzWiek.java

+package gotowe.p04_if;
+
+import java.util.Scanner;
+
+public class SprawdzWiek {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		
+		System.out.print("Ile masz lat? ");
+		int wiek = scanner.nextInt();
+		
+		// W zależności od wieku opisz status osoby:
+		if(wiek < 0) {
+			System.err.println("Wiek nie może być ujemny");
+		} else if(wiek < 4) {
+			System.out.println("Jesteś niemowlakiem");
+		} else if(wiek < 7) {
+			System.out.println("Jesteś przedszkolakiem");
+		} else if(wiek < 19) {
+			System.out.println("Jesteś uczniem");
+		} else if(wiek < 65) {
+			System.out.println("Jesteś pracownikiem");
+		} else {
+			System.out.println("Jesteś emerytem");
+		}
+	}
+
+}

src/main/java/gotowe/p04_if/TeoriaIf.java

+package gotowe.p04_if;
+
+import java.util.Scanner;
+
+public class TeoriaIf {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		System.out.print("Podaj liczbę: ");
+		int liczba = scanner.nextInt();
+		
+		System.out.println("Wczytana liczba: " + liczba);
+		
+		if(liczba < 10) {
+			System.out.println("liczba mniejsza niż 10");
+			System.out.println("czyli jednocyfrowa (albo ujemna)");
+		} else {
+			System.out.println("liczba nie była malutka");
+		}
+		
+		// Jeśli za if-em lub else-em do wykonania jest tylko jedna instrukcja,
+		// to teoretycznie nie trzeba brać jej w nawiasy klamrowe
+		if(liczba % 2 == 0)
+			System.out.println("liczba jest parzysta");
+		else
+			System.out.println("liczba jest nieparzysta");
+		
+		// Ale ze względu na czytelność kodu oraz perspektywę dalszej modyfikacji
+		// lepiej od początku stosować nawiasy klamrowe.
+		
+		// Za instrukcjami strukturalnymi (if, switch, while, for) w praktyce nie stawia się średnika ;
+		
+		// if może istnieć bez części else.
+		// Wtedy: jeśli warunek prawdziwy: wykonujemy instrukcje z podanego bloku
+		// jeśli nieprawdziwy - to ich nie wykonujemy (program idzie dalej)
+		
+		if(liczba == 21) {
+			System.out.println("BINGO!");
+			System.out.println("To jest dokładnie 21");
+		}
+		
+		System.out.println("To się zawsze wypisze");
+		
+		// Jeśli do rozpatrzenia mam więcej niż 2 sytuacje, to typowy zapis jest taki:
+		if(liczba > 0) {
+			System.out.println("Liczba dodatnia");
+		} else if(liczba < 0) {
+			System.out.println("Liczba ujemna");
+		} else {
+			System.out.println("Równa zero");
+		}
+		
+		// W Javie, inaczej niż w C, nie można do ifa przekazywać liczb.
+		// Ani, inaczej niż w Pythonie, napisów, list itp rzeczy. W Javie tylko boolean.
+//		if(liczba) {
+//			System.out.println("nie zero");
+//		} else {
+//			System.out.println("zero");
+//		}
+
+		System.out.println("Koniec programu");
+	}
+
+}

src/main/java/gotowe/p05_switch/DzienTygodnia0.java

+package gotowe.p05_switch;
+
+import javax.swing.JOptionPane;
+
+public class DzienTygodnia0 {
+
+	public static void main(String[] args) {
+		int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj nr dnia tygodnia"));
+		
+		if(numer == 1) {
+			JOptionPane.showMessageDialog(null, "To jest poniedziałek");
+		} else if(numer == 2) {
+			JOptionPane.showMessageDialog(null, "To jest wtorek");
+		} else if(numer == 3) {
+			JOptionPane.showMessageDialog(null, "To jest środa");
+		} else if(numer == 4) {
+			JOptionPane.showMessageDialog(null, "To jest czwartek");
+		} else if(numer == 5) {
+			JOptionPane.showMessageDialog(null, "To jest piątek");
+			JOptionPane.showMessageDialog(null, "Weekendu początek");
+		} else if(numer == 6) {
+			JOptionPane.showMessageDialog(null, "To jest sobota");
+		} else if(numer == 7) {
+			JOptionPane.showMessageDialog(null, "To jest niedziela");
+		} else {
+			JOptionPane.showMessageDialog(null, "Niepoprawny numer dnia: " + numer, "Błąd", JOptionPane.ERROR_MESSAGE);			
+		}
+		
+		JOptionPane.showMessageDialog(null, "Koniec programu");
+	}
+
+}

src/main/java/gotowe/p05_switch/DzienTygodnia1.java

+package gotowe.p05_switch;
+
+import javax.swing.JOptionPane;
+
+public class DzienTygodnia1 {
+    /* switch przechodzi do tego case, którego wartość została przekazana w parametrze
+     * i od tego miejsca kontynuuje wykonanie do samego końca
+     * albo do napotkania instrukcji break (która powoduje wyjście ze switcha).
+     *
+     * W tej wersji pomiędzy case'ami nie ma breaków, dlatego wykonują się dalsze instrukcje aż do końca.
+     */
+
+	public static void main(String[] args) {
+		int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj nr dnia tygodnia"));
+		
+		switch(numer) {
+		case 1: 
+			JOptionPane.showMessageDialog(null, "To jest poniedziałek");
+		case 2:
+			JOptionPane.showMessageDialog(null, "To jest wtorek");
+		case 3:
+			JOptionPane.showMessageDialog(null, "To jest środa");
+		case 4:
+			JOptionPane.showMessageDialog(null, "To jest czwartek");
+		case 5:
+			JOptionPane.showMessageDialog(null, "To jest piątek");
+			JOptionPane.showMessageDialog(null, "Weekendu początek");
+		case 6:
+			JOptionPane.showMessageDialog(null, "To jest sobota");
+		case 7:
+			JOptionPane.showMessageDialog(null, "To jest niedziela");
+		default:
+			JOptionPane.showMessageDialog(null, "Niepoprawny numer dnia: " + numer, "Błąd", JOptionPane.ERROR_MESSAGE);			
+		}
+		
+		JOptionPane.showMessageDialog(null, "Koniec programu");
+	}
+
+}

src/main/java/gotowe/p05_switch/DzienTygodnia2.java

+package gotowe.p05_switch;
+
+import javax.swing.JOptionPane;
+
+public class DzienTygodnia2 {
+    /* Ta wersja pokazuje najbardziej klasyczny zapis switch, jaki działa w Javie od samego początku.
+     * Tak samo jest też w C, C++.
+     *
+     * Pod koniec każdego case'a jest break, który powoduje, że program nie przejdzie do następnego.
+     * break powoduje wyjście ze switch, ale break nie przerywa całego programu.
+     */
+
+	public static void main(String[] args) {
+		int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj nr dnia tygodnia"));
+		
+		switch(numer) {
+		case 1: 
+			JOptionPane.showMessageDialog(null, "To jest poniedziałek");
+			break;
+		case 2:
+			JOptionPane.showMessageDialog(null, "To jest wtorek");
+			break;
+		case 3:
+			JOptionPane.showMessageDialog(null, "To jest środa");
+			break;
+		case 4:
+			JOptionPane.showMessageDialog(null, "To jest czwartek");
+			break;
+		case 5:
+			JOptionPane.showMessageDialog(null, "To jest piątek");
+			JOptionPane.showMessageDialog(null, "Weekendu początek");
+			break;
+		case 6:
+			JOptionPane.showMessageDialog(null, "To jest sobota");
+			break;
+		case 7:
+			JOptionPane.showMessageDialog(null, "To jest niedziela");
+			return;
+		default:
+			JOptionPane.showMessageDialog(null, "Niepoprawny numer dnia: " + numer, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+		
+		JOptionPane.showMessageDialog(null, "Koniec programu");
+	}
+
+}

src/main/java/gotowe/p05_switch/DzienTygodnia3.java

+package gotowe.p05_switch;
+
+import javax.swing.JOptionPane;
+
+public class DzienTygodnia3 {
+    /* W Java 14 pojawiły się nowe możliwości dla switch.
+     * Jedną z nich jest wpisanie za case znaków -> zamiast :
+     * powoduje to, że wykona się tylko jeden case i nie trzeba pisać break, aby przerwać.
+     * Za strzałką może być albo jedna instrukcja;  albo {blok}
+     */
+
+	public static void main(String[] args) {
+		int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj nr dnia tygodnia"));
+		
+		switch(numer) {
+			case 1 -> JOptionPane.showMessageDialog(null, "To jest poniedziałek");
+			case 2 -> JOptionPane.showMessageDialog(null, "To jest wtorek");
+			case 3 -> JOptionPane.showMessageDialog(null, "To jest środa");
+			case 4 -> JOptionPane.showMessageDialog(null, "To jest czwartek");
+			case 5 -> {
+				JOptionPane.showMessageDialog(null, "To jest piątek");
+				JOptionPane.showMessageDialog(null, "Weekendu początek");
+			}
+			case 6 -> JOptionPane.showMessageDialog(null, "To jest sobota");
+			case 7 -> JOptionPane.showMessageDialog(null, "To jest niedziela");
+			default -> JOptionPane.showMessageDialog(null, "Niepoprawny numer dnia: " + numer, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+		
+		JOptionPane.showMessageDialog(null, "Koniec programu");
+	}
+
+}

src/main/java/gotowe/p05_switch/DzienTygodnia4.java

+package gotowe.p05_switch;
+
+import javax.swing.JOptionPane;
+
+// Rozwiązanie wykorzystujące zmienną, w której zapamiętamy nazwę dnia → dzięki temu nie będzie tyle razy showMessageDialog
+public class DzienTygodnia4 {
+
+	public static void main(String[] args) {
+		int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj nr dnia tygodnia"));
+		
+		String dzien;
+		switch(numer) {
+		case 1: 
+			dzien = "poniedziałek";
+			break;
+		case 2:
+			dzien = "wtorek";
+			break;
+		case 3:
+			dzien = "środa";
+			break;
+		case 4:
+			dzien = "czwartek";
+			break;
+		case 5:
+			dzien = "piątek";
+			break;
+		case 6:
+			dzien = "sobota";
+			break;
+		case 7:
+			dzien = "niedziela";
+			return;
+		default:
+			dzien = "Niepoprawny numer dnia: " + numer;
+		}
+		
+		JOptionPane.showMessageDialog(null, "To jest " + dzien);
+	}
+
+}

src/main/java/gotowe/p05_switch/DzienTygodnia5.java

+package gotowe.p05_switch;
+
+import javax.swing.JOptionPane;
+
+// W tej wersji piszemy własną funkcję (czyli w Javie "metodę statyczną"),
+// która dokonuje tłumaczenia numeru na nazwę dnia tygodnia.
+// To jest poprawne również w starszych wersjach Javy.
+public class DzienTygodnia5 {
+	
+	static String nazwaDniaTygodnia(int nr) {
+		switch(nr) {
+		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: " + nr);
+		}
+	}
+
+	public static void main(String[] args) {
+		try {
+			int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj nr dnia tygodnia"));
+			String dzien = nazwaDniaTygodnia(numer);
+			JOptionPane.showMessageDialog(null, "To jest " + dzien);
+		} catch (Exception e) {
+			JOptionPane.showMessageDialog(null, e, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+		JOptionPane.showMessageDialog(null, "Koniec programu");
+	}
+
+}

src/main/java/gotowe/p05_switch/DzienTygodnia6.java

+package gotowe.p05_switch;
+
+import javax.swing.JOptionPane;
+
+public class DzienTygodnia6 {
+	// W tej wersj używamy "switch expression" (od Java 14), czyli switch zwraca wynik,
+	// który można np. wpisać do zmiennej.
+	// switch jest jakby funkcją, której wynik pobieramy
+	
+	public static void main(String[] args) {
+		try {
+			int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj nr dnia tygodnia"));
+			String dzien = switch(numer) {
+				case 1 -> "poniedziałek";
+				case 2 -> "wtorek";
+				case 3 -> "środa";
+				case 4 -> "czwartek";
+				case 5 -> "piątek";
+				case 6 -> "sobota";
+				case 7 -> "niedziela";
+				default -> throw new IllegalArgumentException("Niepoprawny numer dnia: " + numer);
+			};
+			JOptionPane.showMessageDialog(null, "To jest " + dzien);
+		} catch (Exception e) {
+			JOptionPane.showMessageDialog(null, e, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+		JOptionPane.showMessageDialog(null, "Koniec programu");
+	}
+
+}

src/main/java/gotowe/p05_switch/IleDniMaMiesiac1.java

+package gotowe.p05_switch;
+
+import javax.swing.JOptionPane;
+
+/* Program dla podanej nazwy miesiąca (np "styczeń")
+ * ma wypisać, ile dni ma ten miesiąc. */
+
+public class IleDniMaMiesiac1 {
+	// Wersja poprawna, ale napisana w bardzo prymitywny sposób - każda sytuacja opisana oddzielnym casem , jest duplikacja kodu
+	
+	public static void main(String[] args) {
+		String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
+		
+		switch(miesiac) {
+		case "styczeń":
+			JOptionPane.showMessageDialog(null, "31 dni");
+			break;
+		case "luty":
+			JOptionPane.showMessageDialog(null, "28 lub 29 dni");
+			break;
+		case "marzec":
+			JOptionPane.showMessageDialog(null, "31 dni");
+			break;
+		case "kwiecień":
+			JOptionPane.showMessageDialog(null, "30 dni");
+			break;
+		case "maj":
+			JOptionPane.showMessageDialog(null, "31 dni");
+			break;
+		case "czerwiec":
+			JOptionPane.showMessageDialog(null, "30 dni");
+			break;
+		case "lipiec":
+			JOptionPane.showMessageDialog(null, "31 dni");
+			break;
+		case "sierpień":
+			JOptionPane.showMessageDialog(null, "31 dni");
+			break;
+		case "wrzesień":
+			JOptionPane.showMessageDialog(null, "30 dni");
+			break;
+		case "październik":
+			JOptionPane.showMessageDialog(null, "31 dni");
+			break;
+		case "listopad":
+			JOptionPane.showMessageDialog(null, "30 dni");
+			break;
+		case "grudzień":
+			JOptionPane.showMessageDialog(null, "31 dni");
+			break;
+		default:
+			JOptionPane.showMessageDialog(null, "Nieznany miesiąc " + miesiac, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+	}
+
+}

src/main/java/gotowe/p05_switch/IleDniMaMiesiac2.java

+package gotowe.p05_switch;
+
+import javax.swing.JOptionPane;
+
+public class IleDniMaMiesiac2 {
+    // Wersja z tradycyjnym switch z : i break. - działa w starych wersjach Javy oraz w C
+    // W tej wersji staramy się grupować przypadki z taką samą odpowiedzią.
+    // Jeśli napiszemy wiele case-ów bez break, to dla każdego z nich wykonamy taką samą rzecz.
+	// W przypadku lutego zadajemy dodatkowe pytanie o rok przestępny.
+	
+	public static void main(String[] args) {
+		String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
+		
+		switch(miesiac) {
+		case "styczeń":
+		case "marzec":
+		case "maj":
+		case "lipiec":
+		case "sierpień":
+		case "październik":
+		case "grudzień":
+			JOptionPane.showMessageDialog(null, "31 dni");
+			break;
+		case "kwiecień":
+		case "czerwiec":
+		case "wrzesień":
+		case "listopad":
+			JOptionPane.showMessageDialog(null, "30 dni");
+			break;
+		case "luty":
+			if(JOptionPane.showConfirmDialog(null, "Czy to jest rok przestępny?") == JOptionPane.YES_OPTION) {
+				JOptionPane.showMessageDialog(null, "29 dni");
+			} else {
+				JOptionPane.showMessageDialog(null, "28 dni");				
+			}
+			break;
+		default:
+			JOptionPane.showMessageDialog(null, "Nieznany miesiąc " + miesiac, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+	}
+
+}

src/main/java/gotowe/p05_switch/IleDniMaMiesiac3.java

+package gotowe.p05_switch;
+
+import javax.swing.JOptionPane;
+
+public class IleDniMaMiesiac3 {
+    // Wersja dla Javy 14:
+	// Dzięki użyciu -> nie trzeba pisać break.
+	// W przypadku lutego zadajemy dodatkowe pytanie o rok przestępny - trzeba to umieścić w {bloku}.
+	// Od Javy 14 wiele wartości można umieścić w jednym case rozdzielając przecinkiem ,
+	// W tej wersji wielkość liter jest ignorowana, dzięki temu, że napis użytkownika zamieniamy na małe litery
+	// I usuwamy niepotrzebne spacje.
+	
+	public static void main(String[] args) {
+		String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
+		
+		switch(miesiac.strip().toLowerCase()) {
+		case "styczeń", "marzec", "maj", "lipiec", "sierpień", "październik", "grudzień" ->
+			JOptionPane.showMessageDialog(null, "31 dni");
+		case "kwiecień", "czerwiec", "wrzesień", "listopad" ->
+			JOptionPane.showMessageDialog(null, "30 dni");
+		case "luty" -> {
+			if(JOptionPane.showConfirmDialog(null, "Czy to jest rok przestępny?", "Pytanko", JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION) {
+				JOptionPane.showMessageDialog(null, "29 dni");
+			} else {
+				JOptionPane.showMessageDialog(null, "28 dni");				
+			}
+		}
+		default ->
+			JOptionPane.showMessageDialog(null, "Nieznany miesiąc " + miesiac, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+	}
+
+}

src/main/java/gotowe/p05_switch/IleDniMaMiesiac4.java

+package gotowe.p05_switch;
+
+import javax.swing.JOptionPane;
+
+public class IleDniMaMiesiac4 {
+	/* W tej wersji używamy "switch expression".
+	 * W prostych przypadkach (30 lub 31 dni) wystarczy wpisac wartośc za strzałką ->
+	 * W przypadku lutego mamy dodatkowego if-a i aby w tej sytuacji (generalnie: gdy mamy {blok kodu})
+	 * to wynik switcha zwracamy za pomocą słowa kluczowego yield.
+	 * 
+	 * Z kolei w przypadku niepoprawnej nazwy nie ma żadnego wyniku - zamiast tego wyrzucamy wyjątek.
+	 */
+	
+	public static void main(String[] args) {
+		String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
+		
+		int ileDni = switch(miesiac.strip().toLowerCase()) {
+			case "styczeń", "marzec", "maj", "lipiec", "sierpień", "październik", "grudzień" ->
+				31;
+			case "kwiecień", "czerwiec", "wrzesień", "listopad" ->
+				30;
+			case "luty" -> {
+				int rok = Integer.parseInt(JOptionPane.showInputDialog("O który rok chodzi?"));
+				if(rok % 4 == 0 && rok % 100 != 0 || rok % 400 == 0) {
+					yield 29;
+				} else {
+					yield 28;
+				}
+			}
+			default -> throw new IllegalArgumentException("Nieznany miesiąc " + miesiac);
+		};
+		
+		JOptionPane.showMessageDialog(null, "Miesiąc " + miesiac + " ma " + ileDni + " dni");
+	}
+
+}

src/main/java/gotowe/p06_liczby/BityIBajty.java

+package gotowe.p06_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/gotowe/p06_liczby/Ciekawostki.java

+package gotowe.p06_liczby;
+
+public class Ciekawostki {
+
+	public static void main(String[] args) {
+		// Liczby całkowite mają ograniczony zakres,
+		// a wyjście poza ten zakres (gdy wynik obliczenia nie mieści się w zakresie)
+		// daje w efekcie "integer overflow", czyli przekręcenie licznika
+		int miliard = 1_000_000_000;
+		System.out.println(2 * miliard);
+		System.out.println(3 * miliard);
+		System.out.println(5 * miliard); // typ int - granica to nieco ponad 2 mld
+		System.out.println(5L * miliard); // typ long
+		System.out.println(10L * miliard * miliard); // ale long też ma swój limit
+		// To jest bardzo groźne, bo wychodzi błędny wynik i program działa dalej, ale pracuje na niepoprawnych danych.
+		// efekt: Ariane 5
+		
+		// Sposób na obsługę liczb całkowitych bez limitu: BigInteger.
+		System.out.println();
+		
+		// Obliczenia na liczbach zmiennoprzecinkowych (float oraz double) są nieprecyzyjne.
+		// Wewnętrznie liczba zapisana jest w systemie dwójkowym, a nie każdy ułamek dziesiętny da się w ten sposób zapisać.
+		// Liczby są pamiętane "w lekkim zniekształceniu", a niektóre operacje mogą ten błąd kumulować i staje się on coraz bardziej zauważalny.
+		double cena = 1.2;
+		System.out.println(3 * cena);
+		System.out.println();
+		
+		// Sposób na obsługę liczb z ułamkiem dziesiętnym bez pomyłek: BigDecimal.
+		// Zalecany sposób liczenie pieniędzy w Javie.
+		
+		
+		int x = 0321;
+		// System ósemkowy (oktalny), czyli to jest równe 3×8² + 2×8 + 1 = 192 + 16 + 1 = 209
+		System.out.println("x = " + x);
+		
+		System.out.println();
+		
+		x = 19;
+		System.out.println(x / 5);
+		// Dzielenie całkowite (gdy l.całkowitą dzielimy przez całkowitą) daje w wyniku część całkowitą ilorazu.
+		// Część ułamkowa jest odrzucana; to nie jest zaokrąglenie, tylko obcięcie.
+	}
+
+}

src/main/java/gotowe/p06_liczby/Dzielenie.java

+package gotowe.p06_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/gotowe/p06_liczby/JakSprawdzicOverflow.java

+package gotowe.p06_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/gotowe/p06_liczby/LiteralyLiczbowe.java

+package gotowe.p06_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/gotowe/p06_liczby/Mnozenie1_Int.java

+package gotowe.p06_liczby;
+
+import java.util.Scanner;
+
+public class Mnozenie1_Int {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		
+		System.out.println("Podaj dwie liczby do pomnożenia: ");
+		long x = scanner.nextLong();
+		long y = scanner.nextLong();
+		
+		long wynik = x * y;
+		System.out.println("wynik normalnego mnożenia: " + wynik);
+		
+		// operacje matematyczne pod większą kontrolą (ale działające wolniej):
+		try {
+			long wynik2 = Math.multiplyExact(x, y);
+			System.out.println("wynik exact mnożenia: " + wynik2);
+		} catch(ArithmeticException e) {
+			System.out.println("wynik nie mieści się w zakresie");
+		}
+	}
+
+}

src/main/java/gotowe/p06_liczby/Mnozenie2_Long.java

+package gotowe.p06_liczby;
+
+import java.util.Scanner;
+
+public class Mnozenie2_Long {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		
+		System.out.println("Podaj dwie liczby do pomnożenia: ");
+		int x = scanner.nextInt();
+		int y = scanner.nextInt();
+		
+		int wynik = x * y;
+		System.out.println("wynik normalnego mnożenia: " + wynik);
+		
+		// operacje matematyczne pod większą kontrolą (ale działające wolniej):
+		try {
+			int wynik2 = Math.multiplyExact(x, y);
+			System.out.println("wynik exact mnożenia: " + wynik2);
+		} catch(ArithmeticException e) {
+			System.out.println("wynik nie mieści się w zakresie");
+		}
+	}
+
+}

src/main/java/gotowe/p06_liczby/Mnozenie3_Double.java

+package gotowe.p06_liczby;
+
+import java.math.BigDecimal;
+import java.util.Locale;
+import java.util.Scanner;
+
+public class Mnozenie3_Double {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		scanner.useLocale(Locale.US);
+		
+		System.out.println("Podaj dwie liczby do pomnożenia: ");
+		double x = scanner.nextDouble();
+		double y = scanner.nextDouble();
+		
+		double wynik = x * y;
+		System.out.println("wynik mnożenia: " + wynik);
+		
+		BigDecimal x_dokladny = new BigDecimal(x);
+		BigDecimal y_dokladny = new BigDecimal(y);
+		BigDecimal w_dokladny = new BigDecimal(wynik);
+		System.out.println("\nDokładnie w pamięci komputera");
+		System.out.println("x = " + x_dokladny);
+		System.out.println("y = " + y_dokladny);
+		System.out.println("w = " + w_dokladny);
+	}
+
+}

src/main/java/gotowe/p06_liczby/WypiszZakresy.java

+package gotowe.p06_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/gotowe/p07_petle/A_Wstep.java

+package gotowe.p07_petle;
+
+public class A_Wstep {
+
+	public static void main(String[] args) {
+		// Pętla to konstrukcja, która pozwala na wielokrotne wykonanie fragmentu programu.
+		
+		// Zamiast pisać 3 razy to samo:
+		System.out.println("Ala ma kota");
+		System.out.println("    ale nie ma psa.");
+		System.out.println("Ala ma kota");
+		System.out.println("    ale nie ma psa.");
+		System.out.println("Ala ma kota");
+		System.out.println("    ale nie ma psa.");
+		System.out.println();
+		
+		// można napisać pętlę, która spowoduje wykonanie podanego fragmentu wiele razy.
+		for(int i = 1; i <= 5; i++) {
+			System.out.println("Ola ma psa");
+			System.out.println("    oraz kota.");
+		}
+	}
+
+}

src/main/java/gotowe/p07_petle/B_RodzajePetli.java

+package gotowe.p07_petle;
+
+public class B_RodzajePetli {
+
+	public static void main(String[] args) {
+		System.out.println("while:");
+		// while(WARUNEK) { INSTRUKCJE }
+		// jeśli WARUNEK jest prawdziwy → wykonaj INSTRUKCJE i wróć ponownie do
+		// sprawdzenia warunku
+		// jeśli WARUNEK nieprawdziwy → nie wykonuj INSTRUKCJI, tylko idź za koniec
+		// pętli
+		int a = 1;
+		while (a <= 5) {
+			System.out.println("a = " + a);
+			a++;
+		}
+		System.out.println("koniec while. teraz a = " + a);
+		System.out.println();
+
+		// pętla do-while:
+		// do { INSTRUKCJE } while(WARUNEK);
+		// najpierw jeden raz wykonywane są INSTRUKCJE,
+		// następnie sprawdzany jest WARUNEK
+		// jeśli WARUNEK jest prawdziwy → wróć na początek, wykonaj INSTRUKCJE (itd)
+		// jeśli WARUNEK nieprawdziwy → idź za pętlę
+		System.out.println("do-while:");
+		int b = 1;
+		do {
+			System.out.println("b = " + b);
+			b++;
+		} while (b <= 5);
+		System.out.println("koniec do-while. teraz b = " + b);
+		System.out.println();
+
+		// for(INICJALIZACJA; WARUNEK; KROK) { INSTRUKCJE }
+		// 1) najpierw jeden raz wykonywana jest INICJALIZACJA
+		// (w ramach inicjalizacji można zadeklarować zmienną, np. int i)
+		// 2) sprawdzany jest WARUNEK
+		// jeśli fałszywy, to wychodzimy z pętli (przechodzimy poniżej pętli)
+		// jeśli prawdziwy, to:
+		// 3) wykonywane są INSTRUKCJE
+		// 4) wykonywana jest instrukcja KROK
+		// przechodzimy do punktu 2) - sprawdzenie warunku
+		System.out.println("pętla for:");
+		for (int c = 1; c <= 5; c++) {
+			System.out.println("c = " + c);
+		}
+		System.out.println("Koniec for. ");
+		// System.out.println("Teraz c = " + c); // zmienna c może być używana tylko w
+		// pętli
+		System.out.println();
+
+		// wersja z deklaracją zmiennej przed pętlą:
+		int d;
+		for (d = 1; d <= 5; d++) {
+			System.out.println("d = " + d);
+		}
+		System.out.println("Koniec for. d = " + d);
+		System.out.println();
+
+		// Od Javy 5 dostępna jest pętla "for-each".
+		// Służy do wykonania operacji dla każdego elementu tablicy lub kolekcji
+		// for(Typ ZMIENNA : KOLEKCJA) { INSTRUKCJE }
+		// Każdy element KOLEKCJI jest wpisywany do ZMIENNEJ i wykonywan INSTRUKCJE, w których można używać tej zmiennej
+		String[] miasta = { "Warszawa", "Kraków", "Katowice" };
+		for (String miasto : miasta) {
+			System.out.println("Pozdrowienia dla miasta " + miasto);
+		}
+	}
+
+}

src/main/java/gotowe/p07_petle/PetlaNieskonczona.java

+package gotowe.p07_petle;
+
+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");
+    }
+
+}