Jak działają dziedziczenie, klasy abstrakcyjne i interfejsy?

Question

Accepted Answer

PHP obsługuje dziedziczenie OOP i abstrakcję poprzez trzy powiązane mechanizmy: **dziedziczenie klas** (`extends`), **klasy abstrakcyjne** (częściowe klasy bazowe) i **interfejsy** (kontrakty). Każdy z nich służy innemu celowi projektowemu.

## Dziedziczenie — rozszerzenie klasy rodzicielskiej

```php
<?php
class Animal {
    public function __construct(protected string $name) {}
    public function eat(): string { return "{$this->name} eats"; }
}

class Dog extends Animal {              // Dog inherits Animal's members
    public function bark(): string { return "Woof"; }
    public function eat(): string {     // override
        return parent::eat() . " noisily";   // parent:: calls the superclass method
    }
}
```

Klasa pochodna `extends` klasę rodzicielską, dziedzicząc i opcjonalnie nadpisując jej składniki. `parent::` wywołuje nadpisaną metodę rodzicielską. PHP obsługuje **dziedziczenie pojedyncze** (tylko jeden rodzic).

## Klasy abstrakcyjne — częściowa baza (nie można instancjonować)

```php
abstract class Shape {
    abstract public function area(): float;     // abstract — subclasses MUST implement
    public function describe(): string {         // concrete — shared implementation
        return "Area: " . $this->area();
    }
}
class Circle extends Shape {
    public function __construct(private float $r) {}
    public function area(): float { return 3.14159 * $this->r ** 2; }   // must implement
}
// new Shape();  // ❌ error — abstract classes can't be instantiated
```

**Klasa abstrakcyjna** łączy metody abstrakcyjne (które podklasy muszą implementować) z konkretnym kodem wspólnym — bazą, której nie można instancjonować bezpośrednio.

## Interfejsy — czyste kontrakty (wiele dozwolonych)

```php
interface Drawable {
    public function draw(): void;       // only signatures — no implementation
}
interface Serializable {
    public function serialize(): string;
}

class Widget implements Drawable, Serializable {   // implement MULTIPLE interfaces
    public function draw(): void { /* ... */ }
    public function serialize(): string { return "..."; }
}
```

**Interfejs** definiuje kontrakt (sygnatury metod, bez implementacji). Klasa może `implement` **wiele** interfejsów — sposób PHP na obejście ograniczenia dziedziczenia pojedynczego przy udostępnianiu możliwości.

## Kiedy używać którego

```text
extends (inheritance) → "is-a" relationship, reuse + override behavior
abstract class → a base with SHARED code + methods subclasses must implement (single)
interface → a CONTRACT/capability multiple unrelated classes can fulfill (multiple)
→ "Program to an interface" — depend on interfaces for flexible, testable designs.
```

## Dlaczego to ważne

Dziedziczenie, klasy abstrakcyjne i interfejsy to narzędzia programowania obiektowego, a zrozumienie różnic jest ważne dla projektowania dobrze ustrukturyzowanych aplikacji PHP (i do pracy z frameworkami, które w dużej mierze polegają na tych mechanizmach). **Dziedziczenie** (`extends`) zapewnia ponowne wykorzystanie kodu poprzez relacje typu "is-a", ale PHP dopuszcza tylko dziedziczenie pojedyncze. **Klasy abstrakcyjne** zapewniają wspólną bazę zarówno z zaimplementowanym kodem, jak i metodami, które podklasy muszą zdefiniować — dobre dla ściśle powiązanych klas dzielących logikę. **Interfejsy** definiują kontrakty/możliwości, a kluczowo — klasa może implementować **wiele** z nich — co czyni interfejsy kluczem do elastycznych, luźno powiązanych projektów i odpowiedzią PHP na ograniczenie dziedziczenia pojedynczego.

Wiedzenie, kiedy używać każdego (dziedziczenie dla reużycia relacji is-a, klasy abstrakcyjne dla wspólnej częściowej implementacji, interfejsy dla kontraktów/możliwości) oraz zasada **programowania do interfejsów** (poleganie na abstrakcjach dla testowalnego, elastycznego, przyjaznego frameworkom kodu), to ważna wiedza dla projektowania obiektowego w PHP.

Te mechanizmy stanowią podstawę tego, jak frameworki takie jak Laravel i Symfony strukturyzują swój kod (interfejsy i abstrakcyjne klasy bazowe wszędzie), co czyni je niezbędnymi zarówno do dobrego projektowania własnego kodu, jak i rozumienia frameworków, na których się polega.