Przykłady z pierwszego dnia zajęć

src/main/java/p01_podstawy/Hello.java

+package p01_podstawy;
+
+public class Hello {
+    public static void main(String[] args) {
+        System.out.println("Heloł!");
+    }
+}

src/main/java/p01_podstawy/PrePostInkrementacja.java

+package p01_podstawy;
+
+public class PrePostInkrementacja {
+
+    public static void main(String[] args) {
+        int i = 100;
+
+        System.out.println(i);
+        i++;
+        System.out.println(i);
+        ++i;
+        System.out.println(i);
+        System.out.println();
+
+        // odczytaj starą wartość i później zmień
+        System.out.println(i++);
+
+        // najpierw zmień, a potem odczytaj nową wartość
+        System.out.println(++i);
+
+        System.out.println(i++ + ++i);
+
+        int[] tab = {10, 33, 222, 2, 77, 33, 130};
+        i = 0;
+        while(i < tab.length && tab[i++] < 100);
+
+        System.out.println("Liczba znaleziona na pozycji " + i);
+    }
+
+}

src/main/java/p01_podstawy/Zmienne1.java

+package p01_podstawy;
+
+public class Zmienne1 {
+
+    public static void main(String[] args) {
+        // nie wolno:
+        // x = 123;
+        // System.out.println(x);
+
+        // deklaracja zmiennych lokalnych:
+        int x, y;
+        // wciąż zmienne nie mają wartości, są "niezainicjalizowane", nie wolno ich odczytywać
+
+        // System.out.println(x);
+        x = 125;
+        System.out.println(x);
+        if(x > 100) {
+            y = 200;
+            System.out.println(y);
+        }
+        // tutaj kompilator ocenia, że y "być może jest niezainicjalozowany"
+        // (static code analysis)
+        // System.out.println(y);
+
+        if(x % 2 == 0) {
+            y = 400;
+        } else {
+            y = 500;
+        }
+        System.out.println(y);
+
+        // W Javie bardzo często wartość wpisuje się od razu w momencie deklaracji
+        int z = x + y;
+        String imie = "Ala", imie2= " Ola";
+        System.out.println(imie + " " + imie2 + " " + z);
+    }
+}

src/main/java/p01_podstawy/Zmienne2.java

+package p01_podstawy;
+
+public class Zmienne2 {
+
+    public static void main(String[] args) {
+        // Java 10
+        // zamiast nazwy typu używamy var → komplilator sam ustala typ zmiennej
+        var imie = "Ala";
+        var i = 1234;
+        System.out.println(imie + " " + i);
+
+        // zmienne mają ustalony typ; nie wolno wpisać czegoś innego
+//        imie = 5432;
+//        i = "kalafior";
+//        i = 3.14;
+
+        // Typem uniwersalnym, że do zmiennej można wpisać praktycznie wszystko, jest Object
+        Object o;
+        o = "Ula ma rybki";
+        System.out.println(o + " klasy " + o.getClass());
+
+        o = 12 + 34; // mówiąc precyzyjnie, powstaje tu obiekt klasy Integer
+        System.out.println(o + " klasy " + o.getClass());
+    }
+}

src/main/java/p02_interakcja/argumenty/Argumenty.java

