Przykłady z podstaw programowania

src/p01_rozmowa/Rozmowa1.java

+package p01_rozmowa;
+
+import javax.swing.JOptionPane;
+
+public class Rozmowa1 {
+
+	public static void main(String[] args) {
+		String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+		JOptionPane.showMessageDialog(null, "Witaj " + imie);
+		
+		int wiek = Integer.parseInt(JOptionPane.showInputDialog("Ile masz lat?"));
+		
+		if(wiek >= 18) {
+			JOptionPane.showMessageDialog(null, "Możesz kupić piwo");
+		} else {
+			JOptionPane.showMessageDialog(null, "Nie możesz kupić piwa");
+		}
+	}
+
+}

src/p01_rozmowa/Rozmowa2.java

+package p01_rozmowa;
+
+import javax.swing.JOptionPane;
+
+public class Rozmowa2 {
+
+	public static void main(String[] args) {
+		String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+		JOptionPane.showMessageDialog(null, "Witaj " + imie);
+		
+		int wiek = Integer.parseInt(JOptionPane.showInputDialog("Ile masz lat?"));
+		
+		if(wiek >= 18) {
+			JOptionPane.showMessageDialog(null, "Możesz kupić piwo");
+			int cena = Integer.parseInt(JOptionPane.showInputDialog("Ile kosztuje piwo?"));
+			int ilosc = Integer.parseInt(JOptionPane.showInputDialog("Ile sztuk kupujesz?"));
+			int kwota = cena * ilosc;
+			JOptionPane.showMessageDialog(null, "Do zapłaty " + kwota);
+		} else {
+			JOptionPane.showMessageDialog(null, "Nie możesz kupić piwa");
+		}
+	}
+
+}

src/p01_rozmowa/Rozmowa3.java

+package p01_rozmowa;
+
+import javax.swing.JOptionPane;
+
+public class Rozmowa3 {
+
+	public static void main(String[] args) {
+		String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+		JOptionPane.showMessageDialog(null, "Witaj " + imie);
+		
+		int wiek = Integer.parseInt(JOptionPane.showInputDialog("Ile masz lat?"));
+		
+		if(wiek >= 18) {
+			JOptionPane.showMessageDialog(null, "Możesz kupić piwo");
+			double cena = Double.parseDouble(JOptionPane.showInputDialog("Ile kosztuje piwo?"));
+			int ilosc = Integer.parseInt(JOptionPane.showInputDialog("Ile sztuk kupujesz?"));
+			double kwota = cena * ilosc;
+			// tutaj może dojść do pomyłki związanej z naturą liczb "zmiennoprzecinkowych"
+			JOptionPane.showMessageDialog(null, "Do zapłaty " + kwota);
+		} else {
+			JOptionPane.showMessageDialog(null, "Nie możesz kupić piwa");
+		}
+	}
+
+}

src/p01_rozmowa/Rozmowa4.java

+package p01_rozmowa;
+
+import javax.swing.JOptionPane;
+
+public class Rozmowa4 {
+
+	public static void main(String[] args) {
+		String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+		JOptionPane.showMessageDialog(null, "Witaj " + imie);
+		
+		int wiek = Integer.parseInt(JOptionPane.showInputDialog("Ile masz lat?"));
+		
+		if(wiek >= 18) {
+			JOptionPane.showMessageDialog(null, "Możesz kupić piwo");
+			double cena = Double.parseDouble(JOptionPane.showInputDialog("Ile kosztuje piwo?"));
+			int ilosc = Integer.parseInt(JOptionPane.showInputDialog("Ile sztuk kupujesz?"));
+			double kwota = cena * ilosc;
+			// tutaj może dojść do pomyłki związanej z naturą liczb "zmiennoprzecinkowych"
+			// ale podczas wyświetlania wyniku zaokrąglimy liczbę do 2 miejsc po przecinku, co w praktyce ukrywa ten problem
+			JOptionPane.showMessageDialog(null, String.format("Za %d piw zapłacisz %.2f", ilosc, kwota));
+		} else {
+			JOptionPane.showMessageDialog(null, "Nie możesz kupić piwa");
+		}
+	}
+
+}

