Przykłady na if

.gitignore

 /.vscode/
+/bin/
 /*.log

src/App.java

 public class App {
     public static void main(String[] args) throws Exception {
-        System.out.println("Hello, World!");
+        System.out.println("Cześć. Hello, World!");
     }
 }

src/p01_podstawy/Argumenty.java

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

src/p01_podstawy/Hello.java

+package p01_podstawy;
+
+import java.time.LocalTime;
+
+public class Hello {
+    public static void main(String[] args) {
+        System.out.println("Hello JetBrains");
+        System.out.println(LocalTime.now());
+    }
+}

src/p01_podstawy/RodzajeOkien.java

+package p01_podstawy;
+
+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/p01_podstawy/Rozmowa.java

+package p01_podstawy;
+
+import javax.swing.*;
+
+public class Rozmowa {
+    public static void main(String[] args) {
+        String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+        // zadanie: odczytaj także informację o mieście i w powitaniu wypisz także to miasto
+        String miasto = JOptionPane.showInputDialog("Skąd 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, "Niepełnoletnim wstęp wzbroniony");
+        }
+    }
+}

src/p01_podstawy/Typy.java

+package p01_podstawy;
+
+import java.math.BigDecimal;
+
+public class Typy {
+
+    public static void main(String[] args) {
+        // W Javie istnieje 8 typów "prostych":
+        // byte, short, int, long - liczby całkowite ze znakiem z różnymi zakresami wartości
+        
+        short s1 = 10000;
+        System.out.println(s1);
+        // short s2 = 1000000; // nie da się wpisać miliona, bo za duża wartość
+        
+        int milion = 1000000;
+        System.out.println(milion);
+        System.out.println(milion * milion);
+        // gdy wynik obliczenie wychodzi poza zakres, to pojawi się błędny wynik - "integer overflow"
+
+        long duzo = 100_000_000_000L;
+        System.out.println(duzo);
+        System.out.println(2 * duzo);
+
+        // float, double - liczby "zmiennoprzecinkowe", czyli liczby z ułamkiem, ale działające "dziwnie"
+        // float (32 bity) ma mniejszy zakres i precyzję, a double (64 bity) większy zakres i precyzję
+        double cena = 1.20;
+        System.out.println(cena);
+        System.out.println(3 * cena);
+
+        // char - pojedynczy znak, który technicznie jest tak naprawdę kodem znaku
+        char c = 'A';
+        System.out.println(c);   // A
+        System.out.println(c+1); // 66
+        
+        // boolean - wartości logiczne false i true
+        boolean warunek = (cena * 3 == 3.6);
+        System.out.println(warunek);
+    
+        // Poza typami prostymi, istnieją typy obiektowe:
+        // - klasy, interfejsy, rekordy, enumy, ale też tablice
+        // - sama platforma Java definiuje kilka tysięcy takich typów
+        // - ale każdy programista może definiować swoje
+        
+        String napis = "Ala";
+        napis += " ma kota";
+        System.out.println(napis);
+        
+        BigDecimal cenaBD = new BigDecimal("1.20");
+        BigDecimal trzy = BigDecimal.valueOf(3);
+        System.out.println(cenaBD.multiply(trzy));
+    }
+
+}
+

src/p01_podstawy/Zakupy1.java

+package p01_podstawy;
+
+import javax.swing.*;
+
+/* Program zadaje trzy pytania:
+   - Podaj nazwę towaru
+   - Podaj cenę jednej sztuki
+   - Ile sztuk chcesz kupić?
+   Program oblicza kwotę do zapłaty i wypisuje komunikat o takiej strukturze (poniżej tylko przykład):
+   Za 5 sztuk towaru długopis płacisz 15 zł.
+*/
+public class Zakupy1 {
+    public static void main(String[] args) {
+        String towar = JOptionPane.showInputDialog("Podaj nazwę towaru");
+        int cena = Integer.parseInt(JOptionPane.showInputDialog("Ile kosztuje jedna sztuka?"));
+        int sztuk = Integer.parseInt(JOptionPane.showInputDialog("Ile sztuk chcesz kupić?"));
+        JOptionPane.showMessageDialog(null, "Za " + sztuk + " sztuk towaru " + towar + " płacisz " + cena*sztuk + " zł.");
+    }
+}

