Dodatkowe gotowe przykłady

src/p02_liczby/BityIBajty.java

+package p02_liczby;
+
+public class BityIBajty {
+
+	public static void main(String[] args) {
+		System.out.println("Zwiększanie bajta:");
+		byte b = 0;
+		for (int i = 1; i <= 260; i++) {
+			String bity = Integer.toBinaryString(Byte.toUnsignedInt(b));
+			bity = String.format("%8s", bity);
+			bity = bity.replace(' ', '0');
+			
+			System.out.printf("%4d  :  %s%n", b, bity);
+			b++;
+		}
+	}
+}

src/p02_liczby/Ciekawostki.java

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

src/p02_liczby/Dzielenie.java

+package p02_liczby;
+
+public class Dzielenie {
+
+	public static void main(String[] args) {
+		double d = 1.25;
+		
+		int n = 5;
+		
+		// Uwaga na kolejność działań gdy miesza się inty i double
+		// Tutaj: int dzielony porzez int - wynik obcinany do liczby całkowitej
+		System.out.println(n / 3 * d);
+		
+		 // dzielenie na doublach
+		System.out.println(n * d / 3);
+		System.out.println(1.0 * n / 3 * d);
+		System.out.println((double)n / 3 * d);
+		System.out.println();
+		
+		System.out.println("Dzielenie całkowite i reszta z dzielenia:");
+		for(int i = -10; i <= 10; i++) {
+			System.out.printf("%3d / 3 = %2d      %3d %% 3 = %2d\n", i, i / 3, i, i % 3);
+		}
+
+	}
+
+}

src/p02_liczby/IntPomiarCzasu.java

+package p02_liczby;
+
+public class IntPomiarCzasu {
+	static final int LIMIT = 1_000_000_000;
+	
+	public static void main(String[] args) {
+		// obliczamy sumę liczb z dużego zakresu, od 1 do miliard
+		// liczby to będzie int / Integer , a sumę liczymy jako long / Long
+		
+		long poczatek = System.currentTimeMillis(); // nanoTime - w nanosekundach
+		long suma = 0;
+		for(int i = 1; i <= LIMIT; i++) {
+			suma += i;
+		}
+		long koniec = System.currentTimeMillis();
+		System.out.println("Suma: " + suma);
+		System.out.println("Czas: " + (koniec-poczatek));
+	}
+
+}

src/p02_liczby/IntegerOverflow.java

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

src/p02_liczby/IntegerPomiarCzasu.java

+package p02_liczby;
+
+public class IntegerPomiarCzasu {
+	static final int LIMIT = 1_000_000_000;
+	
+	public static void main(String[] args) {
+		// obliczamy sumę liczb z dużego zakresu, od 1 do miliard
+		// liczby to będzie int / Integer , a sumę liczymy jako long / Long
+		
+		long poczatek = System.currentTimeMillis(); // nanoTime - w nanosekundach
+		Long suma = 0L;
+		for(Integer i = 1; i <= LIMIT; i++) {
+			suma += i;
+		}
+		long koniec = System.currentTimeMillis();
+		System.out.println("Suma: " + suma);
+		System.out.println("Czas: " + (koniec-poczatek));
+	}
+
+}

src/p02_liczby/JakSprawdzicOverflow.java

+package p02_liczby;
+
+import java.util.Scanner;
+
+public class JakSprawdzicOverflow {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Podaj pierwszą liczbę: ");
+		int x = sc.nextInt();
+		System.out.println("Podaj drugą liczbę: ");
+		int y = sc.nextInt();
+		
+		int iloczyn = x * y;
+		System.out.println("Wynik zwykłego mnożenia: " + iloczyn);
+
+		try {
+			int sprawdzony = Math.multiplyExact(x, y);
+			System.out.println("Wynik zabezpieczonego mnożenia: " + sprawdzony);
+		} catch (ArithmeticException e) {
+			System.out.println("Overflow");
+		}
+	}
+
+}

src/p02_liczby/LiteralyLiczbowe.java

