Student - obsługa ocen

src/p11_klasy/podstawy/Dziedziczenie.java

@@ -30,7 +30,10 @@ public class Dziedziczenie {
 		student.kierunek = "medycyna";
 		student.rok = 1;
 		System.out.println(student.imie + " studiuje " + student.kierunek + " na " + student.rok + " roku");
-		System.out.println(student.sredniaOcen());
+		student.dodajOcene(4);
+		student.dodajOcene(4);
+		student.dodajOcene(5);
+		System.out.println("średnia: " + student.sredniaOcen());
 		
 		// Dziedziczenie zapewnia nie tylko to, że dostępne są odziedziczone pola i metody,
 		// ale też na poziomie logicznym "Student jest Osobą"

src/p11_klasy/podstawy/Student.java

 package p11_klasy.podstawy;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class Student extends Osoba {
 	String kierunek;
 	int rok;
+	List<Integer> oceny = new ArrayList<>();
 	
 	public Student() {
 		
@@ -14,8 +18,15 @@ public class Student extends Osoba {
 		this.rok = rok;
 	}
 	
+	void dodajOcene(int ocena) {
+		oceny.add(ocena);
+	}
+
 	double sredniaOcen() {
-		return 4.5;
+		return oceny.stream()
+				.mapToInt(Integer::intValue)
+				.average()
+				.orElse(0);
 	}
 
 }

src/p11_klasy/podstawy_v5/Dziedziczenie.java

+package p11_klasy.podstawy_v5;
+
+public class Dziedziczenie {
+
+	public static void main(String[] args) {
+		System.out.println("Osoba:");
+		Osoba osoba = new Osoba();
+		System.out.println(osoba);
+		osoba.imie = "Ala";
+		osoba.nazwisko = "Kowalska";
+		osoba.wiek = 30;
+		System.out.println(osoba);
+		// Osoba posiada tylko te elementy, które pochjodzą z klasy Osoba, a nie posiada tych dodanych w klasie Student
+//		osoba.kierunek = "podróżniczka";
+//		System.out.println(osoba.kierunek);
+		
+		System.out.println();
+		
+		System.out.println("Student:");
+		Student student = new Student();
+		System.out.println(student);
+		// Obiekt Student posiada wszystkie te pola i metody, które zostały zdefiniowane w klasie Osoba
+		student.imie = "Adam";
+		student.nazwisko = "Abacki";
+		student.wiek = 20;
+		System.out.println(student);
+		student.przedstawSie();
+		
+		// oraz dodatkowo pola i metody zdefiniowane w klasie Student
+		student.kierunek = "medycyna";
+		student.rok = 1;
+		System.out.println(student.imie + " studiuje " + student.kierunek + " na " + student.rok + " roku");
+		student.dodajOcene(4);
+		student.dodajOcene(4);
+		student.dodajOcene(5);
+		System.out.println("średnia: " + student.sredniaOcen());
+		
+		// Dziedziczenie zapewnia nie tylko to, że dostępne są odziedziczone pola i metody,
+		// ale też na poziomie logicznym "Student jest Osobą"
+		if(student instanceof Osoba) {
+			System.out.println("Student jest osobą");
+		} else {
+			System.out.println("Student nie jest osobą");			
+		}
+		
+		// We wszystkich miejscach kodu, w które można by włożyć obiekt klasy Osoba, można też włożyć obiekt klasy Student.
+		// Obiekt Student może być wpisany do zmiennej typu Osoba
+		Osoba ktos = student;
+		System.out.println(ktos + " jest klasy " + ktos.getClass());
+		System.out.println();
+		
+		// Student może kupić piwo
+		Sklep sklep = new Sklep("Lidl", 6);
+		sklep.sprzedajPiwo(student);
+		sklep.sprzedajPiwo(ktos);
+		System.out.println();
+		
+		// Student może być właścicielem konta
+		Konto kontoStudenckie = new Konto(1313, 123, student);
+		System.out.println(kontoStudenckie);
+		System.out.println();
+		
+		// Kwestia konstruktorów
+		// W Javie konstruktory nie są dziedziczone z nadklasy.
+		// Z faktu, że w Osoba istnieje konstruktor typu (String, String, int) nie wynika istnienie takiego konstruktora w klasie Student
+		// Student student2 = new Student("Marek", "Markowski", 23);
+
+		Student student3 = new Student("Marek", "Markowski", 23, "informatyka", 4);
+		System.out.println(student3);
+		System.out.println(student3.imie + " studiuje " + student3.kierunek + " na " + student3.rok + " roku");
+	}
+
+}

src/p11_klasy/podstawy_v5/Konto.java

+package p11_klasy.podstawy_v5;
+
+public class Konto {
+	int numer;
+	int saldo;
+	Osoba wlasciciel;
+
+	public Konto(int numer, int saldo, Osoba wlasciciel) {
+		this.numer = numer;
+		this.saldo = saldo;
+		this.wlasciciel = wlasciciel;
+	}
+
+	@Override
+	public String toString() {
+		return "Konto nr " + numer + ", saldo: " + saldo + ", wł. " + wlasciciel;
+	}
+	
+	void wplata(int kwota) {
+		saldo += kwota;
+	}
+	
+	void wyplata(int kwota) {
+		saldo -= kwota;
+	}
+
+}

src/p11_klasy/podstawy_v5/KontoTest.java

+package p11_klasy.podstawy_v5;
+
+public class KontoTest {
+
+	public static void main(String[] args) {
+		Osoba ala = new Osoba("Ala", "Kowalska", 30);
+		Konto konto = new Konto(1, 1000, ala);
+		System.out.println(konto);
+		
+		// dodaj metody wplata i wyplata tak, aby zadziałał poniższy kod:
+		konto.wplata(500);
+		System.out.println(konto); // teraz saldo ma być równe 1500
+		
+		konto.wyplata(300);
+		System.out.println(konto); // teraz saldo ma być równe 1200
+
+	}
+
+}

src/p11_klasy/podstawy_v5/Osoba.java

+package p11_klasy.podstawy_v5;
+
+import java.util.Objects;
+
+public class Osoba {
+	// Zmienna deklarowana na poziomie klasy to jest:
+	// pole (field), atrybut (attribute), zmienna instancyjna (instance variable)
+	// Każdy obiekt tej klasy zawiera pola (które nie są statyczne).
+	String imie, nazwisko;
+	int wiek;
+	
+	// Klasa może posiadać wiele konstruktorów, które różnią się liczbą lub typem parametrów
+	Osoba() {
+		
+	}
+	
+	Osoba(String imie, String nazwisko, int wiek) {
+		this.imie = imie;
+		this.nazwisko = nazwisko;
+		this.wiek = wiek;
+	}
+	
+	{ // blok inicjalizacyjny - fragment kodu, który wykona się podczas tworzenia każdego obiektu
+	  // jeszcze przed konstruktorem
+		System.out.println("powstaje obiekt Osoba");
+	}
+	
+	static {
+		// blok inicjalizacyjny statyczny - wykonuje się raz, gdy klasa jest ładowana do maszyny wirtualnej
+		System.out.println("static Osoba");
+	}
+	
+	// Metoda to czynność, którą "potrafi wykonać obiekt".
+	// nie piszemy już "static"
+	// Wewnątrz metody można odwoływać się do pól należących do obiektu.
+	// Te odwołania można poprzedzać this ("ten obiekt, w którym jesteśmy), ale w Javie nie trzeba tego robić.
+	void przedstawSie() {
+		System.out.println("Nazywam się " + imie + " " + nazwisko + " i mam " + wiek + " lat.");
+	}
+	
+	boolean pelnoletnia() {
+		return wiek >= 18;
+	}
+	
+	@Override
+	public String toString() {
+		return imie + " " + nazwisko + " (" + wiek + " lat)";
+	}
+	
+// Błędna realizacja equals - jako parametr zadeklarowana Osoba
+//	public boolean equals(Osoba other) {
+//		return this.imie.equals(other.imie)
+//				&& this.nazwisko.equals(other.nazwisko)
+//				&& this.wiek == other.wiek;
+//	}
+	
+	// Prawdziwa metoda equals jako swój parametr musi przyjmować Object
+	// Tutaj wygenerujemy standardowe implementacje equals i hashCode oferowane przez edytor
+	
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Osoba other = (Osoba) obj;
+		return Objects.equals(imie, other.imie) && Objects.equals(nazwisko, other.nazwisko) && wiek == other.wiek;
+	}
+	
+	@Override
+	public int hashCode() {
+		return Objects.hash(imie, nazwisko, wiek);
+	}
+	
+}

src/p11_klasy/podstawy_v5/Porownywanie.java

+package p11_klasy.podstawy_v5;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Porownywanie {
+
+	public static void main(String[] args) {
+		Osoba a = new Osoba("Ala", "Kowalska", 30);
+		Osoba b = new Osoba("Ola", "Malinowska", 30);
+		Osoba c = new Osoba("Ala", "Kowalska", 30);
+		Osoba r = a;
+		
+		System.out.println("\nWszystkie obiekty:");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);
+		System.out.println("r: " + r);
+
+		// operator == sprawdza "czy to jest ten sam obiekt"
+		// porównywane są adresy, a nie zawartość obiektów
+		System.out.println("\nPorównanie ==:");
+		System.out.println("a == a: " + (a == a));
+		System.out.println("a == b: " + (a == b));
+		System.out.println("a == c: " + (a == c));
+		System.out.println("a == r: " + (a == r));
+		
+		// Metoda equals ma służyć do logicznego porównywania obiektów.
+		// Bardzo często działa tak, że sprawdza, czy zawartość obiektów jest równa (np. tak jest dla Stringów)
+		// Ale dla własnej klasy TO AUTOR KLASY MUSI ZDEFINIOWAĆ metodę equals,
+		// aby działała w taki sposób. Domyślnie equals działa tak samo jak ==
+		System.out.println("\nPorównanie eq:");
+		System.out.println("a eq a: " + a.equals(a));
+		System.out.println("a eq b: " + a.equals(b));
+		System.out.println("a eq c: " + a.equals(c));
+		System.out.println("a eq r: " + a.equals(r));
+		
+		// Metoda hashCode zwraca liczbę int na podstawie obiektu.
+		// Domyślnie jest to liczba uzyskiwana na podstawie adresu; taka, aby była unikalna w skali maszyny wirtualnej
+		
+		// Autor klasy może zmienić definicję hashCode i POWINIEN TO ZROBIĆ jeśli definiuje equals
+		// Jeśli obiekty są równe w sensie equals, to hasz kody muszą być równe
+		// Jeśli obiekty są różne (equals daje false), to haszkody z dużym prawdopodobieństwem powinny być różne.
+		// Zazwyczaj własny hashCode jest jakąś formą sumy kontrolnej wyliczaj na podstawie wartości pól.
+		System.out.println("\nHasz kody:");
+		System.out.println("a: " + a.hashCode());
+		System.out.println("b: " + b.hashCode());
+		System.out.println("c: " + c.hashCode());
+		System.out.println("r: " + r.hashCode());
+		System.out.println();
+		
+		Set<Osoba> set = new HashSet<>();
+		set.add(a);
+		set.add(b);
+		set.add(c);
+		set.add(r);
+		System.out.println("Rozmiar zbioru: " + set.size());
+		System.out.println(set);
+	}
+
+}

src/p11_klasy/podstawy_v5/Przyklad0.java

+package p11_klasy.podstawy_v5;
+
+public class Przyklad0 {
+
+	public static void main(String[] args) {
+		// Dzięki temu, że istnieje klasa Osoba, możemy zadeklarować zmienną typu Osoba.
+		Osoba o;
+		
+		// ale uwaga - w Javie sama deklaracja zmiennej nie tworzy obiektu
+		// System.out.println(o); - błąd kompilacji - niezainicjowana zmienna
+		
+		// można też utworzyć nowy obiekt klasy Osoba i wpisać go do zmiennej
+		o = new Osoba();
+		System.out.println(o);
+		
+		// Najczęściej w jednej linii deklaruje się zmienną i wpisuje nowy obiekt:
+		Osoba p = new Osoba();
+		System.out.println(p);
+		
+		// Każdy obiekt w języku Java (nawet zupełnie pustej klasy)
+		// posiada pewne metody, które można uruchomić.
+		// toString - zwraca tekstową postać obiektu
+		String s = o.toString();
+		System.out.println(s);
+		
+		// getClass - zwraca "obiekt klasy" z informacjami nt klasy, do której należy obiekt
+		System.out.println(o.getClass());
+		Class<?> klasa = o.getClass();
+		System.out.println("pakiet: "  + klasa.getPackageName() + ", klasa " + klasa.getSimpleName());
+
+		// equals i hashCode związane z porównywaniem obiektów
+		System.out.println("hasz o : " + o.hashCode());
+		System.out.println("hasz p : " + p.hashCode());
+		if(o.equals(p)) {
+			System.out.println("obiekty równe");
+		} else {
+			System.out.println("obiekty nierówne");			
+		}
+		
+		// metody wait (z kilku wersjach) i notify - służą do synchronizacji wątków w aplikacjach wielowątkowych
+		
+		// toString, equals, hashCode często są nadpisywane przez autorów klas.
+	}
+
+}

