1. Klasa abstrakcyjna: powtórzmy podstawy
Zanim przejdziemy do porównania, odświeżmy, czym jest klasa abstrakcyjna.
Klasa abstrakcyjna — to klasa, której nie można utworzyć bezpośrednio (nie da się napisać new Animal()), ale może zawierać zarówno zwykłe metody (z implementacją), jak i metody abstrakcyjne (bez implementacji). Klasa abstrakcyjna jest często używana jako podstawa dla innych klas, które dziedziczą jej zachowanie i/lub są zobowiązane zaimplementować pewne metody.
Na przykład, jeśli w naszej aplikacji są różne środki transportu, możemy wprowadzić klasę abstrakcyjną Transport:
public abstract class Transport {
private String model;
public Transport(String model) {
this.model = model;
}
public String getModel() {
return model;
}
// Metoda abstrakcyjna — brak implementacji, tylko deklaracja
public abstract void move();
// Zwykła metoda — posiada implementację
public void printInfo() {
System.out.println("Model środka transportu: " + model);
}
}
Cechy klasy abstrakcyjnej:
- Może zawierać pola (stan).
- Może zawierać zaimplementowane metody.
- Może zawierać metody abstrakcyjne (obowiązkowe do zaimplementowania w klasach potomnych).
- Nie można tworzyć instancji bezpośrednio.
- Służy do definiowania wspólnego zachowania i stanu.
2. Interfejs: powtórzmy podstawy
Interfejs — to zbiór metod, które klasa musi zaimplementować. Interfejs nie opisuje stanu (nie może mieć zwykłych pól, jedynie stałe) i nie zawiera implementacji metod (do Java 8). Interfejs to czysty kontrakt: „Jeśli mnie zaimplementujesz, musisz umieć zrobić to i owo”.
Przykład interfejsu:
public interface Movable {
void move(int x, int y);
}
Cechy interfejsu:
- Nie zawiera stanu (tylko public static final stałe).
- Do Java 8 — tylko metody abstrakcyjne (od Java 8 pojawiły się metody default i static, ale o nich później).
- Metody są domyślnie public abstract.
- Klasa może implementować wiele interfejsów.
- Służy do opisu możliwości, „co klasa potrafi robić”.
3. Tabela porównawcza: klasa abstrakcyjna vs interfejs
Czas porównać te dwa narzędzia wprost! Oto obrazowa tabela:
| Cecha | Klasa abstrakcyjna | Interfejs |
|---|---|---|
| Składnia | |
|
| Czy można tworzyć instancję? | Nie | Nie |
| Czy może zawierać zwykłe metody? | Tak | Do Java 8 — nie, od Java 8 — tylko default/static |
| Czy może zawierać metody abstrakcyjne? | Tak | Tak (wszystkie metody do Java 8 są abstrakcyjne) |
| Czy może zawierać pola (stan)? | Tak (dowolne pola) | Tylko public static final (stałe) |
| Czy może zawierać konstruktory? | Tak | Nie |
| Dziedziczenie | Tylko jedna klasa (abstrakcyjna lub zwykła) | Można zaimplementować wiele interfejsów |
| Modyfikatory metod | Dowolne (public, protected, private) | Metody są domyślnie public abstract. Od Java 9 można dodawać metody private do użytku wewnątrz interfejsu |
| Dziedziczenie poprzez | |
|
| Typowe zastosowanie | Wspólna implementacja i stan | Opis możliwości, ról |
| Przykłady z JDK | |
|
4. Kiedy używać interfejsu, a kiedy klasy abstrakcyjnej?
Interfejs stosuj, gdy:
- Chcesz opisać, „co klasa potrafi robić”, nie wnikając w to, jak to robi.
- Potrzebujesz, aby klasa mogła zaimplementować kilka niezależnych możliwości.
- Przykład: Comparable (można porównywać), Serializable (można serializować), Runnable (można uruchamiać w wątku).
Klasy abstrakcyjnej używaj, gdy:
- Chcesz zdefiniować wspólną implementację i stan, które będą mieć wszyscy potomkowie.
- Potrzebujesz, aby wszyscy potomkowie mieli określone pola lub metody z implementacją.
- Dziedziczenie — ściśle „jeden do jednego”: klasa może dziedziczyć tylko po jednej klasie (zwykłej lub abstrakcyjnej).
Życiowe analogie
- Interfejs — to jak „prawo jazdy”: jeśli je masz, możesz prowadzić samochód, ale nikt nie mówi, jakim konkretnie i jak to robisz.
- Klasa abstrakcyjna — to jak „ogólny projekt samochodu”: wszystkie auta mają kierownicę, pedały, silnik, ale każda marka realizuje detale po swojemu.
5. Przykłady ze standardowej biblioteki Java
Interfejs: Comparable
public interface Comparable<T> {
int compareTo(T o);
}
Każda klasa, która implementuje ten interfejs, musi zaimplementować metodę compareTo. Na przykład String, Integer, LocalDate i wiele innych.
Klasa abstrakcyjna: AbstractList
public abstract class AbstractList<E> implements List<E> {
// Domyślna implementacja niektórych metod List
// Niektóre metody pozostawiono jako abstrakcyjne
}
AbstractList implementuje już część zachowania kolekcji (np. metody dodawania/usuwania), ale pozostawia niektóre metody abstrakcyjne, aby klasy potomne mogły zaimplementować je po swojemu.
6. Przykłady kodu: porównanie na praktyce
Interfejs
Utwórzmy interfejs i klasę, która go implementuje.
public interface Printable {
void print();
}
public class Document implements Printable {
@Override
public void print() {
System.out.println("Drukuję dokument...");
}
}
Klasa abstrakcyjna
Teraz klasa abstrakcyjna i jej potomek.
public abstract class Machine {
public void turnOn() {
System.out.println("Maszyna włączona.");
}
public abstract void work();
}
public class Printer extends Machine {
@Override
public void work() {
System.out.println("Drukarka drukuje...");
}
}
Klasa implementuje oba: interfejs i klasę abstrakcyjną
public class SmartPrinter extends Machine implements Printable {
@Override
public void work() {
System.out.println("Inteligentna drukarka pracuje...");
}
@Override
public void print() {
System.out.println("Inteligentna drukarka drukuje...");
}
}
7. Wielokrotna implementacja interfejsów: dlaczego to jest fajne
W Javie klasa może dziedziczyć tylko po jednej klasie (abstract lub zwykłej), ale implementować dowolną liczbę interfejsów! To pozwala tworzyć elastyczne, łatwo rozszerzalne architektury.
public interface Scannable {
void scan();
}
public class MultiFunctionPrinter extends Machine implements Printable, Scannable {
@Override
public void work() {
System.out.println("Wielofunkcyjna drukarka pracuje...");
}
@Override
public void print() {
System.out.println("Wielofunkcyjna drukarka drukuje...");
}
@Override
public void scan() {
System.out.println("Wielofunkcyjna drukarka skanuje...");
}
}
Kiedy co wybrać?
- Jeśli projektujesz podstawową funkcjonalność ze wspólnym stanem (np. pola), użyj klasy abstrakcyjnej.
- Jeśli chcesz nadać obiektom „etykiety możliwości” (np. „umie drukować”, „umie się porównywać”, „umie się serializować”) — użyj interfejsów.
- Jeśli nie masz pewności — zacznij od interfejsu. W Javie to dobry zwyczaj: interfejsy dają większą elastyczność i rozszerzalność.
8. Typowe błędy i pułapki
Błąd nr 1: Próba dziedziczenia po wielu klasach — Java na to nie pozwala!
Klasa może dziedziczyć tylko po jednej klasie, ale implementować wiele interfejsów. Na przykład, class A extends B, C — błąd, a class A extends B implements X, Y, Z — proszę bardzo.
Błąd nr 2: Mylenie pól interfejsu i klasy.
W interfejsie można deklarować tylko stałe (public static final). Nie można zadeklarować zwykłego stanu, na przykład private int count; — kompilator natychmiast cię zatrzyma.
Błąd nr 3: Niezaimplementowanie wszystkich metod interfejsu.
Jeśli klasa nie implementuje choć jednej metody interfejsu — musi zostać zadeklarowana jako abstract, w przeciwnym razie kompilator zgłosi błąd.
Błąd nr 4: Próba utworzenia instancji interfejsu lub klasy abstrakcyjnej.
Oba te typy to „półprodukty”. Można je tylko rozszerzać, ale nie można utworzyć bezpośrednio:
Printable p = new Printable(); // Błąd!
Machine m = new Machine(); // Błąd!
Błąd nr 5: Przekonanie, że interfejs może mieć konstruktor.
Interfejsy nie mogą mieć konstruktorów, ponieważ nie opisują stanu obiektów. Tylko klasy (zwykłe i abstrakcyjne) mogą je mieć.
GO TO FULL VERSION