+package p02_liczby;
+
+public class LiteralyLiczbowe {
+
+	public static void main(String[] args) {
+		int x;
+
+		x = 123; // format dziesiętny
+		System.out.println(x);
+
+		x = 0123; // system ósemkowy
+		//NK x = 08;  // cyfry od 0 do 7
+		System.out.println(x);
+
+		x = 0x100; // system szesnastkowy
+		System.out.println(x);
+		x = 0x7F;
+		
+		// system 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_liczby/Rzutowania.java

+package p02_liczby;
+
+public class Rzutowania {
+
+	// "Hierarchia" typów prostych:
+	// byte < short < int < long < float < double
+	// char < int
+	
+	public static void main(String[] args) {
+		int x = 107;
+		float f = 3.14f;
+		long l3 = 13;
+
+		// rzutowanie niejawne - na zmienną typu "szerszego" można zapisać wartość typu "węższego" (widening)
+		long l = x;
+		float f2 = l3;
+		//NK x = l;
+		//NK l = f;
+		f = l;
+		
+		// rzutowanie jawne można stosować zawsze; czasem może wiązać się z "popsuciem" wartości liczbowej
+		x = (int) l;
+		System.out.println(x);
+		
+		// można stosować jawne rzutowanie nawet gdy nie jest konieczne
+		l = x;
+		l = (long) x;
+		System.out.println(l);
+		
+		l = 4_000_000_000L;
+		x = (int) l;
+		System.out.println(x); // zmieniona wartość, ostatnie 32 bity z zapisu tej liczby
+
+		f = 100.99F;
+		x = (int)f;  // obcina do wartości całkowitej
+		System.out.println(x); // 100
+		
+		f = 4e9f; // 4 * 10^9 czyli 4mld
+		x = (int)f; // po wyjściu poza zakres przyjmuje MAXINT / MININT
+		System.out.println(x);
+		
+		// Na zmienne typu byte, short i char można wpisywać konkretne wartości całkowite, o ile kompilator widzi, że mieszczą się w zakresie
+		
+		byte b1 = 100;
+		//NK byte b2 = 200;
+
+		x = 100;
+		//NK byte b3 = x;
+		
+		final int fi = 10;
+		b1 = fi; // jeśli wartość jest "stałą" (jest final i jest znana w czasie kompilacji)
+		
+		b1 = 50;
+		//NK b1 = x; // bo "nie każdy int mieści się w byte"
+		x = b1;  // OK, bo byte mieści się w int
+		
+		//NK int i3 = 3L;
+		
+		float f3 = 3L;
+		
+		
+		byte b = 13;
+		b = 15;
+		//NK b = 130;
+		
+		x = 15;
+		//NK b = x;
+		b = (byte)x;
+		
+		//NK wezByte(88);
+		wezByte((byte)88);
+		wezByte(b);
+		System.out.println();
+		
+		System.out.println(dajByte());
+		System.out.println(dajZnak());
+		System.out.println();
+		
+		l = 5_000_000_000L;
+		x = (int)l;
+		System.out.println(x);
+		// rzutowanie liczb całkowitych - bierzemye ostatnie bity z zapisu liczby w pamięci
+		// zobaczę to samo, co w int overflow gdy mnożyłem 5 * 1000000000
+		System.out.println("5mld long   rzut na int: " + x);
+		
+		double d = 5_000_000_000.0;
+		x = (int)d;
+		System.out.println("5mld double rzut na int: " + x);
+		// rzutowanie float i double na liczbę całkowitą - bierzemy wartość, która jest najbliżej,
+		// w tym przypadku będzie to Integer.MAX_VALUE
+		
+		byte b2 = 40, b3 = 50;
+		
+		// Operacje arytmetyczne + - * / %  - są zdefiniowane dla typu int, a nie dla byte i short
+		// dlatego ich ywniki trzeba zrzutowa, aby pisać na zmienne tych typów
+		//NK byte b4 = b2 + b3;
+		byte b4 = (byte)(b2 + b3);
+		
+		// ale bez rzutowania działają ++ i +=
+		
+		System.out.println(b2);
+		b2++;
+		System.out.println(b2);
+		
+		b2 += 10;
+		System.out.println(b2);
+	}
+	
+	static byte dajByte() {
+		return 65;
+	}
+
+	/* NK
+	static byte dajByteInaczej() {
+		int x = 65;
+		return x;
+	}
+	*/
+
+	static char dajZnak() {
+		return 65;
+	}
+	
+	static void wezByte(byte bbb) {
+		System.out.println(bbb);
+	}
+
+}

src/p02_liczby/WypiszZakresy.java

+package p02_liczby;
+ 
+public class WypiszZakresy {
+ 
+    public static void main(String[] args) {
+        System.out.println("byte  " + Byte.BYTES + " bajtów, od " + Byte.MIN_VALUE + " do " + Byte.MAX_VALUE);
+        System.out.println("short " + Short.BYTES + " bajtów, od " + Short.MIN_VALUE + " do " + Short.MAX_VALUE);
+        System.out.println("int   " + Integer.BYTES + " bajtów, od " +Integer.MIN_VALUE + " do " + Integer.MAX_VALUE);
+        System.out.println("long  " + Long.BYTES + " bajtów, od " +Long.MIN_VALUE + " do " + Long.MAX_VALUE);
+ 
+        System.out.println("char  " + Character.BYTES + " bajtów, od " + (int) Character.MIN_VALUE + " do " + (int) Character.MAX_VALUE);
+        System.out.println();
+        
+        // bez ograniczen: klasy BigInteger (calkowite) i BigDecimal (z ulamkiem)
+        
+        System.out.println("float  " + Float.BYTES + " bajtów, od " +Float.MIN_VALUE + " do " + Float.MAX_VALUE);
+        System.out.println("    min normal : " + Float.MIN_NORMAL);
+        System.out.println("double  " + Double.BYTES + " bajtów, od " +Double.MIN_VALUE + " do " + Double.MAX_VALUE);
+        System.out.println("    min normal : " + Double.MIN_NORMAL);
+        System.out.println();
+        
+        System.out.println("boolean : false i true");
+    }
+}

src/p02_liczby/Znaki.java

+package p02_liczby;
+
+public class Znaki {
+
+	public static void main(String[] args) {
+		System.out.println("A");
+		System.out.println("A" + 5);
+
+		System.out.println('A');
+		System.out.println('A' + 5);
+		System.out.println('A' + 'B');
+		System.out.println((char)('A' + 'B'));
+		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_interakcja/argumenty/Argumenty.java

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

+package p03_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
+        // %f - liczba z ułamkiem
+        // %x - liczba szesnastkowo
+        System.out.printf("Osoba %s ma %d lat.\n", s, x);
+        double pi = Math.PI;
+        // Zostaną użyte "lokale" z ustawień systemu, u mnie polskie - liczba wypisuje się z przecinkiem
+        System.out.printf("|%10s|%4d|%-4d|%04d|%6.3f|%n", s, x, x, x, pi);
+
+        // Wskazuję lokale amerykańskie - liczba wypisze się z kropką
+        System.out.printf(Locale.US, "|%10s|%4d|%-4d|%04d|%6.3f|%n", s, x, x, x, pi);
+        System.out.println();
+
+        // Jeśli bardzo potrzebujemy, to na standadowe wyjście można wypisywać też dane binarne.
+        System.out.write(65);
+        System.out.write(66);
+        System.out.write(67);
+        System.out.write(10);
+    }
+
+}

src/p03_interakcja/konsola/B_SuroweWejscie1.java

+package p03_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/p03_interakcja/konsola/B_SuroweWejscie2.java

+package p03_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/p03_interakcja/konsola/C_Skaner1.java

+package p03_interakcja.konsola;
+
+import java.util.Scanner;
+
+public class C_Skaner1 {
+    public static void main(String[] args) {
+        // Tworzymy obiekt klasy Scanner. Ten skaner będzie czytał dane ze standardowego wejścia.
+        Scanner sc = new Scanner(System.in);
+
+        System.out.println("Napisz linię tekstu:");
+        String linia = sc.nextLine();
+        System.out.println("Napisałeś: " + linia);
+
+        System.out.println("Wpisz liczbę całkowitą:");
+        int x = sc.nextInt();
+
+        System.out.println("Wpisz liczbę z przecinkiem (!):");
+        double d = sc.nextDouble();
+
+        System.out.println("Liczby: " +x + " , " + d);
+
+        System.out.print("Wpisz dwa słowa: ");
+        String slowo1 = sc.next();
+        String slowo2 = sc.next();
+
+        System.out.println("Pierwsze: " + slowo1);
+        System.out.println("Drugie  : " + slowo2);
+
+        // Gdy teraz wczytam "linię" co tam będzie? Reszta linii wpisana za tymi ↑ dwoma słowami
+        linia = sc.nextLine();
+        System.out.println("Linia zawiera: " + linia);
+
+        System.out.println("KONIEC");
+    }
+}

src/p03_interakcja/konsola/C_Skaner2_LiczbaCzyNieLiczba.java

+package p03_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/p03_interakcja/konsola/D_BufRead.java

+package p03_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/p03_interakcja/konsola/E_KlasaConsole.java

+package p03_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/p03_interakcja/okna/OknoDialogowe1.java

+package p03_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/p03_interakcja/okna/OknoDialogowe2.java

+package p03_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/p03_interakcja/okna/OknoDialogowe3.java

+package p03_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/p03_interakcja/okna/RodzajeOkien.java

+package p03_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/p03_interakcja/skaner/KlasaScanner.java

+package p03_interakcja.skaner;
+
+import java.util.Scanner;
+
+public class KlasaScanner {
+
+	public static void main(String[] args) {
+		// Do wygodnego wczytywania danych tekstowych ze standardowego wejścia, używa się klasy Scanner.
+		
+		// Deklaruję zmienną scanner typu Scanner i wpisuję do niej nowy obiekt klasy Scanner,
+		// który będzie pobierał dane ze standardowego wejścia.
+		Scanner scanner = new Scanner(System.in);
+		
+		System.out.println("Wpisz linię tekstu:");
+		String linia = scanner.nextLine();
+		System.out.println("Wpisana linia: " + linia);
+		if(!linia.isBlank()) {
+			System.out.println("Linia jest niepusta");
+		}
+
+		System.out.print("Wpisz liczbę całkowitą: ");
+		int x = scanner.nextInt();
+		System.out.print("Wpisz liczbę z ułamkiem: ");
+		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/p03_interakcja/skaner/Prostokat.java

+package p03_interakcja.skaner;
+
+import java.util.Scanner;
+
+// Program odczytuje długości boków prostokąta i oblicza pole powierzchni oraz obwód.
+
+// Klasa Scanner oraz opercaje String.format i printf biorą pod uwagę ustawienia regionalne komputera.
+// Gdy ustawiony jest język angielski, to używają kropki w ułamku dziesiętnym,
+// gdy ustawiony jest język polski, to uywają przecinka.
+// W wersjach ProstokatUS1 i 2 wymuszamy użycie kropki.
+
+public class Prostokat {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		
+		System.out.print("Podaj długość prostokąta: ");
+		double a = scanner.nextDouble();
+		System.out.print("Podaj szerokość prostokąta: ");
+		double b = scanner.nextDouble();
+		
+		double pole = a*b;
+		double obwod = 2*a + 2*b;
+		System.out.println("Pole: " + pole);
+		System.out.println("Obwód: " + obwod);
+		
+		// wersja printf (działa tak samo jak String.format):
+		System.out.printf("Dla prostokąta o bokach %.3f × %.3f pole wynosi %.3f a obwód %.3f\n",
+				a, b, pole, obwod);
+
+	}
+
+}

src/p03_interakcja/skaner/ProstokatUS1.java

+package p03_interakcja.skaner;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class ProstokatUS1 {
+
+	public static void main(String[] args) {
+		// Zanim utworzę Scanner i wykonam jakąkolwiek operację zw z localami,
+		// zmieniam domyśle ustawienia TEJ APLIKACJI
+		Locale.setDefault(Locale.US);
+		
+		Scanner scanner = new Scanner(System.in);
+		
+		System.out.print("Podaj długość prostokąta: ");
+		double a = scanner.nextDouble();
+		System.out.print("Podaj szerokość prostokąta: ");
+		double b = scanner.nextDouble();
+		
+		double pole = a*b;
+		double obwod = 2*a + 2*b;
+		System.out.println("Pole: " + pole);
+		System.out.println("Obwód: " + obwod);
+		
+		// wersja printf (działa tak samo jak String.format):
+		System.out.printf("Dla prostokąta o bokach %.3f × %.3f pole wynosi %.3f a obwód %.3f\n",
+				a, b, pole, obwod);
+
+	}
+
+}

src/p03_interakcja/skaner/ProstokatUS2.java

+package p03_interakcja.skaner;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class ProstokatUS2 {
+
+	public static void main(String[] args) {
+		// Tworząc Scanner oraz używając operacji printf, wskazuję Locale, które mają być użyte.
+		Scanner scanner = new Scanner(System.in);
+		scanner.useLocale(Locale.US);
+		
+		System.out.print("Podaj długość prostokąta: ");
+		double a = scanner.nextDouble();
+		System.out.print("Podaj szerokość prostokąta: ");
+		double b = scanner.nextDouble();
+		
+		double pole = a*b;
+		double obwod = 2*a + 2*b;
+		System.out.println("Pole: " + pole);
+		System.out.println("Obwód: " + obwod);
+		
+		// wersja printf (działa tak samo jak String.format):
+		System.out.printf(Locale.US, "Dla prostokąta o bokach %.3f × %.3f pole wynosi %.3f a obwód %.3f\n",
+				a, b, pole, obwod);
+	}
+
+}

src/p03_interakcja/skaner/StandardoweWejscie1.java

+package p03_interakcja.skaner;
+
+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/p03_interakcja/skaner/StandardoweWejscie2.java

+package p03_interakcja.skaner;
+
+import java.io.IOException;
+import java.util.Arrays;
+
+public class StandardoweWejscie2 {
+
+	public static void main(String[] args) throws IOException {
+        System.out.println("Napisz coś");
+
+        // Można też wczytać całą porcję bajtów do tablicy
+        byte[] bajty = new byte[100];
+        int ile = System.in.read(bajty);
+
+        System.out.println("Odczytano " + ile + " bajtów.");
+        System.out.println(Arrays.toString(bajty));
+
+        // Można utworzyć napis na podstawie ciągu bajtów:
+        String napis = new String(bajty, 0, ile);
+        // String napis = new String(bajty, 0, ile, "UTF-8");
+        System.out.println("Napisałeś: " + napis);
+	}
+
+}