public

Das PHP-Schlüsselwort public

public ist einer der drei Sichtbarkeits-Modifikatoren (Zugriffsmodifikatoren) von PHP, neben private und protected. Ein mit public deklariertes Klassenmitglied kann gelesen und geschrieben – oder bei Methoden aufgerufen – werden von überall: innerhalb der Klasse, aus einer Unterklasse heraus und von jedem Code, der ein Objekt der Klasse besitzt.

Diese Seite behandelt die Syntax, den Anwendungsbereich von public, die Unterschiede zu den anderen Modifikatoren, die Regeln für die Standardsichtbarkeit sowie praktische Fallstricke beim öffentlichen Exponieren von Mitgliedern. Wenn Klassen neu für Sie sind, beginnen Sie mit PHP-Klassen und -Objekte.

Syntax

Platzieren Sie das Schlüsselwort public vor einer Eigenschafts-, Methoden- oder Konstantendeklaration:

class MyClass {
  public $myPublicProperty;          // public property
  public const VERSION = '1.0';      // public constant (PHP 7.1+)

  public function myPublicMethod() {
    // accessible from anywhere
  }
}

public kann folgende Elemente modifizieren:

• Eigenschaften — public $name;
• Methoden — public function greet() { ... }
• Konstanten — public const MAX = 10; (PHP 7.1+; Konstanten sind implizit public, wenn kein Modifikator angegeben wird)
• Constructor-Promotion-Parameter — public function __construct(public string $name) {} (PHP 8.0+)

Standardsichtbarkeit

Die Sichtbarkeit ist in PHP optional. Die Standardeinstellung hängt vom Mitgliedstyp ab:

• Eine Methode ohne Modifikator ist implizit public. function honk() und public function honk() bedeuten dasselbe.
• Eine Eigenschaft muss einen der Modifikatoren (public, protected oder private) oder var verwenden. Historisch war var $x; ein Alias für public $x; und wird noch akzeptiert, ist jedoch nicht empfohlen.
• Eine Klassenkonstante ohne Modifikator ist implizit public.

Das explizite Schreiben von public ist der empfohlene Stil – es macht die Absicht für jeden, der den Code liest, offensichtlich.

Beispiele

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

Beispiele für das PHP-Schlüsselwort public

<?php

// Example 1
class Car
{
  public $model;
  public $color;

  public function __construct($model, $color)
  {
    $this->model = $model . PHP_EOL;
    $this->color = $color;
  }

  public function honk()
  {
    return "Beep beep!" . PHP_EOL;
  }
}

$myCar = new Car("Tesla", "red");
echo $myCar->model; // Output: Tesla
echo $myCar->honk(); // Output: Beep beep!

// Example 2
class Math
{
  public static function add($a, $b)
  {
    return $a + $b;
  }

  public static function multiply($a, $b)
  {
    return $a * $b;
  }
}

echo Math::add(5, 10); // Output: 15
echo Math::multiply(5, 10); // Output: 50

Hier sind $model, honk() und die statischen Math-Methoden alle public, sodass der aufrufende Code direkt über -> (Instanzen) oder :: (statische Mitglieder) auf sie zugreift.

Constructor Promotion (PHP 8.0+)

Seit PHP 8.0 können Sie eine öffentliche Eigenschaft direkt aus einem Konstruktor-Parameter deklarieren und initialisieren, wodurch der wiederkehrende $this->x = $x;-Boilerplate entfällt:

<?php

class Point
{
  public function __construct(
    public int $x = 0,
    public int $y = 0
  ) {}
}

$p = new Point(3, 4);
echo "$p->x,$p->y" . PHP_EOL; // Output: 3,4

Dies entspricht der Deklaration von public int $x; und der Zuweisung im Konstruktorrumpf. Weitere Einzelheiten finden Sie unter PHP-Konstruktor.

public vs. protected vs. private

PHP verfügt über drei Sichtbarkeitsmodifikatoren. Der Unterschied liegt darin, von wo auf ein Mitglied zugegriffen werden kann:

Das folgende Skript zeigt die Grenzen in der Praxis:

<?php

class Base
{
  public $open = 'public';
  protected $family = 'protected';
  private $secret = 'private';

  public function reveal()
  {
    // Inside the class, all three are reachable.
    return "$this->open / $this->family / $this->secret" . PHP_EOL;
  }
}

$b = new Base();

echo $b->open . PHP_EOL;  // Output: public  (allowed from outside)
echo $b->reveal();        // Output: public / protected / private

// echo $b->family;       // Fatal error: Cannot access protected property
// echo $b->secret;       // Fatal error: Cannot access private property

Nur $open ist von außerhalb der Klasse direkt erreichbar. $family und $secret können nur über die öffentliche Methode reveal() gelesen werden.

Wann sollte public verwendet werden?

Verwenden Sie public für die Teile einer Klasse, die ihre API bilden – die Methoden und Daten, auf die sich anderer Code stützen soll. Alles andere sollte private oder protected sein.

• Exponieren Sie Verhalten, keinen rohen Zustand. Bevorzugen Sie public-Methoden (getEmail(), withdraw($amount)) gegenüber public-Eigenschaften, damit Sie die Kontrolle über die Validierung behalten und die Interna später ändern können, ohne bestehende Aufrufer zu beeinträchtigen.
• Eine public-Eigenschaft ist ein Vertrag: Sobald externer Code davon abhängt, ist das Umbenennen oder Entfernen eine breaking change.
• Verwenden Sie public static für Hilfs-/Factory-Methoden, die keine Instanz benötigen (siehe PHP-Statische Methoden).
• Interface-Methoden sind immer effektiv public – siehe PHP-Interfaces.

Zusammenfassung

• public macht ein Klassenmitglied von überall zugänglich; es ist der freizügigste der drei Sichtbarkeitsmodifikatoren von PHP.
• Methoden und Konstanten sind standardmäßig public; Eigenschaften müssen ihre Sichtbarkeit explizit angeben.
• Reservieren Sie public für die beabsichtigte API einer Klasse und verbergen Sie Implementierungsdetails hinter private/protected für eine bessere Kapselung.

Fahren Sie mit private, protected und PHP-Vererbung fort, um Ihr Verständnis von Sichtbarkeit abzurunden.

Übungen