Hvordan fungerer arv, abstrakte klasser og grensesnitt?

Question

Accepted Answer

PHP støtter OOP-arv og abstraksjon gjennom tre relaterte mekanismer: **klassearv** (`extends`), **abstrakte klasser** (delvis baseklasser), og **grensesnitt** (kontrakter). Hver tjener et annet designformål.

## Arv — utvid en overordnet klasse

```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 overordnet klasse, arver og kan eventuelt overstyre medlemmene. `parent::` kaller den overordnede metoden som er overstyrt. PHP støtter **enkelt arv** (kun én overordnet klasse).

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

```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 må implementere) med konkret delt kode — en base som ikke kan instansieres direkte.

## Grensesnitt — rene kontrakter (flere tillatt)

```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 **grensesnitt** definerer en kontrakt (metodesignaturer, ingen implementering). En klasse kan `implement` **mange** grensesnitt — PHPs måte å omgå enkelt arv for deling av funksjoner.

## Når skal man bruke hva

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

Arv, abstrakte klasser og grensesnitt er kjerneverktøy innen OOP, og forståelse av forskjellene er viktig for design av velstrukturerte PHP-applikasjoner (og for arbeid med rammeverk, som er sterkt avhengige av disse). **Arv** (`extends`) gir kodegjenbruk gjennom "is-a"-relasjoner, men PHP tillater kun enkelt arv. **Abstrakte klasser** gir en delt base med både implementert kode og metoder som underklasser må definere — godt for nært beslektede klasser som deler logikk. **Grensesnitt** definerer kontrakter/funksjoner, og avgjørende — en klasse kan implementere **mange** av dem — noe som gjør grensesnitt nøkkelen til fleksible, løst koblede design og PHPs svar på enkelt-arv-begrensningen.

Kunnskap om når man skal bruke hver enkelt (arv for is-a-gjenbruk, abstrakte klasser for delt delvis implementering, grensesnitt for kontrakter/funksjoner), og prinsippet om **programmering mot grensesnitt** (avhengig av abstraksjoner for testbar, fleksibel, rammeverk-vennlig kode), er viktig kunnskap for objektorientert PHP-design.

Disse mekanismene ligger til grunn for hvordan rammeverk som Laravel og Symfony strukturerer koden sin (grensesnitt og abstrakte basisklasser overalt), noe som gjør dem essensielle både for å designe din egen kode godt og for å forstå rammeverket du bygger på.