+package p02_interakcja.argumenty;
+
+/*
+Gdy uruchamiamy jakiś program w systemowym wierszu poleceń,
+możemy po jego nazwie podać dowolne napisy – argumenty programu.
+
+java p02_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/p02_interakcja/konsola/A_Print.java

+package p02_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 znakiem +
+        // Do napisu można 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 podobne 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
+        // %x - liczba szesnastkowo
+        // %f - liczba z ułamkiem
+        // %s - napis, ale to działa dla dowolnej wartości, która zostanie zamieniona na napis
+        //      za pomocą String.valueOf()   - jest to standardowa konwersja na trekst, jak przy wypisywaniu printem
+        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/p02_interakcja/konsola/B_SuroweWejscie1.java

+package p02_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/p02_interakcja/konsola/B_SuroweWejscie2.java

+package p02_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/p02_interakcja/konsola/C_Skaner1.java

+package p02_interakcja.konsola;
+
+import java.util.Locale;
+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);
+        // sc.useLocale(Locale.US); // gdyby tak zrobić, to double wpisuje się z kropką
+
+        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/p02_interakcja/konsola/C_Skaner2_LiczbaCzyNieLiczba.java

+package p02_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/p02_interakcja/konsola/D_BufRead.java

+package p02_interakcja.konsola;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+// Aby czytać wejście linia po linii, można użyć 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".equalsIgnoreCase(wiersz))
+                    break;
+            }
+
+            System.out.println("KONIEC");
+        } catch(IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/p02_interakcja/konsola/E_KlasaConsole.java

+package p02_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");
+
+        Console konsola = System.console();
+        System.out.println("System.console() = " + konsola);
+
+        if(konsola == null) {
+            System.out.println("Brak możliwości utworzenia konsoli.");
+            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/p02_interakcja/konsola/Zakupy1.java

+package p02_interakcja.konsola;
+
+import java.util.Scanner;
+
+public class Zakupy1 {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Podaj nazwę produktu: ");
+        String produkt = scanner.nextLine();
+        System.out.print("Podaj cenę: ");
+        double cena = scanner.nextDouble();
+        System.out.print("Ile sztuk " + produkt + " chcesz kupić? ");
+        int sztuki = scanner.nextInt();
+
+        // Obliczyć kwotę do zapłaty i wypisać w postaci:
+        // Za 5 sztuk towaru mleko zapłacisz 9.5
+        double koszt = cena * sztuki;
+        System.out.println("Za " + sztuki + " sztuk towaru " + produkt + " zapłacisz " + koszt);
+    }
+}

src/main/java/p02_interakcja/konsola/Zakupy2.java

+package p02_interakcja.konsola;
+
+import java.util.Scanner;
+
+public class Zakupy2 {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Podaj nazwę produktu: ");
+        String produkt = scanner.nextLine();
+        System.out.print("Podaj cenę: ");
+        double cena = scanner.nextDouble();
+        System.out.print("Ile sztuk " + produkt + " chcesz kupić? ");
+        int sztuki = scanner.nextInt();
+        double koszt = cena * sztuki;
+        // System.out.printf("Za %d sztuk towaru %s zapłacisz %f%n", sztuki, produkt, koszt);
+        System.out.printf("Za %d sztuk towaru %s zapłacisz %.2f%n", sztuki, produkt, koszt);
+    }
+}

src/main/java/p02_interakcja/konsola/Zakupy3.java

+package p02_interakcja.konsola;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class Zakupy3 {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        scanner.useLocale(Locale.US);
+        // scanner.useLocale(Locale.of("pl", "PL")); // w starszych wersjach Javy new Locale("pl", "PL")
+        // scanner.useLocale(Locale.of("en", "GB"));
+        System.out.print("Podaj nazwę produktu: ");
+        String produkt = scanner.nextLine();
+        System.out.print("Podaj cenę: ");
+        double cena = scanner.nextDouble();
+        System.out.print("Ile sztuk " + produkt + " chcesz kupić? ");
+        int sztuki = scanner.nextInt();
+        double koszt = cena * sztuki;
+        System.out.printf(Locale.US, "Za %d sztuk towaru %s zapłacisz %.2f%n", sztuki, produkt, koszt);
+    }
+}

src/main/java/p02_interakcja/konsola/Zakupy4.java

+package p02_interakcja.konsola;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class Zakupy4 {
+
+    public static void main(String[] args) {
+        Locale.setDefault(Locale.US);
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Podaj nazwę produktu: ");
+        String produkt = scanner.nextLine();
+        System.out.print("Podaj cenę: ");
+        double cena = scanner.nextDouble();
+        System.out.print("Ile sztuk " + produkt + " chcesz kupić? ");
+        int sztuki = scanner.nextInt();
+        double koszt = cena * sztuki;
+        System.out.printf("Za %d sztuk towaru %s zapłacisz %.2f%n", sztuki, produkt, koszt);
+    }
+}

src/main/java/p02_interakcja/okna/OknoDialogowe1.java

+package p02_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/p02_interakcja/okna/OknoDialogowe2.java

+package p02_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/p02_interakcja/okna/OknoDialogowe3.java

+package p02_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/p02_interakcja/okna/RodzajeOkien.java

+package p02_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());
+		// 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/p03_sterowanie/BreakContinue_Prezentacja.java

+package p03_sterowanie;
+
+import javax.swing.JOptionPane;
+
+public class BreakContinue_Prezentacja {
+
+    public static void main(String[] args) {
+        int licznik = 0;
+
+        while(true) {
+            licznik++;
+            JOptionPane.showMessageDialog(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.showMessageDialog(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.showMessageDialog(null, "Koniec pętli, nie było break ani continue");
+        }
+
+        JOptionPane.showMessageDialog(null, "Koniec programu");
+    }
+
+}

src/main/java/p03_sterowanie/If1_Teoria.java

+package p03_sterowanie;
+
+import java.util.Random;
+
+public class If1_Teoria {
+
+    public static void main(String[] args) {
+        Random random = new Random();
+        int x = random.nextInt(100);
+        int y = random.nextInt(100);
+        System.out.println("Wylosowane liczby: " + x + ", " + y);
+
+        // najbardziej typy zapis: if z else.
+        // jeśli warunek logiczny prawdziwy, to wykouje się fragment kodu za if-em
+        // a jeśli fałszywy, to wykonuje się fragment kodu za else.
+        if(x + y >= 100) {
+            System.out.println("suma liczb >= 100");
+            System.out.println("czyli dużo...");
+        } else {
+            System.out.println("suma liczb < 100");
+        }
+
+        // Jeśli do wykonania jest tylko jedna instrukcja, można jej nie brać w {klamerki}
+        // (ale ja je daję nawet w takich przypadkach)
+        if(x % 2 == 0)
+            System.out.println("x jest parzysty");
+        else
+            System.out.println("x jest nieparzysty");
+
+        // można pisać if bez towarzyszącego else
+        if(x < 10) {
+            System.out.println("x jest jednocyfrowy");
+        }
+        System.out.println("To się zawsze wypisze");
+
+        // można też pisać ciąg wielu ifów na zasadzie if - else if - else
+        if(x > y) {
+            System.out.println("x jest większy");
+        } else if(x < y) {
+            System.out.println("y jest większy");
+        } else {
+            System.out.println("obie liczby równe");
+        }
+
+        // W Javie do if można przekazać wyłącznei wartości typu logicznego boolean
+        // Nie ma żadnych automatycznych konwersji jak w C++, Pythonie czy JS
+//        if(x) {
+//            System.out.println("w C to by znaczyło że nie zero");
+//        }
+
+        // W Javie trzeba
+        // if(x != 0) {.... }
+        // if(! napis.isEmpty()) { ... }
+        // albo jeszcze lepiej:
+        // if(napis != null && !napis.isEmpty()) { ... }
+    }
+}

src/main/java/p03_sterowanie/If2_AndOr.java

+package p03_sterowanie;
+
+import java.util.Random;
+
+public class If2_AndOr {
+    public static void main(String[] args) {
+        Random random = new Random();
+        int x = random.nextInt(100);
+        int y = random.nextInt(100);
+        System.out.println("Wylosowane liczby: " + x + ", " + y);
+
+        // Wprowadzenie: gdy sprawdzić dwa warunki i dopiero cś zrobić, to możemy
+        // a) zagniezdzić ifa - raczej "brzydkie", jedyną zaletą jest to, że mogę napisać oddzielne else do obu części warunku
+        if(x > 50) {
+            if(y > 50) {
+                System.out.println("obie liczby >50");
+            } else {
+                System.out.println("y nie jest >50");
+            }
+        } else {
+            System.out.println("x nie jest >50");
+        }
+        System.out.println();
+
+        // b) użyć spójników logicznych
+        // && - logiczne "i", "and", koniunkcja
+        if(x > 50 && y > 50) {
+            System.out.println("obie liczby >50");
+        } else {
+            System.out.println("jakaś liczba jest <=50");
+        }
+
+        // || - logiczne "lub", "or", alternatywa
+        if(x > 50 || y > 50) {
+            System.out.println("istnieje liczba >50");
+        } else {
+            System.out.println("żadna z liczb nie jest >50");
+        }
+
+        String napis = "Ala ma kota";
+        // String napis = "Basia ma psa";
+        // String napis = "";
+        // String napis = null;
+
+        // spójniki && i || (pisane podwójnie) są "leniwe"
+        // dzięki temu taki kod jest poprawny:
+        if(napis != null && !napis.isEmpty() && napis.charAt(0) == 'A') {
+            System.out.println("Litera A");
+        } else {
+            System.out.println("coś innego");
+        }
+
+        // UWAGA! & i | pisane pojedynczo też istnieją (i dodatkowo ^ na tej samej zasadzie)
+        // - stosowane do liczb całkowitych są operacjami na bitach
+        // - stosowane do wartości logicznych realizują logicę spójników logicznych ALE SĄ "GORLIWE" (earger)
+//        if((napis != null) & !napis.isEmpty() & (napis.charAt(0) == 'A')) {
+//            System.out.println("Litera A");
+//        } else {
+//            System.out.println("coś innego");
+//        }
+
+        // ^ to jest "xor" (exlusive or), czyli po polsku "albo" / "alternatywa rozłączna"
+
+        if(x > 50 ^ y > 50) {
+            System.out.println("dokładnie jedna liczba >50");
+        } else {
+            System.out.println("obie liczby są małe, albo o obie są duże");
+        }
+
+    }
+}

src/main/java/p03_sterowanie/Losowanie.java

+package p03_sterowanie;
+
+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);
+		
+		// alternatywnie, bez tworzenia obiektu Random - każdy wątek ma swojego prywatnego randoma
+		// Od Java 7
+		int r = ThreadLocalRandom.current().nextInt();
+		System.out.println(r);
+		
+		char losowaLitera1 = (char)(65 + random.nextInt(26));
+		char losowaLitera2 = (char)('A' + random.nextInt('Z' - 'A' + 1));
+		System.out.print(losowaLitera1);
+		System.out.print(losowaLitera2);
+	}
+
+}

src/main/java/p03_sterowanie/TabliczkaMnozenia.java

+package p03_sterowanie;
+
+public class TabliczkaMnozenia {
+	// Wypisz tabliczkę mnożenia 10×10
+	// Dla chętnych: user podaje liczbę wierszy i kolumn, a program wypisuje tabliczkę o takim kształcie
+
+	public static void main(String[] args) {
+
+		for(int w = 1; w <= 10; w++) {
+			for(int k = 1; k <= 10; k++) {
+				// System.out.print(w*k + " ");
+				System.out.printf("%3d ", w*k);
+			}
+			System.out.println();
+		}
+	}
+
+}

src/main/java/p03_sterowanie/TabliczkaMnozeniaBreak.java

+package p03_sterowanie;
+
+public class TabliczkaMnozeniaBreak {
+	// Wypisz tabliczkę mnożenia 10×10
+	// Dla chętnych: user podaje liczbę wierszy i kolumn, a program wypisuje tabliczkę o takim kształcie
+
+	public static void main(String[] args) {
+
+		PETLA: for(int w = 1; w <= 10; w++) {
+			for(int k = 1; k <= 10; k++) {
+				// System.out.print(w*k + " ");
+				System.out.printf("%3d ", w*k);
+				if(w == 6 && k == 8) {
+					break PETLA;
+				}
+			}
+			System.out.println();
+		}
+	}
+
+}

src/main/java/p03_sterowanie/TabliczkaMnozeniaUser.java

+package p03_sterowanie;
+
+import java.util.Scanner;
+
+public class TabliczkaMnozeniaUser {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		System.out.print("Podaj liczbę wierszy: ");
+		int W = scanner.nextInt();
+		System.out.print("Podaj liczbę kolumn: ");
+		int K = scanner.nextInt();
+		
+		final String format = String.format("%%%dd ", String.valueOf((long)W*K).length());
+
+		for(int w = 1; w <= W; w++) {
+			for(int k = 1; k <= K; k++) {
+				System.out.printf(format, (long)w*k);
+			}
+			System.out.println();
+		}
+	}
+
+}

src/main/java/p03_sterowanie/TabliczkaPrzerwania.java

+package p03_sterowanie;
+
+public class TabliczkaPrzerwania {
+    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/p03_sterowanie/TeoriaPetli.java

+package p03_sterowanie;
+
+import java.util.List;
+
+public class TeoriaPetli {
+
+	public static void main(String[] args) {
+		// GENERALNIE pętla umożliwia wielokrotnie wykonanie fragmentu programu
+		// Np zamiast 5 razy powtarzac to samo w kodzie:
+		System.out.println("Ala ma kota");
+		System.out.println("Ala ma kota");
+		System.out.println("Ala ma kota");
+		System.out.println("Ala ma kota");
+		System.out.println("Ala ma kota");
+		System.out.println();
+		
+		// można napisać pętlę, która wykona się 5 razy:
+		for(int i = 0; i < 5; i++) {
+			System.out.println("Ola ma psa");
+		}
+		System.out.println();
+		
+		// W Javie są takie rodzaje pętli: while, do-while, for, for-each
+		System.out.println("Pętla while:");
+		// while(WARUNEK) { INSTRUKCJE }
+		// Gdy WARUNEK jest prawdziwy, to wykonują się INSTRUKCJE,
+		//   a następnie ponownie sprawdzany jest WARUNEK, itd...
+		// Gdy WARUNEK jest fałszywy, to program przechodzi do dalszej części
+		int a = 1;
+		while(a <= 5) {
+			System.out.println("a = " + a);
+			a++;
+		}
+		System.out.println("Koniec pętli while. Aktualnie a = " + a);
+
+		System.out.println("\nPętla do-while:");
+		// do { INSTRUKCJE } while(WARUNEK);
+		// Na początku wykonywane są INSTRUKCJE, a następnie
+		// sprawdzany jest WARUNEK i:
+		// - jeśli jest prawdziwy, do następuje powrót na początek i ponowne wykonanie INSTRUKCJI itd...
+		// - jeśli jest fałszywy, to program idzie dalej
+		int b = 1;
+		do {
+			System.out.println("b = " + b);
+			b++;
+		} while(b <= 5);
+		System.out.println("Koniec pętli do-while. Aktualnie b = " + b);
+		
+		System.out.println("\nPętla for:");
+		// for(INICJALIZACJA; WARUNEK; KROK) { INSTRUKCJE }
+		// Na początku raz wykonywana jest INICJALIZACJA
+		// (może to być deklaracja zmiennej)
+		// Następnie - podobnie jak w pętli while - sprawdzany jest WARUNEK
+		// - jeśli prawdziwy, to wykonywane są INSTRUKCJE, a następnie dodatkowo KROK
+		// - jeśli fałszywy, to idziemy za pętlę
+		
+		// Najbardziej typowy przykład: przeglądanie zakresu liczbowego:
+		for(int i = 1; i <= 5; i++) {
+			System.out.println("i = " + i);
+		}
+		// Jeśli zmienną deklarowaliśmy wewnątrz pętli (a tak jest najczęściej),
+		// to teraz nie ma już do niej dostępu.
+		// System.out.println("Koniec pętli for, i = " + i);
+		System.out.println("Koniec pętli for");
+		
+		List<String> lista = List.of("Ala", "Ola", "Ela");
+		System.out.println("\nPętla for-each");
+		// Od Java 5
+		// for(Typ zmienna : kolekcja) { INSTRUKCJE }
+		// Wykonuje podane instrukcje dla każdego elementu kolekcji (może to być też tablica)
+		for(String imie : lista) {
+			System.out.println("Witaj " + imie);
+		}
+		System.out.println();
+		
+		// Od Java 8 istnieje jeszcze metoda forEach, która formalnie nie jest pętlą,
+		// ale można jej użyć zamiasta pętli
+		// To coś ze strzałką, to jest "wyrażenie lambda"
+		lista.forEach(imie -> System.out.println("Cześć " + imie));
+	}
+
+}

src/main/java/p04_switch/DzienTygodnia0.java

+package p04_switch;
+
+import javax.swing.JOptionPane;
+
+public class DzienTygodnia0 {
+
+    public static void main(String[] args) {
+        int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia"));
+        
+        // w tej wersji używam if / else if
+        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 " + numer, "Błąd", JOptionPane.ERROR_MESSAGE);
+        }
+        JOptionPane.showMessageDialog(null, "Koniec programu");
+
+    }
+
+}
+

src/main/java/p04_switch/DzienTygodnia1.java

+package p04_switch;
+
+import javax.swing.JOptionPane;
+
+public class DzienTygodnia1 {
+	/* Instrukcja switch w wersji tradycyjnej (jak w języku C) działa tak:
+	 * Program przechodzi do tego case'a, którego wartość pasuje,
+	 * i kontynuuje swoje wykonanie aż do końca albo do napotkania instrukcji break.
+	 * Gdy nie ma breaków, to wykonują się kolejne case'y aż do końca.
+	 */
+
+	public static void main(String[] args) {
+		int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer 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 " + numer, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+		JOptionPane.showMessageDialog(null, "Koniec programu");
+
+	}
+
+}

