Wie funktionieren Vererbung, abstrakte Klassen und Interfaces?

Question

Accepted Answer

PHP unterstützt OOP-Vererbung und Abstraktion durch drei verwandte Mechanismen: **Klassenvererbung** (`extends`), **abstrakte Klassen** (teilweise Basisklassen) und **Interfaces** (Verträge). Jeder dient einem anderen Designzweck.

## Vererbung — eine übergeordnete Klasse erweitern

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

Eine Unterklasse `extends` eine übergeordnete Klasse und erbt ihre Member optional überschreibend. `parent::` ruft die überschriebene Methode der übergeordneten Klasse auf. PHP unterstützt **Einfachvererbung** (nur ein übergeordnete Klasse).

## Abstrakte Klassen — eine teilweise Basis (kann nicht instanziiert werden)

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

Eine **abstrakte Klasse** mischt abstrakte Methoden (Unterklassen müssen diese implementieren) mit konkretem gemeinsamen Code — eine Basis, die nicht direkt instanziiert werden kann.

## Interfaces — reine Verträge (mehrfach möglich)

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

Ein **Interface** definiert einen Vertrag (Methodensignaturen, keine Implementierung). Eine Klasse kann **viele** Interfaces `implement`ieren — PHPs Weg um Einfachvererbung zu überwinden, um Fähigkeiten zu teilen.

## Wann man welches verwendet

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

## Warum es wichtig ist

Vererbung, abstrakte Klassen und Interfaces sind zentrale OOP-Werkzeuge, und das Verständnis der Unterschiede ist wichtig für die Gestaltung gut strukturierter PHP-Anwendungen (und für die Arbeit mit Frameworks, die stark auf diese angewiesen sind). **Vererbung** (`extends`) ermöglicht Codewiederverwendung durch "ist-ein"-Beziehungen, aber PHP erlaubt nur Einfachvererbung. **Abstrakte Klassen** bieten eine gemeinsame Basis mit sowohl implementiertem Code als auch Methoden, die Unterklassen definieren müssen — gut für eng verwandte Klassen, die Logik teilen. **Interfaces** definieren Verträge/Fähigkeiten, und entscheidend ist, dass eine Klasse **viele** davon implementieren kann — was Interfaces zum Schlüssel für flexible, entkoppelte Designs und PHPs Antwort auf die Einfachvererbungs-Einschränkung macht.

Zu wissen, wann man welches verwendet (Vererbung für "ist-ein"-Wiederverwendung, abstrakte Klassen für gemeinsame teilweise Implementierung, Interfaces für Verträge/Fähigkeiten), und das Prinzip der **Programmierung gegen Interfaces** (Abhängigkeit von Abstraktionen für testbaren, flexiblen, Framework-freundlichen Code) ist wichtiges Wissen für objektorientiertes PHP-Design.

Diese Mechanismen bilden die Grundlage, wie Frameworks wie Laravel und Symfony ihren Code strukturieren (Interfaces und abstrakte Basisklassen überall), was sie sowohl für die Gestaltung Ihres eigenen Codes als auch für das Verständnis der Frameworks, auf denen Sie aufbauen, unverzichtbar macht.