CodeGym /Kursy /JAVA 25 SELF /Implementacja abstrakcji i hierarchii

Implementacja abstrakcji i hierarchii

JAVA 25 SELF
Poziom 19, Lekcja 2
Dostępny

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
abstract
abstract
-
Circle zaimplementowano zaimplementowano
radius
Rectangle zaimplementowano zaimplementowano
width, height

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.

1
Zadanie
JAVA 25 SELF, poziom 19, lekcja 2
Niedostępne
Symulator transportu: samochód jedzie 🛣️
Symulator transportu: samochód jedzie 🛣️
1
Zadanie
JAVA 25 SELF, poziom 19, lekcja 2
Niedostępne
Biblioteka figur geometrycznych 🔵⬛
Biblioteka figur geometrycznych 🔵⬛
1
Zadanie
JAVA 25 SELF, poziom 19, lekcja 2
Niedostępne
Podstawowy system zarządzania personelem 🧑‍💼
Podstawowy system zarządzania personelem 🧑‍💼
1
Zadanie
JAVA 25 SELF, poziom 19, lekcja 2
Niedostępne
Elastyczny system płatności w sklepie 💰
Elastyczny system płatności w sklepie 💰
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION