Hur fungerar arv, abstrakta klasser och gränssnitt?

Question

Accepted Answer

PHP stöder OOP-arv och abstraktion genom tre relaterade mekanismer: **klassarv** (`extends`), **abstrakta klasser** (partiella basklasser) och **gränssnitt** (kontrakt). Var och en tjänar ett annat designsyfte.

## Arv — utöka en överordnad klass

```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 underklass `extends` en överordnad och ärver och kan eventuellt åsidosätta dess medlemmar. `parent::` anropar den åsidosatta överordnade metoden. PHP stöder **enkelt arv** (endast en överordnad).

## Abstrakta klasser — en partiell bas (kan inte instansieras)

```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 klass** blandar abstrakta metoder (underklasser måste implementera) med konkret delad kod — en bas som inte kan instansieras direkt.

## Gränssnitt — rena kontrakt (flera tillåtna)

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

Ett **gränssnitt** definierar ett kontrakt (metodsignaturer, ingen implementering). En klass kan `implement` **många** gränssnitt — PHPs sätt att kringgå enkelt arv för att dela funktioner.

## När man använder vilket

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

## Varför det är viktigt

Arv, abstrakta klasser och gränssnitt är centrala OOP-verktyg, och att förstå skillnaderna är viktigt för att utforma välstrukturerade PHP-applikationer (och för att arbeta med ramverk, som förlitar sig mycket på dessa). **Arv** (`extends`) ger kodåteranlvendelse via "är-en"-relationer, men PHP tillåter endast enkelt arv. **Abstrakta klasser** ger en delad bas med både implementerad kod och metoder som underklasser måste definiera — bra för närbesläktade klasser som delar logik. **Gränssnitt** definierar kontrakt/funktioner, och viktigt är att en klass kan implementera **många** av dem — vilket gör gränssnitt till nyckeln till flexibel, löst kopplad design och PHPs svar på begränsningen med enkelt arv.

Att veta när man ska använda var och en (arv för är-en-återanvändning, abstrakta klasser för delad partiell implementering, gränssnitt för kontrakt/funktioner) och principen **programmering mot gränssnitt** (beroende av abstraktioner för testbar, flexibel, ramverksvänlig kod) är viktig kunskap för objektorienterad PHP-design.

Dessa mekanismer utgör grunden för hur ramverk som Laravel och Symfony strukturerar sin kod (gränssnitt och abstrakta basklasser överallt), vilket gör dem väsentliga för både att utforma din egen kod väl och för att förstå de ramverk du bygger på.