przykłady z drugiego spotkania

src/main/java/gotowe/p02_zmienne/B_RodzajeZmiennych.java

@@ -25,6 +25,7 @@ public class B_RodzajeZmiennych {
         obiekt.metodaInstancyjna(50);
 
         System.out.println(statyczna);
+        System.out.println(B_RodzajeZmiennych.statyczna);
         System.out.println(obiekt.instancyjna);
 
         B_RodzajeZmiennych innyObiekt = new B_RodzajeZmiennych();

src/main/java/gotowe/p02_zmienne/PolaFinal.java

@@ -12,4 +12,9 @@ public class PolaFinal {
     public PolaFinal(int nr) {
         numer = nr;
     }
+
+    // metoda nie ma prawa zmienić wartości
+    void zmien() {
+        //ERR numer += 5;
+    }
 }

src/main/java/klasy/Konto.java

+package klasy;
+
+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/main/java/klasy/Mutowalnosc.java

+package klasy;
+
+public class Mutowalnosc {
+
+    static void metoda(String s, StringBuilder b, int x, Integer y) {
+        // s += " ma kota";
+        s = s.concat(" ma kota");
+        b = b.append(" ma psa");
+        x += 15;
+        y += 25;
+    }
+
+    public static void main(String[] args) {
+        String s = "Ala";
+        StringBuilder b = new StringBuilder("Ola");
+        int x = 1000;
+        Integer y = 2000;
+        // Integer y = new Integer(2000);
+
+        metoda(s, b, x, y);
+        System.out.println(s);
+        System.out.println(b);
+        System.out.println(x);
+        System.out.println(y);
+    }
+}

src/main/java/klasy/Osoba.java

+package klasy;
+
+public class Osoba {
+    static final int WIEK_PELNOLETNIOSCI = 18;
+    String imie, nazwisko;
+    int wiek;
+
+    public Osoba() {
+        super();
+    }
+
+    public Osoba(String imie, String nazwisko, int wiek) {
+        this.imie = imie;
+        this.nazwisko = nazwisko;
+        this.wiek = wiek;
+    }
+
+    boolean pelnoletnia() {
+        return wiek >= WIEK_PELNOLETNIOSCI;
+    }
+
+    void przedstawSie() {
+        System.out.println("Nazywam się " + imie + " " + nazwisko + " i mam " + wiek + " lat.");
+    }
+
+    @Override
+    public String toString() {
+        return "Osoba{" +
+                "imie='" + imie + '\'' +
+                ", nazwisko='" + nazwisko + '\'' +
+                ", wiek=" + wiek +
+                '}';
+    }
+}

src/main/java/klasy/Polimorfizm1.java

+package klasy;
+
+public class Polimorfizm1 {
+    public static void main(String[] args) {
+        Osoba osoba = new Osoba("Ala", "Kowalska", 30);
+        Student student = new Student("Adam", "Abacki", 22, "geologia", 2);
+        System.out.println(osoba);
+        osoba.przedstawSie();
+        System.out.println();
+
+        System.out.println(student);
+        student.przedstawSie();
+        System.out.println();
+
+        Osoba ktos;
+        ktos = osoba;
+        ktos.przedstawSie();
+
+        // mimo tego, że zmienna jest typu Osoba, to gdy znajduje się w niej obiekt klasy Student,
+        // metoda przedstawSie wykona się w wersji studenckiej
+        ktos = student;
+        ktos.przedstawSie();
+        System.out.println();
+
+        Sklep sklep = new Sklep("Lidl", 6);
+        sklep.sprzedajPiwo(osoba);
+        sklep.sprzedajPiwo(student);
+        sklep.sprzedajPiwo(ktos);
+
+        // Zauważmy, że ze zmiennej ktos nie da się odczytać pól kierunek i rok, czy ocen
+        // System.out.println(ktos.kierunek);
+        // Bo "nie każda Osoba ma te dane"
+
+        // Ale obiekt można zrzutować do zmiennej typu Student.
+        // Jeśli wiemy, że w zmiennej ktos na pewno jest Student, to można tak:
+        Student s1 = (Student)ktos;
+        System.out.println(s1.kierunek);
+
+        System.out.println( ((Student)ktos).rok );
+
+        // Ale jeśli w zmiennej nie studenta, tylko zwykła osoba, to będzie wyjątek ClassCastException
+//		Student s2 = (Student)osoba;
+//		System.out.println(s2.kierunek);
+
+        // Próba rzutowania na typ zupełnie niespokrewniony, gdzie ewidentnie widać, że nie ma to szans, jest błedem kompilacji
+        // String txt = (String)osoba;
+        // to nie to samo, co zamiana na napis za pomocą toString()
+        // to już się kompiluje, ale powoduje wyjątek ClassCastException
+        // String txt = (String)(Object)osoba;
+
+        // Metoda getClass zwraca aktualną informację o tym, jakiej kalsy jest obiekt.
+        System.out.println(ktos.getClass());
+
+        // Aby sprawdzić, czy rzutowanie będzie możliwe, używamy instanceof:
+        // Gdyby w zmiennej ktos był obiekt klasy StudentInformatyki, to też wyszłoby true
+        if(ktos instanceof Student) {
+            // rzutowanie jest bezpieczne
+            System.out.println( ((Student)ktos).rok );
+        }
+
+        // Od Javy 17 (?) jest dostępne instanceof, które od razu wpisuje wynik do zmiennej:
+        if(ktos instanceof Student s5) {
+            s5.dodajOcene(4);
+            s5.dodajOcene(5);
+            System.out.println(s5.sredniaOcen());
+        }
+
+        // Przypisanie do zmiennej i rzutowanie nie tworzą nowych obiektów, tylko cały czas odnosimy się do tego samego obiektu.
+
+        student.kierunek = "zoologia";
+        student.dodajOcene(5);
+        System.out.println();
+
+        ktos.przedstawSie();
+        System.out.println(student.oceny);
+        System.out.println(student.sredniaOcen());
+        System.out.println(((Student)ktos).sredniaOcen());
+    }
+}

src/main/java/klasy/Polimorfizm2.java

+package klasy;
+
+public class Polimorfizm2 {
+
+	public static void main(String[] args) {
+		// Dzięki temu, że "Student jest Osobą" i "Pracownik jest Osobą",
+		// można obiekty tych klas umieści w tablicy (kolekcji itp.) osób.
+		Osoba[] osoby = {
+			new Osoba("Ala", "Kowalska", 44),
+			new Osoba("Ola", "Malinowska", 13),
+			new Student("Adam", "Abacki", 20, "medycyna", 1),
+			new StudentInformatyki("Karol", "Infobacki", 23, 3),
+			new Pracownik("Jan", "Kowalski", 40, "kierowca", 3300),
+		};
+		
+        // Przeglądając elementy tablicy wiemy na pewno, że są to Osoby,
+        // ale dodatkowo może się okazać, że niektóre osoby są Student albo Pracownik
+        // Każda osoba posiada imię, nazwisko i wiek - można te dany odczytać.
+        // Każda osoba potrafi się przedstawić - można wywołać przedstawSie()
+        // ale w każdej podklasie ta metoda może mieć inną treść ("overriding").
+        // Wykona się wersja z właściwej klasy.
+        for (Osoba osoba : osoby) {
+            System.out.println("* kolejna osoba to " + osoba.imie + " " + osoba.nazwisko);
+            System.out.println("    " + osoba);
+            System.out.print("    ");
+            // System.out.println(osoba.kierunek); // nie każda osoba jest studentem
+            osoba.przedstawSie();
+            System.out.println("    to jest obiekt klasy: " + osoba.getClass().getSimpleName());
+            
+            // Można jawnie sprawdzić czy zmienna wskazuje na obiekt określonej klasy
+            // (lub dalszej podklasy - np. StudentInformatyki jest w tym sensie Studentem)
+            if(osoba instanceof Student) {
+                // Jeśli tak jest, to możemy bezpiecznie zrzutować (cast) zmienną na typ Student
+                Student student = (Student) osoba;
+                
+                System.out.println("    To jest student kierunku " + student.kierunek
+                        + ", który ma średnią ocen " + student.sredniaOcen());
+            }
+            
+            // natomiast taki if nie byłby prawdziwy dla obiektu klasy StudentInformatyki
+            if(osoba.getClass() == Student.class) {
+                System.out.println("    to jest konkretnie klasy Student");
+            }
+
+            System.out.println();
+        }
+	}
+
+}

src/main/java/klasy/Pracownik.java

+package klasy;
+
+import java.math.BigDecimal;
+
+// W Javie nie ma "wielodziedziczenia", klasa ma dokładnie jedną nadklasę.
+public class Pracownik extends Osoba {
+	private final static int PENSJA_MINIMALNA = 4000;
+	
+	String zawod;
+	BigDecimal pensja;
+	
+	Pracownik() {
+		
+	}
+
+	Pracownik(String imie, String nazwisko, int wiek, String zawod, BigDecimal pensja) {
+		// wywołanie konstruktora z nadklasy
+		super(imie, nazwisko, wiek);
+		this.zawod = zawod;
+		this.pensja = pensja;
+	}
+
+	Pracownik(String imie, String nazwisko, int wiek, String zawod, double pensja) {
+		// wywołanie innego konstruktora z tej samej klasy
+		this(imie, nazwisko, wiek, zawod, BigDecimal.valueOf(pensja).setScale(2));
+	}
+	
+	Pracownik(String imie, String nazwisko, int wiek, String zawod, int pensja) {
+		this(imie, nazwisko, wiek, zawod, BigDecimal.valueOf(pensja).setScale(2));
+	}
+
+	Pracownik(String imie, String nazwisko, int wiek, String zawod, String pensja) {
+		this(imie, nazwisko, wiek, zawod, new BigDecimal(pensja));
+	}
+
+	Pracownik(String imie, String nazwisko, int wiek, String zawod) {
+		this(imie, nazwisko, wiek, zawod, PENSJA_MINIMALNA);
+	}
+	// tworzenie wielu konstruktorów w tej samej klasie to jest "przeciążanie konstruktorów" / "overloading"
+	
+	@Override
+	public void przedstawSie() {
+		System.out.println("Dzień dobry, tu "+ imie + ", pracuję jako " + zawod + " i zarabiam " + pensja +" zł.");
+	}
+
+	@Override
+	public String toString() {
+		return "Pracownik [zawod=" + zawod + ", pensja=" + pensja + ", imie=" + imie + ", nazwisko=" + nazwisko
+				+ ", wiek=" + wiek + "]";
+	}
+	
+}

src/main/java/klasy/Program.java

+package klasy;
+
+public class Program {
+
+    public static void main(String[] args) {
+        Osoba a = new Osoba();
+        System.out.println(a);
+        System.out.println(a.imie + " " + a.nazwisko + " " + a.wiek);
+        a.przedstawSie();
+
+        a.imie = "Ala";
+        a.nazwisko = "Kowalska";
+        a.wiek = 30;
+        System.out.println(a);
+        System.out.println(a.imie + " " + a.nazwisko + " " + a.wiek);
+        a.przedstawSie();
+        System.out.println();
+
+        Osoba b = new Osoba("Ola", "Malinowska", 40);
+        System.out.println(b);
+        b.przedstawSie();
+        System.out.println();
+
+        Student st = new Student();
+        st.imie = "Adam";
+        st.nazwisko = "Malinowski";
+        st.wiek = 22;
+        st.kierunek = "historia";
+        st.rok = 3;
+        System.out.println(st);
+        st.przedstawSie();
+
+        System.out.println();
+
+        // konstruktory nie są automatycznie dziedziczone
+        // Student st2 = new Student("Jan", "Kowalski", 20);
+        Student st2 = new Student("Jan", "Kowalski", 20, "medycyna", 1);
+        st2.przedstawSie();
+
+
+    }
+}

src/main/java/klasy/Referencje1.java

+package klasy;
+
+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/main/java/klasy/Referencje2.java

+package klasy;
+
+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/main/java/klasy/Referencje3.java

+package klasy;
+
+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/main/java/klasy/Sklep.java

+package klasy;
+
+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("^^^^^^^^^^^^^^^");
+	}
+
+}
\ No newline at end of file

