Hoe werken erfelijkheid, abstracte klassen en interfaces?

Question

Accepted Answer

PHP ondersteunt OOP-erfelijkheid en abstractie door drie gerelateerde mechanismen: **klassieke erfelijkheid** (`extends`), **abstracte klassen** (gedeeltelijke basisklassen), en **interfaces** (contracten). Elk dient een ander ontwerpdoel.

## Erfelijkheid — een ouderklasse uitbreiden

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

Een subklasse `extends` een ouder, erft zijn leden en kan deze optioneel overschrijven. `parent::` roept de overschreven oudermetode aan. PHP ondersteunt **enkele erfelijkheid** (slechts één ouder).

## Abstracte klassen — een gedeeltelijke basis (kan niet worden geïnstantieerd)

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

Een **abstracte klasse** combineert abstracte methoden (subklassen moeten deze implementeren) met concrete gedeelde code — een basis die niet rechtstreeks kan worden geïnstantieerd.

## Interfaces — pure contracten (meerdere toegestaan)

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

Een **interface** definieert een contract (methodesignaturen, geen implementatie). Een klasse kan **veel** interfaces `implement` — PHPs manier om single inheritance te omzeilen voor het delen van mogelijkheden.

## Wanneer welke gebruiken

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

## Waarom het belangrijk is

Erfelijkheid, abstracte klassen en interfaces zijn kerngereedschappen voor OOP, en het begrijpen van de verschillen is belangrijk voor het ontwerpen van goed gestructureerde PHP-applicaties (en voor werken met frameworks, die zich zwaar op deze steunen). **Erfelijkheid** (`extends`) biedt code hergebruik via "is-een"-relaties, maar PHP staat slechts enkele erfelijkheid toe. **Abstracte klassen** bieden een gedeelde basis met zowel geïmplementeerde code als methoden die subklassen moeten definiëren — geschikt voor nauw gerelateerde klassen die logica delen. **Interfaces** definiëren contracten/mogelijkheden, en cruciaal is dat een klasse **veel** van hen kan implementeren — wat interfaces essentieel maakt voor flexibele, losgekoppelde ontwerpen en PHPs antwoord op de single-inheritance-beperking.

Weten wanneer elk moet worden gebruikt (erfelijkheid voor is-een hergebruik, abstracte klassen voor gedeelde gedeeltelijke implementatie, interfaces voor contracten/mogelijkheden), en het principe van **programmeren naar interfaces** (afhangen van abstracties voor testbare, flexibele, framework-vriendelijke code), is belangrijke kennis voor object-georiënteerd PHP-ontwerp.

Deze mechanismen liggen ten grondslag aan hoe frameworks zoals Laravel en Symfony hun code structureren (interfaces en abstracte basisklassen overal), waardoor ze essentieel zijn voor zowel het goed ontwerpen van je eigen code als het begrijpen van de frameworks waarop je voortbouwt.