PHP Constructor: __construct and Property Promotion

A PHP constructor is a method named __construct(). PHP calls it automatically when you write new ClassName(...), and the arguments in the parentheses become its parameters, so the object starts life with its values already set.

<?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";

Without a constructor you would create an empty object and set each property afterwards, and nothing would stop you from forgetting one. With a constructor, new User() without arguments is an ArgumentCountError.

Constructor property promotion

Declaring a property, listing it as a parameter and assigning $this->name = $name repeats each name three times. Since PHP 8.0, a visibility keyword in front of a constructor parameter does all three at once:

<?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";

A promoted parameter can also be readonly (public readonly string $id), which is the shortest way to write an immutable value object. You can mix promoted and normal parameters, and the constructor body can still contain code that runs after the promoted properties are assigned.

Default values and named arguments

Constructor parameters take defaults like any function. Parameters with defaults go after the required ones. With named arguments (PHP 8.0) the caller can skip to the option it wants instead of repeating every default before it:

<?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";

Run it: the output contains HTML, so the Page tab shows the three buttons rendered, and the Output tab shows the tags PHP printed. Note the parentheses in (new Button('Save'))->render(): since PHP 8.4 they are optional, but PHP 8.3 needs them.

Validate arguments in the constructor

A constructor cannot return false or an error code: whatever it returns is ignored. To refuse bad input, throw an exception. The object is then never created, so the rest of the program can trust every Temperature it receives.

<?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";
}

The try catch page covers catching these exceptions in more detail.

Multiple constructors with static factory methods

PHP has no constructor overloading: one class, one __construct. When an object can be built from different inputs (a date string, an array, a timestamp), add named static methods that prepare the arguments and call new static(...). Making the constructor private forces everyone through the factories.

<?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) from outside the class now throws an Error ("Call to private Color::__construct() from global scope"). The static page explains why new static is used here rather than new self.

Call the parent constructor with parent::__construct

When a child class defines its own constructor, the parent's constructor does not run by itself. Call it with parent::__construct(...), usually first, so the parent's properties are set before the child adds its own:

<?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";

If the child has no constructor at all, PHP uses the parent's, and new Truck('Volvo') would pass its arguments straight to Vehicle::__construct. More on this in inheritance.

Forgetting parent::__construct

This mistake produces no error at the line where it happens. The child constructor runs, the parent's typed properties stay uninitialized, and the program fails later, wherever the first read happens:

<?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";
}

Add parent::__construct(); as the first line of Post::__construct and run it again: it prints the date. A related method, __destruct(), runs when the last reference to an object goes away or the script ends. It is rarely needed in everyday code, because PHP closes files and frees memory by itself at the end of each request.