src/p11_klasy/podstawy_v5/Przyklad1.java

+package p11_klasy.podstawy_v5;
+
+public class Przyklad1 {
+
+	public static void main(String[] args) {
+		Osoba a = new Osoba();
+		Osoba b = new Osoba();
+		
+		System.out.println("Początkowe wartości pól:");
+		System.out.println(a.imie + " " + a.nazwisko + " " + a.wiek);
+
+		a.imie = "Ala";
+		a.nazwisko = "Kowalska";
+		a.wiek = 30;
+
+		b.imie = "Basia";
+		b.nazwisko = "Malinowska";
+		b.wiek = 40;
+		
+		// Każdy obiekt posiada własne wartości pól.
+		System.out.println("Ustawione wartości pól:");
+		System.out.println("a: " + a.imie + " " + a.nazwisko + " " + a.wiek);
+		System.out.println("b: " + b.imie + " " + b.nazwisko + " " + b.wiek);
+		System.out.println();
+		
+		// wywołanie metody na obiekcie
+		a.przedstawSie();
+		b.przedstawSie();
+		System.out.println();
+		
+		a.wiek++;
+		a.przedstawSie();
+		b.przedstawSie();
+		
+		if(a.pelnoletnia()) {
+			System.out.println(a.imie + " jest pełnoletnia");
+		} else {
+			System.out.println("ALARM");
+		}
+		
+		// Obiektów w Javie nie usuwa się w sposób jawny - robi to "garbage collector" gdy zauważa,
+		// że do obiektu nie ma już dostępu (nie ma możliwości użycia)
+		// Dzieje się to asynchronicznie, czyli nie wiemy kiedy dokładnie.
+	}
+
+}

src/p11_klasy/podstawy_v5/Przyklad2_Konstruktory.java

+package p11_klasy.podstawy_v5;
+
+public class Przyklad2_Konstruktory {
+
+	public static void main(String[] args) {
+		System.out.println("Początek main");
+		// Tworzenie obiektów na zasadzie:
+		// - konstruktor domyślny, które niezainicjowane pola (null, 0)
+		// - a następnie wpisujemy wszystkie wartości
+		// ma dwie wady:
+		// 1) rozwlekłość zapisu
+		// 2) przez jakiś czas obiekt nie jest poprawnie zainicjowany, nie jest gotowy do pracy
+		//    programista może "zapomnieć" wpisać dane do pól i działać z takim upośledzonym obiektem
+		
+		Osoba a = new Osoba();
+		a.imie = "Ala";
+		a.przedstawSie(); // Ala null 0 lat
+		a.nazwisko = "Kowalska";
+		a.wiek = 30;
+		a.przedstawSie();
+		System.out.println();
+		
+		// Gdy w klasie zdefiniujemy odpowiedni konstruktor, będziemy mogli tworzyć obiektu od razu wypełnione danymi
+		Osoba b = new Osoba("Ola", "Malinowska", 20);
+		b.przedstawSie();
+	}
+
+	static {
+		System.out.println("blok statyczny w programie");
+	}
+}

src/p11_klasy/podstawy_v5/Referencje1.java

+package p11_klasy.podstawy_v5;
+
+public class Referencje1 {
+
+	public static void main(String[] args) {
+		Osoba ala = new Osoba("Ala", "Kowalska", 30);
+		Osoba ola = new Osoba("Ola", "Malinowska", 30);
+		
+		Konto a = new Konto(1, 1000, ala);
+		Konto b = new Konto(2, 2000, ola);
+		Konto c = b;
+
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);
+		System.out.println();
+		
+		// zmiana wewnątrz obiektu - zmienna c "widzi" tę zmianę
+		b.wplata(48);
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);
+		System.out.println();
+		
+		// zmiana samej zmiennej b. b wskazuje na inny obiekt,
+		// ale to nie wpływa na c
+		b = a;
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);
+		System.out.println();
+		
+		// tracimy dowiązanie do konta nr 2
+		c = b;
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);
+		System.out.println();
+		
+		a = null;
+		// teraz zmienna a nie wskazuje na żaden obiekt
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);
+		System.out.println();
+		
+		c = b = a;
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);		
+	}
+
+}

src/p11_klasy/podstawy_v5/Referencje2.java

+package p11_klasy.podstawy_v5;
+
+public class Referencje2 {
+	
+	static void metoda(Konto a, Konto b, int x) {
+		System.out.println("Początek metody");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("x: " + x);
+		System.out.println();
+		
+		x += 55;
+		a = b;
+		b.wplata(48);
+		
+		System.out.println("Koniec metody");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("x: " + x);
+		System.out.println();		
+	}
+
+	public static void main(String[] args) {
+		Osoba ala = new Osoba("Ala", "Kowalska", 30);
+		Osoba ola = new Osoba("Ola", "Malinowska", 30);
+		
+		Konto a = new Konto(1, 1000, ala);
+		Konto b = new Konto(2, 2000, ola);
+		int x = 5000;
+		
+		System.out.println("Początek main");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("x: " + x);
+		System.out.println();
+		
+		metoda(a, b, x);
+		
+		System.out.println("Koniec main");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("x: " + x);
+	}
+
+}

src/p11_klasy/podstawy_v5/Referencje3.java

+package p11_klasy.podstawy_v5;
+
+public class Referencje3 {
+	
+	static void metoda(Konto a, Konto b, Konto c, int x) {
+		System.out.println("Początek metody:");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);
+		System.out.println("x: " + x);
+		System.out.println();
+		
+		x += 55;		
+		b.wplata(48);
+		
+		a = new Konto(a.numer, a.saldo, a.wlasciciel);
+		a.wplata(33);
+		a.wlasciciel.imie = "Alicja";
+		
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);
+		System.out.println("x: " + x);
+		System.out.println();
+	}
+
+	public static void main(String[] args) {
+		Osoba ala = new Osoba("Ala", "Kowalska", 30);
+		Osoba ola = new Osoba("Ola", "Malinowska", 40);
+
+		Konto a = new Konto(1, 1000, ala);
+		Konto b = new Konto(2, 2000, ola);
+		Konto c = b;
+		int x = 5000;
+		
+		System.out.println("Początek main:");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);
+		System.out.println("x: " + x);
+		System.out.println();
+		
+		metoda(a, b, c, x);
+		
+		System.out.println("Koniec main:");
+		System.out.println("a: " + a);
+		System.out.println("b: " + b);
+		System.out.println("c: " + c);
+		System.out.println("x: " + x);
+	}
+
+}

src/p11_klasy/podstawy_v5/Sklep.java

