mitmario.dev

Konstruktor und Sichtbarkeit

PHP Sandbox 4 Min Lesezeit 4 BeispieleLektion 1 von 6

Ein Posten ohne Preis lässt sich anlegen, als wäre nichts. Auffallen tut das erst, wenn jemand damit rechnet. Und von außen kann jeder $kaffee->preisCent = 1 schreiben, ohne dass die Klasse etwas davon merkt.

Klasse und Objekt kennst du vom Ende von Abschnitt 6, mit new, -> und $this. Dort stand auch schon ein Konstruktor, nur ohne Erklärung. Die kommt jetzt. Gespielt wird wieder auf der Kommandozeile, also steht die Ausgabe im Terminal. Der Reiter Browser bleibt in diesem Abschnitt leer, bis auf ein Beispiel in der Lektion über Vererbung.

Ein Objekt, dem ein Wert fehlt

Ein Objekt in mehreren Schritten
<?php

declare(strict_types=1);

class Posten
{
    public string $titel;
    public int $menge;
    public int $preisCent;
}

$kaffee = new Posten();
$kaffee->titel = "Kaffee";
$kaffee->menge = 2;
$kaffee->preisCent = 490;

echo $kaffee->titel, ": ", $kaffee->menge, " Stück\n";

// Und hier derselbe Aufbau, nur ist eine Zeile abhanden gekommen.

$tee = new Posten();
$tee->titel = "Tee";
$tee->menge = 3;

try {
    $zeile = $tee->titel . ": " . $tee->preisCent;
    echo $zeile, "\n";
} catch (Error $fehler) {
    echo "Kaputt: ", $fehler->getMessage(), "\n";
}

Ohne Konstruktor entsteht ein Objekt mit new, und danach füllt man jede Eigenschaft von Hand. Zwischen dem new und der letzten Zuweisung ist das Objekt halbfertig. Beim zweiten Posten im Beispiel bleibt es so, denn eine Zeile fehlt. PHP bricht ab, sobald jemand den Preis liest, mit Typed property Posten::$preisCent must not be accessed before initialization.

Die Eigenschaft wurde also gelesen, bevor sie einen Wert bekommen hat. Sie hat den Typ int, und null ist keine Zahl. Deshalb steht dort noch gar nichts.

Ein Array hätte an dieser Stelle mit Undefined array key "preisCent" gewarnt, null geliefert und weitergerechnet. Das Objekt bricht ab, und das ist besser. Aufgefallen ist der Fehler trotzdem erst beim Lesen, und das ist oft weit weg von der Stelle, an der die Zuweisung vergessen wurde.

Im Reiter Debug siehst du, wie kaffee Zeile für Zeile von Posten {} bis zu allen drei Werten wächst, und tee bleibt dabei bei Posten {titel: "Tee", menge: 3} stehen.

Der Konstruktor macht die Angaben zur Pflicht

Derselbe Bauplan mit einem Konstruktor
<?php

declare(strict_types=1);

class Posten
{
    public string $titel;
    public int $menge;
    public int $preisCent;

    public function __construct(string $titel, int $menge, int $preisCent)
    {
        $this->titel = $titel;
        $this->menge = $menge;
        $this->preisCent = $preisCent;
    }
}

$kaffee = new Posten("Kaffee", 2, 490);

echo $kaffee->titel, ": ", $kaffee->menge, " Stück\n";

// Und jetzt der Versuch von eben, mit einer fehlenden Angabe.

try {
    $tee = new Posten("Tee", 3);
} catch (ArgumentCountError $fehler) {
    echo "Abgelehnt: ", get_class($fehler), "\n";
}

__construct ruft PHP beim new von selbst auf. Was in den Klammern hinter new Posten(...) steht, landet in seinen Parametern. Methoden mit zwei Unterstrichen vorn im Namen ruft normalerweise PHP selbst auf, nicht du.

In einem Konstruktor steht, was ein Objekt zum Existieren braucht, und PHP besteht darauf. new Posten("Tee", 3) scheitert jetzt sofort mit einem ArgumentCountError, und zwar in der Zeile, in der die Angabe fehlt. Der Name sagt es schon. Es kamen zu wenige Argumente an. Eine Rechnung drei Funktionen weiter bekommt das halbe Objekt gar nicht erst zu sehen.

Konstruktor-Promotion spart die halbe Klasse

Derselbe Posten mit Konstruktor-Promotion
<?php

declare(strict_types=1);

class Posten
{
    public function __construct(
        public string $titel,
        public int $menge,
        public int $preisCent,
    ) {
    }

    public function summeCent(): int
    {
        return $this->menge * $this->preisCent;
    }
}

$kaffee = new Posten("Kaffee", 2, 490);
$tee = new Posten(titel: "Tee", preisCent: 250, menge: 3);

echo $kaffee->titel, ": ", number_format($kaffee->summeCent() / 100, 2, ",", "."), "\n";
echo $tee->titel, ": ", number_format($tee->summeCent() / 100, 2, ",", "."), "\n";