src/main/java/klasy/Student.java

+package klasy;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Student extends Osoba {
+    String kierunek;
+    int rok;
+    List<Integer> oceny = new ArrayList<>();
+
+    // blok inicjalizacyjny - wykonywane podczas tworzenia każdego obiektu jeszcze przed konstruktorem
+    { System.out.println("init Student"); }
+
+    // blok inicjalizacyjny statyczny - wykonywane podczas ładowania klasy do pamięci (gdy klasa jest potrzebna po raz pierwszy)
+    static { System.out.println("static Student"); }
+
+    public Student() {
+        // nie trzeba pisać super(); , bo Java i tak to doda
+    }
+
+    public Student(String imie, String nazwisko, int wiek, String kierunek, int rok) {
+        // wywołanie konstruktora z nadklasy (a mówiąc trochę bardziej precyzyjnie: wskazanie który konstruktor ma być użyty - bo Java ZAWSZE uruchamia jedne z konstruktorów z nadklasy)
+        super(imie, nazwisko, wiek);
+        this.kierunek = kierunek;
+        this.rok = rok;
+    }
+
+    // Jeśli chodzi o metody, podklasa może
+    // 1) Nie zmieniać metod odziedziczonych z nadklasy
+    // przykład: pelnoletnia()
+    // Taka metoda w nadklasie może być zadeklarowana jako "final" - to znaczy,
+    // że jest to ostateczna definicja i podklasa nie może jeje zmienić
+
+    // 2) Dodać nowe metody, których nie było w nadklasie
+    void dodajOcene(int ocena) {
+        oceny.add(ocena);
+    }
+
+    double sredniaOcen() {
+        return oceny.stream()
+                .mapToInt(Integer::intValue)
+                .average()
+                .orElse(0);
+    }
+
+    // 3) Nadpisać (override) metody, które były zdefiniowane w nadklasie
+    //    czyli dla istniejących metoda podać inną treść.
+
+    void przedstawSie() {
+        System.out.println("Hej tu " + imie + " " + nazwisko + ", studiuję " + kierunek + ", jestem na " + rok + " roku");
+    }
+
+    // Od Javy 5 przed definicją metody, która nadpisuje definicję z nadklasy, można umieścić adnotację @Override
+    // Ważne: nawet bez tej adnotacji nadpisanie jest skuteczne. Adnotacja tylko:
+    // - zwiększa czytelność kodu ("rzuca się w oczy")
+    // - powoduje błąd kompilacji, gdyby okazało się, że jednak tutaj nie nadpisujemy metody, tylko definiujemy nową (np. literówka w nazwie, parametry innego typu)
+    @Override
+    public String toString() {
+        return super.toString() + ", student " + rok + " roku kierunku " + kierunek;
+    }
+
+}

src/main/java/klasy/StudentInformatyki.java

+package klasy;
+
+public class StudentInformatyki extends Student {
+	// Czasami podklasa nie ma nowych pól ani metod,
+	// a jest wprowadzana po to, aby ustalić pewne szczegóły
+	// Jest to podklasa / podzbiór w sensie matematycznym (logicznym).
+	
+	public StudentInformatyki(String imie, String nazwisko, int wiek, int rok) {
+		// ustalamy, że kierunkiem studiów jest "informatyka" i nie może być inaczej
+		super(imie, nazwisko, wiek, "informatyka", rok);
+	}
+}