+package p11_klasy.podstawy_v5;
+
+class Sklep {
+	String nazwa;
+	int cenaPiwa;
+	int utarg = 0;
+	
+	Sklep(String nazwa, int cenaPiwa) {
+		this.nazwa = nazwa;
+		this.cenaPiwa = cenaPiwa;
+	}
+
+	void sprzedajPiwo(Osoba klient) {
+		System.out.println("________________");
+		System.out.println("Klient wchodzi do sklepu " + nazwa + ". Kliencie, przedstaw się...");
+		klient.przedstawSie();
+		if(klient.pelnoletnia()) {
+			System.out.println("Osoba " + klient.imie + " kupuje piwo za " + cenaPiwa + " zł");
+			utarg += cenaPiwa;
+		} else {
+			System.out.println("Osoba " + klient.imie + " nie może kupić piwa, bo ma tylko " + klient.wiek + " lat.");
+		}
+		System.out.println("^^^^^^^^^^^^^^^");
+	}
+
+}

src/p11_klasy/podstawy_v5/SklepProgram.java

+package p11_klasy.podstawy_v5;
+
+class SklepProgram {
+
+	public static void main(String[] args) {
+		Osoba ala = new Osoba("Ala", "Kowalska", 30);
+		System.out.println(ala);
+		System.out.println("imię osoby a: " + ala.imie);
+		
+		Osoba basia = new Osoba("Basia", "Malinowska", 13);
+		System.out.println(basia);
+		System.out.println("imię osoby b: " + basia.imie);
+		System.out.println();
+		
+		ala.przedstawSie();
+		if(ala.pelnoletnia()) {
+			System.out.println(ala.imie + " jest pełnoletnia");
+		} else {
+			System.out.println(ala.imie + " jest niepełnoletnia");
+		}
+		System.out.println();
+		
+		basia.przedstawSie();
+		if(basia.pelnoletnia()) {
+			System.out.println(basia.imie + " jest pełnoletnia");
+		} else {
+			System.out.println(basia.imie + " jest niepełnoletnia");
+		}
+		System.out.println();
+		
+		Sklep zabka = new Sklep("Żabka", 6);
+		zabka.sprzedajPiwo(ala);
+		zabka.sprzedajPiwo(basia);
+		
+		Sklep biedronka = new Sklep("Biedronka", 5);
+		biedronka.sprzedajPiwo(ala);
+		biedronka.sprzedajPiwo(ala);
+		biedronka.sprzedajPiwo(ala);
+		
+		System.out.println("Utarg w Żabce: " + zabka.utarg);
+		System.out.println("Utarg w Biedronce: " + biedronka.utarg);
+	}
+
+}

src/p11_klasy/podstawy_v5/Student.java

+package p11_klasy.podstawy_v5;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Student extends Osoba {
+	String kierunek;
+	int rok;
+	List<Integer> oceny = new ArrayList<>();
+	
+	public Student() {
+		
+	}
+	
+	public Student(String imie, String nazwisko, int wiek, String kierunek, int rok) {
+		super(imie, nazwisko, wiek);
+		this.kierunek = kierunek;
+		this.rok = rok;
+	}
+	
+	void dodajOcene(int ocena) {
+		oceny.add(ocena);
+	}
+
+	double sredniaOcen() {
+		return oceny.stream()
+				.mapToInt(Integer::intValue)
+				.average()
+				.orElse(0);
+	}
+
+}

src/p11_klasy/podstawy_v5/Wypisywanie.java

+package p11_klasy.podstawy_v5;
+
+public class Wypisywanie {
+
+	public static void main(String[] args) {
+		Osoba a = new Osoba("Ala", "Kowalska", 30);
+		Osoba b = new Osoba("Ola", "Malinowska", 40);
+		
+		// co się dzieje, gdy wypisujemy obiekt?
+		System.out.println(a);
+		System.out.println(b);
+		System.out.println();
+		
+		// Java zamienia obiekt na postać tekstową za pomocą metody toString:
+		String s = a.toString();
+		System.out.println(s);
+		
+		// to samo dzieje się, gdy dodajemy obiekt do string lub gdy używamy metody String.valueOf:
+		// String.valueOf(cokolwiek) jest uniwersalnym sposobem, aby stworzyć st
+		s = String.valueOf(a);
+		System.out.println(s);
+
+		System.out.println("Witamy osobę: " + a);
+	}
+
+}