Dużo gotowych przykładów Java SE

src/main/java/emp/v2_obiektowo/Employee.java

+package emp.v2_obiektowo;
+
+import java.time.LocalDate;
+import java.util.Objects;
+
+public class Employee {
+	private int id;
+	private String firstName;
+	private String lastName;
+	private String jobTitle;
+	private int salary;
+	private LocalDate hireDate;
+	private String departmentName;
+	private String streetAddress;
+	private String postalCode;
+	private String city;
+	private String country;
+
+	public Employee(int id, String firstName, String lastName, String jobTitle, int salary, LocalDate hireDate,
+			String departmentName, String streetAddress, String postalCode, String city, String country) {
+		this.id = id;
+		this.firstName = firstName;
+		this.lastName = lastName;
+		this.jobTitle = jobTitle;
+		this.salary = salary;
+		this.hireDate = hireDate;
+		this.departmentName = departmentName;
+		this.streetAddress = streetAddress;
+		this.postalCode = postalCode;
+		this.city = city;
+		this.country = country;
+	}
+
+	public int getId() {
+		return id;
+	}
+
+	public void setId(int id) {
+		this.id = id;
+	}
+
+	public String getFirstName() {
+		return firstName;
+	}
+
+	public void setFirstName(String firstName) {
+		this.firstName = firstName;
+	}
+
+	public String getLastName() {
+		return lastName;
+	}
+
+	public void setLastName(String lastName) {
+		this.lastName = lastName;
+	}
+
+	public String getJobTitle() {
+		return jobTitle;
+	}
+
+	public void setJobTitle(String jobTitle) {
+		this.jobTitle = jobTitle;
+	}
+
+	public int getSalary() {
+		return salary;
+	}
+
+	public void setSalary(int salary) {
+		this.salary = salary;
+	}
+
+	public LocalDate getHireDate() {
+		return hireDate;
+	}
+
+	public void setHireDate(LocalDate hireDate) {
+		this.hireDate = hireDate;
+	}
+
+	public String getDepartmentName() {
+		return departmentName;
+	}
+
+	public void setDepartmentName(String departmentName) {
+		this.departmentName = departmentName;
+	}
+
+	public String getStreetAddress() {
+		return streetAddress;
+	}
+
+	public void setStreetAddress(String streetAddress) {
+		this.streetAddress = streetAddress;
+	}
+
+	public String getPostalCode() {
+		return postalCode;
+	}
+
+	public void setPostalCode(String postalCode) {
+		this.postalCode = postalCode;
+	}
+
+	public String getCity() {
+		return city;
+	}
+
+	public void setCity(String city) {
+		this.city = city;
+	}
+
+	public String getCountry() {
+		return country;
+	}
+
+	public void setCountry(String country) {
+		this.country = country;
+	}
+
+	@Override
+	public String toString() {
+		return "Employee [id=" + id + ", firstName=" + firstName + ", lastName=" + lastName + ", jobTitle=" + jobTitle
+				+ ", salary=" + salary + ", hireDate=" + hireDate + ", departmentName=" + departmentName
+				+ ", streetAddress=" + streetAddress + ", postalCode=" + postalCode + ", city=" + city + ", country="
+				+ country + "]";
+	}
+
+	@Override
+	public int hashCode() {
+		return Objects.hash(city, country, departmentName, firstName, hireDate, id, jobTitle, lastName, postalCode,
+				salary, streetAddress);
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Employee other = (Employee) obj;
+		return Objects.equals(city, other.city) && Objects.equals(country, other.country)
+				&& Objects.equals(departmentName, other.departmentName) && Objects.equals(firstName, other.firstName)
+				&& Objects.equals(hireDate, other.hireDate) && id == other.id
+				&& Objects.equals(jobTitle, other.jobTitle) && Objects.equals(lastName, other.lastName)
+				&& Objects.equals(postalCode, other.postalCode) && salary == other.salary
+				&& Objects.equals(streetAddress, other.streetAddress);
+	}
+	
+}

src/main/java/emp/v2_obiektowo/Grupowanie1.java

