protected

Das PHP-Schlüsselwort protected

protected ist einer der drei Zugriffsmodifikatoren in PHP (neben public und private). Es steuert die Sichtbarkeit — wer ein Klassenmitglied lesen oder aufrufen darf.

Ein mit protected deklariertes Mitglied kann zugegriffen werden:

• innerhalb der Klasse, die es deklariert, und
• innerhalb jeder Klasse, die von ihr erbt (eine Unterklasse).

Es kann nicht von „außen" zugegriffen werden — das heißt, von regulärem Code, der lediglich ein Objekt hält ($obj->member). Dieser Mittelweg ist genau das, was protected nützlich macht: Es verbirgt Implementierungsdetails vor der Außenwelt und erlaubt gleichzeitig Unterklassen, darauf aufzubauen. Den vollständigen Vergleich finden Sie unter PHP-Zugriffsmodifikatoren.

Diese Seite behandelt die Syntax, das Verhalten von protected in der Vererbung, häufige Stolperfallen und wann man es statt private oder public verwenden sollte.

Syntax

Setzen Sie das Schlüsselwort protected vor eine Eigenschafts- oder Methodendeklaration:

class MyClass {
  protected $myProtectedProperty;

  protected function myProtectedMethod() {
    // Code here
  }
}

Sie können auch ein statisches Mitglied als protected markieren:

class Config {
  protected static $instances = 0;

  protected static function register() {
    self::$instances++;
  }
}

protected vs. private vs. public

Die drei Modifikatoren unterscheiden sich nur darin, wo ein Mitglied sichtbar ist:

Der wesentliche Unterschied: private-Mitglieder sind selbst für Unterklassen unsichtbar, während protected-Mitglieder entlang der Vererbungskette weitergegeben werden. Wählen Sie protected, wenn eine Unterklasse die Daten oder den Hilfsmethod legitim benötigt, diese aber nicht Teil der öffentlichen API sein sollen.

Beispiele

Die folgenden Beispiele zeigen, wie protected-Mitglieder von einer Unterklasse verwendet werden (erlaubt) — anschließend sehen wir, was passiert, wenn externer Code dasselbe versucht.

<?php

// Example 1
class Animal
{
  protected $name;

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

  protected function getName()
  {
    return $this->name;
  }
}

class Dog extends Animal
{
  public function bark()
  {
    $name = $this->getName();
    echo "$name barks!" . PHP_EOL;
  }
}

$dog = new Dog("Rufus");
$dog->bark(); // Output: Rufus barks!

// Example 2
class BankAccount
{
  protected $balance = 0;

  public function deposit($amount)
  {
    $this->balance += $amount;
  }

  protected function canWithdraw($amount)
  {
    return $amount <= $this->balance;
  }
}

class SavingsAccount extends BankAccount
{
  public function withdraw($amount)
  {
    if ($this->canWithdraw($amount)) {
      $this->balance -= $amount;
      echo "Withdrawal successful!" . PHP_EOL;
    } else {
      echo "Insufficient funds!" . PHP_EOL;
    }
  }
}

$savingsAccount = new SavingsAccount();
$savingsAccount->deposit(100);
$savingsAccount->withdraw(50); // Output: Withdrawal successful!
$savingsAccount->withdraw(100); // Output: Insufficient funds!

In beiden Klassen ruft die Unterklasse (Dog, SavingsAccount) das protected-Mitglied ihres Elternteils auf. Die Daten und Hilfslogik bleiben durch Vererbung wiederverwendbar, ohne jemals externem Code zugänglich zu sein.

Zugriff auf protected-Mitglieder von außen schlägt fehl

Sobald Sie versuchen, ein protected-Mitglied aus regulärem Code heraus zu berühren, wirft PHP einen fatalen Fehler:

<?php

class Animal {
  protected $name = "Rufus";
}

$animal = new Animal();
echo $animal->name; // Fatal error: Cannot access protected property Animal::$name

Das ist der Schutz in Aktion — die Eigenschaft ist schlicht kein Teil der öffentlichen Oberfläche des Objekts.

Stolperfalle: Eine Unterklasse kann Geschwister desselben Typs ansprechen

Eine häufige Überraschung ist, dass die Sichtbarkeit per Klasse geprüft wird, nicht pro einzelnem Objekt. Ein Objekt kann auf die protected-Mitglieder eines anderen Objekts zugreifen, solange beide Instanzen derselben Klasse (oder einer verwandten Klasse, die das Mitglied sehen kann) sind:

<?php

class Wallet {
  protected $balance = 100;

  public function isRicherThan(Wallet $other): bool
  {
    // $other->balance is protected, but we're inside Wallet, so it's allowed
    return $this->balance > $other->balance;
  }
}

$a = new Wallet();
$b = new Wallet();
var_dump($a->isRicherThan($b)); // bool(false)

Wann man protected verwenden sollte

Greifen Sie auf protected zurück, wenn:

• Eine Unterklasse internen Zustand oder Hilfsmethoden wiederverwenden oder überschreiben muss, externer Code aber nicht.
• Sie eine Basisklasse entwerfen, die erweitert werden soll (siehe PHP abstrakte Klassen), und nur Unterklassen „Bausteine"-Methoden anbieten möchten.

Bevorzugen Sie private, wenn auch Unterklassen nicht von einem internen Detail abhängen sollen — das gibt Ihnen die Freiheit, es später zu ändern, ohne Kindklassen zu beeinträchtigen. Bevorzugen Sie public nur für die beabsichtigte, dokumentierte API der Klasse.

Zusammenfassung

• protected-Mitglieder sind innerhalb der deklarierenden Klasse und ihrer Unterklassen sichtbar, nicht aber für externen Code.
• Es ist der Mittelweg zwischen public (überall sichtbar) und private (nur in der deklarierenden Klasse sichtbar).
• Die Sichtbarkeit wird pro Klasse durchgesetzt, sodass gleichartige Objekte die protected-Mitglieder voneinander sehen können.
• Verwenden Sie es, um wiederverwendbare Interna entlang einer Vererbungskette weiterzugeben, ohne sie der öffentlichen API preiszugeben.

Vertiefen Sie Ihre Kenntnisse mit PHP-Vererbung, PHP-Klassen und -Objekte und Statische Eigenschaften.

Übungen