1. Budowanie hierarchii: od abstrakcji do szczegółów
Implementacja abstrakcji i hierarchii to sposób na strukturyzację kodu od ogólnych zasad do konkretnych detali. Najpierw opisujemy, co powinny potrafić wszystkie obiekty (abstrakcja), a potem doprecyzowujemy, jak dokładnie robi to każda konkretna klasa.
W programowaniu, jak i w życiu, wszystko zaczyna się od pytań. Na przykład: „Co wspólnego mają koło i prostokąt?” Odpowiedź: oba to figury. A co jest wspólne dla figur? Zwykle mają pole i można je narysować.
W Javie wyraża się to przez klasę abstract:
public abstract class Shape {
public abstract double area();
public abstract void draw();
}
Tutaj mówimy:
- Każda figura musi umieć obliczać swoje pole (area()).
- Każda figura musi umieć się narysować (draw()).
- Jak dokładnie to robi — to nas na razie nie obchodzi.
Teraz utwórzmy konkretne figury:
public class Circle extends Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public double area() {
return Math.PI * radius * radius;
}
@Override
public void draw() {
System.out.println("Rysujemy koło o promieniu " + radius);
}
}
public class Rectangle extends Shape {
private double width, height;
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
@Override
public double area() {
return width * height;
}
@Override
public void draw() {
System.out.println("Rysujemy prostokąt " + width + "x" + height);
}
}
Co zrobiliśmy?
- Wyniesiono część wspólną do klasy abstrakcyjnej.
- Uszczegółowiono zachowanie w klasach dziedziczących.
Schematycznie:
. Shape
/ \
Circle Rectangle
Tabela: co gdzie zaimplementowano
| Klasa | area() | draw() | Własne pola |
|---|---|---|---|
| Shape | |
|
- |
| Circle | zaimplementowano | zaimplementowano | |
| Rectangle | zaimplementowano | zaimplementowano | |
2. Dlaczego to wygodne? (i dlaczego to w ogóle działa)
Jednolity interfejs do pracy z różnymi obiektami
Załóżmy, że masz kolekcję figur:
Shape[] shapes = {
new Circle(5),
new Rectangle(3, 4),
new Circle(2.5)
};
Możesz iterować po nich jednakowo, nie myśląc o typie:
for (Shape shape : shapes) {
shape.draw();
System.out.println("Pole: " + shape.area());
}
Niech JVM sama rozstrzyga, co jest kołem, a co prostokątem! To właśnie polimorfizm (już o nim mówiliśmy i będziemy mówić bardziej szczegółowo — w następnym bloku).
Łatwość rozszerzania
Chcesz dodać trójkąt? Po prostu piszesz (nowy typ — starego kodu nie zmieniamy): Triangle extends Shape.
public class Triangle extends Shape {
private double base, height;
public Triangle(double base, double height) {
this.base = base;
this.height = height;
}
@Override
public double area() {
return 0.5 * base * height;
}
@Override
public void draw() {
System.out.println("Rysujemy trójkąt: podstawa " + base + ", wysokość " + height);
}
}
Reszty kodu (np. iteracji po liście figur) nie trzeba zmieniać.
Unikanie duplikacji kodu
Jeśli wszystkie figury mają wspólną właściwość (np. kolor), wygodnie wynieść ją do klasy abstrakcyjnej:
public abstract class Shape {
private String color = "czarny";
public String getColor() { return color; }
public void setColor(String color) { this.color = color; }
public abstract double area();
public abstract void draw();
}
Teraz każdy potomny — zarówno koło, jak i trójkąt — odziedziczy kolor.
3. Praktyka: tworzymy mini‑edytor grafiki
Spróbujmy zebrać wszystko razem. Wyobraź sobie, że tworzysz prosty edytor graficzny.
Klasa abstrakcyjna Figure
public abstract class Figure {
private String color = "black";
public String getColor() { return color; }
public void setColor(String color) { this.color = color; }
public abstract void draw();
public abstract void resize(double factor);
}
Konkretne figury
public class Line extends Figure {
private double length;
public Line(double length) {
this.length = length;
}
@Override
public void draw() {
System.out.println("Rysujemy linię o długości " + length + " kolorem " + getColor());
}
@Override
public void resize(double factor) {
length *= factor;
System.out.println("Nowa długość linii: " + length);
}
}
public class Ellipse extends Figure {
private double a, b;
public Ellipse(double a, double b) {
this.a = a;
this.b = b;
}
@Override
public void draw() {
System.out.println("Rysujemy elipsę z osiami " + a + " i " + b + " kolorem " + getColor());
}
@Override
public void resize(double factor) {
a *= factor;
b *= factor;
System.out.println("Nowe osie elipsy: " + a + ", " + b);
}
}
Chcesz dodać nowe narzędzie, na przykład Polygon? Po prostu utwórz nową klasę — cały kod edytora działa przez abstrakcyjną Figure.
Użycie w kodzie
Figure[] figures = {
new Line(10),
new Ellipse(5, 3)
};
for (Figure figure : figures) {
figure.setColor("red");
figure.draw();
figure.resize(1.5);
}
Wynik:
Rysujemy linię o długości 10.0 kolorem red
Nowa długość linii: 15.0
Rysujemy elipsę z osiami 5.0 i 3.0 kolorem red
Nowe osie elipsy: 7.5, 4.5
Wizualizacja hierarchii
. Figure
/ \
Line Ellipse
4. Jak uniknąć duplikacji: wspólne pola i metody
Czasem wszyscy potomni mają nie tylko wspólne metody, ale i wspólne pola (np. współrzędne środka). Klasa abstrakcyjna to idealne miejsce na to:
public abstract class Figure {
private double x, y; // współrzędne środka
public Figure(double x, double y) {
this.x = x;
this.y = y;
}
public void moveTo(double newX, double newY) {
x = newX;
y = newY;
System.out.println("Figura przeniesiona do punktu (" + x + ", " + y + ")");
}
public abstract void draw();
}
Teraz dowolne Line lub Ellipse mogą się przemieszczać bez ponownej implementacji tej metody.
5. Jeszcze jeden przykład: systemy płatności
Abstrakcja to nie tylko figury! Wyobraź sobie, że piszesz system obsługi płatności.
Klasa abstrakcyjna Payment
public abstract class Payment {
public abstract void process();
}
Konkretne implementacje
public class CreditCardPayment extends Payment {
@Override
public void process() {
System.out.println("Przetwarzanie płatności z karty kredytowej");
}
}
public class PaypalPayment extends Payment {
@Override
public void process() {
System.out.println("Przetwarzanie płatności przez PayPal");
}
}
Użycie
Payment[] payments = {
new CreditCardPayment(),
new PaypalPayment()
};
for (Payment payment : payments) {
payment.process();
}
Wynik:
Przetwarzanie płatności z karty kredytowej
Przetwarzanie płatności przez PayPal
6. Zalety takiego podejścia
- Jednolity interfejs: można pracować z różnymi obiektami w ten sam sposób.
- Rozszerzalność: dodawanie nowych typów obiektów nie wymaga przepisywania starego kodu.
- Minimum duplikacji: część wspólna jest wyniesiona do bazowej klasy abstrakcyjnej.
- Elastyczność: można używać kolekcji typów abstrakcyjnych, nie martwiąc się o szczegóły.
7. Przykład z życia: transport
Abstrakcja pojawia się nie tylko w podręcznikach. Na przykład, jeśli projektujesz system do zarządzania transportem:
public abstract class Transport {
public abstract void move();
public abstract void fuelUp();
}
Konkretne rodzaje transportu implementują szczegóły:
public class Car extends Transport {
@Override
public void move() {
System.out.println("Samochód jedzie po drodze");
}
@Override
public void fuelUp() {
System.out.println("Tankujemy benzynę");
}
}
public class Bicycle extends Transport {
@Override
public void move() {
System.out.println("Rower kręci pedałami");
}
@Override
public void fuelUp() {
System.out.println("Rower nie potrzebuje paliwa, tylko kanapek dla rowerzysty!");
}
}
8. Przydatny schemat: jak budować hierarchię abstrakcji
[Klasa abstrakcyjna]
|
[Konkretna podklasa]
|
[Jeszcze bardziej konkretna podklasa] (jeśli potrzeba)
- Wszystko wspólne — na górze!
- Wszystko unikalne — na dole!
9. Typowe błędy przy implementacji abstrakcji i hierarchii
Błąd nr 1: Duplikacja kodu w podklasach.
Jeśli zauważysz, że w każdej podklasie piszesz te same pola lub metody — to sygnał, by wynieść je do klasy abstrakcyjnej. Nie bój się zrobić abstrakcji „szerszej”, jeśli to zmniejszy duplikację.
Błąd nr 2: Naruszenie zasady „od ogólnego do szczegółowego”.
Czasem początkujący programiści zaczynają budować hierarchię „od detali”, zapominając o tym, co wspólne. W rezultacie pojawiają się dziwne klasy w rodzaju RedCircleWithShadow, które słabo pasują do ogólnej struktury. Zawsze najpierw wydzielaj abstrakcję, a potem szczegóły.
Błąd nr 3: Zbyt głębokie hierarchie.
Jeśli łańcuch dziedziczenia ma więcej niż 3–4 poziomy, zastanów się: może czas użyć kompozycji lub interfejsów zamiast dziedziczenia?
Błąd nr 4: Wymuszona implementacja nieadekwatnych metod.
Jeśli klasa abstrakcyjna zawiera zbyt wiele metod abstrakcyjnych, nieadekwatnych dla części potomnych, warto przemyśleć strukturę. Na przykład nie wszystkie środki transportu potrzebują metody fuelUp() (rowerowi nie jest ona potrzebna).
Błąd nr 5: Mylenie klasy abstrakcyjnej z interfejsem.
Klasa abstrakcyjna — gdy istnieje wspólny stan i/lub częściowa implementacja. Interfejs — gdy trzeba tylko „obiecać” istnienie metod, ale nie przechowywać danych i nie implementować zachowania. Nie mieszaj tych podejść bez potrzeby.
GO TO FULL VERSION