src/p01_rozmowa/Rozmowa5.java

+package p01_rozmowa;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+import javax.swing.JOptionPane;
+
+public class Rozmowa5 {
+
+	public static void main(String[] args) {
+		String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+		JOptionPane.showMessageDialog(null, "Witaj " + imie);
+		
+		int wiek = Integer.parseInt(JOptionPane.showInputDialog("Ile masz lat?"));
+		
+		if(wiek >= 18) {
+			JOptionPane.showMessageDialog(null, "Możesz kupić piwo");
+			// W tej wersji cenę wczytamy jako BigDecimal, co gwarantuje precyzyjne obliczenia na liczbach z ułamkiem
+			
+			BigDecimal cena = new BigDecimal(JOptionPane.showInputDialog("Ile kosztuje piwo?"));
+			int ilosc = Integer.parseInt(JOptionPane.showInputDialog("Ile sztuk kupujesz?"));
+			BigDecimal kwota = cena.multiply(BigDecimal.valueOf(ilosc));
+			// ewentualnie zaokrąglenie do 2 miejsc po przecinku:
+			// kwota = kwota.setScale(2, RoundingMode.HALF_UP);
+			JOptionPane.showMessageDialog(null, "Do zapłaty " + kwota);
+		} else {
+			JOptionPane.showMessageDialog(null, "Nie możesz kupić piwa");
+		}
+	}
+
+}

src/p02_teoria_zmiennych/BityIBajty.java

+package p02_teoria_zmiennych;
+
+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/p02_teoria_zmiennych/DeklaracjeZmiennych.java

+package p02_teoria_zmiennych;
+
+public class DeklaracjeZmiennych {
+
+	public static void main(String[] args) {
+		// Nie wolno używać zmiennych, które nie są zadeklarowane
+		// 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 pewno 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/p02_teoria_zmiennych/Dzielenie.java

+package p02_teoria_zmiennych;
+
+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/p02_teoria_zmiennych/IntegerOverflow.java

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

src/p02_teoria_zmiennych/LiteralyLiczbowe.java

+package p02_teoria_zmiennych;
+
+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/p02_teoria_zmiennych/PrzegladTypow.java

+package p02_teoria_zmiennych;
+
+import java.time.LocalDateTime;
+
+public class PrzegladTypow {
+
+    public static void main(String[] args) {
+   	 // 8 typów prostych:
+   	 // liczby całkowite: 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" / "zmiennoprzecinkowe" (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/p02_teoria_zmiennych/WypiszZakresy.java

+package p02_teoria_zmiennych;
+ 
+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 ograniczeń: klasy BigInteger (całkowite) i BigDecimal (z ułamkiem)
+   	 
+    	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/p02_teoria_zmiennych/Znaki.java

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

src/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(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/p03_if/TeoriaIf.java

+package p03_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/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 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/p04_switch/DzienTygodnia1.java

+package p04_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/p04_switch/DzienTygodnia2.java

+package p04_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");
+			break;
+		default:
+			JOptionPane.showMessageDialog(null, "Niepoprawny numer dnia: " + numer, "Błąd", JOptionPane.ERROR_MESSAGE);			
+		}
+		
+		JOptionPane.showMessageDialog(null, "Koniec programu");
+	}
+
+}

src/p04_switch/DzienTygodnia5.java

+package p04_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/p04_switch/IleDniMaMiesiac1.java

+package p04_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/p04_switch/IleDniMaMiesiac2.java

+package p04_switch;
+
+import javax.swing.JOptionPane;
+
+/* Program dla podanej nazwy miesiąca (np "styczeń")
+ * ma wypisać, ile dni ma ten miesiąc. */
+
+public class IleDniMaMiesiac2 {
+	// 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ń":
+		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":
+			JOptionPane.showMessageDialog(null, "28 lub 29 dni");
+			break;
+		default:
+			JOptionPane.showMessageDialog(null, "Nieznany miesiąc " + miesiac, "Błąd", JOptionPane.ERROR_MESSAGE);
+		}
+	}
+
+}

src/p05_petle/A_Wstep.java

+package p05_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/p05_petle/B_RodzajePetli.java

+package p05_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" / "enhanced for loop".
+		// 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 wykonywane 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/p05_petle/BreakContinue_Prezentacja.java

+package p05_petle;
+
+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/p05_petle/Parkomat1.java

+package p05_petle;
+
+import java.util.Scanner;
+
+/* Parkowanie kosztuje 3 zł za godzinę.
+  Program pyta o liczbę godzin parkowania i na tej podstawie oblicza kwotę do zapłaty.
+  Następnie W PĘTLI:
+    - program wypisuje ile pozostało do zapłaty
+    - program prosi o wrzucenie kolejnej monety
+  aż zostanie wpłacona wymagana suma.
+
+  Jeśli należy się reszta, to program wypisuje ile reszty wydaje.
+*/
+
+public class Parkomat1 {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		System.out.print("Ile godzin parkowania? ");
+		int ileGodzin = scanner.nextInt();
+		
+		int doZaplaty = ileGodzin * 3;
+		System.out.println("Za " + ileGodzin + " godzin parkowania do zapłaty jest " + doZaplaty);
+		
+		int suma = 0;
+		
+		while(suma < doZaplaty) {
+			System.out.println("Do tej pory wrzucono " + suma + ", pozostało jeszcze " + (doZaplaty - suma));
+			System.out.print("Wrzuć monetę: ");
+			int moneta = scanner.nextInt();
+			suma += moneta; // równoważne: suma = suma + moneta;
+		}
+		if(suma > doZaplaty) {
+			System.out.println("Wydaję resztę: " + (suma - doZaplaty));
+		}
+		System.out.println("Koniec");
+	}
+
+}

src/p05_petle/Parkomat2.java

+package p05_petle;
+
+import java.util.Scanner;
+
+public class Parkomat2 {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		System.out.print("Ile godzin parkowania? ");
+		int ileGodzin = scanner.nextInt();
+		
+		int doZaplaty = ileGodzin * 3;
+		System.out.println("Za " + ileGodzin + " godzin parkowania do zapłaty jest " + doZaplaty);
+		
+		while(doZaplaty > 0) {
+			System.out.println("Pozostało jeszcze " + doZaplaty);
+			System.out.print("Wrzuć monetę: ");
+			doZaplaty -= scanner.nextInt();
+		}
+		if(doZaplaty < 0) {
+			System.out.println("Wydaję resztę: " + (-doZaplaty));
+		}
+		System.out.println("Koniec");
+	}
+
+}

src/p05_petle/Parkomat3.java

+package p05_petle;
+
+import java.util.Scanner;
+
+public class Parkomat3 {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		System.out.print("Ile godzin parkowania? ");
+		int ileGodzin = scanner.nextInt();
+		
+		int doZaplaty = ileGodzin * 3;
+		System.out.println("Za " + ileGodzin + " godzin parkowania do zapłaty jest " + doZaplaty);
+		
+		while(true) {
+			System.out.println("Pozostało jeszcze " + doZaplaty);
+			System.out.print("Wrzuć monetę: ");
+			doZaplaty -= scanner.nextInt();
+			if(doZaplaty < 0) {
+				System.out.println("Wydaję resztę: " + (-doZaplaty));
+				break;
+			}
+			if(doZaplaty == 0) {
+				System.out.println("Jesteśmy kwita");
+				break;
+			}
+		}
+		System.out.println("Koniec");
+	}
+
+}

src/p05_petle/PowtorzNapis.java

+package p05_petle;
+
+import java.util.Scanner;
+
+public class PowtorzNapis {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.println("Podaj tekst:");
+		String linia = sc.nextLine();
+		
+		System.out.print("Ile razy powtórzyć? ");
+		int ileRazy = sc.nextInt();
+		
+		for(int i = 0; i < ileRazy; i++) {
+			System.out.println(linia);
+		}
+	}
+
+}

src/p05_petle/Przerwania.java

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