PHP 构造函数：__construct 和属性提升

PHP 构造函数是一个名为 __construct() 的方法。当你写 new ClassName(...) 时，PHP 会自动调用它，括号里的参数会成为它的参数，所以对象一创建出来，各项值就已经设置好了。

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

如果没有构造函数，你得先创建一个空对象，再逐个设置属性，而且没有任何机制能阻止你漏掉一个。有了构造函数，不带参数的 new User() 就会抛出 ArgumentCountError。

构造函数属性提升

声明属性、把它列为参数、再赋值 $this->name = $name，每个名字都要重复写三遍。从 PHP 8.0 开始，在构造函数参数前加上访问控制关键字，就能一次完成这三件事：

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

提升的参数也可以是 readonly（public readonly string $id），这是编写不可变值对象最简短的方式。提升参数和普通参数可以混用，构造函数体中仍然可以写代码，它们会在提升属性赋值之后运行。

默认值和命名参数

构造函数的参数和普通函数一样可以有默认值。带默认值的参数要放在必填参数后面。使用命名参数（PHP 8.0）时，调用方可以直接跳到想设置的选项，而不必把它前面的每个默认值都重复一遍：

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

运行它：输出中包含 HTML，所以“页面”标签页会显示渲染好的三个按钮，“输出”标签页则显示 PHP 打印出的标签。注意 (new Button('Save'))->render() 中的括号：从 PHP 8.4 开始可以省略，但 PHP 8.3 必须写。

在构造函数中校验参数

构造函数不能返回 false 或错误码：它返回的任何值都会被忽略。要拒绝不合法的输入，就抛出异常。这样对象根本不会被创建，程序的其他部分就可以放心使用收到的每个 Temperature。

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

try catch 页面更详细地讲解了如何捕获这些异常。

用静态工厂方法实现多个构造函数

PHP 没有构造函数重载：一个类只有一个 __construct。当对象可以由不同的输入构建时（日期字符串、数组、时间戳），可以添加有名字的静态方法，由它们准备好参数并调用 new static(...)。把构造函数设为 private，就能强制所有人都通过工厂方法创建对象。

<?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) 会抛出 Error（“Call to private Color::__construct() from global scope”）。static 页面解释了这里为什么用 new static 而不是 new self。

用 parent::__construct 调用父类构造函数

当子类定义了自己的构造函数时，父类的构造函数不会自动运行。用 parent::__construct(...) 调用它，通常放在第一行，这样父类的属性会在子类添加自己的属性之前设置好：

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

如果子类根本没有构造函数，PHP 会使用父类的构造函数，new Truck('Volvo') 会把参数直接传给 Vehicle::__construct。更多内容见继承。

忘记调用 parent::__construct

这个错误在出错的那一行不会产生任何报错。子类的构造函数照常运行，父类的类型化属性保持未初始化状态，程序直到后面第一次读取这些属性时才会失败：

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

在 Post::__construct 的第一行加上 parent::__construct();，再运行一次：它就会输出日期。与之相关的 __destruct() 方法会在对象的最后一个引用消失或脚本结束时运行。日常代码中很少需要它，因为 PHP 会在每个请求结束时自行关闭文件并释放内存。