src/p01_podstawy/Zakupy2.java

+package p01_podstawy;
+
+import javax.swing.*;
+
+public class Zakupy2 {
+    public static void main(String[] args) {
+        String towar = JOptionPane.showInputDialog("Podaj nazwę towaru");
+        double cena = Double.parseDouble(JOptionPane.showInputDialog("Ile kosztuje jedna sztuka?"));
+        int sztuk = Integer.parseInt(JOptionPane.showInputDialog("Ile sztuk chcesz kupić?"));
+        double koszt = cena * sztuk;
+        JOptionPane.showMessageDialog(null, "Za " + sztuk + " sztuk towaru " + towar + " płacisz " + koszt + " zł.");
+    }
+}

src/p01_podstawy/Zakupy3.java

+package p01_podstawy;
+
+import javax.swing.*;
+import java.util.Locale;
+
+public class Zakupy3 {
+    public static void main(String[] args) {
+        String towar = JOptionPane.showInputDialog("Podaj nazwę towaru");
+        double cena = Double.parseDouble(JOptionPane.showInputDialog("Ile kosztuje jedna sztuka?"));
+        int sztuk = Integer.parseInt(JOptionPane.showInputDialog("Ile sztuk chcesz kupić?"));
+        double koszt = cena * sztuk;
+
+        JOptionPane.showMessageDialog(null,
+                String.format("Za %d sztuk towaru %s płacisz %.2f zł.", sztuk, towar, koszt));
+    }
+}
+
+// byte < short < int < long < float < double
+// char < int

src/p01_podstawy/Zakupy4.java

+package p01_podstawy;
+
+import javax.swing.*;
+import java.awt.*;
+import java.util.Locale;
+
+public class Zakupy4 {
+    public static void main(String[] args) {
+        try {
+            // Gdybyśmy chcieli, aby liczby były formatowane z kropką...
+            Locale.setDefault(Locale.US);
+            String towar = JOptionPane.showInputDialog("Podaj nazwę towaru");
+            double cena = Double.parseDouble(JOptionPane.showInputDialog("Ile kosztuje jedna sztuka?"));
+            int sztuk = Integer.parseInt(JOptionPane.showInputDialog("Ile sztuk chcesz kupić?"));
+            double koszt = cena * sztuk;
+            JOptionPane.showMessageDialog(null,
+                    String.format("Za %d sztuk towaru %s płacisz %.2f zł.", sztuk, towar, koszt));
+        } catch (NumberFormatException e) {
+            JOptionPane.showMessageDialog(null, e, "Błąd", JOptionPane.ERROR_MESSAGE);
+        } catch (HeadlessException e) {
+            // ten wyjątek pojawiłby się, gdybyśmy uruchomili ten program w środowisku bez interfejsu graficznego
+            System.err.println("Ta maszyna nie ma interfejsu graficznego");
+        }
+    }
+}

src/p01_podstawy/Zmienne.java