src/main/java/p04_switch/DzienTygodnia2.java

+package p04_switch;
+
+import javax.swing.JOptionPane;
+
+public class DzienTygodnia2 {
+	/* Tutaj widzimy najbardziej typy zapis instrukcji switch, jaki występował w Javie
+	 * od początku (i tak samo w języku C i C++).
+	 */
+
+	public static void main(String[] args) {
+		int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer 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");
+			break;
+		default:
+			JOptionPane.showMessageDialog(null, "Niepoprawny numer " + numer, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+		JOptionPane.showMessageDialog(null, "Koniec programu");
+	}
+
+}

src/main/java/p04_switch/DzienTygodnia3.java

+package p04_switch;
+
+import javax.swing.JOptionPane;
+
+public class DzienTygodnia3 {
+	/* Od Javy 14 zamiast : można użyć ->
+	 * wtedy każdy case jest niezależny (nie trzeba pisać break).
+	 */
+
+	public static void main(String[] args) {
+		int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer 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 " + numer, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+		JOptionPane.showMessageDialog(null, "Koniec programu");
+	}
+
+}

src/main/java/p04_switch/DzienTygodnia4.java

+package p04_switch;
+
+import javax.swing.JOptionPane;
+
+public class DzienTygodnia4 {
+	/* W tak prostym przypadku, gdy dla liczby chcemy znać wartość (nazwę dnia tygodnia), zamiast switch można użyć tablicy. */
+
+	public static void main(String[] args) {
+		String[] tydzien = {"poniedziałek", "wtorek", "środa", "czwartek", "piątek", "sobota", "niedziela"};
+		
+		int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia"));
+		if(numer < 1 || numer > 7) {
+			JOptionPane.showMessageDialog(null, "Niepoprawny numer " + numer, "Błąd", JOptionPane.ERROR_MESSAGE);
+		} else {
+			JOptionPane.showMessageDialog(null, "To jest " + tydzien[numer-1]);
+		}
+	}
+
+}

src/main/java/p04_switch/DzienTygodnia5.java

+package p04_switch;
+
+import javax.swing.JOptionPane;
+
+public class DzienTygodnia5 {
+	// W tej wersji definiujemy funkcję, która zajmuje się zamianą numeru dnia tygodnia na jego nazwę.
+	
+	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: return "Niepoprawny numer";
+		}
+	}
+	
+	public static void main(String[] args) {
+		int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia"));
+		String nazwa = nazwaDniaTygodnia(numer);
+		JOptionPane.showMessageDialog(null, "To jest " + nazwa);
+	}
+
+}

src/main/java/p04_switch/DzienTygodnia5e.java

+package p04_switch;
+
+import javax.swing.JOptionPane;
+
+public class DzienTygodnia5e {
+	// W tej wersji definiujemy funkcję, która zajmuje się zamianą numeru dnia tygodnia na jego nazwę.
+	// Sytuację błędnych danych obsłużymy za pomocą wyjątków.
+	
+	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");
+		}
+	}
+	
+	public static void main(String[] args) {
+		try {
+			int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia"));
+			String nazwa = nazwaDniaTygodnia(numer);
+			JOptionPane.showMessageDialog(null, "To jest " + nazwa);
+		} catch (Exception e) {
+			JOptionPane.showMessageDialog(null, e, "Błąd!", JOptionPane.ERROR_MESSAGE);
+		}
+		JOptionPane.showMessageDialog(null, "Koniec programu");
+	}
+
+}

src/main/java/p04_switch/DzienTygodnia6.java

+package p04_switch;
+
+import javax.swing.JOptionPane;
+
+public class DzienTygodnia6 {
+	// W tej wersji używamy "switch expression" - od Java 14.
+	// switch expression to jest coś, co przypomina funkcję i zwraca jedną z z wartości na podstawie argumentu.
+	// (tutaj na podstawie wartości numer zwracane są napisy "poniedziałek" albo "wtorek" itd)
+	// ale nie jest to pisane jako odzielna funkcja, która ma swoją nazwę i może być wywoływana z różnych miejsc,
+	// tylko jest to wpisane w formie switcha w tym miejcu, gdzie jest potrzebne.
+	
+	public static void main(String[] args) {
+		try {
+			int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj numer dnia tygodnia"));
+			// String ile = args.length == 0 ? "zero" : "więcej";
+
+			String nazwa = 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");
+			};
+			JOptionPane.showMessageDialog(null, "To jest " + nazwa);
+		} catch (Exception e) {
+			JOptionPane.showMessageDialog(null, e, "Błąd!", JOptionPane.ERROR_MESSAGE);
+		}
+		JOptionPane.showMessageDialog(null, "Koniec programu");
+	}
+
+}

