Interfaces und Abstrakte Klassen in PHP

Erste Schritte: Interfaces & Abstrakte Klassen in PHP

Bei größer werdenden PHP‑Projekten helfen Interfaces und abstrakte Klassen,
eine klare Architektur zu schaffen.
Beide geben Kontrakte vor: Sie definieren was eine Klasse bereitstellen muss,
nicht unbedingt wie sie es tut.
In diesem Tutorial vergleichen wir beide Konzepte, zeigen Syntax und Einsatzszenarien.

1. Interfaces

Ein Interface definiert lediglich Methodensignaturen (Name, Parameter, Rückgabetyp).
Enthalten ist kein Programmcode, keine Eigenschaften – nur der Vertrag.
Eine Klasse, die das Interface implementiert, muss alle Methoden bereitstellen. 

interface Zahlbar {
    public function zahle(float $betrag): bool;
    public function storniere(int $transaktionsId): void;
}
  • interface statt class
  • Alle Methoden sind automatisch public.
  • Mehrere Interfaces pro Klasse möglich (implements A, B).

1.1 Interface implementieren

class PayPalZahlung implements Zahlbar {
    public function zahle(float $betrag): bool {
        // PayPal‑API …
        return true;
    }
    public function storniere(int $transaktionsId): void {
        // Storno‑Logik …
    }
}

Verletzt die Klasse eine der Signaturen, wirft PHP einen Fatal Error.

2. Abstrakte Klassen

Eine abstrakte Klasse kann sowohl konkreten Code enthalten
als auch abstrakte Methoden (ohne Body).
Du kannst sie selbst nicht instanziieren – erst eine Kind‑Klasse,
die alle abstrakten Methoden umsetzt, ist voll einsatzfähig. 

abstract class Fahrzeug {
    protected int $geschwindigkeit = 0;

    abstract public function beschleunigen(int $kmh): void;

    public function aktuellerSpeed(): int {
        return $this->geschwindigkeit;
    }
}
  • abstract class: darf konkrete Eigenschaften + Methoden haben.
  • abstract function: Kind‑Klasse muss sie überschreiben.

2.1 Ableiten & Implementieren

class Auto extends Fahrzeug {
    public function beschleunigen(int $kmh): void {
        $this->geschwindigkeit += $kmh;
    }
}

$a = new Auto();
$a->beschleunigen(50);
echo $a->aktuellerSpeed();  // 50

3. Interface vs. Abstrakte Klasse

Merkmal Interface Abstrakte Klasse
Kann konkrete Methoden enthalten? Nein (ab PHP 8.1: default‑Implementierung via public function foo() {}  möglich, jedoch meist ohne State) Ja
Kann Felder/Eigenschaften enthalten? Nein Ja
Mehrfach implementierbar/erbbar? Eine Klasse kann mehrere Interfaces implementieren Nur eine abstrakte (Eltern)‑Klasse erben (Single Inheritance)
Instanziierbar? Nein Nein

4. Kombination: Abstrakt + Interface

Du kannst eine abstrakte Klasse selbst Interfaces implementieren lassen.
So gibst du Basis‑Code vor und zwingst trotzdem zu weiteren Methoden. 

interface JsonSerializable {
    public function toJson(): string;
}

abstract class Model implements JsonSerializable {
    public function toJson(): string {
        return json_encode(get_object_vars($this));
    }
    abstract public function validate(): bool;
}

class User extends Model {
    public string $name;
    public function __construct(string $name) { $this->name = $name; }
    public function validate(): bool { return $this->name !== ''; }
}

5. Best Practices

  1. Nutze Interfaces, um lose Kopplung zu erreichen – z. B. für Payment‑Gateways, Logger, Repositories.
  2. Nutze abstrakte Klassen, wenn du gemeinsamen Code + State mitgeben möchtest.
  3. Eine Klasse kann viele Interfaces, aber nur eine Elternklasse – plane früh, ob du Basiscode wirklich brauchst.
  4. Für Dependency Injection typehintest du gegen Interfaces statt konkrete Implementierungen – leichter zu testen / austauschbar.

Fazit

Interfaces definieren reine Verträge;
abstrakte Klassen kombinieren Verträge mit gemeinsamem Basis‑Code.
Durch ihren gezielten Einsatz erzielst du sauberen, wartbaren und erweiterbaren OOP‑Code in PHP,
bei dem Implementierungen austauschbar bleiben und Wiederholungen vermieden werden.