+package p01_podstawy;
+
+public class Zmienne {
+    public static void main(String[] args) {
+        // W Javie nie wolno używać zmiennych, które nie zostały zadeklarowane.
+        // x = 100;
+        // System.out.println(x);
+        // Deklaracja zmiennej podaje jej typ oraz nazwę:
+        String miasto;
+        int x;
+        // teraz do zmiennej mogę wpisać wartość. instrukcja przypisania (assignment)
+        miasto = "Warszawa";
+        System.out.println("Miastem jest " + miasto);
+        // nie wolno jednak odczytywać zmiennych, które nie zostały zainicjowane (nie mają żadnej wartości)
+        // System.out.println(x);
+        x = 123;
+        System.out.println(x);
+        // nie mogę wpisać wartości innego typu
+        // x = "Ala ma kota";
+
+        // Najczęściej początkową wartość wprowadza się w momencie deklaracji.
+        int y = 1000 - x;
+        System.out.println(y);
+        // teraz nie piszemy już int:
+        // int y = 5432;
+        // przypisanie innej wartości to po prostu
+        y = 5000;
+        System.out.println(y);
+        y = y + 50;
+        System.out.println(y);
+        // istnieje skrócony zapis:
+        y += 5;
+        System.out.println(y);
+        // zmiana o jeden może być zapisana jeszcze krócej: ++ lub --
+        y++;
+        System.out.println(y);
+        System.out.println();
+
+        int z;
+        if(y > 1000) {
+            z = 333;
+            System.out.println(z);
+        }
+        // kompilator "nie ma pewności", że zmienna jest zainicjaowana
+        // System.out.println(z);
+
+        if(y > 1000) {
+            z = 777;
+        } else {
+            z = 888;
+        }
+        System.out.println(z);
+
+        // wyrażenie warunkowe
+        // wynikiem jest jedna wartość albo druga wartość w zależności od warunku
+        String dzien = z > 800 ? "sobota" : "niedziela";
+        System.out.println(dzien);
+    }
+}

src/p02_scanner/KlasaScanner.java

+package p02_scanner;
+
+import java.util.Scanner;
+
+public class KlasaScanner {
+    public static void main(String[] args) {
+        System.out.println("Napisz coś:");
+        // System.in to jest "standardowe wejście", ale operujące na poziomie bajtów.
+        // Aby wczytywać dane tekstowe, użyjemy obiektu klasy Scanner.
+        // Tworzymy nowy obiekt klasy Scanner i wpisujemy do zmiennej typu Scanner
+        // nazwą tej zmiennej jest scanner, a ten skaner czyta dane ze standardowego wejścia.
+        Scanner scanner = new Scanner(System.in);
+        String linia = scanner.nextLine();
+        System.out.println("Napisałeś " + linia);
+        System.out.print("Podaj liczbę całkowitą: ");
+        int x = scanner.nextInt();
+        System.out.println("Twoja liczba to " + x);
+        
+        double y = scanner.nextDouble();
+        System.out.println(x + " × " + y + " = " + (x*y));
+        
+        System.out.println("Wpisz dwa słowa lub więcej: ");
+        String slowo1 = scanner.next();
+        String slowo2 = scanner.next();
+        String resztaLinii = scanner.nextLine();
+        
+        System.out.println("Pierwsze słowo: " + slowo1);
+        System.out.println("Drugie słowo: " + slowo2);
+        System.out.println("Koniec linii (długość "
+                    + resztaLinii.length() + "): " + resztaLinii);
+    } 
+}

src/p02_scanner/Prostokat.java

+package p02_scanner;
+
+import java.text.DecimalFormat;
+import java.util.Scanner;
+
+/* Program odczytuje dwie liczby - długości boków prostokąta.
+ * Następnie oblicza i wypisuje pole powierzchni oraz obwód tego prostokąta.
+ */
+public class Prostokat {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Podaj długość pierwszego boku: ");
+        double a = scanner.nextDouble();
+        System.out.print("Podaj długość drugiego boku: ");
+        double b = scanner.nextDouble();
+        double pole = a*b;
+        double obwod = 2*a + 2*b;
+//        System.out.println("Pole wynosi " + pole + " a obwód " + obwod);
+//        System.out.printf("Pole wynosi %f a obwód %f\n", pole, obwod);
+        System.out.printf("Pole wynosi %.3f a obwód %.3f\n", pole, obwod);
+        
+        DecimalFormat decimalFormat = new DecimalFormat("0.00");
+        System.out.println(decimalFormat.format(pole));
+    }
+
+}

src/p02_scanner/StandardoweWejscie1.java

