In der objektorientierten Programmierung mit PHP bilden abstrakte Klassen das Fundament für strukturierte Vererbungshierarchien. Eine abstrakte Klasse fungiert als Bauplan (Blueprint), der gemeinsame Eigenschaften und Methoden vorgibt, ohne selbst instanziiert werden zu können. Kindklassen erben von dieser Basisklasse und müssen die darin definierten abstrakten Methoden konkret implementieren. Dieses Tutorial erklärt die vollständige Syntax abstrakter Klassen, zeigt den Unterschied zu Interfaces und behandelt praxisnahe Anwendungsfälle einschließlich der neuen abstrakten Properties ab PHP 8.4.
Zunächst wird geklärt, was eine abstrakte Klasse überhaupt ist und wie sie sich von normalen Klassen und Interfaces unterscheidet. Anschließend folgen konkrete Codebeispiele bis hin zu den neuen abstrakten Properties in PHP 8.4.
Was ist eine abstrakte Klasse?
Eine abstrakte Klasse ist eine Klasse, die mit dem Schlüsselwort abstract gekennzeichnet wird und nicht direkt instanziiert werden kann. Sie dient ausschließlich als Basisklasse für andere Klassen, die über extends von ihr erben. Der Sinn einer abstrakten Klasse liegt darin, eine gemeinsame Struktur für verwandte Klassen festzulegen und gleichzeitig bestimmte Methoden zur Implementierung an die Kindklassen zu delegieren.
<?php
abstract class Tier
{
protected string $name;
public function __construct(string $name)
{
$this->name = $name;
}
/* Abstrakte Methode: muss in Kindklassen implementiert werden */
abstract public function laut(): string;
/* Konkrete Methode: wird an alle Kindklassen vererbt */
public function vorstellen(): string
{
return "Ich bin {$this->name} und mache: "
. $this->laut();
}
}
Die Klasse Tier enthält sowohl eine abstrakte Methode laut() als auch eine konkrete Methode vorstellen(). Die abstrakte Methode besitzt nur eine Signatur ohne Implementierung. Die konkrete Methode hingegen enthält bereits fertigen Code, den alle Kindklassen erben. Ein Versuch, die abstrakte Klasse direkt zu instanziieren, führt zu einem fatalen Fehler.
<?php
/* Dieser Code erzeugt einen Fatal Error */
$tier = new Tier('Unbekannt');
/* Error: Cannot instantiate abstract class Tier */
PHP verhindert die direkte Instanziierung, weil abstrakte Klassen unvollständig sind. Erst wenn eine Kindklasse alle abstrakten Methoden implementiert hat, kann ein Objekt erzeugt werden. Dieses Verhalten stellt sicher, dass keine Objekte mit fehlender Funktionalität entstehen.
Abstrakte Methoden definieren
Abstrakte Methoden sind Methodensignaturen ohne einen Methodenkörper. Sie geben den Namen, die Parameter und den Rückgabetyp vor, überlassen die eigentliche Logik jedoch vollständig der Kindklasse.
<?php
abstract class Formular
{
/* Abstrakte Methode mit Parametern und Rückgabetyp */
abstract protected function validiere(array $daten): bool;
/* Abstrakte Methode ohne Rückgabetyp */
abstract public function render(): void;
/* Konkrete Methode, die abstrakte Methoden nutzt */
public function absenden(array $daten): string
{
if ($this->validiere($daten)) {
return 'Formular erfolgreich gesendet.';
}
return 'Validierung fehlgeschlagen.';
}
}
Abstrakte Methoden dürfen die Sichtbarkeiten public oder protected tragen. Eine abstrakte Methode als private zu deklarieren ist nicht erlaubt, da Kindklassen auf private Methoden keinen Zugriff haben und sie somit nicht implementieren könnten. Wichtig ist auch, dass eine Klasse, die mindestens eine abstrakte Methode enthält, zwingend selbst als abstract deklariert werden muss.
Kindklassen müssen abstrakte Methoden implementieren
Jede Kindklasse, die von einer abstrakten Elternklasse erbt, muss sämtliche abstrakten Methoden mit einer konkreten Implementierung versehen. Andernfalls erzeugt PHP einen fatalen Fehler. Die Kindklasse verwendet dazu das Schlüsselwort extends.
<?php
class Hund extends Tier
{
public function laut(): string
{
return 'Wuff!';
}
}
class Katze extends Tier
{
public function laut(): string
{
return 'Miau!';
}
}
$hund = new Hund('Bello');
echo $hund->vorstellen();
/* Ausgabe: Ich bin Bello und mache: Wuff! */
$katze = new Katze('Luna');
echo $katze->vorstellen();
/* Ausgabe: Ich bin Luna und mache: Miau! */
Beide Kindklassen implementieren die abstrakte Methode laut() mit jeweils eigener Logik. Die konkrete Methode vorstellen() aus der Elternklasse steht automatisch in beiden Kindklassen zur Verfügung und ruft intern die jeweilige Implementierung von laut() auf. Dieses Zusammenspiel aus abstrakten und konkreten Methoden ist das Kernprinzip abstrakter Klassen.
Bei der Implementierung gelten Regeln für die Sichtbarkeit. Die implementierende Methode darf die Sichtbarkeit erweitern, aber nicht einschränken. Eine als protected deklarierte abstrakte Methode darf in der Kindklasse als public implementiert werden. Der umgekehrte Weg von public zu protected ist hingegen nicht erlaubt und führt zu einem Fehler.
Konkrete Methoden in abstrakten Klassen
Eine abstrakte Klasse muss nicht ausschließlich abstrakte Methoden enthalten. Sie kann ebenso konkrete Methoden bereitstellen, die gemeinsame Logik für alle Kindklassen kapseln. Das macht abstrakte Klassen besonders wertvoll gegenüber Interfaces, die keine Methodenimplementierungen bieten.
<?php
abstract class Datenbank
{
protected string $host;
protected string $name;
public function __construct(string $host, string $name)
{
$this->host = $host;
$this->name = $name;
}
/* Abstrakte Methode: jeder Treiber verbindet anders */
abstract protected function verbinden(): bool;
/* Konkrete Methode: gemeinsame Logik */
public function status(): string
{
if ($this->verbinden()) {
return "Verbindung zu {$this->name} auf {$this->host} hergestellt.";
}
return "Verbindung fehlgeschlagen.";
}
/* Konkrete Methode: Konfiguration ausgeben */
public function getConfig(): array
{
return [
'host' => $this->host,
'name' => $this->name
];
}
}
class MySQLDatenbank extends Datenbank
{
protected function verbinden(): bool
{
/* MySQL-spezifische Verbindungslogik */
return true;
}
}
class SQLiteDatenbank extends Datenbank
{
protected function verbinden(): bool
{
/* SQLite-spezifische Verbindungslogik */
return true;
}
}
$db = new MySQLDatenbank('localhost', 'shop');
echo $db->status();
/* Ausgabe: Verbindung zu shop auf localhost hergestellt. */
print_r($db->getConfig());
/*
Array
(
[host] => localhost
[name] => shop
)
*/
Die abstrakte Klasse Datenbank stellt einen Konstruktor, eine konkrete Methode status() und eine konkrete Methode getConfig() bereit. Nur die treiberspezifische Methode verbinden() bleibt abstrakt. So wird doppelter Code vermieden, während jede Kindklasse ihre eigene Verbindungslogik implementiert.
Vererbungshierarchie als Diagramm
Das folgende Diagramm zeigt die Beziehung zwischen einer abstrakten Klasse und ihren Kindklassen am Beispiel der Klasse Tier.
classDiagram
class Tier {
<<abstract>>
#name: string
+__construct(name)
+laut()* string
+vorstellen() string
}
class Hund {
+laut() string
}
class Katze {
+laut() string
}
Tier <|-- Hund
Tier <|-- Katze
Das Diagramm verdeutlicht, dass Hund und Katze von der abstrakten Klasse Tier erben. Die mit einem Stern gekennzeichnete Methode laut() ist abstrakt und wird in jeder Kindklasse separat implementiert. Die Methode vorstellen() ist konkret und steht beiden Kindklassen direkt zur Verfügung.
Abstrakte Properties (ab PHP 8.4)
Seit PHP 8.4 unterstützt die Sprache abstrakte Properties. Damit lassen sich in einer abstrakten Klasse Eigenschaften definieren, die von Kindklassen implementiert werden müssen. Zuvor konnten abstrakte Klassen zwar normale Properties enthalten, deren Überschreibung in Kindklassen war jedoch nicht erzwingbar.
<?php
abstract class Fahrzeug
{
/* Abstrakte Property: Kindklasse muss sie definieren */
abstract public string $typ { get; }
abstract public int $maxGeschwindigkeit { get; }
public function beschreibung(): string
{
return "{$this->typ} mit maximal {$this->maxGeschwindigkeit} km/h";
}
}
class Auto extends Fahrzeug
{
public string $typ { get => 'PKW'; }
public int $maxGeschwindigkeit { get => 250; }
}
class Fahrrad extends Fahrzeug
{
public string $typ { get => 'Fahrrad'; }
public int $maxGeschwindigkeit { get => 45; }
}
$auto = new Auto();
echo $auto->beschreibung();
/* Ausgabe: PKW mit maximal 250 km/h */
Abstrakte Properties erweitern das Konzept abstrakter Methoden auf Eigenschaften. So kann die Basisklasse sicherstellen, dass bestimmte Daten in jeder Kindklasse vorhanden sind, ohne deren konkreten Wert vorzugeben.
Unterschied: Abstrakte Klasse vs. Interface
Abstrakte Klassen und Interfaces sind beides Werkzeuge der objektorientierten Programmierung in PHP, erfüllen jedoch unterschiedliche Zwecke. Die wichtigsten Unterschiede betreffen Zustand, Vererbung und Mehrfachimplementierung.
Eine abstrakte Klasse kann Properties (Zustandsvariablen), konkrete Methoden mit vollständiger Implementierung und einen Konstruktor enthalten. Ein Interface hingegen definiert ausschließlich Methodensignaturen ohne jegliche Implementierung. Eine Klasse kann nur von einer einzigen abstrakten Klasse erben (extends), aber beliebig viele Interfaces implementieren (implements).
Die Faustregel lautet: Abstrakte Klassen eignen sich, wenn verwandte Klassen gemeinsamen Code und Zustand teilen sollen. Interfaces sind die bessere Wahl, wenn verschiedene, nicht verwandte Klassen einen gemeinsamen Vertrag erfüllen müssen. Beide Konzepte lassen sich auch kombinieren, indem eine abstrakte Klasse ein Interface implementiert.
<?php
/* Interface: definiert einen Vertrag */
interface Exportierbar
{
public function exportieren(): string;
}
/* Abstrakte Klasse: gemeinsamer Zustand und Logik */
abstract class Dokument implements Exportierbar
{
protected string $titel;
public function __construct(string $titel)
{
$this->titel = $titel;
}
abstract public function inhalt(): string;
/* Interface-Methode konkret implementiert */
public function exportieren(): string
{
return "Export: {$this->titel} - {$this->inhalt()}";
}
}
class Rechnung extends Dokument
{
private float $betrag;
public function __construct(string $titel, float $betrag)
{
parent::__construct($titel);
$this->betrag = $betrag;
}
public function inhalt(): string
{
return "Rechnungsbetrag: {$this->betrag} EUR";
}
}
$rechnung = new Rechnung('Rechnung 2024-001', 149.99);
echo $rechnung->exportieren();
/* Ausgabe: Export: Rechnung 2024-001 - Rechnungsbetrag: 149.99 EUR */
In diesem Beispiel implementiert die abstrakte Klasse Dokument das Interface Exportierbar und stellt die Methode exportieren() bereits konkret bereit. Kindklassen wie Rechnung müssen lediglich die abstrakte Methode inhalt() implementieren und erhalten die Export-Funktionalität automatisch.
Praxisbeispiel: Zahlungsanbieter
Ein typischer Anwendungsfall für abstrakte Klassen ist die Modellierung verschiedener Zahlungsanbieter. Alle Anbieter teilen gemeinsame Funktionalität wie die Formatierung von Beträgen, unterscheiden sich jedoch in der konkreten Zahlungsabwicklung.
<?php
abstract class ZahlungsAnbieter
{
protected string $waehrung;
public function __construct(string $waehrung = 'EUR')
{
$this->waehrung = $waehrung;
}
/* Abstrakte Methode: jeder Anbieter zahlt anders */
abstract public function bezahlen(float $betrag): bool;
/* Konkrete Methode: gemeinsame Formatierung */
public function formatiereBetrag(float $betrag): string
{
return number_format($betrag, 2, ',', '.') . ' ' . $this->waehrung;
}
/* Konkrete Methode: Logging */
public function log(string $nachricht): void
{
echo "[" . date('Y-m-d H:i:s') . "] " . $nachricht . PHP_EOL;
}
}
class PayPalZahlung extends ZahlungsAnbieter
{
public function bezahlen(float $betrag): bool
{
$this->log("PayPal: Zahlung von " . $this->formatiereBetrag($betrag) . " eingeleitet.");
/* PayPal-API-Aufruf hier */
return true;
}
}
class KreditkartenZahlung extends ZahlungsAnbieter
{
public function bezahlen(float $betrag): bool
{
$this->log("Kreditkarte: Zahlung von " . $this->formatiereBetrag($betrag) . " verarbeitet.");
/* Kreditkarten-Gateway-Aufruf hier */
return true;
}
}
class Bankueberweisung extends ZahlungsAnbieter
{
public function bezahlen(float $betrag): bool
{
$this->log("Bank: " . $this->formatiereBetrag($betrag) . " zur Ueberweisung vorgemerkt.");
return true;
}
}
/* Nutzung mit Type Hinting auf die abstrakte Klasse */
function bestellungBezahlen(ZahlungsAnbieter $anbieter, float $betrag): void
{
if ($anbieter->bezahlen($betrag)) {
echo "Zahlung erfolgreich: " . $anbieter->formatiereBetrag($betrag) . PHP_EOL;
}
}
$paypal = new PayPalZahlung();
bestellungBezahlen($paypal, 59.99);
$kreditkarte = new KreditkartenZahlung('USD');
bestellungBezahlen($kreditkarte, 120.00);
Die Funktion bestellungBezahlen() akzeptiert jeden Zahlungsanbieter, der von ZahlungsAnbieter erbt. Durch das Type Hinting auf die abstrakte Klasse ist sichergestellt, dass sowohl die Methode bezahlen() als auch formatiereBetrag() verfügbar sind. Neue Zahlungsanbieter lassen sich jederzeit ergänzen, ohne die bestehende Logik ändern zu müssen.
Fazit
Abstrakte Klassen in PHP sind ein zentrales Werkzeug der objektorientierten Programmierung. Sie definieren eine gemeinsame Struktur für verwandte Klassen, indem sie abstrakte Methoden als Pflichtimplementierungen vorgeben und gleichzeitig konkrete Methoden mit geteilter Logik bereitstellen. Im Gegensatz zu Interfaces können abstrakte Klassen Zustandsvariablen, Konstruktoren und vollständig implementierte Methoden enthalten. Ab PHP 8.4 erweitern abstrakte Properties die Möglichkeiten zusätzlich. Die Wahl zwischen abstrakter Klasse und Interface hängt vom Anwendungsfall ab: Abstrakte Klassen sind ideal, wenn Kindklassen gemeinsamen Code und Zustand erben sollen, während Interfaces für reine Verträge zwischen nicht verwandten Klassen die bessere Wahl darstellen. Beide Konzepte lassen sich in der Praxis wirkungsvoll kombinieren, um flexible und wartbare Architekturen zu schaffen.
