Vererbung und Sichtbarkeiten

Erste Schritte: Vererbung und Sichtbarkeiten: public, protected, private

In der objektorientierten PHP‑Welt ermöglicht Vererbung,
dass eine Klasse (Kind‑Klasse) Eigenschaften & Methoden einer anderen Klasse (Eltern‑Klasse) übernimmt.
Gemeinsam mit den Sichtbarkeiten public, protected und private
legst du fest, welche Teile nach außen sichtbar sind und welche intern bleiben.
Dieses Tutorial zeigt dir, wie beides zusammenspielt.

1. Grundlagen der Vererbung

Mit extends deklarierst du, dass eine Klasse von einer anderen erbt.

class Tier {
    public function geraeusch() {
        return "macht Geräusch";
    }
}

class Hund extends Tier {
    public function geraeusch() {
        return "Wuff!";
    }
}

• Hund erbt automatisch alles aus Tier.
• Überschreibt Hund eine Methode (gleicher Name & Signatur),
  spricht man von Override – PHP nutzt die Kind‑Version.

1.1 parent:: aufrufen

Willst du innerhalb der Kind‑Methode den Eltern‑Code zusätzlich ausführen,
greifst du auf parent:: zu:

class Katze extends Tier {
    public function geraeusch() {
        return parent::geraeusch() . " und Miau!";
    }
}

2. Sichtbarkeiten: public, protected, private

Stufe	Zugriff innerhalb der Klasse	in Kind‑Klassen	von außen
public	ja	ja	ja
protected	ja	ja	nein
private	ja	nein	nein

• public – überall erreichbar (API deiner Klasse).
• protected – nur intern & in abgeleiteten Klassen.
• private – strikt innerhalb der Klasse, nicht vererbbar.

2.1 Beispiel mit Eigenschaftsichtbarkeit

class Konto {
    public    $inhaber;        // offen für alle
    protected $saldo = 0;      // nur Konto + Kind‑Klassen
    private   $pin;            // nur Konto selbst

    public function __construct($inhaber, $pin) {
        $this->inhaber = $inhaber;
        $this->pin     = $pin;
    }

    public function einzahlen($betrag) {
        $this->saldo += $betrag;
    }

    protected function internSaldo() {
        return $this->saldo;   // OK: protected innerhalb der Klasse
    }
}

class Sparkonto extends Konto {
    public function zeigeSaldo() {
        // $this->saldo ist erreichbar (protected)
        return $this->internSaldo();
    }
}

$k = new Sparkonto("Lisa", 1234);
$k->einzahlen(100);

// echo $k->saldo;    // Fehler: protected
echo $k->zeigeSaldo(); // 100

3. Konstruktor & Vererbung

In Kind‑Klassen kannst (oder musst) du den Eltern‑Konstruktor aufrufen:

class Person {
    protected $name;
    public function __construct($name) {
        $this->name = $name;
    }
}

class Mitarbeiter extends Person {
    private $abteilung;
    public function __construct($name, $abteilung) {
        parent::__construct($name);   // Elternkonstruktor
        $this->abteilung = $abteilung;
    }
}

4. final & abstract

• final class – verbietet Vererbung.
• final function – Methode darf in Kind‑Klasse nicht überschrieben werden.
• abstract class – enthält unvollständige (abstract‑)Methoden;
  kann nicht direkt instanziiert werden.

abstract class Fahrzeug {
    abstract public function starteMotor();
}

class Motorrad extends Fahrzeug {
    public function starteMotor() {
        return "Motor startet ...";
    }
}

5. Best Practices

1. Expose nur, was wirklich extern gebraucht wird (public sparsam nutzen).
2. Implementiere Wiederverwendbares in Eltern‑Klasse; Spezialfälle in Kind‑Klassen.
3. Nutze protected statt private, wenn Kind‑Klassen Zugriff benötigen.
4. Für unveränderliche Methoden final setzen (z. B. Sicherheits‑Logik).
5. Verwende abstract für „Schablonen“ mit Pflicht‑Methoden.

Fazit

Mit Vererbung organisierst du gemeinsam genutzte Logik in Eltern‑Klassen,
während spezialisierte Funktionalität in Kind‑Klassen lebt.
Die Sichtbarkeiten public, protected und private
regeln, wer auf welche Members zugreifen darf.
Durch einen überlegten Einsatz von Vererbung, Sichtbarkeit und Schlüsselwörtern wie final
und abstract schreibst du flexiblen, wartbaren und sicher gekapselten OOP‑Code in PHP.