extends

Das PHP-Schlüsselwort extends

extends ist die Art und Weise, wie eine Klasse Vererbung in PHP deklariert: Eine Kind- (oder Unterklasse), die mit extends erstellt wird, erhält automatisch die nicht-privaten Eigenschaften und Methoden ihrer Eltern- (oder Oberklasse). Anstatt gemeinsamen Code in jede verwandte Klasse zu kopieren, schreibt man ihn einmal in einer Elternklasse und lässt Unterklassen ihn spezialisieren.

Diese Seite behandelt die Syntax, den Aufruf des Elterncodes mit parent::, die Funktionsweise des Methoden-Overridings, die Zugriffsmodifikator-Regeln, die bestimmen, was eine Kindklasse erbt, sowie häufige Fallstricke. PHP unterstützt nur Einfachvererbung — eine Klasse kann genau eine Elternklasse mit extends angeben (verwenden Sie Interfaces, wenn ein Typ mehrere Rollen übernehmen soll).

Syntax

class ChildClass extends ParentClass {
  // additional or overriding members
}

Die Kindklasse kann drei Dinge tun:

1. Erben – Mitglieder der Elternklasse unverändert übernehmen.
2. Hinzufügen – eigene neue Eigenschaften und Methoden definieren.
3. Überschreiben – eine geerbte Methode durch erneute Deklaration mit demselben Namen ersetzen.

Ein erstes Beispiel

<?php

class Fruit {
  public $name;
  public $color;

  public function __construct($name, $color) {
    $this->name = $name;
    $this->color = $color;
  }

  public function getInfo() {
    echo "This fruit is a {$this->name} and it is {$this->color}.";
  }
}

// Apple inherits everything from Fruit and overrides getInfo().
class Apple extends Fruit {
  public function getInfo() {
    echo "This fruit is an {$this->name} and it is {$this->color}.";
  }
}

$apple = new Apple("apple", "red");
$apple->getInfo();
// Output: This fruit is an apple and it is red.

Apple deklariert weder $name, noch $color oder einen Konstruktor — diese werden von Fruit geerbt. Es definiert nur getInfo() neu, was die Version der Elternklasse überschreibt.

Die Elternklasse mit parent:: aufrufen

Eine Kindklasse möchte das Verhalten der Elternklasse oft erweitern statt ersetzen. Wenn eine Kindklasse einen eigenen Konstruktor definiert, ruft PHP den Elternkonstruktor nicht automatisch auf — Sie müssen ihn explizit mit parent::__construct() aufrufen. Dieselbe parent::-Syntax funktioniert für jede überschriebene Methode.

<?php

class Car {
  public $model;
  public $year;

  public function __construct($model, $year) {
    $this->model = $model;
    $this->year = $year;
  }

  public function getInfo() {
    echo "This car is a {$this->model} from {$this->year}.";
  }
}

class Toyota extends Car {
  public function __construct($year) {
    // Fill in the model, defer the rest to the parent.
    parent::__construct("Toyota", $year);
  }

  public function getInfo() {
    parent::getInfo();            // reuse the parent's output...
    echo " (built by Toyota)";    // ...then add to it.
  }
}

$toyota = new Toyota(2021);
$toyota->getInfo();
// Output: This car is a Toyota from 2021. (built by Toyota)

Hätte Toyota keinen eigenen Konstruktor, würde es den Konstruktor von Car erben, und man würde es mit new Toyota("Corolla", 2021) erstellen.

Was eine Kindklasse erben kann — und was nicht

Zugriffsmodifikatoren bestimmen die Sichtbarkeit über die Vererbungsgrenze hinweg:

• public-Mitglieder werden geerbt und sind überall verwendbar.
• protected-Mitglieder werden geerbt und sind innerhalb der Kindklasse zugänglich, jedoch nicht von außen.
• private-Mitglieder sind in der Kindklasse nicht zugänglich. Sie existieren zwar auf dem object, aber die Kindklasse kann nicht namentlich auf sie zugreifen.

<?php

class Account {
  public $owner = "Ann";
  protected $balance = 100;   // visible to children
  private $pin = "1234";      // hidden from children

  public function reveal() {
    return "$this->owner, balance $this->balance, pin $this->pin";
  }
}

class SavingsAccount extends Account {
  public function summary() {
    // $this->balance works (protected); $this->pin would be null/undefined.
    return "{$this->owner} has {$this->balance}";
  }
}

$s = new SavingsAccount();
echo $s->summary();
// Output: Ann has 100

Siehe PHP-Zugriffsmodifikatoren für die vollständigen Regeln zu public / protected / private.

Eine Klasse oder Methode mit final versiegeln

Verwenden Sie das Schlüsselwort final, um weitere Erweiterungen zu verhindern. Eine final class kann keine Elternklasse sein; eine final-Methode kann von einer Unterklasse nicht überschrieben werden. Dies ist nützlich, wenn ein Überschreiben eine Invariante brechen würde, auf die Ihre Klasse angewiesen ist.

class PaymentGateway {
  final public function charge() { /* must not be altered */ }
}

Häufige Fallstricke

• parent::__construct() vergessen. Ein eigener Kindkonstruktor überdeckt den der Elternklasse. Wenn Sie ihn nicht aufrufen, bleiben die Eigenschaften der Elternklasse uninitialisiert.
• Einfachvererbung. class A extends B, C ist ein Syntaxfehler. Kombinieren Sie Verhalten stattdessen mit Interfaces oder Traits.
• Private Mitglieder werden nicht geteilt. Eine private-Eigenschaft der Elternklasse ist für die Kindklasse unsichtbar; machen Sie sie protected, wenn Unterklassen darauf zugreifen müssen.
• Überschreibende Signaturen müssen kompatibel bleiben. Eine überschreibende Methode muss dieselben (oder weitergehende) Argumente akzeptieren, sonst gibt PHP eine Warnung aus.

Verwandte Themen

• PHP-Vererbung — das übergeordnete Konzept, das extends umsetzt.
• PHP-Klassen und -Objekte — die Grundbausteine.
• Abstrakte Klassen — Elternklassen, die erweitert werden müssen.
• Interfaces — Verträge für nicht verwandte Klassen.

Übungen