+package p02_scanner;
+
+import java.io.IOException;
+
+public class StandardoweWejscie1 {
+
+    public static void main(String[] args) throws IOException {
+        // standardowe wyjście:
+        System.out.println("Standardowe wyjście");
+        
+        // wyjście błędów - przez ten kanał wypisywane są info o wyjątkach. my też możemy coś wypisać:
+        System.err.println("Wyjście błędów");
+
+        // standardowe wejście:
+        int x = System.in.read();
+        System.out.println("Pierwszy bajt: " + x);
+        
+        int y = System.in.read();
+        System.out.println("Drugi bajt: " + y);
+    }
+
+}
+

src/p02_scanner/StandardoweWejscie2.java

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

src/p03_if/Losowanie.java

+package p03_if;
+
+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/p03_if/SpojnikiLogiczne.java

+package p03_if;
+
+import java.util.Random;
+
+public class SpojnikiLogiczne {
+
+    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 chcemy sprawdzić dwa warunki i dopiero coś 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");
+        }
+        // spójniki pisane podwójnie && i || działają w sposób "leniwy"
+    }
+
+}
+

src/p03_if/SprawdzWiek.java

+package p03_if;
+
+import java.util.Scanner;
+
+/* Program wczytuje informację o wieku.
+ * W zależności od wieku wypisuje napój przeznaczony dla osoby o takim wieku.
+ * 0-3 - mleko
+ * 4-17 - cola
+ * 18-64 - piwko
+ * 65+ - biovital
+ */
+
+public class SprawdzWiek {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.println("Ile masz lat?");
+        int wiek = scanner.nextInt();
+        if(wiek < 0) {
+            System.err.println("wiek ujemny!");            
+        } else if(wiek <= 3) {
+            System.out.println("pijesz mleko");
+        } else if(wiek <= 17) {
+            System.out.println("pijesz colę");
+        } else if(wiek <= 64) {
+            System.out.println("pijesz piwo");
+        } else {
+            System.out.println("pijesz Biovital");
+        }
+    }
+
+}

src/p03_if/TeoriaIf.java

+package p03_if;
+
+import java.util.Random;
+
+public class TeoriaIf {
+
+    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");
+        } 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");
+        }
+
+        String str = "Ala ma kota";
+        int liczba = 1;
+        
+// W Javie nie ma automatycznej konwersji liczb (ani innych rzeczy) na boolean
+//          if(liczba) {
+//              System.out.println("Nie zero");
+//          }
+//        
+//          if(liczba = 0) {
+//              System.out.println("Nie zero");
+//          }
+//        if(str) {
+//            System.out.println("napis nie jest pusty");
+//        }
+        
+// Warunkiem najczęściej jest porównanie, ale może też być wywołanie metody typu boolean
+        if(str.isEmpty()) {
+            System.out.println("puste");
+        }
+
+        // może też być bezpośrednie użycie zmiennej typu boolean
+        boolean logika = x > 10 && y % 3 == 0;
+        if(logika) {
+            System.out.println("Dziwny warunek jest prawdą");
+        } else {
+            System.out.println("Nieprawda");
+        }
+
+        System.out.println("Koniec programu");
+    }
+
+}
+

src/p04_pierwsze_petle/PowtorzNapis.java

+package p04_pierwsze_petle;
+
+import java.util.Scanner;
+
+public class PowtorzNapis {
+    /* Użytkownik wprowadza napis (linię tekstu)
+     * oraz liczbę powtórzeń,
+     * a następnie program tyle razy wypisuje podany tekst na ekran.
+     */
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.println("Podaj swój tekst:");
+        String napis = scanner.nextLine();
+        System.out.println("Ile razy powtórzyć?");
+        int ileRazy = scanner.nextInt();
+        for(int i=0; i < ileRazy; i++) {
+            System.out.println(napis);
+        }
+    }
+}

src/p04_pierwsze_petle/Wprowadzenie.java

