Jak fungují dědičnost, abstraktní třídy a rozhraní?

Question

Accepted Answer

PHP podporuje OOP dědičnost a abstrakci prostřednictvím tří souvisejících mechanismů: **dědičnost tříd** (`extends`), **abstraktní třídy** (částečné základní třídy) a **rozhraní** (kontrakty). Každá z nich slouží jiným účelům návrhu.

## Dědičnost — rozšíření nadřazené třídy

```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
    }
}
```

Podtřída `extends` nadřazenou třídu, dědí a volitelně přepisuje její členy. `parent::` volá přepsanou metodu nadřazené třídy. PHP podporuje **jednotnou dědičnost** (pouze jeden nadřazený prvek).

## Abstraktní třídy — částečný základ (nelze instancovat)

```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
```

**Abstraktní třída** kombinuje abstraktní metody (které musí podtřídy implementovat) se sdíleným konkrétním kódem — základ, který nelze přímo instancovat.

## Rozhraní — čisté kontrakty (více jich je povoleno)

```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 "..."; }
}
```

**Rozhraní** definuje kontrakt (signatury metod, bez implementace). Třída může `implement` **mnoho** rozhraní — PHP způsob, jak obejít jednotnou dědičnost při sdílení schopností.

## Kdy použít které

```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.
```

## Proč na tom záleží

Dědičnost, abstraktní třídy a rozhraní jsou základními OOP nástroji, a pochopení jejich odlišností je důležité pro návrh dobře strukturovaných PHP aplikací (a pro práci s frameworky, které se na ně velmi spoléhají). **Dědičnost** (`extends`) poskytuje opakované použití kódu prostřednictvím vztahů "is-a", ale PHP umožňuje pouze jednotnou dědičnost. **Abstraktní třídy** poskytují sdílený základ s jak implementovaným kódem, tak metodami, které musí podtřídy definovat — dobré pro úzce související třídy sdílející logiku. **Rozhraní** definují kontrakty/schopnosti, a zásadně třída může implementovat **mnoho** z nich — což dělá rozhraní klíčem k flexibilním, nezávislým návrhům a PHP odpověď na omezení jednotné dědičnosti.

Vědět, kdy použít každé (dědičnost pro is-a opakované použití, abstraktní třídy pro sdílenou částečnou implementaci, rozhraní pro kontrakty/schopnosti), a princip **programování vůči rozhraním** (závislost na abstrakcích pro testovatelný, flexibilní, framework-přátelský kód) je důležitou znalostí pro objektově orientovaný návrh PHP.

Tyto mechanismy jsou základem toho, jak frameworky jako Laravel a Symfony strukturují svůj kód (rozhraní a abstraktní základní třídy všude), což je činí zásadními pro návrh vlastního kódu i pro pochopení frameworků, na kterých stavíte.