PHP Konstruktor: __construct und Property Promotion

Ein PHP-Konstruktor ist eine Methode namens __construct(). PHP ruft sie automatisch auf, wenn du new ClassName(...) schreibst, und die Argumente in den Klammern werden zu ihren Parametern, sodass das Objekt mit bereits gesetzten Werten startet.

<?php
class User
{
    public string $name;
    public int $age;

    public function __construct(string $name, int $age)
    {
        $this->name = $name;
        $this->age = $age;
    }
}

$ada = new User('Ada', 36);
echo "{$ada->name} is {$ada->age}\n";

Ohne Konstruktor würdest du ein leeres Objekt erzeugen und danach jede Eigenschaft setzen, und nichts würde dich davon abhalten, eine zu vergessen. Mit Konstruktor ist new User() ohne Argumente ein ArgumentCountError.

Constructor Property Promotion

Eine Eigenschaft zu deklarieren, sie als Parameter aufzuführen und $this->name = $name zuzuweisen, wiederholt jeden Namen dreimal. Seit PHP 8.0 erledigt ein Sichtbarkeits-Schlüsselwort vor einem Konstruktorparameter alle drei Schritte auf einmal:

<?php
class User
{
    public function __construct(
        public string $name,
        public int $age,
        private string $email = '',
    ) {}

    public function contact(): string
    {
        return $this->email !== '' ? $this->email : 'no email';
    }
}

$u = new User('Grace', 45, 'grace@example.com');
echo $u->name, ', ', $u->age, ', ', $u->contact(), "\n";

$v = new User('Linus', 28);
echo $v->name, ', ', $v->contact(), "\n";

Ein promoteter Parameter kann auch readonly sein (public readonly string $id), der kürzeste Weg, ein unveränderliches Value Object zu schreiben. Du kannst promotete und normale Parameter mischen, und der Konstruktorrumpf kann weiterhin Code enthalten, der nach der Zuweisung der promoteten Eigenschaften läuft.

Standardwerte und benannte Argumente

Konstruktorparameter nehmen Standardwerte wie jede Funktion. Parameter mit Standardwerten stehen nach den Pflichtparametern. Mit benannten Argumenten (PHP 8.0) kann der Aufrufer direkt zur gewünschten Option springen, statt jeden Standardwert davor zu wiederholen:

<?php
class Button
{
    public function __construct(
        public string $label,
        public string $color = 'blue',
        public string $size = 'medium',
        public bool $disabled = false,
    ) {}

    public function render(): string
    {
        $attr = $this->disabled ? ' disabled' : '';
        return "<button class=\"{$this->color} {$this->size}\"{$attr}>{$this->label}</button>";
    }
}

echo (new Button('Save'))->render(), "\n";
echo (new Button('Delete', 'red'))->render(), "\n";
echo (new Button('Wait', disabled: true))->render(), "\n";

Führe es aus: Die Ausgabe enthält HTML, also zeigt der Tab Page die drei Buttons gerendert, und der Tab Output zeigt die Tags, die PHP ausgegeben hat. Beachte die Klammern in (new Button('Save'))->render(): Seit PHP 8.4 sind sie optional, aber PHP 8.3 braucht sie.

Argumente im Konstruktor validieren

Ein Konstruktor kann kein false und keinen Fehlercode zurückgeben: Was er zurückgibt, wird ignoriert. Um ungültige Eingaben abzulehnen, wirfst du eine Exception. Das Objekt wird dann nie erzeugt, also kann sich der Rest des Programms auf jede Temperature verlassen, die es bekommt.

<?php
class Temperature
{
    public function __construct(public readonly float $celsius)
    {
        if ($celsius < -273.15) {
            throw new InvalidArgumentException("Below absolute zero: $celsius");
        }
    }

    public function fahrenheit(): float
    {
        return $this->celsius * 9 / 5 + 32;
    }
}

echo (new Temperature(21.5))->fahrenheit(), "\n";

try {
    $t = new Temperature(-300);
} catch (InvalidArgumentException $e) {
    echo 'Rejected: ', $e->getMessage(), "\n";
}

Die Seite zu try catch behandelt das Abfangen dieser Exceptions ausführlicher.

Mehrere Konstruktoren mit statischen Factory-Methoden

PHP hat kein Überladen von Konstruktoren: eine Klasse, ein __construct. Wenn sich ein Objekt aus verschiedenen Eingaben bauen lässt (einem Datums-String, einem Array, einem Timestamp), fügst du benannte statische Methoden hinzu, die die Argumente vorbereiten und new static(...) aufrufen. Ein private Konstruktor zwingt alle, über die Factories zu gehen.

<?php
class Color
{
    private function __construct(
        public readonly int $r,
        public readonly int $g,
        public readonly int $b,
    ) {}

    public static function fromRgb(int $r, int $g, int $b): static
    {
        return new static($r, $g, $b);
    }

    public static function fromHex(string $hex): static
    {
        [$r, $g, $b] = sscanf(ltrim($hex, '#'), '%02x%02x%02x');
        return new static($r, $g, $b);
    }

    public function css(): string
    {
        return "rgb({$this->r}, {$this->g}, {$this->b})";
    }
}

echo Color::fromRgb(255, 128, 0)->css(), "\n";
echo Color::fromHex('#1e90ff')->css(), "\n";

new Color(1, 2, 3) von außerhalb der Klasse wirft jetzt einen Error („Call to private Color::__construct() from global scope“). Die Seite zu static erklärt, warum hier new static statt new self verwendet wird.

Den Elternkonstruktor mit parent::__construct aufrufen

Wenn eine Kindklasse ihren eigenen Konstruktor definiert, läuft der Konstruktor der Elternklasse nicht von selbst. Ruf ihn mit parent::__construct(...) auf, meist zuerst, damit die Eigenschaften der Elternklasse gesetzt sind, bevor das Kind seine eigenen hinzufügt:

<?php
class Vehicle
{
    public function __construct(
        protected string $brand,
        protected int $wheels = 4,
    ) {}

    public function describe(): string
    {
        return "{$this->brand} with {$this->wheels} wheels";
    }
}

class Truck extends Vehicle
{
    public function __construct(string $brand, private int $capacityKg)
    {
        parent::__construct($brand, 6);
    }

    public function describe(): string
    {
        return parent::describe() . ", carries {$this->capacityKg} kg";
    }
}

echo (new Vehicle('Fiat'))->describe(), "\n";
echo (new Truck('Volvo', 18000))->describe(), "\n";

Hat das Kind gar keinen Konstruktor, verwendet PHP den der Elternklasse, und new Truck('Volvo') würde seine Argumente direkt an Vehicle::__construct übergeben. Mehr dazu unter Vererbung.

parent::__construct vergessen

Dieser Fehler erzeugt in der Zeile, in der er passiert, keinen Fehler. Der Kindkonstruktor läuft, die typisierten Eigenschaften der Elternklasse bleiben nicht initialisiert, und das Programm scheitert später, wo auch immer zuerst gelesen wird:

<?php
class Model
{
    protected array $attributes;

    public function __construct()
    {
        $this->attributes = ['created' => '2026-03-14'];
    }

    public function get(string $key): mixed
    {
        return array_key_exists($key, $this->attributes) ? $this->attributes[$key] : null;
    }
}

class Post extends Model
{
    public function __construct(public string $title)
    {
        // parent::__construct() is missing
    }
}

$post = new Post('Hello');
try {
    echo $post->get('created'), "\n";
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

Füge parent::__construct(); als erste Zeile von Post::__construct hinzu und führe den Code erneut aus: Er gibt das Datum aus. Eine verwandte Methode, __destruct(), läuft, wenn der letzte Verweis auf ein Objekt verschwindet oder das Skript endet. Im Alltag braucht man sie selten, weil PHP am Ende jeder Anfrage Dateien schließt und Speicher selbst freigibt.