Klasy - przykłady dziedziczenia

src/p10_klasy_podstawy/Dziedziczenie1.java

+package p10_klasy_podstawy;
+
+public class Dziedziczenie1 {
+
+    public static void main(String[] args) {
+        Osoba osoba = new Osoba("Ala", "Kowalska", 30);
+        System.out.println(osoba);
+        System.out.println(osoba.imie + " " + osoba.nazwisko);
+        osoba.przedstawSie();
+        System.out.println();
+        
+        Student student = new Student();
+        student.imie = "Jan";
+        student.nazwisko = "Kowalski";
+        student.wiek = 20;
+        student.rok = 2;
+        student.kierunek = "geologia";
+        
+        // Obiekt klasy Student posiada te pola i metody, co każda Osoba
+        System.out.println(student);
+        System.out.println(student.imie + " " + student.nazwisko);
+        student.przedstawSie();
+        
+        // ale dodatkowo posiada pola i metody zdefiniowane w klasie Student
+        System.out.println(student.rok + " rok kierunku " + student.kierunek);
+        student.dodajOcene(5);
+        student.dodajOcene(4);
+        student.dodajOcene(4);
+        System.out.println(student.sredniaOcen());
+        // zwykła Osoba tego nie posiada
+        // System.out.println(osoba.sredniaOcen());
+        
+        // O ile pola i metody są dziedziczone przez podklasę, to konstruktory nie.
+        // Student student2 = new Student("Adam", "Abacki", 22);
+        // Student student2 = new Osoba("Adam", "Abacki", 22);
+        
+        Student student3 = new Student("Kasia", "Kuchcińska", 23, 3, "medycyna");
+        System.out.println(student3);
+    }
+
+}

src/p10_klasy_podstawy/Dziedziczenie2.java

+package p10_klasy_podstawy;
+
+public class Dziedziczenie2 {
+
+    public static void main(String[] args) {
+        Osoba osoba = new Osoba("Ala", "Kowalska", 30);
+        Student student = new Student("Jan", "Kowalski", 20, 2, "geologia");
+
+        osoba.przedstawSie();
+        student.przedstawSie();
+        
+        System.out.println();
+
+        // Nawet, gdy zmienna jest typu Osoba, ale w tej zmiennej jest referencja do
+        // obiektu klasy Student,
+        // to przy wywołaniu metody wykona się wersja z klasy Student.
+        // W mechanizmie override decydujące znaczenie ma typ obiektu w czasie
+        // wykonania.
+        Osoba ktos;
+        ktos = osoba;
+        ktos.przedstawSie();
+        ktos = student;
+        ktos.przedstawSie();
+        System.out.println();
+
+        Sklep sklep = new Sklep("Żabka", 7);
+        sklep.sprzedajPiwo(osoba);
+        sklep.sprzedajPiwo(student);
+
+        System.out.println();
+        Osoba[] osoby = { osoba, student };
+        for (Osoba o : osoby) {
+            o.przedstawSie();
+        }
+
+        // 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);
+
+        // 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());
+        }
+
+    }
+
+}

src/p10_klasy_podstawy/Dziedziczenie3.java

+package p10_klasy_podstawy;
+
+public class Dziedziczenie3 {
+
+    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, 1, "medycyna"),
+            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/p10_klasy_podstawy/Konto.java

+package p10_klasy_podstawy;
+
+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 " + this.numer + ", saldo " + this.saldo + ", wł " + this.wlasciciel;
+    }
+
+    void wplata(int kwota) {
+        this.saldo += kwota;
+    }
+
+    void wyplata(int kwota) {
+        this.saldo -= kwota;
+    }
+}

src/p10_klasy_podstawy/Pracownik.java

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

+package p10_klasy_podstawy;
+
+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/p10_klasy_podstawy/Student.java

+package p10_klasy_podstawy;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Student extends Osoba {
+    int rok;
+    String kierunek;
+    List<Integer> oceny = new ArrayList<>();
+    
+    Student() {
+    }
+    
+    Student(String imie, String nazwisko, int wiek, int rok, String kierunek) {
+        // wywołanie konstruktora z nadklasy; to musi być pierwsza instrukcja w konstruktorze podklasy
+        super(imie, nazwisko, wiek);
+        this.rok = rok;
+        this.kierunek = kierunek;
+    }
+    
+    // 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() {
+        double suma = 0;
+        for(Integer ocena : oceny) {
+            suma += ocena;
+        }
+        return suma / oceny.size();
+    }
+
+    // 3) Nadpisać (override) metody, które były zdefiniowane w nadklasie
+    //    czyli dla istniejących metoda podać inną treść.
+    @Override
+    public void przedstawSie() {
+        System.out.println("Hej, tu " + imie + " " + nazwisko + ", studiuję kierunek " + kierunek + " 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/p10_klasy_podstawy/StudentInformatyki.java

+package p10_klasy_podstawy;
+
+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, rok, "informatyka");
+    }
+}