+package emp.v2_obiektowo;
+
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+// Schemat grupowania w oparciu o "pętlę w pętli".
+// Nie jest to optymalne rzwiązanie pod względem wydajności.
+// Gdy mamy 107 pracowników i 19 stanowisk, to pętla for i if w linii 28 wykonają się 107*19 razy.
+// Da się to zrobić sprytniej / szybciej - zobaczymy w kolejnych wersjach.
+public class Grupowanie1 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		
+		// etap 1 - zebrać zbiór jobsów bez powtórzeń
+		Set<String> jobs = new TreeSet<>();
+		for (Employee emp : emps) {
+			jobs.add(emp.getJobTitle());
+		}
+
+		// etap 2 - dla każdego joba obliczyć wynik podonie jak w przykładach 4 i 5
+		for(String job : jobs) {
+			double suma = 0;
+			int ilosc = 0;
+			
+			for (Employee emp : emps) {
+				if (job.equals(emp.getJobTitle())) {
+					suma += emp.getSalary();
+					ilosc++;
+				}
+			}
+			double srednia = suma / ilosc;
+			System.out.printf("|%32s | %2d | %8.2f |\n", job, ilosc, srednia);
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/Grupowanie2.java

+package emp.v2_obiektowo;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+// To jest klasyczny algorytm grupowania / agregacji z wykorzystaniem słowników.
+// To rozwiązanie jest bardziej wydajne niż v1, bo tylko jeden raz przeglądamy listę pracowników,
+// a operacje na słownikach (odczyt, zapis, sprawdzanie) są szybkie.
+// Tutaj używamy tylko operacji dostępnych w starych wersjach Javy, co najmniej od Javy 5.
+public class Grupowanie2 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		
+		Map<String, Integer> sumy = new HashMap<>();
+		Map<String, Integer> ilosci= new HashMap<>();
+		
+		for (Employee emp : emps) {
+			if (sumy.containsKey(emp.getJobTitle())) {
+				// już wcześniej występowali pracownicy z tego stanowiska
+				// trzeba odczytać dotychczasową wartość i zapisać powiększoną
+				int dotychczasowaSuma = sumy.get(emp.getJobTitle());
+				sumy.put(emp.getJobTitle(), dotychczasowaSuma + emp.getSalary());
+				int dotychczasowaIlosc = ilosci.get(emp.getJobTitle());
+				ilosci.put(emp.getJobTitle(), dotychczasowaIlosc + 1);
+			} else {
+				// to jest pierwszy pracownik z danego stanowiska
+				sumy.put(emp.getJobTitle(), emp.getSalary());
+				ilosci.put(emp.getJobTitle(), 1);
+			}
+		}
+		
+//		System.out.println(sumy);
+//		System.out.println(ilosci);
+		
+		for(String job : sumy.keySet()) {
+			int suma = sumy.get(job);
+			int ilosc = ilosci.get(job);
+			double srednia = 1.0 * suma / ilosc;
+			System.out.printf("|%32s | %2d | %8.2f |\n", job, ilosc, srednia);
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/Grupowanie2a.java

+package emp.v2_obiektowo;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+// To jest klasyczny algorytm grupowania / agregacji z wykorzystaniem słowników.
+// To rozwiązanie jest bardziej wydajne niż v1, bo tylko jeden raz przeglądamy listę pracowników,
+// a operacje na słownikach (odczyt, zapis, sprawdzanie) są szybkie.
+// Tutaj używamy tylko operacji dostępnych w starych wersjach Javy, co najmniej od Javy 5.
+public class Grupowanie2a {
+
+	public static void main(String[] args) {
+		final List<Employee> emps = ObslugaCSV.wczytaj();
+		
+		final Map<String, Integer> sumy = new HashMap<>();
+		final Map<String, Integer> ilosci= new HashMap<>();
+		
+		for (Employee emp : emps) {
+			final String jobTitle = emp.getJobTitle();
+			if (sumy.containsKey(jobTitle)) {
+				// już wcześniej występowali pracownicy z tego stanowiska
+				// trzeba odczytać dotychczasową wartość i zapisać powiększoną
+				int dotychczasowaSuma = sumy.get(jobTitle);
+				sumy.put(jobTitle, dotychczasowaSuma + emp.getSalary());
+				int dotychczasowaIlosc = ilosci.get(jobTitle);
+				ilosci.put(jobTitle, dotychczasowaIlosc + 1);
+			} else {
+				// to jest pierwszy pracownik z danego stanowiska
+				sumy.put(jobTitle, emp.getSalary());
+				ilosci.put(jobTitle, 1);
+			}
+		}
+		
+//		System.out.println(sumy);
+//		System.out.println(ilosci);
+		
+		for(String job : sumy.keySet()) {
+			int suma = sumy.get(job);
+			int ilosc = ilosci.get(job);
+			double srednia = 1.0 * suma / ilosc;
+			System.out.printf("|%32s | %2d | %8.2f |\n", job, ilosc, srednia);
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/Grupowanie3.java

+package emp.v2_obiektowo;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+// Używamy operacji dodanej w Java 8 : getOrDefault
+public class Grupowanie3 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		
+		Map<String, Integer> sumy = new HashMap<>();
+		Map<String, Integer> ilosci= new HashMap<>();
+		
+		for (Employee emp : emps) {
+			int dotychczasowaSuma = sumy.getOrDefault(emp.getJobTitle(), 0);
+			sumy.put(emp.getJobTitle(), dotychczasowaSuma + emp.getSalary());
+			int dotychczasowaIlosc = ilosci.getOrDefault(emp.getJobTitle(), 0);
+			ilosci.put(emp.getJobTitle(), dotychczasowaIlosc+1);
+		}
+		
+		for(String job : sumy.keySet()) {
+			int suma = sumy.get(job);
+			int ilosc = ilosci.get(job);
+			double srednia = 1.0 * suma / ilosc;
+			System.out.printf("|%32s | %2d | %8.2f |\n", job, ilosc, srednia);
+		}
+	}
+
+}
+
+
+
+

src/main/java/emp/v2_obiektowo/Grupowanie4.java

+package emp.v2_obiektowo;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+// Używamy operacji dodanych w Java 8 : putIfAbsent i computeIfPresent
+
+public class Grupowanie4 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		
+		Map<String, Integer> sumy = new HashMap<>();
+		Map<String, Integer> ilosci= new HashMap<>();
+		
+		for (Employee emp : emps) {
+			// w razie gdyby wartości jeszcze nie było, wstaw 0
+			sumy.putIfAbsent(emp.getJobTitle(), 0);
+			ilosci.putIfAbsent(emp.getJobTitle(), 0);
+			
+			// zakładając, że wartość już jest, zwiększ - robimy to "funkcyjnie"
+			// funkcja przyjmuje dwa parametry: klucz i starą wartość
+			// a na ich podstawie ma zwrócić nową wartość do umieszczenia w słowniku
+			sumy.computeIfPresent(emp.getJobTitle(), 
+					(klucz, dotychczasowaSuma) -> dotychczasowaSuma + emp.getSalary());
+
+			ilosci.computeIfPresent(emp.getJobTitle(), 
+					(klucz, dotychczasowaIlosc) -> dotychczasowaIlosc + 1);
+		}
+		
+		for(String job : sumy.keySet()) {
+			int suma = sumy.get(job);
+			int ilosc = ilosci.get(job);
+			double srednia = 1.0 * suma / ilosc;
+			System.out.printf("|%32s | %2d | %8.2f |\n", job, ilosc, srednia);
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/Grupowanie5.java

+package emp.v2_obiektowo;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+// Używamy operacji dodanej w Java 8 : merge
+// To jest operacja, która implementuje schemat pokazywany w wersji 2.
+
+public class Grupowanie5 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		
+		Map<String, Integer> sumy = new HashMap<>();
+		Map<String, Integer> ilosci= new HashMap<>();
+		
+		for (Employee emp : emps) {
+			sumy.merge(emp.getJobTitle(), emp.getSalary(), Integer::sum);
+			ilosci.merge(emp.getJobTitle(), 1, Integer::sum);
+			// merge dla podanego klucza (miejsca w słowniku) robi tak:
+			// - jeśli jeszcze niczego nie ma, to wstawia wartość 2 parametru (np. salary)
+			// - jeśli już coś jest, to starą wartość aktualizuje za pomocą funkcji dodanej w 3 parametrze (tutaj: dodawania)
+			//   z wykorzystaniem wartości podanej w drugim parametrze
+		}
+		
+		for(String job : sumy.keySet()) {
+			int suma = sumy.get(job);
+			int ilosc = ilosci.get(job);
+			double srednia = 1.0 * suma / ilosc;
+			System.out.printf("|%32s | %2d | %8.2f |\n", job, ilosc, srednia);
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/Grupowanie6.java

+package emp.v2_obiektowo;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class Grupowanie6 {
+
+	public static void main(String[] args) {
+		final List<Employee> emps = ObslugaCSV.wczytaj();
+		
+		// W tej wersji w słowniku jako wartość będziemy pamiętać 2-el. tablicę
+		// na pozycji 0 - ilość, na pozycji 1 - suma pensji
+		final Map<String, int[]> mapa = new TreeMap<>();		
+		
+		for (Employee emp : emps) {
+			final String jobTitle = emp.getJobTitle();
+			if (mapa.containsKey(jobTitle)) {
+				int[] t = mapa.get(jobTitle);
+				t[0] += 1;
+				t[1] += emp.getSalary();
+				// Uwaga! Nie trzeba tej tablicy zapisywać w mapie,
+				// bo pobraliśmy referencję do tego samego obiektu, który jest przechowywany w mapie.
+			} else {
+				mapa.put(emp.getJobTitle(), new int[] {1, emp.getSalary()});
+			}
+		}
+		
+		// Aby przejrzeć zawartość słownika, klucze wraz z wartościami, używa się entrySet.
+		for (Map.Entry<String, int[]> entry : mapa.entrySet()) {
+			String job = entry.getKey();
+			int ilosc = entry.getValue()[0];
+			int suma = entry.getValue()[1];
+			double srednia = 1.0 * suma / ilosc;
+			System.out.printf("|%32s | %2d | %8.2f |\n", job, ilosc, srednia);
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/Grupowanie7.java

+package emp.v2_obiektowo;
+
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+// Podejście obiektowe do grupowania.
+
+public class Grupowanie7 {
+
+	public static void main(String[] args) {
+		final List<Employee> emps = ObslugaCSV.wczytaj();
+		final Map<String, JobInfo> mapa = new TreeMap<>();		
+		
+		for (Employee emp : emps) {
+			final String jobTitle = emp.getJobTitle();
+			JobInfo jobInfo = mapa.get(jobTitle);
+			if (jobInfo == null) {
+				jobInfo = new JobInfo(jobTitle);
+				mapa.put(jobTitle, jobInfo);
+			}
+			jobInfo.update(emp);				
+		}
+		
+		for (JobInfo jobInfo : mapa.values()) {
+			System.out.println(jobInfo);
+		}
+	}
+
+	// Klasa zgnieżdżona - tylko dla przykładu.
+	// Równie dobrze mógłbym tę klase zdefiniować w osobnym pliku.
+	
+	// Obiekt tej klasy przechowuje statystyki job
+	private static class JobInfo {
+		final String jobTitle;
+		int count = 0;
+		int sum = 0;
+		int min = Integer.MAX_VALUE;
+		int max = Integer.MIN_VALUE;
+		
+		JobInfo(String jobTitle) {
+			this.jobTitle = jobTitle;
+		}
+
+		void update(Employee emp) {
+			int salary = emp.getSalary();
+			count++;
+			sum += salary;
+			if(salary < min) {
+				min = salary;
+			}
+			if(salary > max) {
+				max = salary;
+			}
+		}
+		
+		double avg() {
+			return (double)sum / count;
+		}
+
+		@Override
+		public String toString() {
+			return "jobTitle=" + jobTitle + ", count=" + count + ", sum=" + sum + ", min=" + min + ", max="
+					+ max + ", avg=" + avg();
+		}
+	}
+}

src/main/java/emp/v2_obiektowo/ObslugaCSV.java

+package emp.v2_obiektowo;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class ObslugaCSV {
+	private static final String DOMYSLNY_PLIK = "emps.csv";
+	private static final String SEP = ";";
+
+	// Gdy w jednej klasie mamy dwie metody o tej samej nazwie różniące się typem parametru,
+	// to nazywa się to "przeciążanie" / "overloading"
+	public static List<Employee> wczytaj(String sciezka) {
+		return wczytaj(new File(sciezka));
+	}
+	
+	public static List<Employee> wczytaj() {
+		return wczytaj(DOMYSLNY_PLIK);
+	}
+	
+	public static List<Employee> wczytaj(File plik) {
+		List<Employee> emps = new ArrayList<>();
+		try(Scanner scanner = new Scanner(plik)) {
+			while(scanner.hasNextLine()) {
+				String linia = scanner.nextLine();
+				String[] t = linia.split(SEP, 11);
+				Employee emp = new Employee(Integer.parseInt(t[0]),
+						t[1], t[2], t[3], Integer.parseInt(t[4]), LocalDate.parse(t[5]),
+						t[6], t[7], t[8], t[9], t[10]);
+				emps.add(emp);
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+		return emps;
+	}
+	
+	public static void zapisz(List<Employee> emps, String sciezka) {
+		zapisz(emps, new File(sciezka));
+	}
+	
+	public static void zapisz(List<Employee> emps, File plik) {
+		try(PrintWriter out = new PrintWriter(plik)) {
+			for (Employee emp : emps) {
+				out.print(emp.getId());
+				out.print(SEP);
+				out.print(emp.getFirstName());
+				out.print(SEP);
+				out.print(emp.getLastName());
+				out.print(SEP);
+				out.print(emp.getJobTitle());
+				out.print(SEP);
+				out.print(emp.getSalary());
+				out.print(SEP);
+				out.print(emp.getHireDate());
+				out.print(SEP);
+				out.print(emp.getDepartmentName());
+				out.print(SEP);
+				out.print(emp.getStreetAddress());
+				out.print(SEP);
+				out.print(emp.getPostalCode());
+				out.print(SEP);
+				out.print(emp.getCity());
+				out.print(SEP);
+				out.print(emp.getCountry());
+				out.println();
+			}
+		} catch (FileNotFoundException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/P1_WypiszPola.java

+package emp.v2_obiektowo;
+
+import java.util.List;
+
+public class P1_WypiszPola {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		
+		for (Employee emp : emps) {
+			// System.out.println(emp.getFirstName() + " " + emp.getLastName());
+			System.out.printf("Pracownik %s %s (%s) zarabia $%d\n",
+					emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary());
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/P2_WypiszBogatych.java

+package emp.v2_obiektowo;
+
+import java.util.List;
+
+public class P2_WypiszBogatych {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		
+		for (Employee emp : emps) {
+			if(emp.getSalary() >= 10000) {
+				System.out.printf("Pracownik %s %s (%s) zarabia $%d\n",
+					emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary());
+			}
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/P3_SredniaWszystkich.java

+package emp.v2_obiektowo;
+
+import java.util.List;
+
+public class P3_SredniaWszystkich {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		
+		double suma = 0;
+		for (Employee emp : emps) {
+			suma += emp.getSalary();
+		}
+		double srednia = suma / emps.size();
+		System.out.println("Średnia: " + srednia);
+	}
+
+}

src/main/java/emp/v2_obiektowo/P4_SredniaProgramistow.java

+package emp.v2_obiektowo;
+
+import java.util.List;
+
+public class P4_SredniaProgramistow {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		
+		double suma = 0;
+		int ilosc = 0;
+		for (Employee emp : emps) {
+			if ("Programmer".equals(emp.getJobTitle())) {
+				suma += emp.getSalary();
+				ilosc++;
+			}
+		}
+		double srednia = suma / ilosc;
+		System.out.println("Średnia: " + srednia);
+	}
+
+}
+
+// spr. czy nazwa stanowiska zawiera słowo programmer:
+// if (emp.getJobTitle() != null && emp.getJobTitle().toLowerCase().contains("programmer")) {
+
+

src/main/java/emp/v2_obiektowo/P6_MinMax.java

+package emp.v2_obiektowo;
+
+import java.util.List;
+
+public class P6_MinMax {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		
+		Employee min = null;
+		Employee max = null;
+		
+		for (Employee emp : emps) {
+			if(max == null || emp.getSalary() > max.getSalary()) {
+				max = emp;
+			}
+			if(min == null || emp.getSalary() < min.getSalary()) {
+				min = emp;
+			}
+		}
+		
+		if(max != null) {
+			System.out.printf("Najbogatszy: %s %s (%s), $%d\n",
+					max.getFirstName(), max.getLastName(), max.getJobTitle(), max.getSalary());
+		}
+		
+		if(min != null) {
+			System.out.printf("Najbiedniejszy: %s %s (%s), $%d\n",
+					min.getFirstName(), min.getLastName(), min.getJobTitle(), min.getSalary());
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/P6_MinMax_v2.java

+package emp.v2_obiektowo;
+
+import java.util.List;
+
+public class P6_MinMax_v2 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		
+		if(emps.isEmpty()) {
+			System.out.println("Brak danych");
+			return;
+		}
+		
+		Employee min = emps.get(0);
+		Employee max = emps.get(0);
+		
+		for (Employee emp : emps) {
+			if(emp.getSalary() > max.getSalary()) {
+				max = emp;
+			}
+			if(emp.getSalary() < min.getSalary()) {
+				min = emp;
+			}
+		}
+		
+		System.out.printf("Najbogatszy: %s %s (%s), $%d\n", max.getFirstName(), max.getLastName(), max.getJobTitle(), max.getSalary());
+
+		System.out.printf("Najbiedniejszy: %s %s (%s), $%d\n", min.getFirstName(), min.getLastName(), min.getJobTitle(), min.getSalary());
+	}
+
+}

src/main/java/emp/v2_obiektowo/P7_Sortowanie_v1.java

+package emp.v2_obiektowo;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class P7_Sortowanie_v1 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		// W tej wersji użyję wyłącznie technik dostępnych w starszych wersjach Javy, przed Java 8.
+		
+		Collections.sort(emps, new Comparator<Employee>() {
+			public int compare(Employee emp1, Employee emp2) {
+				// metoda compare ma zwrócić wartość ujemną, jesli emp1 jest "mniejszy"
+				// wartość dodatnią jeśli emp1 jest "większy" od emp2
+				// zero jeśli oba są równe
+				// Tutaj wystarczy odjąć od siebie pensje pracowników
+				return emp2.getSalary() - emp1.getSalary();
+			}
+		});
+		
+		for (Employee emp : emps) {
+			System.out.printf("%s %s (%s) zarabia %d\n",
+					emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary());
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/P7_Sortowanie_v2.java

+package emp.v2_obiektowo;
+
+import java.util.List;
+
+public class P7_Sortowanie_v2 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		// W tej wersji użyjemy zapisów z Java 8:
+		// Metoda sort w liście oraz wyrażenie lambda do określenia Comparatora
+		emps.sort((emp1, emp2) -> emp2.getSalary() - emp1.getSalary());
+		
+		for (Employee emp : emps) {
+			System.out.printf("%s %s (%s) zarabia %d\n",
+					emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary());
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/P7_Sortowanie_v3.java

+package emp.v2_obiektowo;
+
+import java.util.Comparator;
+import java.util.List;
+
+public class P7_Sortowanie_v3 {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		// W tej wersji użyjemy zapisów z Java 8:
+		// Metoda Comparator.comparing wskazująca po czym sortujemy
+		emps.sort(Comparator.comparing(Employee::getSalary).reversed());
+		
+		for (Employee emp : emps) {
+			System.out.printf("%s %s (%s) zarabia %d\n",
+					emp.getFirstName(), emp.getLastName(), emp.getJobTitle(), emp.getSalary());
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/P8_Podwyzka.java

+package emp.v2_obiektowo;
+
+import java.util.List;
+
+import javax.swing.JOptionPane;
+
+public class P8_Podwyzka {
+
+	public static void main(String[] args) {
+		String job = JOptionPane.showInputDialog("Podaj nazwę stanowiska, które ma dostać podwyżkę, np. Programmer");
+		int podwyzka = Integer.parseInt(JOptionPane.showInputDialog("Podaj kwotę podwyżki"));
+		
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.cvs");
+		int ile = 0;
+		for (Employee emp : emps) {
+			if (emp.getJobTitle().equals(job)) {
+				emp.setSalary(emp.getSalary() + podwyzka);
+				ile++;
+			}
+		}
+		
+		ObslugaCSV.zapisz(emps, "po_podwyzce.csv");
+		System.out.println("Gotowe, zmieniono " + ile + " rekordów.");
+	}
+
+}

src/main/java/emp/v2_obiektowo/P8a_Podwyzka.java

+package emp.v2_obiektowo;
+
+import java.io.File;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+import javax.swing.JFileChooser;
+import javax.swing.JOptionPane;
+import javax.swing.filechooser.FileNameExtensionFilter;
+
+public class P8a_Podwyzka {
+
+	public static void main(String[] args) {
+		JFileChooser chooser = new JFileChooser(".");
+		chooser.setDialogTitle("Wybierz plik z danymi");
+		chooser.setFileFilter(new FileNameExtensionFilter("Pliki CSV", "csv", "txt"));
+		
+		int coSieStalo = chooser.showOpenDialog(null);
+		if(coSieStalo != JFileChooser.APPROVE_OPTION) {
+			// użytkownik kliknął Cancel lub doszło do błędu
+			return;
+		}
+		// Wiemy teraz, że metoda zakończyła się sukcesem (APPROVE_OPTION)
+		// i w poniższy sposób pobieramy dane wskazanego pliku:
+		File wejscie = chooser.getSelectedFile();
+		List<Employee> emps = ObslugaCSV.wczytaj(wejscie);
+		
+		// Zbierzmy zestaw stanowisk bez powtórzeń. Użyjemy do tego Set
+		Set<String> jobs = new TreeSet<>();
+		for(Employee emp : emps) {
+			jobs.add(emp.getJobTitle());
+		}
+		
+		String job = (String)JOptionPane.showInputDialog(null,
+				"Kto ma dostać podwyżkę?", "Wybierz stanowisko", JOptionPane.QUESTION_MESSAGE,
+				null, jobs.toArray(), "President");
+				
+		int podwyzka = Integer.parseInt(JOptionPane.showInputDialog("Podaj kwotę podwyżki"));
+		
+		int ile = 0;
+		for (Employee emp : emps) {
+			if (emp.getJobTitle().equals(job)) {
+				emp.setSalary(emp.getSalary() + podwyzka);
+				ile++;
+			}
+		}
+
+		JOptionPane.showMessageDialog(null, "Zmieniono " + ile + " rekordów.");
+		
+		coSieStalo = chooser.showSaveDialog(null);
+		if(coSieStalo != JFileChooser.APPROVE_OPTION) {
+			// użytkownik kliknął Cancel lub doszło do błędu
+			return;
+		}
+		File wyjscie = chooser.getSelectedFile();
+		if(wyjscie.exists()) {
+			coSieStalo = JOptionPane.showConfirmDialog(null, "Plik istnieje. Czy chcesz go zastąpić?", "Uwaga", JOptionPane.YES_NO_OPTION);
+			if(coSieStalo == JOptionPane.NO_OPTION) {
+				return;
+			}
+		}
+		
+		ObslugaCSV.zapisz(emps, wyjscie);
+		JOptionPane.showMessageDialog(null, "Gotowe");
+	}
+
+}

src/main/java/emp/v2_obiektowo/P9_MiastaBezPowtorzen.java

+package emp.v2_obiektowo;
+
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class P9_MiastaBezPowtorzen {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj();
+		
+		Set<String> miasta = new TreeSet<>();
+		for (Employee emp : emps) {
+			miasta.add(emp.getCity());
+		}
+		
+		// System.out.println(miasta);
+		for (String miasto : miasta) {
+			System.out.println(" * " + miasto);
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/TestOdczytu.java

+package emp.v2_obiektowo;
+
+import java.util.List;
+
+public class TestOdczytu {
+
+	public static void main(String[] args) {
+		List<Employee> emps = ObslugaCSV.wczytaj("emps.csv");
+		System.out.println("Odczytano " + emps.size() + " rekordów");
+
+		for (Employee emp : emps) {
+			System.out.println(emp);
+		}
+	}
+
+}

src/main/java/emp/v2_obiektowo/zadania.txt

+1. Wypisz dane wszystkich pracowników w takiej formie:
+   Steven King (President) zarabia 24000
+   
+2. Wypisz tylko tych, którzy zarabiają >= 10 tys.
+
+3. Oblicz średnią pensję wszystkich pracowników.
+
+4. Oblicz średnią pensję programistów.
+
+5. Program za pomocą JOptionPane ma pytać o nazwę stanowiska,
+   a następnie obliczyć średnią na tym stanowisku.
+
+   Dla chętnych 5a: za pomocą JFileChooser pozwolić wybrać plik z dysku.
+
+   Dla chętnych 2 (jako praca domowa):
+   zrobić z tego program okienkowy Swing, w którym wybiera się plik z dysku,
+   a następnie nazwę stanowiska z JComboBox...
+
+6. Wypisz kto zarabia najwięcej, a kto najmniej (cały obiekt albo imię, nazwisko i pensję).
+
+// 7. Posortuj pracowników wg pensji i wypisz w kolejności malejącej.
+
+// 8. Dodaj metodę zapisującą listę do pliku i napisz program, który wybranym pracownikom (np. Programmer)
+   daje podwyżkę i zmienione dane zapisuje do nowego pliku.
+
+9. Wypisz nazwy miast bez powtórzeń.
+
+// 10. "Grupowanie" - dla każdego stanowiska występującego w pliku oblicz średnią pensję na tym stanowisku.
+
+            job_title            | count |          avg           
+---------------------------------+-------+------------------------
+ Human Resources Representative  |     1 |  6500.0
+ Marketing Representative        |     1 |  6000.0
+ Administration Assistant        |     1 |  4400.0
+ Programmer                      |     5 |  5760.0
+ Marketing Manager               |     1 | 13000.0
+ Public Accountant               |     1 |  8300.0
+ Shipping Clerk                  |    20 |  3215.0
+ Accounting Manager              |     1 | 12000.0
+ Stock Clerk                     |    20 |  2785.0
+ Purchasing Manager              |     1 | 11000.0
+ Sales Manager                   |     5 | 12200.0
+ Sales Representative            |    30 |  8350.0
+ Stock Manager                   |     5 |  7280.0
+ Accountant                      |     5 |  7920.0
+ Finance Manager                 |     1 | 12000.0
+ Administration Vice President   |     2 | 17000.0
+ Public Relations Representative |     1 | 10000.0
+ President                       |     1 | 24000.0
+ Purchasing Clerk                |     5 |  2780.0
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/main/java/pcz/p01_interakcja/argumenty/Argumenty.java

+package pcz.p01_interakcja.argumenty;
+
+/*
+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/main/java/pcz/p01_interakcja/konsola/A_Print.java

+package pcz.p01_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/main/java/pcz/p01_interakcja/konsola/B_SuroweWejscie1.java

+package pcz.p01_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/pcz/p01_interakcja/konsola/B_SuroweWejscie2.java

+package pcz.p01_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/pcz/p01_interakcja/konsola/C_Skaner1.java

+package pcz.p01_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/main/java/pcz/p01_interakcja/konsola/C_Skaner2_LiczbaCzyNieLiczba.java

+package pcz.p01_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/pcz/p01_interakcja/konsola/D_BufRead.java

+package pcz.p01_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/pcz/p01_interakcja/konsola/E_KlasaConsole.java

+package pcz.p01_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/pcz/p01_interakcja/okna/OknoDialogowe1.java

+package pcz.p01_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/pcz/p01_interakcja/okna/OknoDialogowe2.java

+package pcz.p01_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/pcz/p01_interakcja/okna/OknoDialogowe3.java

+package pcz.p01_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/pcz/p01_interakcja/okna/RodzajeOkien.java

+package pcz.p01_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());
+
+        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");
+        }
+    }
+
+}

src/main/java/pcz/p02_zmienne/A_TeoriaZmiennych.java

+package pcz.p02_zmienne;
+
+public class A_TeoriaZmiennych {
+
+    public static void main(String[] args) {
+        System.out.println("Początek programu");
+
+        // Aby użyć zmiennej, trzeba ją zadeklarować.
+        //NK x = 15;
+        //NK System.out.println(x);
+
+        // Deklaracja zmiennej:
+        String txt;
+        int x, innaZmienna;
+
+        // Zmienne lokalne (czyli deklarowane wewnątrz metod)
+        // nie są automatycznie inicjowane na żadną wartość.
+        // Niezainicjowanych zmiennych lokalnych nie wolno odczytywać (błąd kompilacji).
+
+        //NK System.out.println(txt);
+        //NK System.out.println(x);
+        //NK x = 2 * x;
+        //NK x += 5;
+
+        // Instrukcja przypisania (assignment)
+        txt = "Ala";
+        x = 25;
+
+        System.out.println(x); // OK
+        System.out.println(txt); // OK
+
+        // ponowne przypisanie = zmiana wartości zmiennej
+
+        txt = "Ola";
+        x = x + 1;
+        System.out.println(x);
+
+        // Rozszerzone operatory przypisania:
+        x += 4; // równoważne x = x + 4
+        System.out.println(x);
+        // dostępne także dla innych operatorów
+        x *= 2;
+        System.out.println(x);
+        System.out.println();
+
+        // Zazwyczaj wartość zmiennej podaje się od razu w miejscu deklaracji (deklaracja z inicjalizacją):
+        int y = 100, z = 200;
+        String miasto = "Warszawa";
+
+        System.out.println(y + z);
+        System.out.println(miasto);
+
+        // Typowe podejście Javy:
+        // Zmienne lokalne deklaruje się dopiero kiedy są potrzebne
+        // i od razu podaje się ich początkową wartość.
+    }
+
+}

src/main/java/pcz/p02_zmienne/B_RodzajeZmiennych.java

+package pcz.p02_zmienne;
+
+//NK int globalna;
+
+public class B_RodzajeZmiennych {
+    // zmienna statyczna - istnieje jeden egzemplarz w pamięci
+    static int statyczna = 10;
+
+    // zmienna instancyjna (inaczej: pole, atrybut) należy do obiektu
+    // Każdy obiekt tej klasy, w której jesteśmy, będzie posiadał taką zmienną
+    int instancyjna = 20;
+
+    public static void main(String[] args) {
+        // zmienna lokalna, czyli deklarowana w obrębie metody
+        int lokalna = 30;
+
+        metodaStatyczna(40);
+
+        // metody instancyjnej nie da się wywołać w kontekście statycznym (np. w main)
+        // metodaInstancyjna(50);
+
+        // Trzeba utworzyć obiekt i wywołać tę metodę na obiekcie.
+        // Tworzę obiekt, czyli "instancję"
+        B_RodzajeZmiennych obiekt = new B_RodzajeZmiennych();
+        obiekt.metodaInstancyjna(50);
+
+        System.out.println(statyczna);
+        System.out.println(obiekt.instancyjna);
+
+        B_RodzajeZmiennych innyObiekt = new B_RodzajeZmiennych();
+        innyObiekt.instancyjna = 123;
+        innyObiekt.metodaInstancyjna(33);
+    }
+
+    static void metodaStatyczna(int parametr) {
+        int lokalna = 60;
+
+        System.out.println("metodaStatyczna:");
+        System.out.println("statyczna: " + statyczna);
+        // m "kontekście statycznym", czyli w metodzie statycznej nie ma dostępu do zmiennych instancyjnych,
+        // bo "nie wiemy w jakim obiekcie"
+        //NK System.out.println("instancyjna: " + instancyjna);
+        System.out.println("lokalna: " + lokalna);
+        System.out.println("parametr: " + parametr);
+        System.out.println();
+    }
+
+    void metodaInstancyjna(int parametr) {
+        int lokalna = 70;
+
+        System.out.println("metodaInstancyjna:");
+        System.out.println("statyczna: " + statyczna);
+        System.out.println("instancyjna: " + instancyjna);
+        System.out.println("lokalna: " + lokalna);
+        System.out.println("parametr: " + parametr);
+        System.out.println();
+    }
+
+}

src/main/java/pcz/p02_zmienne/C_Inicjalizacja.java

+package pcz.p02_zmienne;
+
+public class C_Inicjalizacja {
+    // zmienne statyczne - inicjowane domyślnie na 0, false lub null
+    static int st;
+
+    // zmienne instancyjne - inicjowane domyślnie na 0, false lub null
+    int inst;
+
+    public static void main(String[] args) {
+        // zmienne lokalne - nie są automatyczne inicjowane
+        int lokalna;
+
+        System.out.println(st); // 0
+        //NK System.out.println(inst); // próba dostępu do zmiennej niestatycznej w kontekście statycznym
+
+        C_Inicjalizacja obiekt = new C_Inicjalizacja();
+        System.out.println(obiekt.inst); // 0
+
+        // błąd kompilacji - aby odczytać zmienną lokalną, musi zostać wcześniej zainicjalizowana (w taki sposób, żeby kompilator miał pewność)
+        //NK System.out.println(lokalna);
+
+        if(st >= 0) {
+            lokalna = 13;
+            System.out.println(lokalna); // OK - tu zmienna "na pewno jest zainicjowana"
+        }
+        //NK System.out.println(lokalna); // tutaj wg kompilatora "może być niezainicjowana"
+
+        if(st >= 0) {
+            lokalna = 10;
+        } else {
+            lokalna = 20;
+        }
+        System.out.println(lokalna); // OK
+    }
+
+}

src/main/java/pcz/p02_zmienne/D_Zasieg.java

+package pcz.p02_zmienne;
+
+public class D_Zasieg {
+    static int x;
+
+    public static void main(String[] args) {
+        System.out.println("A: " + x);
+        x = 100;
+        System.out.println("B: " + x);
+
+        int x = 500;
+        System.out.println("C: " + x);
+        metoda();
+        System.out.println("I: " + x);
+
+    }
+
+    static void metoda() {
+        // w tym miejscu nie widać lokalnych zmiennych z innych metod (np. main)
+        // a widać zmienne z poziomu klasy ("globalne")
+        System.out.println("D: " + x);
+
+        if(x > 0) {
+            String x = "700";
+            System.out.println("E: " + x);
+        }
+
+        System.out.println("F: " + x);
+
+        {
+            // wolno przesłaniać zmienne klasowe za pomocą zmiennych lokalnych
+            int x = 300;
+            System.out.println("G: " + x);
+            if(true) {
+                // nie wolno przesłaniać zmiennych lokalnych
+                //NK int x = 400;	
+                // System.out.println("H: " + x);
+            }
+        }
+
+        System.out.println("K: " + x);
+    }
+
+}

src/main/java/pcz/p02_zmienne/Nazwy.java

+package pcz.p02_zmienne;
+
+public class Nazwy {
+
+    public static void main(String[] args) {
+        // Nazwa nie może zaczynać się od cyfry
+        //NK String 1rstElement = "pierwszy";
+
+        // Nazwa może zaczynać się od litery, znaku _ lub znaku $
+        String abc123 = "abc123";
+        String _123 = "qwerty";
+        String $123 = "qwertz";
+
+        // wielkość liter ma znaczenie, to są dwie różne zmienne
+        int x = 10, X = 20;
+
+        System.out.println(x);
+        System.out.println(X);
+
+        // Można używać liter z różnych alfabetów
+        int żółć = 333;
+        System.out.println(żółć);
+
+        String 李 = "李";
+        System.out.println(李);
+
+        \u674e = "babajaga"; // podaję kod Unicode chińskiego znaczka
+        System.out.println(李); // babajaga
+
+        int $a, a; // to są różne zmienne
+
+        int $ = 444, $3 = 33, __ = 44;
+        System.out.println($);
+        System.out.println($3);
+        System.out.println(__);
+
+        // Nazwami nie mogą być słowa kluczowe ani pojedynczy znak podkreślenia
+        // String int = "pomyłka";
+        // String _ = "aaa";
+        // System.out.println(_);
+        String var = "okej, nawet w Javie 11";
+        System.out.println(var);
+    }
+
+}

src/main/java/pcz/p02_zmienne/PolaFinal.java

+package pcz.p02_zmienne;
+
+public class PolaFinal {
+    // pola które są final muszą być jawnie zainicjalizowane
+    // albo w tym miejscu, albo w bloku inicjalizacyjnym, albo w konstruktorze
+    final int numer;
+
+    public PolaFinal() {
+        numer = 0;
+    }
+
+    public PolaFinal(int nr) {
+        numer = nr;
+    }
+}

src/main/java/pcz/p02_zmienne/SlowoVar.java

+package pcz.p02_zmienne;
+
+import java.time.LocalTime;
+
+public class SlowoVar {
+
+    public static void main(String[] args) {
+        // Przykład kompiluje się od Javy 10.
+
+        // Deklaracja zmiennej lokalnej bez podawania typu.
+        // Kompilator domyśla się typu na podstawie tego, co wpisujemy
+        var y = 100;
+        System.out.println(y);
+        y = 101; // OK
+        System.out.println(y);
+
+        // Zmienna ma jednak typ int i nie wolno wpisać wartości niezgodnego typu
+        // y = 3.14; // źle
+        // y = "Ala ma kota"; // źle
+        // System.out.println(y);
+
+        // Konstrukcja dostępna tylka dla zmiennych lokalnych, gdy początkową wartość wpisuje się od razu w miejscu deklaracji.
+        // var z;
+
+        // var nie jest słowem kluczowym i w niekolidujących miejscach można go używać jako nazwy:
+        String var = "tajemnicza zmienna";
+        System.out.println(var);
+
+        // BTW, odpowiednikiem takich zmiennych jak w Pythonie i PHP, na które można wpisać "wszystko",
+        // w Javie jest raczej zmienna typu Object.
+
+        Object o;
+        o = "Ala ma kota";
+        System.out.println(o.getClass().getSimpleName() + " : " + o);
+
+        o = 100 + 15;
+        System.out.println(o.getClass().getSimpleName() + " : " + o);
+
+        o = LocalTime.now();
+        System.out.println(o.getClass().getSimpleName() + " : " + o);
+    }
+
+}

src/main/java/pcz/p02_zmienne/Typy.java

+package pcz.p02_zmienne;
+
+import java.time.LocalDate;
+
+public class Typy {
+
+    public static void main(String[] args) {
+        // Typy dzielą się na dwie kategorie:
+        // 1) typy proste
+        byte b = 15;
+        short s = 1000;
+        int i = 100000;
+        long l1 = 10, l2 = 5000000000L;
+
+        float f = 3.14F;
+        double d = 3.14;
+
+        // char to pojedynczy znak, ale jednocześnie może być traktowany jak liczba z zakresu 0-64k
+        char znak = 'A';
+
+        boolean falsz = false, prawda = true, niewiem = d > 3.0;
+
+        // typów byte i short nie opłaca sie używać, chyba że w dużych tablicach
+
+        // 2) typy obiektowe
+        Object o = new Object();
+        System.out.println(o);
+
+        // klasa String - napisy
+        String imie = "Ala";
+
+        // platforma Java SE definiuje ok 4 tys. klas
+        LocalDate data = LocalDate.now();
+        System.out.println(data);
+        System.out.println(data.getDayOfMonth());
+        System.out.println(data.getDayOfYear());
+        System.out.println();
+
+        // programiści mogą tworzyć własne klasy
+
+        // w Javie również tablice są obiektami:
+        int[] liczby = { 1, 2, 3, 4 };
+        System.out.println(liczby.length);
+
+        System.out.println(liczby[1]); // 2
+    }
+
+}

src/main/java/pcz/p03_instrukcje/a_if/A_TeoriaIf.java

+package pcz.p03_instrukcje.a_if;
+
+import java.util.Random;
+
+public class A_TeoriaIf {
+
+    public static void main(String[] args) {
+        Random random = new Random();
+        int x = random.nextInt(100); // liczba od 0 do 99 włącznie
+        int y = random.nextInt(100);
+
+        System.out.println("Wylosowane liczby:");
+        System.out.printf("x = %d , y = %d\n", x, y);
+
+        // Wzorcowa wersja if:
+        // if(WARUNEK) { INSTRUKCJE1 } else { INSTRUKCJE2 }
+        // Gdy WARUNEK jest prawdą, wykonają się INSTRUKCJE1, a jeśli nieprawdą to INSTRUKCJE2
+        if(x % 2 == 0) {
+            System.out.println("x jest parzysty");
+            System.out.println("Ala ma kota");
+        } else {
+            System.out.println("x jest nieparzysty");
+            System.out.println("Ola ma psa");
+        }
+        System.out.println("a kuku");
+        System.out.println();
+
+        // Jeśli za ifem lub elsem do wykonania jest tylko jedna instrukcja, to można pominąć nawiasy klamrowe.
+        if(x >= 50)
+            System.out.println(">= 50");
+        else
+            System.out.println("<  50");
+        // Używajmy tego jednak z umiarem, tylko w bardzo prostych przypadkach, np. break, throw, return...
+        // W większości przypadków zalecane jest wzięcie wykonywanego kodu w {nawiasy klamrowe},
+        // gdyż łatwiej dokonać późniejszych zmian, np. dodać kolejną linię itp...
+
+        /* Za instrukcją strukturalną (if, while, for...) w praktyce nigdy nie stawia się średnika
+        if(x == y); {
+            System.out.println("Obie liczby są równe!");
+        }
+           Powyższy kod zawsze wyświetliłby podany napis, bo struktiura jest taka:
+           "jeśli x == y, nie rób nic; a później ZAWSZE wypisuj ten tekst"
+        */
+
+        // Można użyć samego if, bez else:
+
+        if(x + y >= 100) {
+            System.out.println("suma x i y jest trzycyfrowa");
+        }
+
+        // ify (i inne instrukcje blokowe) można zagnieżdżać. Tutaj tym bardziej zalecamy pisanie nawiasów {}
+
+        if(x % 2 == 0) {
+            if(y % 2 == 0) {
+                System.out.println("obie liczby są parzyste");
+            } else {
+                System.out.println("x parzysty, y nieparzysty");
+            }
+        } else {
+            if(y % 2 == 0) {
+                System.out.println("x nieparzysty, y parzysty");
+            } else {
+                System.out.println("obie liczby nieparzyste");
+            }
+        }
+        System.out.println();
+
+        // Jeśli rozpatrywanych sytuacji jest więcej niż 2, to typowym sposobem zapisu jest ciąg
+        // if - else if - ... - else
+        if(x > y) {
+            System.out.println("x > y");
+        } else if(x < y) {
+            System.out.println("x < y");
+        } else {
+            System.out.println("x = y");
+        }
+
+        // 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");
+        //  }
+
+        // Warunkiem najczęściej jest porównanie, ale może też być wywołanie metody typu boolean
+        String str = "Ala ma kota";
+        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/main/java/pcz/p03_instrukcje/b_petle/A_RodzajePetli.java

+package pcz.p03_instrukcje.b_petle;
+
+public class A_RodzajePetli {
+
+    public static void petlaWhile() {
+        int i = 1;
+        while(i <= 5) {
+            System.out.println("w pętli: " + i);
+            i++;
+        }
+        System.out.println("za pętlą: " + i);
+    }
+
+    public static void doWhile() {
+        int i = 1;
+        do {
+            System.out.println("w pętli: " + i);
+            i++;
+        } while(i <= 5);
+        System.out.println("za pętlą: " + i);
+    }
+
+    // ominięte w main
+    public static void petlaFor() {
+        for(int i = 1; i <= 5; i++) {
+            System.out.println("w pętli " + i);
+        }
+
+        // NK System.out.println("za pętlą: " + i);
+        int i; // OK
+    }
+
+    public static void petlaFor2() {
+        int i;
+
+        for(i = 1; i <= 5; i++) {
+            System.out.println("w pętli " + i);
+        }
+
+        System.out.println("za pętlą: " + i); // 6
+        // NK int i;
+    }
+
+    // ominięte w main
+    public static void petlaFor3() {
+        // int i;
+
+        for(int i = 1, j = 10; i <= 5 && j < 3; i++, j = i / 10, System.out.println("z pętli " + j)) {
+            System.out.println("w pętli " + i);
+        }
+
+        // System.out.println("za pętlą: " + i);
+    }
+
+    // ominięte w main
+    // w for moga byc dowolne instrukcje
+    public static void petlaFor4(org.w3c.dom.Node node) {
+        for(org.w3c.dom.Node child = node.getFirstChild(); child != null; child = child.getNextSibling()) {
+            System.out.println(child.getTextContent());
+        }
+    }
+
+    public static void losowanie() {
+        for(;;) {
+            double x = Math.random();
+            System.out.println("Wylosowałem " + x);
+            if(x > 0.8)
+                break;
+        }
+        System.out.println("za pętlą");
+    }
+
+    public static void forEach() {
+        String[] imiona = { "Ala", "Ola", "Ela", "Ula" };
+
+        // pozwala przeglądać zawartość tablicy, albo obiekty, które są Iterable 
+        // tzw. "for-each" albo "enhanced for loop", od Javy 5
+        for(String imie: imiona) {
+            System.out.println("Kolejna osoba to " + imie);
+        }
+
+        // Od Javy 10 można tak:
+        //		for(var imie : imiona) {
+        //			System.out.println("Kolejna osoba to " + imie);
+        //		}
+    }
+
+    public static void forEachEgzamin() {
+        // typowa zmyłka z egzaminu
+        int[] t = { 1, 2, 3 };
+        for(int i: t) {
+            // i oznacza WARTOŚĆ z tablicy, a nie indeks
+            // więc tu dojdzie do wyjścia poza zakres tablicy
+            System.out.println(t[i]);
+        }
+    }
+
+    public static void przerwanie() {
+        for(int i = 1; i <= 10; i++) {
+            System.out.println("i = " + i);
+            if(i % 2 == 1) {
+                System.out.println("  nieparzysta, continue");
+                continue;
+            }
+            System.out.println("  nie było continue");
+            if(i % 3 == 0) {
+                System.out.println("  podzielna przed 3, break");
+                break;
+            }
+            System.out.println("  nie było break");
+        }
+        System.out.println("za pętlą");
+    }
+
+    public static int etykiety() {
+        int suma = 0;
+        duza: while(true) {
+            for(int i = 1; i < 10; i++) {
+                suma += i;
+                if(suma > 100)
+                    break duza;
+            }
+        }
+        return suma;
+    }
+
+    public static void main(String[] args) {
+        etykieta: // kompiluje się, ale nie ma jak tego użyć
+        System.out.println("while");
+        petlaWhile();
+
+        //NK goto etykieta;
+
+        System.out.println("\ndo-while");
+        doWhile();
+
+        System.out.println("\nfor");
+        petlaFor2();
+
+        System.out.println("\nLosowanie:");
+        losowanie();
+
+        System.out.println("\nfor-each");
+        forEach();
+
+        System.out.println();
+        przerwanie();
+
+        System.out.println();
+
+        int x = etykiety();
+        System.out.println(x);
+    }
+}

src/main/java/pcz/p03_instrukcje/b_petle/BreakContinue_Prezentacja.java

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

src/main/java/pcz/p03_instrukcje/b_petle/DziwnyWhile.java

+package pcz.p03_instrukcje.b_petle;
+
+public class DziwnyWhile {
+
+    public static void main(String[] args) {
+
+        int x = 1;
+        {
+            System.out.println("Ala ma kota " + x);
+            x++;
+        }
+        while(x <= 10)
+            ;
+        // To jest zwykły blok a potem pętla nieskończona
+
+        System.out.println("Koniec");
+    }
+
+}

src/main/java/pcz/p03_instrukcje/b_petle/Label.java

+package pcz.p03_instrukcje.b_petle;
+
+public class Label {
+    public static void main(String[] args) {
+        label1: System.out.println("Cokolwiek");
+        label2: while(true) {
+            double x = Math.random();
+            if(x > 0.5)
+                break label2;
+        }
+
+        // goto label1;
+        // const int n = 10;
+    }
+}

src/main/java/pcz/p03_instrukcje/b_petle/MartwyKod.java

+package pcz.p03_instrukcje.b_petle;
+
+public class MartwyKod {
+
+    void metoda1() {
+        System.out.println("OK");
+        return;
+        //		System.out.println("błąd");
+        //		System.out.println("kolejna linia");
+    }
+
+    void metoda2() throws Exception {
+        System.out.println("OK");
+        throw new Exception("katastrofa");
+        //		System.out.println("błąd");
+
+    }
+
+    public static void main(String[] args) {
+        // if(true) / if(false) NIE są traktowane jako martwy kod
+        if(false) {
+            System.out.println("Ala ma kota");
+        }
+
+        if(true) {
+            System.out.println("AAAA");
+        } else {
+            System.out.println("BBBB");
+        }
+
+        //		while(false) {
+        //			System.out.println("błąd");
+        //		}
+
+        while(true) {
+            System.out.println("lkdfjg");
+        }
+
+        //		System.out.println("błąd");
+    }
+}

src/main/java/pcz/p03_instrukcje/b_petle/PetlaNieskonczona.java

+package pcz.p03_instrukcje.b_petle;
+
+import java.time.LocalTime;
+
+public class PetlaNieskonczona {
+
+    public static void main(String[] args) {
+        int licznik = 0;
+
+        while(true) {
+            System.out.printf("%12d : %s%n", ++licznik, LocalTime.now());
+        }
+
+        // Kod w tym miejscu jest niepoprawny (Java go nie skompiluje), bo to jest "martwy kod".
+        // System.out.println("Koniec świata");
+    }
+
+}

src/main/java/pcz/p03_instrukcje/b_petle/Przerwania.java

+package pcz.p03_instrukcje.b_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);
+    }
+}

src/main/java/pcz/p03_instrukcje/c_switch/Switch1.java

+package pcz.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class Switch1 {
+
+    public static void main(String[] args) {
+        String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
+        int numer = Integer.parseInt(tekst);
+
+        switch(numer) {
+        case 1:
+            System.out.println("poniedziałek");
+        case 2:
+            System.out.println("wtorek");
+        case 3:
+            System.out.println("środa");
+        case 4:
+            System.out.println("czwartek");
+        case 5:
+            System.out.println("piątek");
+            System.out.println("czyli weekendu początek");
+        case 6:
+            System.out.println("sobota");
+        case 7:
+            System.out.println("niedziela");
+        default:
+            System.out.println("niepoprawny numer dnia tygodnia");
+        }
+
+        System.out.println("Koniec programu");
+    }
+
+}

src/main/java/pcz/p03_instrukcje/c_switch/Switch2.java

+package pcz.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class Switch2 {
+
+    public static void main(String[] args) {
+        String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
+        int numer = Integer.parseInt(tekst);
+
+        switch(numer) {
+        case 1:
+            System.out.println("poniedziałek");
+            break;
+        case 2:
+            System.out.println("wtorek");
+            break;
+        case 3:
+            System.out.println("środa");
+            break;
+        case 4:
+            System.out.println("czwartek");
+            break;
+        case 5:
+            System.out.println("piątek");
+            System.out.println("czyli weekendu początek");
+            break;
+        case 6:
+            System.out.println("sobota");
+            break;
+        case 7:
+            System.out.println("niedziela");
+            break;
+        default:
+            System.out.println("niepoprawny numer dnia tygodnia");
+        }
+
+        System.out.println("Koniec programu");
+    }
+
+}

src/main/java/pcz/p03_instrukcje/c_switch/Switch3.java

+package pcz.p03_instrukcje.c_switch;
+
+import java.util.Random;
+
+import javax.swing.JOptionPane;
+
+public class Switch3 {
+
+    public static void main(String[] args) {
+        String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
+        int numer = Integer.parseInt(tekst);
+
+        final int SOBOTA = 6; // stała
+        // final int SOBOTA = new Random().nextInt(10);
+
+        switch(numer) {
+        case 3:
+            System.out.println("środa");
+            break;
+        case 1:
+            System.out.println("poniedziałek");
+            break;
+        case 2:
+            System.out.println("wtorek");
+            break;
+        default:
+            System.out.println("niepoprawny numer dnia tygodnia");
+            break;
+        case 4:
+            System.out.println("czwartek");
+            break;
+        case 2 + 3:
+            System.out.println("piątek");
+            break;
+        case SOBOTA:
+            System.out.println("sobota");
+            // tu nie ma break i wypisze się sobota niedziela
+        case 7:
+            System.out.println("niedziela");
+        }
+
+        System.out.println("Koniec programu");
+    }
+
+}

src/main/java/pcz/p03_instrukcje/c_switch/Switch4.java

+package pcz.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class Switch4 {
+
+    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 dnia tygodnia");
+        }
+    }
+
+    public static void main(String[] args) {
+        String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
+
+        try {
+            int numer = Integer.parseInt(tekst);
+            String nazwa = nazwaDniaTygodnia(numer);
+            System.out.println("Ten dzień to " + nazwa);
+        } catch(Exception wylapanyWyjatek) {
+            System.out.println("Wystąpił wyjątek " + wylapanyWyjatek);
+        }
+
+        System.out.println("Koniec programu");
+    }
+
+}

src/main/java/pcz/p03_instrukcje/c_switch/Switch5.java

+package pcz.p03_instrukcje.c_switch;
+
+public class Switch5 {
+
+    static int ileDniMaMiesiac(String nazwa) {
+        switch(nazwa) {
+        case "styczeń":
+        case "marzec":
+        case "maj":
+        case "lipiec":
+        case "sierpień":
+        case "październik":
+        case "grudzień":
+            return 31;
+
+        case "kwiecień":
+        case "czerwiec":
+        case "wrzesień":
+        case "listopad":
+            return 30;
+
+        case "luty":
+            return 28;
+
+        //		case null się nie skompiluje
+        //		case null:
+        //			return 0;
+
+        default:
+            return 0;
+        }
+    }
+
+    public static void main(String[] args) {
+        System.out.println(ileDniMaMiesiac("styczeń"));
+        System.out.println(ileDniMaMiesiac("luty"));
+        System.out.println(ileDniMaMiesiac("listopad"));
+        System.out.println();
+
+        // takie bajery nie działają:
+        System.out.println(ileDniMaMiesiac("Lipiec"));
+        System.out.println(ileDniMaMiesiac(" lipiec "));
+        System.out.println(ileDniMaMiesiac("*ec"));
+        System.out.println(ileDniMaMiesiac("%ec"));
+
+        System.out.println(ileDniMaMiesiac(""));
+        System.out.println(ileDniMaMiesiac(null)); // NPE
+
+    }
+
+}

src/main/java/pcz/p03_instrukcje/c_switch/Switch6.java

+package pcz.p03_instrukcje.c_switch;
+
+public class Switch6 {
+
+    public static void main(String[] args) {
+        byte bb = 100;
+        // Wartości podawane w case muszą być zgodne z typem parametru switch-a.
+        // W przypadku liczb oznacza to także, że liczba musi mieścić się w zakresie,
+        switch(bb) {
+        case 100:
+            System.out.println("100");
+            break;
+        //NK case 200: System.out.println("200"); break;
+        }
+
+        short ss = 100;
+        switch(ss) {
+        case 100:
+            System.out.println("100");
+            break;
+        case 200:
+            System.out.println("200");
+            break;
+        case 4000:
+            System.out.println("4000");
+            break;
+        //NK case 33000: System.out.println("100"); break;
+        }
+
+        char cc = 'A';
+        switch(cc) {
+        case 'A':
+            System.out.println("AAA");
+            break;
+        case 120:
+            System.out.println("BBB");
+            break;
+        //		case 10 : System.out.println("10"); break;
+        case 0xA:
+            System.out.println("0xA");
+            break;
+        //NK case 65 : System.out.println("CCC"); break;
+        //NK case -1 : System.out.println("DDD"); break;
+        case 64000:
+            System.out.println("EEE");
+            break;
+        //NK case 66000: System.out.println("FFF"); break;
+        }
+
+        /*
+        long l = 27L;
+        // nie ma switch na typach long, float, double
+        switch(l) {
+        case 27L : System.out.println("long 27");
+        }
+        */
+
+    }
+}

src/main/java/pcz/p03_instrukcje/c_switch/Switch8.java

+package pcz.p03_instrukcje.c_switch;
+
+public class Switch8 {
+
+    public static void main(String[] args) {
+        int x = 2;
+
+        switch(x) {
+        // to jest po prostu operacja arytmetyczna (dokładnie "suma bitowa")
+        // nie ma to żadnego szczególnego znaczenia dla switch-a
+        // w tym konkretnym miejscu to wylicza się do wartości 3
+        case 2 | 3:
+            System.out.println("2 | 3");
+            break;
+        //NK		case 3:
+        //			System.out.println("3");
+        case 2: // bo to nie jest naruszenie unikalności
+            System.out.println("2");
+            break;
+        default:
+            System.out.println("default");
+        }
+
+    }
+
+}

src/main/java/pcz/p03_instrukcje/c_switch/SwitchNull_Pusty.java

+package pcz.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class SwitchNull_Pusty {
+
+    public static void main(String[] args) {
+        String s = JOptionPane.showInputDialog("Wpisz napis");
+        System.out.println("Jestem przed switchem, napis = " + s);
+        switch(s) {}
+
+        System.out.println("Jestem za switchem");
+        // morał: przekazanie wartości null do switcha (na napisach lub na enumach)
+        // skutkuje wyjątkiem NPE
+
+    }
+
+}

src/main/java/pcz/p03_instrukcje/c_switch/SwitchString_Interaktywnie.java

+package pcz.p03_instrukcje.c_switch;
+
+import javax.swing.JOptionPane;
+
+public class SwitchString_Interaktywnie {
+
+    public static void main(String[] args) {
+        String s = JOptionPane.showInputDialog("Wpisz napis");
+        System.out.println("Jestem przed switchem, napis = " + s);
+
+        // Wielkość liter, spacje itp.: mają znaczenie.
+        // Nie są przeprowadzane żadne "normalizacje".
+        // Nie działają żadne "wildcardy" typu * % itp.
+
+        // Jeśli do switch przekażemy wartość null dojdzie d wyjątku NullPointerException
+        switch(s) {
+        case "Ala":
+            System.out.println("Ala ma kota");
+            break;
+        case "Ola":
+            System.out.println("Ola ma psa");
+            break;
+        //NK case null: System.out.println("NULL");
+        default:
+            System.out.println("Nieznana osoba");
+        }
+    }
+
+}

src/main/java/pcz/p04_operatory/Bitowe1.java

+package pcz.p04_operatory;
+
+public class Bitowe1 {
+
+    public static void main(String[] args) {
+        byte x = 25;
+        byte y = -25;
+        byte shift = 2;
+
+        System.out.printf("x = %d  y = %d %n", x, y);
+        System.out.println("Bez przycinania (w zakresie int):");
+        System.out.printf("x << %d = %d %n", shift, x << shift);
+        System.out.printf("y << %d = %d %n", shift, y << shift);
+        System.out.printf("x >> %d = %d %n", shift, x >> shift);
+        System.out.printf("y >> %d = %d %n", shift, y >> shift);
+        System.out.printf("x >>> %d = %d %n", shift, x >>> shift);
+        System.out.printf("y >>> %d = %d %n", shift, y >>> shift);
+        System.out.println();
+        System.out.println("Przycięte do byte: ");
+        System.out.printf("x << %d = %d %n", shift, (byte)(x << shift));
+        System.out.printf("y << %d = %d %n", shift, (byte)(y << shift));
+        System.out.printf("x >> %d = %d %n", shift, (byte)(x >> shift));
+        System.out.printf("y >> %d = %d %n", shift, (byte)(y >> shift));
+        System.out.printf("x >>> %d = %d %n", shift, (byte)(x >>> shift));
+        System.out.printf("y >>> %d = %d %n", shift, (byte)(y >>> shift));
+
+    }
+
+}

src/main/java/pcz/p04_operatory/Bitowe2.java

+package pcz.p04_operatory;
+
+public class Bitowe2 {
+
+    public static void main(String[] args) {
+        int x = 0b00000000000000000000000000011001;
+        int y = -x;
+        int z = 0b11111111111111111111111111100111;
+        System.out.println(x);
+        System.out.println(y);
+        System.out.println(z);
+        System.out.println();
+
+        System.out.println("<<");
+        System.out.println(x << 2);
+        System.out.println(y << 2);
+        System.out.println(z << 2);
+        System.out.println(0b11111111111111111111111110011100); // -100
+        System.out.println();
+
+        System.out.println(">>");
+        System.out.println(x >> 2);
+        System.out.println(y >> 2);
+        System.out.println(0b11111111111111111111111111111001);
+        System.out.println();
+
+        System.out.println(">>>");
+        System.out.println(x >>> 2);
+        System.out.println(y >>> 2);
+        System.out.println(0b00111111111111111111111111111001);
+        System.out.println();
+    }
+
+}

src/main/java/pcz/p04_operatory/Leniwosc1.java

+package pcz.p04_operatory;
+
+public class Leniwosc1 {
+    public static void gorliwa() {
+        // opertor "gorliwy"
+        // zawsze oblicza obie strony wyrażenia logicznego, a dopiero potem daje wynik false / true
+        if(lewy() & prawy()) {
+            System.out.println("prawda");
+        } else {
+            System.out.println("fałsz");
+        }
+    }
+
+    public static void leniwa() {
+        // operator "leniwy"
+        // jeśli lewa strona rozstrzyga o ostatecznym wyniku, to prawa strona nie jest sprawdzana
+        if(lewy() && prawy()) {
+            System.out.println("prawda");
+        } else {
+            System.out.println("fałsz");
+        }
+    }
+
+    private static boolean lewy() {
+        System.out.print("lewy ");
+        return false;
+    }
+
+    private static boolean prawy() {
+        System.out.print("prawy ");
+        return true;
+    }
+
+    public static void main(String[] args) {
+        System.out.println("wersja gorliwa");
+        gorliwa();
+
+        System.out.println("\nwersja leniwa:");
+        leniwa();
+    }
+}

src/main/java/pcz/p04_operatory/Leniwosc2.java

+package pcz.p04_operatory;
+
+public class Leniwosc2 {
+    public static void main(String[] args) {
+        int x = 0, y = 0;
+
+        if(++x > 0 | y++ > 0) {
+            System.out.println("prawda");
+        } else {
+            System.out.println("fałsz");
+        }
+        System.out.println("x == " + x);
+        System.out.println("y == " + y);
+        System.out.println();
+
+        x = y = 0;
+        if(++x > 0 || y++ > 0) {
+            System.out.println("prawda");
+        } else {
+            System.out.println("fałsz");
+        }
+        System.out.println("x == " + x);
+        System.out.println("y == " + y);
+        System.out.println();
+
+        x = y = 0;
+        if(x++ > 0 || ++y > 0) {
+            System.out.println("prawda");
+        } else {
+            System.out.println("fałsz");
+        }
+        System.out.println("x == " + x);
+        System.out.println("y == " + y);
+
+    }
+
+}

src/main/java/pcz/p04_operatory/Leniwosc3.java

+package pcz.p04_operatory;
+
+public class Leniwosc3 {
+    public static void main(String[] args) {
+        int x = 0, y = 0;
+
+        if(x++ > 0 || y++ > 0) {
+            System.out.println("prawda");
+        } else {
+            System.out.println("fałsz");
+        }
+        System.out.println("x == " + x);
+        System.out.println("y == " + y);
+        System.out.println();
+
+        x = y = 0;
+        if(++x > 0 || ++y > 0) {
+            System.out.println("prawda");
+        } else {
+            System.out.println("fałsz");
+        }
+        System.out.println("x == " + x);
+        System.out.println("y == " + y);
+
+    }
+
+}

src/main/java/pcz/p04_operatory/Leniwosc4.java

+package pcz.p04_operatory;
+
+public class Leniwosc4 {
+    public static void main(String[] args) {
+        // z prawdopodobieństwem 0.33 na imie wpisz nulla
+        // z prawdopodobieństwem 0.33 na imie wpisz "Ala"
+        // z prawdopodobieństwem 0.34 na imie wpisz "Tadeusz"
+        double los = Math.random();
+        String imie;
+        if(los < 0.33) {
+            imie = null;
+        } else if(los < 0.66) {
+            imie = "Ala";
+        } else {
+            imie = "Tadeusz";
+        }
+
+        System.out.println("imie = " + imie);
+
+        //		if(imie != null & imie.length() >= 5) {
+        //			System.out.println("długie imię");
+        //		} else {
+        //			System.out.println("null albo krótkie imię");
+        //		}
+
+        // jeśli imie będzie null, to w ogóle nie przejdziemy do drugiej części sprawdzenia
+        if(imie != null && imie.length() >= 5) {
+            System.out.println("długie imię");
+        } else {
+            System.out.println("null albo krótkie imię");
+        }
+
+        if(imie == null || imie.isEmpty()) {
+            System.out.println("Brak danych");
+        }
+
+        if(args.length >= 1 && "Ala".equalsIgnoreCase(args[0])) {
+            System.out.println("Ala ma kota");
+        }
+    }
+
+}

src/main/java/pcz/p04_operatory/Logiczne.java

+package pcz.p04_operatory;
+
+import java.util.Random;
+
+public class Logiczne {
+
+    public static void main(String[] args) {
+        Random random = new Random();
+        int x = random.nextInt(1000);
+        int y = random.nextInt(1000);
+        System.out.println("Wylosowane liczby: " + x + " , " + y);
+
+        // koniunkcja, logiczne "i"
+        // alternatywa, logiczne "lub"
+        if(x > 500 && y > 500) {
+            System.out.println("Obie liczby > 500");
+        } else {
+            System.out.println("Któraś z liczb <= 500");
+        }
+
+        if(x > 500 || y > 500) {
+            System.out.println("Co najmniej jedna z liczb > 500");
+        } else {
+            System.out.println("Obie liczby <= 500");
+        }
+
+        // alternatywa rozłączna, "albo", technicznie "xor" (exclusive or)
+        if((x > 500) ^ (y > 500)) {
+            System.out.println("Dokładnie jedna z liczb > 500");
+        } else {
+            System.out.println("Obie liczby są > 500 albo obie liczby są <= 500");
+        }
+
+        // ! negacja
+        if(!(x % 3 == 0)) {
+            System.out.println("Nieprawda, że liczba jest podzielna przez 3");
+        }
+
+    }
+
+}

src/main/java/pcz/p04_operatory/OperatorWarunkowy1.java

+package pcz.p04_operatory;
+
+public class OperatorWarunkowy1 {
+
+    public static void main(String[] args) {
+        int x = 10;
+
+        String s;
+        s = x > 10 ? "A" : "B";
+        System.out.println(s);
+
+        // różwnoważne:
+        if(x > 10) {
+            s = "A";
+        } else {
+            s = "B";
+        }
+
+        s = x > 10 ? "A" : x > 5 ? "B" : "C";
+        System.out.println(s);
+        s = x > 10 ? "A" : (x > 5 ? "B" : "C");
+        System.out.println(s);
+
+        s = x > 8 ? x < 20 ? "A" : "B" : " C";
+        System.out.println(s);
+
+        s = x > 8 ? (x < 20 ? "A" : "B") : " C";
+        System.out.println(s);
+
+        s = x > 8 ? x < 20 ? "A" : "B" : x % 2 == 0 ? "C" : " D";
+        System.out.println(s);
+        s = x > 8 ? (x < 20 ? "A" : "B") : (x % 2 == 0 ? "C" : " D");
+    }
+}

src/main/java/pcz/p04_operatory/OperatorWarunkowy2.java

+package pcz.p04_operatory;
+
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class OperatorWarunkowy2 {
+
+    public static void main(String[] args) {
+        int[] liczby = { 100, 10, 20, 150, 7, 120 };
+        String wynik = IntStream.of(liczby)
+                .mapToObj(a -> a >= 100 ? "duże" : "małe")
+                .collect(Collectors.joining("; "));
+        System.out.println(wynik);
+    }
+}

src/main/java/pcz/p04_operatory/OperatorWarunkowy3.java

+package pcz.p04_operatory;
+
+public class OperatorWarunkowy3 {
+
+    public static void main(String[] args) {
+        // ilustracja zastosowań:
+        String s = Math.random() > 0.5 ? "ala" : null;
+
+        if(s != null && s.length() > 2) {
+            System.out.println("ok");
+        } else {
+            System.out.println("puste");
+        }
+
+    }
+
+}

src/main/java/pcz/p04_operatory/PlusPlus.java

+package pcz.p04_operatory;
+
+public class PlusPlus {
+
+    public static void main(String[] args) {
+        int x;
+        int y;
+
+        x = 10;
+        y = ++x;
+        System.out.println("++x    preinkrementacja");
+        System.out.println("x: " + x + "    ,    y: " + y);
+        System.out.println();
+
+        x = 20;
+        y = x++;
+        System.out.println("x++    postinkrementacja");
+        System.out.println("x: " + x + "    ,    y: " + y);
+        System.out.println();
+
+        x = 50;
+        System.out.println(x++);
+        System.out.println(++x);
+        System.out.println();
+
+        Integer a = 100;
+        a++;
+        System.out.println(a); // a wskazuje już na inny obiekt
+        System.out.println();
+
+        double d = 0.5;
+        System.out.println(d);
+        d++; // można inkrementować też float i double
+        System.out.println(d);
+        System.out.println();
+
+        y = x = 100;
+        System.out.println("x: " + x + "    ,    y: " + y);
+
+        y = 33;
+        y = x += 5; // x zwiększam o 5, a to co wyjdzie, wpisuję także na y
+        System.out.println(" += 5");
+        System.out.println("x: " + x + "    ,    y: " + y);
+    }
+
+}

src/main/java/pcz/p04_operatory/PlusPlusZagadki.java

+package pcz.p04_operatory;
+
+public class PlusPlusZagadki {
+
+    public static void main(String[] args) {
+        int x, y, z;
+
+        x = 1;
+        x = x++ + ++x; // 1 + 3
+        System.out.println(x);
+
+        x = 1;
+        x = ++x + x++; // 2 + 2
+        System.out.println(x);
+
+        y = 1;
+        y += y++;
+        // y = (y + y++)
+        // y = 1 + 1
+        System.out.println(y);
+
+        z = 1;
+        z += z++ + ++z;
+        // z = z + z++ + ++z
+        // z = 1 + 1 + 3 = 5
+        System.out.println(z);
+    }
+}

src/main/java/pcz/p04_operatory/PlusPlusZastosowania.java

+package pcz.p04_operatory;
+
+public class PlusPlusZastosowania {
+
+    static int suma(int[] t) {
+        int suma = 0;
+        int i = 0;
+        while(i < t.length) {
+            suma += t[i++];
+        }
+        return suma;
+    }
+
+    public static void main(String[] args) {
+        int[] a = { 10, 20, 30, 40 };
+        System.out.println(suma(a));
+
+    }
+}

src/main/java/pcz/p04_operatory/Przypisania.java

+package pcz.p04_operatory;
+
+public class Przypisania {
+
+    public static void main(String[] args) {
+        int x, y, z;
+
+        z = y = x = 10;
+        System.out.printf("x=%d, y=%d, z=%d%n", x, y, z);
+
+        x = 10;
+        y = 50;
+        z = 100;
+        z += y = x += 3;
+        System.out.printf("x=%d, y=%d, z=%d%n", x, y, z);
+    }
+
+}

src/main/java/pcz/p04_operatory/ZastosowaniaLeniwychOperatorow.java

+package pcz.p04_operatory;
+
+import javax.swing.JOptionPane;
+
+public class ZastosowaniaLeniwychOperatorow {
+
+    public static void main(String[] args) {
+        String imie = JOptionPane.showInputDialog("Jak masz na imię?");
+
+        if(imie != null && imie.length() <= 3) {
+            JOptionPane.showMessageDialog(null, "Masz krótkie imię");
+        }
+
+        // Gdybym nie sprawdzał czy napis nie jest nullem,
+        // to w przypadku Cancel dochodziłoby do błedu NullPointerException (NPE)
+        // w momencie próby wywołania length()
+        //		if (imie.length() <= 3) {
+        //			JOptionPane.showMessageDialog(null, "Masz krótkie imię");
+        //		}
+
+        // Gdybym zamiast "leniwego" && użył "gorliwego" &
+        // to także doszłoby do błędu, bo Java sprawdzałaby prawą stronę warunku nawet wtedy gdy lewa jest fałszem
+        //		if(imie != null & imie.length() <= 3) {
+        //			JOptionPane.showMessageDialog(null, "Masz krótkie imię");
+        //		}
+
+        String jezyk = JOptionPane.showInputDialog("Jaki jest Twój ulubiony język programowania?");
+
+        if(jezyk != null && jezyk.equals("Java")) {
+            JOptionPane.showMessageDialog(null, "Brawo");
+        } else {
+            JOptionPane.showMessageDialog(null, "Źle");
+        }
+
+        // jeśli chodzi o tę konkretną sytuację, to pisząc w tej kolejności zapobiegamy wyjątkowi NPE
+        if("Java".equals(jezyk)) {
+            JOptionPane.showMessageDialog(null, "Brawo");
+        } else {
+            JOptionPane.showMessageDialog(null, "Źle");
+        }
+    }
+
+}

src/main/java/pcz/p05_liczby/BityIBajty.java

+package pcz.p05_liczby;
+
+public class BityIBajty {
+
+    /* Program wypisuje wartość zmiennej typu byte oraz jej zapis w pamięci w postaci ciągu 8 bitów, zwiększając w pętli wartość o 1.
+     * Widać zjawisko integer overflow: wartość +127 przechodzi w wartość -128.
+     * Dla zmiennych typu short, int, long jest analogicznie; różnica jest w długości ciągu bitów (16, 32 i 64) i zakresie liczb.
+     */
+    public static void main(String[] args) {
+        System.out.println("Zwiększanie bajta:");
+        byte b = 0;
+        for(int i = 0; i <= 512; i++) {
+            String bity = Integer.toBinaryString(Byte.toUnsignedInt(b));
+            bity = String.format("%8s", bity);
+            bity = bity.replace(' ', '0');
+            System.out.printf("%4d  :  %s%n", b, bity);
+            b++;
+        }
+    }
+}

src/main/java/pcz/p05_liczby/Ciekawostki.java

+package pcz.p05_liczby;
+
+public class Ciekawostki {
+
+    public static void main(String[] args) {
+        int x = 5, y = 1000000000;
+        int z = x * y;
+        System.out.println(z);
+        System.out.println(5 * 1000000000);
+        System.out.println(5L * 1000000000);
+        System.out.println(3 * 1000000000);
+
+        // Gdy wynik obliczenia nie mieści się w zakresie dla danego typu (int lub long)
+        // dochodzi do "integer overflow". W Javie nie powoduje to błędu (w sensie wyjątku),
+        // po prostu wychodzi "przekręcony" wynik.
+
+        System.out.println();
+
+        double a = 3.0, b = 1.2;
+        System.out.println(a * b);
+        System.out.println(3 * 1.2);
+
+        double oczekiwany = 3.6;
+        if(a * b == oczekiwany) {
+            System.out.println("OK");
+        } else {
+            System.out.println("Nie OK");
+            System.out.println("różnica: " + (oczekiwany - a * b));
+        }
+
+        System.out.println();
+        // Liczby zmiennoprzecinkowe (w Javie: float i double) działają w przybliżeniu.
+        // W pamięci są zapisany w systemie dwójkowym, a nie dziesiętnym, więc zaokrąglenia nastepują w zapisie binarnym liczby, co utrudnia zrozumienie.
+
+        // Praktyczny morał: double nie używa się do liczenia pieniędzy.
+        // Lepszą alternatywą jest wyspecjalizowana klasa BigDecimal.
+
+        // Liczba całkowita zapisana w kodzie zaczynając od cyfry 0, jest w systemie ósemkowym.
+        int n = 0321; // = 3*64 + 2*8 + 1*1
+        System.out.println(n);
+        System.out.println(0321);
+        //NK int m = 098;
+
+        System.out.println();
+
+        // Od Javy 7 między cyframi można wpisywać znaki _ , które nie zmieniają wartości
+        int i = 123_456_789;
+        System.out.println(i);
+
+        int j = 123____4___5;
+        System.out.println(j);
+    }
+
+}

src/main/java/pcz/p05_liczby/Dzielenie.java

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

src/main/java/pcz/p05_liczby/Floaty.java

+package pcz.p05_liczby;
+
+public class Floaty {
+
+    public static void main(String[] args) {
+        float f = 1.0000001f;
+
+        System.out.println(f);
+        f += 1;
+        System.out.println(f);
+        f -= 1;
+        System.out.println(f);
+        System.out.println();
+
+        // Zaokroglęnia nie są robione w systemie dziesiętnym, tylko dwójkowym
+        f = 1.0000003f;
+        System.out.println(f);
+        f += 1;
+        System.out.println(f);
+        f -= 1;
+        System.out.println(f);
+
+        System.out.println();
+        f = 2222222222f;
+        // System.out.println(f);
+        System.out.printf("%8.0f\n", f);
+        f += 1000;
+        System.out.printf("%8.0f\n", f);
+        f -= 10000000;
+        System.out.printf("%8.0f\n", f);
+
+        // lepsze dla pieniędzy: BigDecimal
+    }
+}

src/main/java/pcz/p05_liczby/IntegerOverflow.java

+package pcz.p05_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/main/java/pcz/p05_liczby/JakSprawdzicOverflow.java

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

src/main/java/pcz/p05_liczby/LiteralyLiczbowe.java

+package pcz.p05_liczby;
+
+public class LiteralyLiczbowe {
+
+    public static void main(String[] args) {
+        int x;
+
+        x = 123; // format dziesiętny
+        System.out.println(x);
+
+        x = 0123; // system ósemkowy
+        //NK x = 08;  // cyfry od 0 do 7
+        System.out.println(x);
+
+        x = 0x100; // system szesnastkowy
+        System.out.println(x);
+        x = 0x7F;
+        System.out.println(x);
+
+        // system dwójkowy - od Javy 7
+        x = 0b1101;
+        System.out.println(x);
+
+        // odstępy pomiędzy cyframi - od Javy 7
+        x = 2_000_000;
+        System.out.println(x);
+
+        //NK long l = 4000000000; // wartość nie mieszcząca się w int
+        long l = 4000000000L; // OK
+
+        // int _1000 = 1313;
+
+        // x = _1000;  // odwołanie do zmiennej :)
+        // x = 1000_;
+        x = 10______00; // po prostu tysiąc
+
+        // dopuszczalne są tylko pomiędzy cyframi.
+        // nie na początku, nie na końcu, nie obok kropki ani obok litery typu i wykładnika
+
+        x = 0x0F_FF_80_00;
+        x = 0b0011_0101;
+
+        System.out.println(x); // 1000
+
+        double dd = 10__00;
+        dd = 3.14; // literał liczbowy z częścią ułamkową jest typu double (a nie float)
+        dd = 1_00.0__0;
+        //dd = 100._9;
+        //dd = 100_.9;
+
+        dd = 100.99d;
+        //dd = 100.99_f;
+
+        // x = 0x_FF;
+
+        // NK x = 1L; // L na końcu oznacza typ long (może być duże lub małe)
+
+        l = 1L;
+        l = 1; // inta można wpisać na zmienną long
+
+        System.out.println();
+
+        float f = 12; // int na float - OK
+        // f = 3.14;
+        // literał z ułamkiem jest typu double, a double nie można wpisać na float
+        f = 3.14F;
+        f = 1.0f;
+        f = 3f;
+        f = 1.13e2F;
+        f = (float)3.14; // kompiluje się, ale niezalecane, bo można zgubić precyzję
+        System.out.println(f);
+
+        double d = 3.14;
+        // NK f = d;
+        // na końcu double'a też można podać info o typie: D  albo d
+        d = 4.44d;
+        d = 4.445D;
+
+        // liczba w notacji dziesiętnej razy 10 do podanej potęgi
+        d = 1.25e3;
+        System.out.println(d);
+        d = 4.44e-3;
+        System.out.println(d);
+        System.out.println();
+
+        // liczba w notacji szestastkowej razy 2 do podanej potęgi - tak to jest przechowywane wewnętrznie!
+        d = 0x3p2; // 12
+        System.out.println(d);
+        d = 0x0.2p0; // 2/16 = 1/8 = 0.125 
+        System.out.println(d);
+        d = 0x1p-3;
+        System.out.println(d);
+    }
+}

src/main/java/pcz/p05_liczby/PomylonyDouble.java

+package pcz.p05_liczby;
+
+public class PomylonyDouble {
+    public static void zaszachraj(int n, double arg) {
+        System.out.println("mnożenie : " + n * arg);
+
+        double suma = 0.0;
+        for(int i = 1; i <= n; i++) {
+            suma += arg;
+        }
+        System.out.println("dodawanie: " + suma);
+        System.out.println();
+    }
+
+    public static void main(String[] args) {
+        zaszachraj(1000, 0.5); // 1/2
+        zaszachraj(1000, 0.125); // 1/8
+
+        zaszachraj(1000, 0.2); // 1/5 - nieskończone rozwinięcie w systemie dwójkowym
+        zaszachraj(1000, 0.3);
+        zaszachraj(1000, 1.0 / 3.0);
+    }
+}

src/main/java/pcz/p05_liczby/ProcentyNaCalkowitych.java

+package pcz.p05_liczby;
+
+public class ProcentyNaCalkowitych {
+
+    public static void main(String[] args) {
+        long netto = 10005;
+        long procent = 23;
+        long brutto = (netto * (100 + procent) + 50) / 100;
+        System.out.println(brutto);
+
+    }
+
+}

src/main/java/pcz/p05_liczby/PrzeciazanieIntLong.java

+package pcz.p05_liczby;
+
+public class PrzeciazanieIntLong {
+
+    public static void main(String[] args) {
+        try {
+            System.out.println("oblicza w wersji int:");
+            System.out.println(Math.multiplyExact(5, 1000_000_000));
+        } catch(Exception e) {
+            System.out.println("wersja int: wyjątek " + e);
+        }
+        System.out.println();
+
+        try {
+            System.out.println("oblicza w wersji long:");
+            System.out.println(Math.multiplyExact(5L, 1000_000_000L));
+        } catch(Exception e) {
+            System.out.println("wersja long: wyjątek " + e);
+        }
+    }
+
+}

src/main/java/pcz/p05_liczby/Rzutowania.java

+package pcz.p05_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/main/java/pcz/p05_liczby/Silnia.java

+package pcz.p05_liczby;
+
+import java.util.Scanner;
+
+public class Silnia {
+
+    // 1 * 2 * 3 * .... * n
+    static long silnia(int n) {
+        long wynik = 1;
+        for(int i = 2; i <= n; i++) {
+            wynik *= i;
+        }
+
+        return wynik;
+    }
+
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+
+        while(true) {
+            System.out.println("Podaj liczbę (-1 aby zakończyć)");
+            int n = sc.nextInt();
+            if(n < 0)
+                break;
+
+            long wynik = silnia(n);
+            System.out.println("Wynik: " + wynik);
+        }
+    }
+
+}

src/main/java/pcz/p05_liczby/SilniaNaRozneSposoby.java

+package pcz.p05_liczby;
+
+import java.math.BigInteger;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+
+public class SilniaNaRozneSposoby {
+
+    static int silniaInt(int n) {
+        int wynik = 1;
+        for(int i = 2; i <= n; i++) {
+            wynik *= i;
+        }
+        return wynik;
+    }
+
+    static long silniaFor(int n) {
+        long wynik = 1;
+        for(int i = 2; i <= n; i++) {
+            wynik *= i;
+        }
+        return wynik;
+    }
+
+    static long silniaWhile(int n) {
+        long wynik = 1;
+
+        while(n > 1) {
+            wynik *= n;
+            n--;
+        }
+
+        return wynik;
+    }
+
+    static long silniaRek(int n) {
+        // rekurencja
+
+        if(n < 2) {
+            return 1;
+        } else {
+            return n * silniaRek(n - 1);
+        }
+    }
+
+    static BigInteger silniaBig(int n) {
+        BigInteger wynik = BigInteger.ONE;
+
+        for(int i = 2; i <= n; i++) {
+            wynik = wynik.multiply(BigInteger.valueOf(i));
+        }
+
+        return wynik;
+    }
+
+    static long silniaKontrolowana(int n) {
+        long wynik = 1;
+        for(int i = 2; i <= n; i++) {
+            wynik = Math.multiplyExact(wynik, i);
+        }
+        return wynik;
+    }
+
+    static long silniaFun(int n) {
+        // też OK return LongStream.rangeClosed(1, n).reduce(1, Math::multiplyExact );
+
+        return LongStream.rangeClosed(1L, n).reduce(1L, (wynik, i) -> wynik * i);
+    }
+
+    static BigInteger silniaBigFun(int n) {
+        return IntStream.rangeClosed(1, n)
+                .mapToObj(BigInteger::valueOf)
+                .reduce(BigInteger.ONE, BigInteger::multiply);
+    }
+
+    public static void main(String[] args) {
+
+        int wynik1 = silniaInt(5);
+        System.out.println(wynik1);
+
+        System.out.println("int, for:");
+        for(int arg = 0; arg <= 50; arg++) {
+            System.out.println(arg + "! = " + silniaInt(arg));
+        }
+        System.out.println();
+
+        System.out.println("long, for:");
+        for(int arg = 0; arg <= 50; arg++) {
+            System.out.println(arg + "! = " + silniaFor(arg));
+        }
+        System.out.println();
+
+        System.out.println("long, while:");
+        for(int arg = 0; arg <= 50; arg++) {
+            System.out.println(arg + "! = " + silniaWhile(arg));
+        }
+        System.out.println();
+
+        System.out.println("long, rekurencja:");
+        for(int arg = 0; arg <= 50; arg++) {
+            System.out.println(arg + "! = " + silniaRek(arg));
+        }
+        System.out.println();
+
+        System.out.println("long, multiplyExact:");
+        for(int arg = 0; arg <= 50; arg++) {
+            try {
+                System.out.println(arg + "! = " + silniaKontrolowana(arg));
+            } catch(ArithmeticException e) {
+                System.out.println("OVERFLOW");
+            }
+        }
+        System.out.println();
+
+        System.out.println("BigInteger, for:");
+        for(int arg = 0; arg <= 100; arg++) {
+            System.out.println(arg + "! = " + silniaBig(arg));
+        }
+        System.out.println();
+
+        System.out.println("long, reduce:");
+        for(int arg = 0; arg <= 50; arg++) {
+            System.out.println(arg + "! = " + silniaFun(arg));
+        }
+        System.out.println();
+
+        System.out.println("BigInteger, reduce:");
+        for(int arg = 0; arg <= 100; arg++) {
+            System.out.println(arg + "! = " + silniaBigFun(arg));
+        }
+        System.out.println();
+
+    }
+
+}
+
+/* wersja w Pythonie:
+
+def silnia(n):
+    wynik = 1
+    for i in range(1, n+1):
+        wynik *= i
+    return wynik
+
+print(silnia(1))
+print(silnia(5))
+print(silnia(100))
+*/
+
+/* wersja w Haskellu:
+silnia n = foldl (*) 1 [1..n]
+
+silnia 5
+silnia 100
+*/

src/main/java/pcz/p05_liczby/TestMegaSilni.java

+package pcz.p05_liczby;
+
+import java.io.IOException;
+import java.math.BigInteger;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.Collections;
+
+public class TestMegaSilni {
+
+    public static void main(String[] args) {
+        System.out.println("Wyliczam silnię od 100 tys.");
+        BigInteger silnia100tys = SilniaNaRozneSposoby.silniaBig(100_000);
+        String silnia100tysTXT = silnia100tys.toString();
+        System.out.printf("Gotowe, wynik ma %d cyfr.", silnia100tysTXT.length());
+        try {
+            final String plik = "silnia_100_tys.txt";
+            Files.write(Paths.get(plik), Collections.singleton(silnia100tysTXT), Charset.defaultCharset(),
+                    StandardOpenOption.CREATE);
+            System.out.println("Zapisałem do pliku " + plik);
+        } catch(IOException e) {
+            System.out.println("Błąd zapisu do pliku");
+        }
+        System.out.println();
+    }
+}

src/main/java/pcz/p05_liczby/WypiszZakresy.java

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

src/main/java/pcz/p05_liczby/Znaki.java

+package pcz.p05_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 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/main/java/pcz/p06_funkcje/gdyby_nie_bylo_static/Geometria.java

+package pcz.p06_funkcje.gdyby_nie_bylo_static;
+
+public class Geometria {
+    // W tej wersji metody geometryczne nie są static.
+    // Powoduje to konieczność utworzenia obiektu ("instancji") tej klasy, gdy ktoś chce użyć tych metod - zob. Program i Testy w tym pakiecie
+
+    double poleKwadratu(double a) {
+        return a * a;
+    }
+
+    double poleKola(double r) {
+        return Math.PI * Math.pow(r, 2);
+    }
+
+}

src/main/java/pcz/p06_funkcje/gdyby_nie_bylo_static/TestyGeometrii.java

+package pcz.p06_funkcje.gdyby_nie_bylo_static;
+
+public class TestyGeometrii {
+
+    public static void main(String[] args) {
+        // ponieważ w tej wersji metody nie są static, to aby je wywołać trzeba utworzyć obiekt
+        // System.out.println("Pole kwadratu 5 = " + Geometria.poleKwadratu(5.0));
+
+        Geometria geo = new Geometria();
+        System.out.println("Pole kwadratu 5 = " + geo.poleKwadratu(5.0));
+        System.out.println("Pole koła 5 = " + geo.poleKola(5.0));
+    }
+
+}

src/main/java/pcz/p06_funkcje/importowanie/Importowanie0.java

+package pcz.p06_funkcje.importowanie;
+
+/* W tej wersji programu nie ma żadnych importów, a wszystkie odwołania do klasy Geometria
+ * oraz standardowych klas JOptionPane i Random są poprzedzone nazwą pakietu.
+ * 
+ * W języku Java ZAWSZE da się napisać program bez użycia import.
+ */
+
+public class Importowanie0 {
+    public static void main(String[] args) {
+        @SuppressWarnings("resource")
+        java.util.Scanner scanner = new java.util.Scanner(System.in);
+
+        petla:
+        while(true)
+          try {
+            System.out.println("\nWybierz figurę:");
+            System.out.println("  K  - kwadrat");
+            System.out.println("  O  - koło");
+            System.out.println("  P  - prostokąt");
+            System.out.println("  T  - trójkąt");
+            System.out.println("  KM - przelicz kilometry na mile");
+            System.out.println("  MK - przelicz mile na kilometry");
+            System.out.println("  CF - przelicz °C na °F");
+            System.out.println("  FC - przelicz °F na °C");
+            System.out.println("  Q  - zakończ");
+            String wybor = scanner.next().toUpperCase();
+            switch(wybor) {
+              case "Q" -> {
+                // muszę użyć "etykiety", aby powiedzieć Javie, że przerywam pętlę while, a nie samego switcha
+                break petla;
+              }
+              case "K" -> {
+                System.out.print("Podaj długość boku kwadratu: ");
+                double a = scanner.nextDouble();
+                double pole = pcz.p06_funkcje.przyklady.Geometria.poleKwadratu(a);
+                double obwod = pcz.p06_funkcje.przyklady.Geometria.obwodKwadratu(a);
+                System.out.printf("Dla kwadratu o boku %.3f pole wynosi %.3f, a obwód %.3f\n", a, pole, obwod);
+              }
+              case "P" -> {
+                System.out.print("Podaj długość pierwszego boku prostokąta: ");
+                double a = scanner.nextDouble();
+                System.out.print("Podaj długość drugiego boku prostokąta: ");
+                double b = scanner.nextDouble();
+                double pole = pcz.p06_funkcje.przyklady.Geometria.poleProstokata(a, b);
+                double obwod = pcz.p06_funkcje.przyklady.Geometria.obwodProstokata(a, b);
+                System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
+              }
+              case "T" -> {
+                System.out.print("Podaj długość pierwszego boku trójkąta: ");
+                double a = scanner.nextDouble();
+                System.out.print("Podaj długość drugiego boku trójkąta: ");
+                double b = scanner.nextDouble();
+                System.out.print("Podaj długość trzeciego boku trójkąta: ");
+                double c = scanner.nextDouble();
+                double pole = pcz.p06_funkcje.przyklady.Geometria.poleTrojkata(a, b, c);
+                double obwod = pcz.p06_funkcje.przyklady.Geometria.obwodTrojkata(a, b, c);
+                System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
+              }
+              case "O" -> {
+                System.out.print("Podaj promień koła: ");
+                double r = scanner.nextDouble();
+                double pole = pcz.p06_funkcje.przyklady.Geometria.poleKola(r);
+                double obwod = pcz.p06_funkcje.przyklady.Geometria.obwodKola(r);
+                System.out.printf("Dla koła o promieniu %.3f pole wynosi %.3f, a obwód %.3f\n", r, pole, obwod);
+              }
+              case "KM" -> {
+                System.out.print("Podaj odległość w kilometrach: ");
+                double km = scanner.nextDouble();
+                double wynik = pcz.p06_funkcje.przyklady.JednostkiMiary.km_na_mile(km);
+                System.out.printf("%.3f km = %.3f mil\n", km, wynik);
+              }
+              case "MK" -> {
+                System.out.print("Podaj odległość w milach: ");
+                double mile = scanner.nextDouble();
+                double wynik = pcz.p06_funkcje.przyklady.JednostkiMiary.mile_na_km(mile);
+                System.out.printf("%.3f mil = %.3f km\n", mile, wynik);
+              }
+              case "FC" -> {
+                System.out.print("Podaj temperaturę w Fahrenheitach: ");
+                double f = scanner.nextDouble();
+                double wynik = pcz.p06_funkcje.przyklady.JednostkiMiary.far_na_cel(f);
+                System.out.printf("%.3f °F = %.3f °C\n", f, wynik);
+              }
+              case "CF" -> {
+                System.out.print("Podaj temperaturę w Celsjuszach: ");
+                double c = scanner.nextDouble();
+                double wynik = pcz.p06_funkcje.przyklady.JednostkiMiary.cel_na_far(c);
+                System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
+              }
+              default -> {
+                System.out.println("Nieznane polecenie " + wybor);
+              }
+            }
+          } catch(Exception e) {
+            System.out.println("Błąd: " + e);
+        }
+    }
+}

src/main/java/pcz/p06_funkcje/importowanie/Importowanie1.java

+package pcz.p06_funkcje.importowanie;
+
+import java.util.Scanner;
+
+import pcz.p06_funkcje.przyklady.Geometria;
+import pcz.p06_funkcje.przyklady.JednostkiMiary;
+
+/* W tej wersji stosujemy najbardziej standardowy sposób importowania, najczęściej używany:
+   każda klasa, do której odwołuje się nasz program, jest zaimportowana osobnym poleceniem.
+    
+   import w Javie NIE służy załadowaniu klas do pamięci, nie wykonuje się w czasie działania programu (tak się dzieje w Python i PHP)
+   To jest tylko wskazanie z jakiego pakietu pochodzi klasa.
+   
+   import nie wpływa na wydajność!
+*/
+public class Importowanie1 {
+    public static void main(String[] args) {
+        @SuppressWarnings("resource")
+        Scanner scanner = new Scanner(System.in);
+
+        petla:
+        while(true)
+          try {
+            System.out.println("\nWybierz figurę:");
+            System.out.println("  K  - kwadrat");
+            System.out.println("  O  - koło");
+            System.out.println("  P  - prostokąt");
+            System.out.println("  T  - trójkąt");
+            System.out.println("  KM - przelicz kilometry na mile");
+            System.out.println("  MK - przelicz mile na kilometry");
+            System.out.println("  CF - przelicz °C na °F");
+            System.out.println("  FC - przelicz °F na °C");
+            System.out.println("  Q  - zakończ");
+            String wybor = scanner.next().toUpperCase();
+            switch(wybor) {
+              case "Q" -> {
+                // muszę użyć "etykiety", aby powiedzieć Javie, że przerywam pętlę while, a nie samego switcha
+                break petla;
+              }
+              case "K" -> {
+                System.out.print("Podaj długość boku kwadratu: ");
+                double a = scanner.nextDouble();
+                double pole = Geometria.poleKwadratu(a);
+                double obwod = Geometria.obwodKwadratu(a);
+                System.out.printf("Dla kwadratu o boku %.3f pole wynosi %.3f, a obwód %.3f\n", a, pole, obwod);
+              }
+              case "P" -> {
+                System.out.print("Podaj długość pierwszego boku prostokąta: ");
+                double a = scanner.nextDouble();
+                System.out.print("Podaj długość drugiego boku prostokąta: ");
+                double b = scanner.nextDouble();
+                double pole = Geometria.poleProstokata(a, b);
+                double obwod = Geometria.obwodProstokata(a, b);
+                System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
+              }
+              case "T" -> {
+                System.out.print("Podaj długość pierwszego boku trójkąta: ");
+                double a = scanner.nextDouble();
+                System.out.print("Podaj długość drugiego boku trójkąta: ");
+                double b = scanner.nextDouble();
+                System.out.print("Podaj długość trzeciego boku trójkąta: ");
+                double c = scanner.nextDouble();
+                double pole = Geometria.poleTrojkata(a, b, c);
+                double obwod = Geometria.obwodTrojkata(a, b, c);
+                System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
+              }
+              case "O" -> {
+                System.out.print("Podaj promień koła: ");
+                double r = scanner.nextDouble();
+                double pole = Geometria.poleKola(r);
+                double obwod = Geometria.obwodKola(r);
+                System.out.printf("Dla koła o promieniu %.3f pole wynosi %.3f, a obwód %.3f\n", r, pole, obwod);
+              }
+              case "KM" -> {
+                System.out.print("Podaj odległość w kilometrach: ");
+                double km = scanner.nextDouble();
+                double wynik = JednostkiMiary.km_na_mile(km);
+                System.out.printf("%.3f km = %.3f mil\n", km, wynik);
+              }
+              case "MK" -> {
+                System.out.print("Podaj odległość w milach: ");
+                double mile = scanner.nextDouble();
+                double wynik = JednostkiMiary.mile_na_km(mile);
+                System.out.printf("%.3f mil = %.3f km\n", mile, wynik);
+              }
+              case "FC" -> {
+                System.out.print("Podaj temperaturę w Fahrenheitach: ");
+                double f = scanner.nextDouble();
+                double wynik = JednostkiMiary.far_na_cel(f);
+                System.out.printf("%.3f °F = %.3f °C\n", f, wynik);
+              }
+              case "CF" -> {
+                System.out.print("Podaj temperaturę w Celsjuszach: ");
+                double c = scanner.nextDouble();
+                double wynik = JednostkiMiary.cel_na_far(c);
+                System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
+              }
+              default -> {
+                System.out.println("Nieznane polecenie " + wybor);
+              }
+            }
+          } catch(Exception e) {
+            System.out.println("Błąd: " + e);
+        }
+    }
+}

src/main/java/pcz/p06_funkcje/importowanie/Importowanie2.java

+package pcz.p06_funkcje.importowanie;
+
+import java.util.*;
+import pcz.p06_funkcje.przyklady.*;
+
+/* Gdy na końcu polecenia import za nazwą pakietu umieścimy *,
+ * to importowane są wszystkie klasy z tego pakietu.
+ * To nie importuje podpakietów (podklatalogów).
+ * importy z * mają niższy priorytet niż importy bezpośrednie.
+ * 
+ * Gdy w programie pojawia się jakaś nazwa, to kompilator szuka klasy w takiej kolejności:
+ * 1. rzeczy zaimportowane bezpośrednio (tak jak w Importowanie1)
+ * 2. bieżący pakiet
+ * 3. klasy zaimportowane za pomocą * (w tym java.lang)
+ * (bo w pewnym sensie kompilator Javy na początku robi niejawnie import java.lang.*;
+ * 
+ * Czy importowanie wszystkich klas z dużego pakietu sprawia problemy?
+ * To nie jest problem z punktu widzenia wydajności, bo import nie ładuje tych klas do pamięci.
+ * Natomiast zwiększa to ryzyko kolizji nazw.
+ * Znany przykład: java.awt.List (lista wyboru w starej technologii okienkowej) i java.util.List (kolekcja).
+ * Sam import nie jest problemem, problem dopiero, gdy użyjemy tej klasy (błąd kompilacji). 
+ */
+
+public class Importowanie2 {
+    public static void main(String[] args) {
+        @SuppressWarnings("resource")
+        Scanner scanner = new Scanner(System.in);
+
+        petla:
+        while(true)
+          try {
+            System.out.println("\nWybierz figurę:");
+            System.out.println("  K  - kwadrat");
+            System.out.println("  O  - koło");
+            System.out.println("  P  - prostokąt");
+            System.out.println("  T  - trójkąt");
+            System.out.println("  KM - przelicz kilometry na mile");
+            System.out.println("  MK - przelicz mile na kilometry");
+            System.out.println("  CF - przelicz °C na °F");
+            System.out.println("  FC - przelicz °F na °C");
+            System.out.println("  Q  - zakończ");
+            String wybor = scanner.next().toUpperCase();
+            switch(wybor) {
+              case "Q" -> {
+                // muszę użyć "etykiety", aby powiedzieć Javie, że przerywam pętlę while, a nie samego switcha
+                break petla;
+              }
+              case "K" -> {
+                System.out.print("Podaj długość boku kwadratu: ");
+                double a = scanner.nextDouble();
+                double pole = Geometria.poleKwadratu(a);
+                double obwod = Geometria.obwodKwadratu(a);
+                System.out.printf("Dla kwadratu o boku %.3f pole wynosi %.3f, a obwód %.3f\n", a, pole, obwod);
+              }
+              case "P" -> {
+                System.out.print("Podaj długość pierwszego boku prostokąta: ");
+                double a = scanner.nextDouble();
+                System.out.print("Podaj długość drugiego boku prostokąta: ");
+                double b = scanner.nextDouble();
+                double pole = Geometria.poleProstokata(a, b);
+                double obwod = Geometria.obwodProstokata(a, b);
+                System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
+              }
+              case "T" -> {
+                System.out.print("Podaj długość pierwszego boku trójkąta: ");
+                double a = scanner.nextDouble();
+                System.out.print("Podaj długość drugiego boku trójkąta: ");
+                double b = scanner.nextDouble();
+                System.out.print("Podaj długość trzeciego boku trójkąta: ");
+                double c = scanner.nextDouble();
+                double pole = Geometria.poleTrojkata(a, b, c);
+                double obwod = Geometria.obwodTrojkata(a, b, c);
+                System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
+              }
+              case "O" -> {
+                System.out.print("Podaj promień koła: ");
+                double r = scanner.nextDouble();
+                double pole = Geometria.poleKola(r);
+                double obwod = Geometria.obwodKola(r);
+                System.out.printf("Dla koła o promieniu %.3f pole wynosi %.3f, a obwód %.3f\n", r, pole, obwod);
+              }
+              case "KM" -> {
+                System.out.print("Podaj odległość w kilometrach: ");
+                double km = scanner.nextDouble();
+                double wynik = JednostkiMiary.km_na_mile(km);
+                System.out.printf("%.3f km = %.3f mil\n", km, wynik);
+              }
+              case "MK" -> {
+                System.out.print("Podaj odległość w milach: ");
+                double mile = scanner.nextDouble();
+                double wynik = JednostkiMiary.mile_na_km(mile);
+                System.out.printf("%.3f mil = %.3f km\n", mile, wynik);
+              }
+              case "FC" -> {
+                System.out.print("Podaj temperaturę w Fahrenheitach: ");
+                double f = scanner.nextDouble();
+                double wynik = JednostkiMiary.far_na_cel(f);
+                System.out.printf("%.3f °F = %.3f °C\n", f, wynik);
+              }
+              case "CF" -> {
+                System.out.print("Podaj temperaturę w Celsjuszach: ");
+                double c = scanner.nextDouble();
+                double wynik = JednostkiMiary.cel_na_far(c);
+                System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
+              }
+              default -> {
+                System.out.println("Nieznane polecenie " + wybor);
+              }
+            }
+          } catch(Exception e) {
+            System.out.println("Błąd: " + e);
+        }
+    }
+}

src/main/java/pcz/p06_funkcje/importowanie/Importowanie3.java

+package pcz.p06_funkcje.importowanie;
+
+import static pcz.p06_funkcje.przyklady.Geometria.obwodKola;
+import static pcz.p06_funkcje.przyklady.Geometria.obwodKwadratu;
+import static pcz.p06_funkcje.przyklady.Geometria.obwodProstokata;
+import static pcz.p06_funkcje.przyklady.Geometria.obwodTrojkata;
+import static pcz.p06_funkcje.przyklady.Geometria.poleKola;
+import static pcz.p06_funkcje.przyklady.Geometria.poleKwadratu;
+import static pcz.p06_funkcje.przyklady.Geometria.poleProstokata;
+import static pcz.p06_funkcje.przyklady.Geometria.poleTrojkata;
+import static pcz.p06_funkcje.przyklady.JednostkiMiary.cel_na_far;
+import static pcz.p06_funkcje.przyklady.JednostkiMiary.far_na_cel;
+import static pcz.p06_funkcje.przyklady.JednostkiMiary.km_na_mile;
+import static pcz.p06_funkcje.przyklady.JednostkiMiary.mile_na_km;
+
+// można też importować zmienne / stałe statyczne:
+import static java.lang.Math.PI;
+
+import java.util.Scanner;
+
+/* Gdy w programie korzystamy tylko z elementów statycznych klasy X (z metod statycznych, zmiennych statycznych, stałych),
+ * to zamiast importować tę klasę i wywoływać te elementy pisząc X.metoda
+ * można zaimportować statycznie tę metodę (albo zmienną, stałą ...).
+ * 
+ * Wtedy w treści programy używamy zaimportowanych rzeczy tak, jakby były zdefiniowane w naszej klasie.
+ * (albo tak jakby były funkcjami, tak jak w Pythonie, C++, PHP itp...)
+ * 
+ * Nie ma jak użyć import static w stosunku do klasy Scanner, bo jej używamy w sposób "obiektowy":
+ * tworzony jest obiekt klasy Scanner i na nim wywoływana jest metoda (nie jest statyczna).
+ */
+public class Importowanie3 {
+    public static void main(String[] args) {
+        @SuppressWarnings("resource")
+        Scanner scanner = new Scanner(System.in);
+
+        System.out.println("Liczba pi: " + PI);
+
+        petla:
+        while(true)
+          try {
+            System.out.println("\nWybierz figurę:");
+            System.out.println("  K  - kwadrat");
+            System.out.println("  O  - koło");
+            System.out.println("  P  - prostokąt");
+            System.out.println("  T  - trójkąt");
+            System.out.println("  KM - przelicz kilometry na mile");
+            System.out.println("  MK - przelicz mile na kilometry");
+            System.out.println("  CF - przelicz °C na °F");
+            System.out.println("  FC - przelicz °F na °C");
+            System.out.println("  Q  - zakończ");
+            String wybor = scanner.next().toUpperCase();
+            switch(wybor) {
+              case "Q" -> {
+                // muszę użyć "etykiety", aby powiedzieć Javie, że przerywam pętlę while, a nie samego switcha
+                break petla;
+              }
+              case "K" -> {
+                System.out.print("Podaj długość boku kwadratu: ");
+                double a = scanner.nextDouble();
+                double pole = poleKwadratu(a);
+                double obwod = obwodKwadratu(a);
+                System.out.printf("Dla kwadratu o boku %.3f pole wynosi %.3f, a obwód %.3f\n", a, pole, obwod);
+              }
+              case "P" -> {
+                System.out.print("Podaj długość pierwszego boku prostokąta: ");
+                double a = scanner.nextDouble();
+                System.out.print("Podaj długość drugiego boku prostokąta: ");
+                double b = scanner.nextDouble();
+                double pole = poleProstokata(a, b);
+                double obwod = obwodProstokata(a, b);
+                System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
+              }
+              case "T" -> {
+                System.out.print("Podaj długość pierwszego boku trójkąta: ");
+                double a = scanner.nextDouble();
+                System.out.print("Podaj długość drugiego boku trójkąta: ");
+                double b = scanner.nextDouble();
+                System.out.print("Podaj długość trzeciego boku trójkąta: ");
+                double c = scanner.nextDouble();
+                double pole = poleTrojkata(a, b, c);
+                double obwod = obwodTrojkata(a, b, c);
+                System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
+              }
+              case "O" -> {
+                System.out.print("Podaj promień koła: ");
+                double r = scanner.nextDouble();
+                double pole = poleKola(r);
+                double obwod = obwodKola(r);
+                System.out.printf("Dla koła o promieniu %.3f pole wynosi %.3f, a obwód %.3f\n", r, pole, obwod);
+              }
+              case "KM" -> {
+                System.out.print("Podaj odległość w kilometrach: ");
+                double km = scanner.nextDouble();
+                double wynik = km_na_mile(km);
+                System.out.printf("%.3f km = %.3f mil\n", km, wynik);
+              }
+              case "MK" -> {
+                System.out.print("Podaj odległość w milach: ");
+                double mile = scanner.nextDouble();
+                double wynik = mile_na_km(mile);
+                System.out.printf("%.3f mil = %.3f km\n", mile, wynik);
+              }
+              case "FC" -> {
+                System.out.print("Podaj temperaturę w Fahrenheitach: ");
+                double f = scanner.nextDouble();
+                double wynik = far_na_cel(f);
+                System.out.printf("%.3f °F = %.3f °C\n", f, wynik);
+              }
+              case "CF" -> {
+                System.out.print("Podaj temperaturę w Celsjuszach: ");
+                double c = scanner.nextDouble();
+                double wynik = cel_na_far(c);
+                System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
+              }
+              default -> {
+                System.out.println("Nieznane polecenie " + wybor);
+              }
+            }
+          } catch(Exception e) {
+            System.out.println("Błąd: " + e);
+        }
+    }
+}