src/main/java/p04_switch/IleDniMaMiesiac1.java

+package p04_switch;
+
+import javax.swing.JOptionPane;
+
+public class IleDniMaMiesiac1 {
+
+	public static void main(String[] args) {
+		String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
+		// Wypisz info ile dni ma ten miesiąc
+		
+		switch(miesiac) {
+		case "styczeń":
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+			break;
+		case "luty":
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 28 lub 29 dni");
+			break;
+		case "marzec":
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+			break;
+		case "kwiecień":
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 30 dni");
+			break;
+		case "maj":
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+			break;
+		case "czerwiec":
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 30 dni");
+			break;
+		case "lipiec":
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+			break;
+		case "sierpień":
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+			break;
+		case "wrzesień":
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 30 dni");
+			break;
+		case "październik":
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+			break;
+		case "listopad":
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 30 dni");
+			break;
+		case "grudzień":
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+			break;
+		default:
+			JOptionPane.showMessageDialog(null, "Niepoprawny miesiąc " + miesiac, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+	}
+
+}

src/main/java/p04_switch/IleDniMaMiesiac2.java

+package p04_switch;
+
+import javax.swing.JOptionPane;
+
+// W tej wersji użyjemy rozwiązań ze starszych wersji Javy: pogrupujemy case'y
+public class IleDniMaMiesiac2 {
+
+	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, "Ten miesiąc ma 31 dni");
+			break;
+		case "kwiecień":
+		case "czerwiec":
+		case "wrzesień":
+		case "listopad":
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 30 dni");
+			break;
+		case "luty":
+			int odp = JOptionPane.showConfirmDialog(null, "Czy rok jest przestępny?", "Pytanko", JOptionPane.YES_NO_OPTION);
+			if(odp == JOptionPane.YES_OPTION) {
+				JOptionPane.showMessageDialog(null, "Ten miesiąc ma 29 dni");
+			} else {
+				JOptionPane.showMessageDialog(null, "Ten miesiąc ma 28 dni");
+			}
+			break;
+		default:
+			JOptionPane.showMessageDialog(null, "Niepoprawny miesiąc " + miesiac, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+	}
+
+}

src/main/java/p04_switch/IleDniMaMiesiac3.java

+package p04_switch;
+
+import javax.swing.JOptionPane;
+
+// W tej wersji użyjemy rozwiązań z Java 14: wiele wartości po przecinku i ->
+public class IleDniMaMiesiac3 {
+
+	public static void main(String[] args) {
+		String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
+	
+		switch(miesiac) {
+		case "styczeń", "marzec", "maj", "lipiec", "sierpień", "październik", "grudzień" ->
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 31 dni");
+		case "kwiecień", "czerwiec", "wrzesień", "listopad" ->
+			JOptionPane.showMessageDialog(null, "Ten miesiąc ma 30 dni");
+		case "luty" -> {
+			int rok = Integer.parseInt(JOptionPane.showInputDialog("Podaj rok"));
+			if(rok % 4 == 0 && rok % 100 != 0 || rok % 400 == 0) {
+				JOptionPane.showMessageDialog(null, "Ten miesiąc ma 29 dni");
+			} else {
+				JOptionPane.showMessageDialog(null, "Ten miesiąc ma 28 dni");
+			}
+		}
+		default ->
+			JOptionPane.showMessageDialog(null, "Niepoprawny miesiąc " + miesiac, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+	}
+
+}

src/main/java/p04_switch/IleDniMaMiesiac7.java

+package p04_switch;
+
+import javax.swing.JOptionPane;
+
+// W tej wersji użyjemy switch expression
+// Gdy w danym case jest jeden wynik do zwrócenia, to piszemy go bezpośrednio za znakiem ->
+// Gdy w danym case (jak tutaj dla lutego) trzeba wykonać jeszcze dodatkowe kroki,
+// to wynik switcha jest wtedy zwracany za pomocą słowa yield
+public class IleDniMaMiesiac7 {
+
+	public static void main(String[] args) {
+		String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
+		
+		int ileDni = switch(miesiac) {
+			case "styczeń", "marzec", "maj", "lipiec", "sierpień", "październik", "grudzień" -> 31;	
+			case "kwiecień", "czerwiec", "wrzesień", "listopad" -> 30;
+			
+			case "luty" -> {
+				int rok = Integer.parseInt(JOptionPane.showInputDialog("Podaj rok"));
+				if(rok % 4 == 0 && rok % 100 != 0 || rok % 400 == 0) {
+					yield 29;
+				} else {
+					yield 28;
+				}
+			}
+			default -> throw new IllegalArgumentException("Niepoprawny miesiąc " + miesiac);
+		};
+		
+		JOptionPane.showMessageDialog(null, "Miesiąc " + miesiac + " ma " + ileDni + " dni");
+		
+	}
+
+}

src/main/java/p04_switch/SwitchNaObiektach.java

+package p04_switch;
+
+import java.io.File;
+import java.time.LocalDate;
+
+public class SwitchNaObiektach {
+
+	/* W Java 21 pojawiły się kolejne możliwości switcha:
+	https://openjdk.org/jeps/441 
+ 	* - case null jako legalny warunek
+ 	* - rozróżnianie obiektów wg ich typu
+ 	* - klauzula when z warunkiem logicznym
+ 	*/
+
+	public static void main(String[] args) {
+		Object jakisObiekt;
+//    	jakisObiekt = "owca";
+//    	jakisObiekt = "koza";
+//    	jakisObiekt = "";
+//    	jakisObiekt = new File("sciezka/do/pliku.txt");
+    	jakisObiekt = LocalDate.of(1997, 8, 19);
+   	 
+    	switch(jakisObiekt) {
+        	case String s when s.startsWith("o") -> System.out.println("To jest napis na o:" + s);
+        	case String s when s.startsWith("k") -> System.out.println("To jest napis na k:" + s);
+        	case String s when s.equalsIgnoreCase("java") -> System.out.println("To jest napis JAVA");
+        	case String s -> System.out.println("To jest inny napis: " + s);
+        	case File f -> System.out.println("To jest plik " + f.getAbsolutePath());
+        	case LocalDate dt -> System.out.println("To jest data " + dt + " (dzień tygodnia " + dt.getDayOfWeek() +")");
+        	case null -> System.out.println("Nie ma nic");
+        	default -> System.out.println("Nie wiem co to jest. Ale klasą jest " + jakisObiekt.getClass());
+    	}
+	}
+
+}
+
+

src/main/java/p04_switch/TypySwitch.java

+package p04_switch;
+
+public class TypySwitch {
+
+	public static void main(String[] args) {
+		short liczba = 100;
+		
+		switch(liczba) {
+			case 1 : System.out.println("jeden");
+			case 2 : System.out.println("dwa");
+			case 100 : System.out.println("sto");
+			// case 1000000: System.out.println("milion");
+		}
+	}
+
+}