private

Das PHP-Schlüsselwort private

private ist ein Sichtbarkeitsmodifikator (auch Zugriffsmodifikator genannt). Wenn du eine Eigenschaft oder Methode als private kennzeichnest, kann sie nur innerhalb derselben Klasse gelesen und aufgerufen werden – niemals von außerhalb des Objekts und niemals von einer abgeleiteten Klasse, die sie erweitert.

Sichtbarkeit ist das Kernprinzip der Kapselung: Sie ermöglicht es einer Klasse, ihre internen Daten und Hilfslogik hinter einer kontrollierten öffentlichen Oberfläche zu verbergen, sodass die Außenwelt nur von dem abhängt, was du bewusst freigibst. PHP kennt drei Sichtbarkeitsstufen:

Diese Seite behandelt die Syntax von private, wann und warum man es einsetzt, sowie typische Stolperfallen – Vererbung, die „gleiche Klasse, verschiedenes Objekt"-Regel und das Fehlerverhalten. Einen umfassenderen Überblick bieten PHP-Zugriffsmodifikatoren und PHP-Klassen und Objekte.

Syntax

Stelle dem Eigenschafts- oder Methodenaufruf das Schlüsselwort private voran:

class MyClass {
  private $myPrivateVariable;

  private function myPrivateFunction() {
    // Only code inside MyClass can call this.
  }
}

Ein private-Member ist innerhalb der Klasse vollständig nutzbar – andere Methoden von MyClass können $this->myPrivateVariable lesen und $this->myPrivateFunction() aufrufen – aber jeder Zugriff von außen wirft einen Error.

Beispiele

Schauen wir uns einige praktische Beispiele an, wie das Schlüsselwort „private" verwendet werden kann:

Beispiele für PHP private

<?php

// Example 1
class Person
{
  private $name;

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

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

  public function greet()
  {
    $name = $this->getName();
    echo "Hello, $name!" . PHP_EOL;
  }
}

$person = new Person("John");
$person->greet(); // Output: Hello, John!

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

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

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

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

In beiden Beispielen sind $name, getName() und $balance Teil der internen Mechanik der Klasse. Die Außenwelt greift nur auf greet(), deposit() und withdraw() zu – die sicheren, validierten Einstiegspunkte. Das ist Kapselung in der Praxis: Der BankAccount-Kontostand kann niemals negativ werden, weil nichts außerhalb der Klasse direkt darauf schreiben kann.

Was passiert, wenn man die Regel bricht

Der Zugriff auf ein privates Member von außerhalb der Klasse führt zu einem fatalen Error – nicht zu einem stillen null:

<?php

class Person
{
  private $name = "John";
}

$p = new Person();
echo $p->name;
// PHP Fatal error: Uncaught Error: Cannot access private property Person::$name

Das ist beabsichtigt – der Fehler tritt sofort auf, anstatt dass Code still von internen Details abhängig wird.

Private gilt pro Klasse, nicht pro Objekt

Eine häufige Überraschung: Private Member sind zwischen zwei Instanzen derselben Klasse sichtbar. Die „private"-Grenze ist die Klasse, sodass ein Objekt die privaten Member eines anderen Objekts lesen kann, solange beide denselben Typ haben:

<?php

class Money
{
  private $cents;

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

  // Reads $other->cents directly — allowed, same class.
  public function add(Money $other)
  {
    return new Money($this->cents + $other->cents);
  }

  public function format()
  {
    return number_format($this->cents / 100, 2);
  }
}

$total = (new Money(150))->add(new Money(350));
echo $total->format(); // Output: 5.00

Private und Vererbung

Anders als protected wird ein private-Member nicht an Unterklassen vererbt. Eine Kindklasse kann die privaten Member der Elternklasse nicht sehen; deklariert sie ein Member mit demselben Namen, erhält sie eine eigene, separate Kopie davon:

<?php

class Base
{
  private $value = "base";

  public function show()
  {
    echo $this->value . PHP_EOL;
  }
}

class Child extends Base
{
  private $value = "child";
}

(new Child())->show(); // Output: base

show() wurde in Base definiert, also sieht es das eigene private $value von Base – das $value der Kindklasse ist eine völlig separate Eigenschaft. Wenn Unterklassen ein Member teilen und überschreiben sollen, verwende stattdessen protected. Weitere Informationen findest du unter PHP-Vererbung.

Wann man private verwenden sollte

• Interner Zustand, der gültig bleiben muss – wie der BankAccount-Kontostand oben. Lege Mutatoren (deposit, withdraw) frei, die die Regeln durchsetzen.
• Hilfsmethoden, die Implementierungsdetails sind, damit du sie später umbenennen oder umschreiben kannst, ohne Aufrufer zu beeinträchtigen.
• Standardmäßig die restriktivste Stufe wählen. Starte mit private; erweitere auf protected oder public nur dann, wenn ein echter Bedarf entsteht. Es ist viel einfacher, die Sichtbarkeit zu lockern, als sie zu verschärfen, nachdem anderer Code bereits davon abhängt.

Vorteile

• Kapselung – gruppiere Daten mit den Methoden, die damit arbeiten, und verhindere, dass der Rest des Programms direkt darauf zugreift. Siehe PHP-Klassen und Objekte.
• Informationsverbergung – Aufrufer hängen von deiner öffentlichen API ab, nicht von deinen internen Details, sodass du die Funktionsweise der Klasse ändern kannst, ohne sie zu beeinträchtigen.
• Invarianten – da Schreibvorgänge über deine Methoden laufen, kannst du garantieren, dass das Objekt immer in einem gültigen Zustand ist.

Zusammenfassung

Das Schlüsselwort private beschränkt ein Klassenmember auf die Klasse, die es deklariert – nicht auf Unterklassen und nicht auf die Außenwelt. Es ist das Standardwerkzeug für Kapselung: Interne Daten und Hilfsmethoden verbergen, eine kleine validierte öffentliche API exponieren und Objekte in einem konsistenten Zustand halten. Greife auf protected zurück, wenn Unterklassen Zugriff benötigen, und auf public nur für die beabsichtigte Schnittstelle.

Übung