Skip to content

2
20250331
Commit 228dad10 by Patryk Czarnik
Options

referencje

parent cdc7a659
Showing with 874 additions and 0 deletions
src/main/java/gotowe/p11_klasy_dalej/Dziedziczenie.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/main/java/gotowe/p11_klasy_dalej/Konto.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/gotowe/p11_klasy_dalej/KontoTest.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/main/java/gotowe/p11_klasy_dalej/Osoba.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/main/java/gotowe/p11_klasy_dalej/Polimorfizm1.java 0 → 100644
package gotowe.p11_klasy_dalej;
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();
// 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("Lidl", 6);
sklep.sprzedajPiwo(osoba);
sklep.sprzedajPiwo(student);
// 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());
}
// 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/gotowe/p11_klasy_dalej/Polimorfizm2.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/gotowe/p11_klasy_dalej/Porownywanie.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/main/java/gotowe/p11_klasy_dalej/Pracownik.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/gotowe/p11_klasy_dalej/Przyklad0.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/main/java/gotowe/p11_klasy_dalej/Przyklad1.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/main/java/gotowe/p11_klasy_dalej/Przyklad2_Konstruktory.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/main/java/gotowe/p11_klasy_dalej/Referencje1.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/gotowe/p11_klasy_dalej/Referencje2.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/gotowe/p11_klasy_dalej/Referencje3.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/gotowe/p11_klasy_dalej/Sklep.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/main/java/gotowe/p11_klasy_dalej/SklepProgram.java 0 → 100644
package gotowe.p11_klasy_dalej;
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/main/java/gotowe/p11_klasy_dalej/Student.java 0 → 100644
package gotowe.p11_klasy_dalej;
import java.util.ArrayList;
import java.util.List;
public class Student extends Osoba {
String kierunek;
int rok;
List<Integer> oceny = new ArrayList<>();
{ System.out.println("init Student"); }
static { System.out.println("static Student"); }
public Student() {
}
public Student(String imie, String nazwisko, int wiek, String kierunek, int rok) {
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: jestPelnoletnia()
// 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/gotowe/p11_klasy_dalej/StudentInformatyki.java 0 → 100644
package gotowe.p11_klasy_dalej;
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);
}
}
src/main/java/gotowe/p11_klasy_dalej/Wypisywanie.java 0 → 100644
package gotowe.p11_klasy_dalej;
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);
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment