Hvordan fungerer arv, abstrakte klasser og interfaces?

Question

Accepted Answer

PHP understøtter OOP-arv og abstraktion gennem tre relaterede mekanismer: **klassearv** (`extends`), **abstrakte klasser** (delvise baseklasser) og **interfaces** (kontrakter). Hver mekanisme tjener et forskelligt designformål.

## Arv — udvid en forældreklasse

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

En underklasse `extends` en forælder og arver samt optionalt tilsidesætter dens medlemmer. `parent::` kalder den tilsidesat forældremetode. PHP understøtter **enkelt arv** (kun én forælder).

## Abstrakte klasser — en delvis base (kan ikke instantieres)

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

En **abstrakt klasse** blander abstrakte metoder (underklasser skal implementere) med konkret delt kode — en base, der ikke kan instantieres direkte.

## Interfaces — rene kontrakter (flere tilladt)

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

Et **interface** definerer en kontrakt (metodesignaturer, ingen implementering). En klasse kan `implement` **mange** interfaces — PHPs måde at omgå enkelt arv for at dele funktionalitet.

## Hvornår skal man bruge hvilken

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

## Hvorfor det betyder noget

Arv, abstrakte klasser og interfaces er centrale OOP-værktøjer, og det er vigtigt at forstå sondringerne for at designe velstrukturerede PHP-applikationer (og for at arbejde med frameworks, som er stærkt afhængige af disse). **Arv** (`extends`) giver kodegenbrug via "is-a"-relationer, men PHP tillader kun enkelt arv. **Abstrakte klasser** giver en delt base med både implementeret kode og metoder, som underklasser skal definere — godt til nærbeslægtede klasser, der deler logik. **Interfaces** definerer kontrakter/funktionaliteter, og afgørende kan en klasse implementere **mange** af dem — hvilket gør interfaces til nøglen til fleksible, løst koblede designs og PHPs svar på enkelt-arv-begrænsningen.

At vide, hvornår man skal bruge hver enkelt (arv for is-a-genbrug, abstrakte klasser for delt delvis implementering, interfaces for kontrakter/funktionaliteter), og princippet om **programmering mod interfaces** (afhængig af abstraktioner for testbar, fleksibel, framework-venlig kode), er vigtig viden for objektorienteret PHP-design.

Disse mekanismer ligger til grund for, hvordan frameworks som Laravel og Symfony strukturerer deres kode (interfaces og abstrakte baseklasser overalt), hvilket gør dem essentielle både for at designe din egen kode godt og for at forstå de frameworks, du bygger på.