+package p04_pierwsze_petle;
+
+public class Wprowadzenie {
+
+    public static void main(String[] args) {
+        // Aby coś powtórzyć określoną liczbę razy,
+        // najlepiej użyć pętli for.
+        // To jest standardowy schemat powtórzenia fragmentu kodu.
+        for(int i=0; i < 5; i++) {
+            System.out.println("Ala ma kota");
+        }
+        System.out.println();
+        
+        System.out.println("Pętla while");
+        // while(WARUNEK) { INSTRUKCJE }
+        int a = 1; // spróbuj 10
+        while(a <= 5) {
+            System.out.println("a = " + a);
+            a++;
+        }
+        System.out.println("Koniec while. Teraz a = " + a);
+        System.out.println();
+        
+        System.out.println("Pętla do-while");
+        // do { INSTRUKCJE } while(WARUNEK); 
+        int b = 1; // spróbuj 10
+        do {
+            System.out.println("b = " + b);
+            b++;
+        } while(b <= 5);
+        System.out.println("Koniec do-while. Teraz b = " + b);
+        System.out.println();
+        
+        System.out.println("Pętla for");
+        // for(INICJALIZACJA; WARUNEK; KROK) { INSTRUKCJE }
+        // Najpierw raz wykonywana jest INICJALIZACJA
+        // bardzo często jest to utworzenie zmiennej i wpisanie początkowej wartości
+        // Następnie (podobnie jak w while) sprawdzany jest WARUNEK
+        // jeśli jest prawdziwy, wykonywane są INSTRUKCJE, a następnie KROK, i znowu spr. WARUNEK
+        // Gdy WARUNEK jest fałszywy, to pętla kończy się.
+        for(int i=1; i <= 5; i++) {
+            System.out.println("i = " + i);
+        }
+        // przy takim sposobie deklaracji (wewnątrz for), nie ma już dostępu do zmiennej i
+        // System.out.println(i);
+        
+        System.out.println();
+        // No i mamy jeszcze pętlę for-each. Ona iteruje po elementach tablicy / kolekcji.
+        String[] miasta = {"Warszawa", "Kraków", "Gdańsk"};
+        for(String miasto : miasta) {
+            System.out.println("Pozdrawiamy miasto " + miasto);
+        }
+        
+    }
+
+}

src/p04_pierwsze_petle/ZgadnijWynikMnozenia1.java

+package p04_pierwsze_petle;
+
+import java.util.Random;
+import java.util.Scanner;
+
+public class ZgadnijWynikMnozenia1 {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        Random random = new Random();
+        int x = random.nextInt(10);
+        int y = random.nextInt(10);
+        // program powinien prosić użytkownika o podanie odpowiedzi tak długo,
+        // aż zostanie podana poprawna odpowiedz,
+        // i wtedy napisać "poprawny wynik, gratulacje..."
+        int nr = 0;
+        int odp;
+        do {
+            System.out.println("Ile to jest " + x + " razy " + y + " ?");
+            odp = scanner.nextInt();
+            nr++;
+        } while(odp != x*y);
+        
+        System.out.println("Dobrze, udało się w próbie nr " + nr);
+    }
+
+}

src/p04_pierwsze_petle/ZgadnijWynikMnozenia2.java

+package p04_pierwsze_petle;
+
+import java.util.Random;
+import java.util.Scanner;
+
+public class ZgadnijWynikMnozenia2 {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        Random random = new Random();
+        int x = random.nextInt(10);
+        int y = random.nextInt(10);
+        // program powinien prosić użytkownika o podanie odpowiedzi tak długo,
+        // aż zostanie podana poprawna odpowiedz,
+        // i wtedy napisać "poprawny wynik, gratulacje..."
+        int nr = 1;
+        System.out.println("Ile to jest " + x + " razy " + y + " ?");
+        int odp = scanner.nextInt();
+        while(odp != x*y) {
+            System.out.println("Błędna odpowiedz. Spróbuj jeszcze raz:");
+            odp = scanner.nextInt();
+            nr++;
+        }
+        
+        System.out.println("Dobrze, udało się w próbie nr " + nr);
+    }
+
+}