Im vorigen Beispiel steht jede Eigenschaft dreimal da. Oben als Deklaration, dann als Parameter und noch einmal in der Zuweisung. Das ist Schreibarbeit, bei der du nichts entscheidest, und trotzdem sind es drei Stellen, die auseinanderlaufen können.

Seit PHP 8.0 gibt es dafür die Konstruktor-Promotion (englisch constructor promotion). Die Sichtbarkeit steht direkt vor dem Parameter, und PHP legt daraus die Eigenschaft an und weist sie zu. Der Rumpf des Konstruktors bleibt leer. Aus zehn Zeilen werden sechs. Der Typ steht weiterhin an jedem Parameter, und PHP prüft ihn genauso wie vorher.

Nebenbei stehen im Beispiel benannte Argumente. new Posten(titel: "Tee", preisCent: 250, menge: 3) hält sich nicht an die Reihenfolge und ist trotzdem eindeutig. Bei new Posten("Tee", 3, 250) musst du raten, welche Zahl die Menge ist und welche der Preis.

public, private und protected

Zwei Zäune, zwei Meldungen
<?php

declare(strict_types=1);

class Posten
{
    public function __construct(
        public string $titel,
        private int $menge,
        public readonly int $preisCent,
    ) {
    }

    public function summeCent(): int
    {
        return $this->menge * $this->preisCent;
    }
}

$kaffee = new Posten("Kaffee", 2, 490);

// 1. public: geht einfach, und das ist das Problem.
$kaffee->titel = "Kaffee, gemahlen";
echo "Titel jetzt: ", $kaffee->titel, "\n";

// 2. private: von hier draussen nicht einmal sichtbar.
try {
    $kaffee->menge = -3;
} catch (Error $fehler) {
    echo "Abgelehnt: ", $fehler->getMessage(), "\n";
}

// 3. readonly: sichtbar, aber einmal gesetzt und fertig.
try {
    $kaffee->preisCent = 1;
} catch (Error $fehler) {
    echo "Abgelehnt: ", $fehler->getMessage(), "\n";
}

echo "Summe bleibt: ", number_format($kaffee->summeCent() / 100, 2, ",", "."), "\n";

Vor jeder Eigenschaft und jeder Methode steht ihre Sichtbarkeit (englisch visibility). Das ist ein Wort, das sagt, von wo aus man sie erreicht:

  • public ist von überall erreichbar, auch von Code, den du nie gesehen hast.
  • private nur innerhalb dieser Klasse. Von außen ist die Eigenschaft nicht einmal sichtbar, ein Zugriff ist ein Error.
  • protected liegt dazwischen und lässt diese Klasse und alle Klassen herein, die von ihr erben. Wozu das gut ist, kommt mit der Vererbung.

Ich fange bei jeder Eigenschaft mit private an und mache sie erst auf, wenn jemand sie von außen wirklich braucht. Was von außen erreichbar ist, wird von außen auch benutzt. Danach lässt es sich nicht mehr ändern, ohne fremden Code kaputtzumachen.

Im Beispiel stehen die Fälle nebeneinander. Den public-Titel überschreibt jeder von außen, und niemand hält ihn auf. Bei private kommt Cannot access private property Posten::$menge, bei readonly heißt es Cannot modify readonly property Posten::$preisCent. Beide Meldungen sind ein Error, und catch (Error $fehler) fängt sie wie jede andere Ausnahme.

Werte, die nach dem Erzeugen feststehen

Der dritte Fall im Beispiel ist readonly. Die Eigenschaft ist von außen lesbar, aber nach dem Erzeugen nicht mehr zu ändern. So sollen sich viele Daten verhalten, etwa ein Preis auf einer Rechnung, eine Bestellnummer oder ein Datum.

readonly gibt es seit PHP 8.1, und es verlangt eine Typangabe. public readonly int $preisCent geht, public readonly $preisCent nicht. Gesetzt werden darf die Eigenschaft ein einziges Mal, und zwar aus der Klasse heraus, fast immer im Konstruktor.

Bei private readonly gewinnt die Sichtbarkeit. Von außen kommt dann die Meldung über die private Eigenschaft. PHP prüft nämlich zuerst, ob dich die Eigenschaft überhaupt etwas angeht, und erst danach, ob sie sich noch ändern lässt. Sinn haben beide zusammen trotzdem. private hält Fremde draußen, und readonly bewahrt dich selbst davor, den Wert später in der Klasse aus Versehen umzubiegen.

Im Reiter Praxis wartet ein Kassenbon. Seine zwei Posten sollen vollständig ankommen und danach unangetastet bleiben.

Zum Mitnehmen

Ein Konstruktor verlangt beim new alle Werte, die ein Objekt braucht, und mit Konstruktor-Promotion stehen Eigenschaft und Zuweisung in einer Zeile. private hält Zugriffe von außen ab, readonly lässt einen Wert nach dem Erzeugen nicht mehr ändern.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.

Was in dieser Lektion steckt

  • Artikel mit 4 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.