Skip to content

9. trait

trait 是类似于类的结构。但是,它们不能被实例化:它们旨在被包含到类中。在类中包含 trait,效果就如同把 trait 的代码复制到了该类中。可在多个类中复用的代码放在 trait 中。

trait 自 PHP 5.4 起就已可用。PHP 8 引入了几项新特性,我们将在本章末尾讨论:抽象方法的签名检查(PHP 8.0)、trait 常量(PHP 8.2)、可在 trait 中使用的 [#[\Override]] 属性(PHP 8.3)。

9.1. 脚本目录结构

本章的脚本位于 [scripts-console/traits] 文件夹中:

1
2
3
4
5
6
php8-oct-2026/scripts-console/traits
├── trait-01.php
├── trait-02.php
├── ...
├── trait-09.php
└── trait-10.php

9.2. 在类中包含 trait

脚本 [trait-01.php] 演示了在类中使用 trait 的基本方式:

<?php

declare(strict_types=1);

class Class04
{
    // 带 [name] 属性提升的构造函数
    public function __construct(private string $name)
    {
    }

    // getter 和 setter
    public function getName(): string
    {
        return $this->name;
    }

    public function setName(string $name): void
    {
        $this->name = $name;
    }
}

trait Trait04
{
    // 属性
    private string $name;

    // getter 和 setter
    public function getName(): string
    {
        return $this->name;
    }

    public function setName(string $name): void
    {
        $this->name = $name;
    }
}

class Class05
{
    // 引入 trait
    use Trait04;

    // 构造函数
    public function __construct(string $name)
    {
        $this->name = $name;
    }
}

// 测试
$class04 = new Class04("Tim");
$class05 = new Class05("Burton");
print $class04->getName() . "\n";
print $class05->getName() . "\n";
// 显示这两个对象
print_r($class04);
print_r($class05);

代码说明

  • 第 5–22 行:定义 [Class04] 类,它有一个属性 [$name] (由构造函数初始化)、它的 getter 和 setter;
  • 第 24–39 行:我们取出 [Class04]—不含其构造函数——的代码,并把它移入 trait [Trait04] 中。这一次,属性连同其类型被显式声明。我们不包含构造函数,因为 trait 不能被实例化;
  • 第 24 行:关键字 [trait] 把 [Trait04] 指定为 trait 而不是类;
  • 第 41–51 行:我们定义一个类 [Class05] ,它包含 trait [Trait04] 的代码,并为其添加一个构造函数,使该类可以被实例化;
  • 第 44 行:放在类内部的关键字 [use] 允许把 trait 包含到类中。不要把它与放在任何类之外、用于从命名空间导入名称的语句 [use] 混淆;
  • 第 54–60 行:测试表明,类 [Class04] 和 [Class05] 的工作方式相同。

结果

> php trait-01.php
Tim
Burton
Class04 Object
(
    [name:Class04:private] => Tim
)
Class05 Object
(
    [name:Class05:private] => Burton
)

第 4–11 行的结果表明,对象 [Class04] 和 [Class05] 的内容相同:trait 的私有属性 [$name] 已成为类 [Class05] 的私有属性。

结论:在类中使用 [use Trait] 语句,等价于把 [Trait] 的代码包含到类中。

9.3. 在不同的类中使用同一个 trait

trait 的主要好处之一似乎是在不同的类之间复用相同的代码(属性 + 方法)。不过,我们将看到,用简单的类也能达到同样的目的。

在类之间共享 trait 的做法,由下面的脚本 [trait-02.php]演示:

<?php

declare(strict_types=1);

trait Trait01
{
    // 属性
    private int $id = 0;

    // 方法
    public function doSomething(): void
    {
        print "Trait01::doSomething... ($this->id)\n";
    }
}

class Class02
{
    // 引入 Trait01
    use Trait01 {
        // 方法 [Trait01::doSomething] 在类中
        // 以名称 [doSomethingInTrait] 访问
        Trait01::doSomething as doSomethingInTrait;
    }

    // 类特有的方法
    public function doSomething(): void
    {
        // id 属性
        $this->id += 10;
        // 使用 Trait01 的方法
        $this->doSomethingInTrait();
        // 本地显示
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // 引入 Trait01
    use Trait01;

    // 类的本地方法
    public function doSomethingElse(): void
    {
        // id 属性
        $this->id += 10;
        // 使用 Trait01 的方法
        $this->doSomething();
        // 本地显示
        print "Class03->doSomethingElse\n";
    }
}

// test01
function test01(): void
{
    $class02 = new Class02();
    $class03 = new Class03();
    $class02->doSomething();
    $class03->doSomethingElse();
}

// test01
print "test01-----------------\n";
test01();

说明

  • 第 5–15 行:一个定义了属性 [$id] 和方法 [doSomething] 的 trait;
  • trait [Trait01] 被包含到两个类中:[Class02] (第 17–36 行)和 [Class03] (第 38–53 行);
  • 第 20–24 行:在 [Class02] 中包含 [Trait01]。包含语句之后跟一个 [{...}] 块,用来调整所包含的方法;
  • 第 23 行:这一行解决了一个冲突:[Trait01] 和 [Class02] 都有一个名为 [doSomething] 的方法。在这种情况下,类的方法优先:trait 的方法被隐藏。[as] 运算符使 [Trait01::doSomething] 方法在类中可以通过名称 [doSomethingInTrait] 访问。因此,在 [Class02] 内部将使用以下写法:
    • [doSomethingInTrait] 用于调用方法 [Trait01::doSomething];
    • [doSomething] 用于调用方法 [Class02::doSomething];
  • 第 30–32 行:类 [Class02] 把 [Trait01] 的属性和方法当作自己的来使用;
  • 第 38–53 行:类 [Class03] 与类 [Class02]类似。这里对 [Trait01] 的包含更简单,因为 [Trait01] 和 [Class03] 的方法之间没有冲突。

结果

1
2
3
4
5
6
> php trait-02.php
test01-----------------
Trait01::doSomething... (10)
Class02->doSomething
Trait01::doSomething... (10)
Class03->doSomethingElse

请注意,trait [Trait01] 并不是在类 [Class02] 和 [Class03] 之间共享的。由于 [Trait01] 被包含到类 [Class02] 和 [Class03] 中,[Trait01] 的属性 [$id] 变成了两个不同的属性:[Class02::$id] 和 [Class03::$id]。结果的第 3 行和第 5 行显示了这一点。如果属性 [$id] 在类 [Class02] 和 [Class03] 之间是共享的,第 5 行的值就会是 20 而不是 10。

脚本 [trait-03.php] 表明,用类代替 trait 也能得到相同的结果:

<?php

declare(strict_types=1);

// 替代 trait 的类
class Class01
{
    // 属性
    private int $id = 0;

    // setter
    public function setId(int $id): void
    {
        $this->id = $id;
    }

    // getter
    public function getId(): int
    {
        return $this->id;
    }

    // 方法
    public function doSomething(): void
    {
        print "Class01::doSomething... ($this->id)\n";
    }
}

class Class02
{
    // 对 Class01 实例的引用,由构造函数注入
    public function __construct(private readonly Class01 $class01)
    {
    }

    // 类特有的方法
    public function doSomething(): void
    {
        // 修改 Class01 的属性
        $id = $this->class01->getId();
        $id += 10;
        $this->class01->setId($id);
        // 使用 Class01 的方法
        $this->class01->doSomething();
        // 本地显示
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // 对 Class01 实例的引用,由构造函数注入
    public function __construct(private readonly Class01 $class01)
    {
    }

    // 类的本地方法
    public function doSomethingElse(): void
    {
        // 修改 Class01 的属性
        $id = $this->class01->getId();
        $id += 10;
        $this->class01->setId($id);
        // 使用 Class01 的方法
        $this->class01->doSomething();
        // 本地显示
        print "Class03->doSomethingElse\n";
    }
}

// test01
function test01(): void
{
    // 两个对象,它们将访问 [Class01] 的两个不同实例
    $class02 = new Class02(new Class01());
    $class03 = new Class03(new Class01());
    // 检查
    $class02->doSomething();
    $class03->doSomethingElse();
}

// test02
function test02(): void
{
    // [Class01] 的共享实例
    $class01 = new Class01();
    // 两个对象,它们将访问 [Class01] 的同一个实例
    $class02 = new Class02($class01);
    $class03 = new Class03($class01);
    // 检查
    $class02->doSomething();
    $class03->doSomethingElse();
}

// test01
print "test01-----------------\n";
test01();
// test02
print "test02-----------------\n";
test02();

说明

  • 第 6–28 行:类 [Class01] 取代了 trait [Trait01]。[Trait01] 的代码被并入了类 [Class02] 和 [Class03] 的代码中。这里则不是这样:[Class01] 对象的引用将被注入到 [Class02] 和 [Class03] 类中。因此 [Class01] 类的属性对 [Class02] 和 [Class03] 对象来说是外部的。由于 [$id] 属性是私有的,必须提供 getter 和 setter。这是与 trait 的第一个区别:你必须编写代码来访问该类的私有属性。我们本可以把 [$id] 属性设为公共的,但这并不推荐:使用 setter 设置属性值,可以对其进行验证;
  • 第 33 行:对象 *[Class01] 的引用通过构造函数,借助参数提升,被注入到 *[Class02] 中。PHP 7 课程使用的是 setter [setClass01]。通过构造函数注入 更可取:[Class02] 对象一经构造就是完整的,而且由于该属性是 [readonly] 的,引用就不能再被更改;
  • 第 41–45 行:对于 [Class01] 代码的任何使用,我们都必须通过属性 [$this->class01];
  • 第 51–70 行:类 [Class03] 是类 [Class02] 的克隆,只是其方法的名称不同;
  • 第 73–81 行:第一个测试。它把类 [Class01] 的两个不同实例分别注入对象 [Class02] 和 [Class03];
  • 第 84–94 行:第二个测试把 [Class01] 类的同一个实例注入对象 [Class02] 和 [Class03]。

结果

> php trait-03.php
test01-----------------
Class01::doSomething... (10)
Class02->doSomething
Class01::doSomething... (10)
Class03->doSomethingElse
test02-----------------
Class01::doSomething... (10)
Class02->doSomething
Class01::doSomething... (20)
Class03->doSomethingElse

结果说明

  • 第 3–6 行:我们得到的结果与使用 trait [Trait01] 时相同。可以得出结论:这里并非必须使用 trait,但它确实减少了代码量,因为不需要用方法来访问 trait 的属性:这些属性是已并入 trait 的那个类的有机组成部分;
  • 第 8–11 行:由于对 [Class01] 的同一个引用被注入到对象 [Class02] 和 [Class03] 中,属性 [Class01::$id] 在这两个对象之间是共享的。这就是为什么在使用 trait 时,结果的第 10 行显示的是 20 而不是 10。可以得出结论:如果需要在对象之间共享属性,就不能使用 trait,而必须使用类。

9.4. 在 trait 中归并方法

在前面的示例中,trait 包含属性和方法。这里我们考虑它只包含方法的情形。这时 trait 类似于对可在不同类中使用的方法所做的提取归并。由于这里的 trait 没有属性,我们考虑其中的方法只对传给它们的参数进行操作的情形。这不是强制的:trait 可以对属性 [$this->attribute1] 进行操作而自身并不拥有该属性。在这种情况下,就要由使用该 trait 的类来提供属性 [$this->attribute1]。

在 trait 只有仅对传入参数进行操作的方法的情况下,我们将说明,该 trait 可以替换为一个带有与 trait 相同的方法、并把这些方法声明为 static 的类。

该 trait 的使用由脚本 [trait-04.php], 演示,它复用了前一个示例中的 trait,但去掉了所有属性:

<?php

declare(strict_types=1);

trait Trait01
{
    // 要共享的方法
    public function doSomething(): void
    {
        print "Trait01::doSomething...\n";
    }
}

class Class02
{
    // 引入 Trait01
    use Trait01 {
        // 方法 [Trait01::doSomething] 在类中
        // 以名称 [doSomethingInTrait] 访问
        Trait01::doSomething as doSomethingInTrait;
    }

    public function doSomething(): void
    {
        // 调用 Trait01 的方法
        $this->doSomethingInTrait();
        // 本地显示
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // 引入 Trait01
    use Trait01;

    // 类的本地方法
    public function doSomethingElse(): void
    {
        // 调用 Trait01 的方法
        $this->doSomething();
        // 本地显示
        print "Class03->doSomethingElse\n";
    }
}

// 测试
(new Class02())->doSomething();
(new Class03())->doSomethingElse();

说明

  • 第 5–12 行:trait [Trait01] 不再有任何属性;
  • 第 17–21 行:[Trait01] 被包含到 [Class02] 中。第 26 行使用了 [Trait01] 的方法;
  • 第 35 行:[Trait01] 被包含到 [Class03] 中。第 41 行使用了 [Trait01] 中的方法。

结果

1
2
3
4
5
> php trait-04.php
Trait01::doSomething...
Class02->doSomething
Trait01::doSomething...
Class03->doSomethingElse

在这种用例中,trait [Trait01] 很容易被一个类取代。下面的 [trait-05.php] 脚本演示了这一点:

<?php

declare(strict_types=1);

// 既不能实例化也不能派生、只包含静态方法的类
final class Class01
{
    // 私有构造函数:不能在类的外部实例化
    private function __construct()
    {
    }

    // 要共享的静态方法
    public static function doSomething(): void
    {
        print "Class01::doSomething...\n";
    }
}

class Class02
{
    public function doSomething(): void
    {
        // 调用 Class01 的静态方法
        Class01::doSomething();
        // 本地显示
        print "Class02->doSomething\n";
    }
}

class Class03
{
    // 类的本地方法
    public function doSomethingElse(): void
    {
        // 调用 Class01 的静态方法
        Class01::doSomething();
        // 本地显示
        print "Class03->doSomethingElse\n";
    }
}

// 测试
(new Class02())->doSomething();
(new Class03())->doSomethingElse();

说明

  • 第 6–18 行:trait [Trait01] 被类 [Class01] 取代,该类的所有方法都是静态的。无需实例化或继承它。PHP 7 课程把它声明为抽象类以防止其实例化,并遗憾 PHP 拒绝前缀 [final abstract]。在 PHP 8 中仍然如此:因此我们改为把该类声明为 [final] (不可派生)并带一个私有构造函数(不可实例化)。我们在应用练习的版本 3 中对类 [Utilities] 就是这样做的;
  • 第 25 行:我们现在不再写 [$this->doSomethingInTrait()],而是写 [Class01::doSomething()],即调用类 [Class01] 的静态方法 [doSomething];
  • 第 37 行:在 [Class03] 中重复同样的处理。

结果

1
2
3
4
5
> php trait-05.php
Class01::doSomething...
Class02->doSomething
Class01::doSomething...
Class03->doSomethingElse

我们确实得到了与使用 trait [Trait01] 时相同的结果,这表明可以避免使用它。我们前面指出,trait 的方法可以对属性 [$this->attribute1] 进行操作,即使 trait 本身没有该属性;由使用该 trait 的类来提供它。这是一种非常规且脆弱的做法:更好的做法是把属性 [$this->attribute1] “上移”到 trait 本身。这样,它必然成为使用该 trait 的类的属性之一。我们将在本章末尾看到,PHP 8 为要求使用 trait 的类提供某些东西提供了一个干净的方案:抽象方法。

9.5. 用 trait 实现多重继承

文献中常常提到 trait 允许多重继承:即一个类可以从多个类继承的能力。C++ 语言支持这一特性,但 Java 和 C# 都不支持,它们只支持单继承。我们将说明,虽然在派生类中使用 trait 确实可以实现类似多重继承的东西,但这种用例也可以用简单的类来实现。

脚本 [trait-06.php] 实现了一个派生类和一个 trait:

<?php

declare(strict_types=1);

trait Trait01
{
    // 属性
    private int $i = 0;

    // 要共享的方法
    public function doSomethingInTrait01(): void
    {
        // 修改 Trait01::$i
        $this->i++;
        // 显示
        print "Trait01::doSomethingInTrait01... i=$this->i\n";
    }
}

class Class02
{
    // 派生类可访问的属性
    protected int $j = 0;

    // 方法
    public function doSomethingInClass02(): void
    {
        // 修改 Class02::$j
        $this->j += 10;
        // 显示
        print "Class02->doSomethingInClass02... j=$this->j\n";
    }
}

// 派生类
class Class03 extends Class02
{
    // 继承 Class02::$j 并包含 Trait01::$i
    use Trait01;

    // 方法
    public function doSomethingInClass03(): void
    {
        // 使用 Trait01 的方法
        $this->doSomethingInTrait01();
        // 修改 Trait01::$i
        $this->i += 100;
        // 修改 Class03::$j (==Class02::$j)
        $this->j += 1000;
        // 显示
        print "Class03->doSomethingInClass03... i=$this->i, j=$this->j\n";
    }
}

// 测试
(new Class02())->doSomethingInClass02();
(new Class03())->doSomethingInClass03();

说明

  • 第 5–18 行:一个 trait [Trait01] ,带有一个属性和一个操作该属性的方法;
  • 第 20–33 行:一个类 [Class02] ,它与 trait [Trait01] 毫无关系。它不使用该 trait;
  • 第 23 行:[Class02] 的唯一属性具有 [protected] 可见性,以便在派生类中可以访问;
  • 第 36 行:类 [Class03] 继承类 [Class02]。此外,它并入了 trait [Trait01] (第 39 行)。最终,它继承了 [Class02] 的属性和方法,并并入了 [Trait01] 的属性和方法。因此这类似于多重继承。

结果

1
2
3
4
> php trait-06.php
Class02->doSomethingInClass02... j=10
Trait01::doSomethingInTrait01... i=1
Class03->doSomethingInClass03... i=101, j=1000

与前面的一个示例一样,我们将说明:

  • trait 可以被类取代;
  • 不再把 trait 并入派生类,而是向其中注入对该类实例的引用。

脚本 [trait-07.php] 如下:

<?php

declare(strict_types=1);

class Class01
{
    // 属性
    private int $i = 0;

    // getter 和 setter
    public function getI(): int
    {
        return $this->i;
    }

    public function setI(int $i): void
    {
        $this->i = $i;
    }

    // 方法
    public function doSomethingInClass01(): void
    {
        // 修改 Class01::$i
        $this->i++;
        // 显示
        print "Class01->doSomethingInClass01... i=$this->i\n";
    }
}

class Class02
{
    // 派生类可访问的属性
    protected int $j = 0;

    // 类特有的方法
    public function doSomethingInClass02(): void
    {
        // 修改 Class02::$j
        $this->j += 10;
        // 显示
        print "Class02->doSomethingInClass02... j=$this->j\n";
    }
}

class Class03 extends Class02
{
    // 对 Class01 实例的引用,由构造函数注入
    public function __construct(private readonly Class01 $class01)
    {
    }

    // 类的本地方法
    public function doSomethingInClass03(): void
    {
        // 使用 Class01 的方法
        $this->class01->doSomethingInClass01();
        // 修改 Class01::$i
        $i = $this->class01->getI();
        $i += 100;
        $this->class01->setI($i);
        // 修改 Class03::$j
        $this->j += 1000;
        // 显示
        print "Class03->doSomethingInClass03... i=$i, j=$this->j\n";
    }
}

// 测试
$class02 = new Class02();
$class03 = new Class03(new Class01());
$class02->doSomethingInClass02();
$class03->doSomethingInClass03();

说明

  • 第 5–29 行:类 *[Class01] 取代了 trait *[Trait01]。由于 [Class01] 对象将通过引用来使用,因此为 [$i] 属性提供了 getter 和 setter;
  • 第 31–44 行:[Class02] 类保持不变;
  • 第 46 行:[Class03] 类继承 [Class02] 类;
  • 第 49 行:对 [Class01] 对象的引用通过构造函数被注入 [Class03] ;
  • 第 54–66 行:[doSomethingInClass03] 方法做的事情与之前相同,但代码更复杂。

结果

1
2
3
4
> php trait-07.php
Class02->doSomethingInClass02... j=10
Class01->doSomethingInClass01... i=1
Class03->doSomethingInClass03... i=101, j=1000

从这个示例我们可以再次得出结论:trait 并非必不可少,但必须承认,它能让派生类中的代码更简短。

9.6. 用 trait 代替抽象类

下面这种用例很常见:你创建一个相当通用的接口 I,它可以产生多种实现。这些实现共享公共代码,但在其他方法上有所不同。实现这种用例有两种方式:

  • 你创建一个抽象类 C,其中包含派生类共有的代码。类 C 实现接口 I,但某些方法(必须在派生类中定义)在类 C 中被声明为抽象方法,因此类 C 本身也是抽象的。然后我们创建派生自 C 的类 C1 和 C2,它们各自以自己的方式实现其父类 C 的抽象方法;
  • 我们创建一个 trait T,它与上一种方案中的抽象类 C 几乎完全相同。该 trait 不实现接口 I,因为在语法上它做不到。然后我们创建类 C1 和 C2,它们实现接口 I 并使用 trait T。这些类剩下要做的,就是实现接口 I 中未由它们所导入的 trait T 实现的那些方法。

下面的示例说明这两种方案何其相似。应用程序 1 实现方案 1([trait-08.php]):

<?php

declare(strict_types=1);

interface Interface1
{
    public function doSomething(): void;

    public function doSomethingElse(): void;
}

abstract class AbstractClass implements Interface1
{
    // 派生类可访问的属性
    protected int $attr1 = 11;
    protected int $attr2 = 12;

    // getter 和 setter
    public function getAttr1(): int
    {
        return $this->attr1;
    }

    public function getAttr2(): int
    {
        return $this->attr2;
    }

    public function setAttr1(int $attr1): static
    {
        $this->attr1 = $attr1;
        return $this;
    }

    public function setAttr2(int $attr2): static
    {
        $this->attr2 = $attr2;
        return $this;
    }

    // 已实现的方法
    #[\Override]
    public function doSomething(): void
    {
        print "AbstractClass::doSomething [$this->attr1,$this->attr2]\n";
    }

    // 未实现的方法
    #[\Override]
    abstract public function doSomethingElse(): void;
}

// 派生类 1
class Class1 extends AbstractClass
{
    // 属性
    private int $attr3 = 13;

    // getter 和 setter
    public function getAttr3(): int
    {
        return $this->attr3;
    }

    public function setAttr3(int $attr3): static
    {
        $this->attr3 = $attr3;
        return $this;
    }

    // doSomethingElse 的实现
    #[\Override]
    public function doSomethingElse(): void
    {
        print "Class1::doSomethingElse [$this->attr1,$this->attr2,$this->attr3]\n";
    }
}

// 派生类 2
class Class2 extends AbstractClass
{
    // 属性
    private int $attr4 = 14;

    // getter 和 setter
    public function getAttr4(): int
    {
        return $this->attr4;
    }

    public function setAttr4(int $attr4): static
    {
        $this->attr4 = $attr4;
        return $this;
    }

    // doSomethingElse 的实现
    #[\Override]
    public function doSomethingElse(): void
    {
        print "Class2::doSomethingElse [$this->attr1,$this->attr2,$this->attr4]\n";
    }
}

// 外部函数
function useInterfaceWith(Interface1 $interface): void
{
    $interface->doSomething();
    $interface->doSomethingElse();
}

// 测试
useInterfaceWith(new Class1());
useInterfaceWith(new Class2());
// “流式”setter 可以链式调用
useInterfaceWith((new Class1())->setAttr1(21)->setAttr2(22)->setAttr3(23));

说明

  • 第 5–10 行:接口 [Interface1] 有两个方法;
  • 第 12 行:抽象类 [AbstractClass] 实现接口 [Interface1]。它有两个属性及其 getter 和 setter,实现了 [doSomething] 方法,该方法属于 [Interface1] 接口(第 43 行),但没有实现 [doSomethingElse] 方法。因此该方法被声明为抽象方法(第 50 行)。抽象类 [AbstractClass] 不能被实例化,要发挥作用必须被继承;
  • 第 29–39 行:这些 setter 是“流式”的:它们不是什么都不返回,而是返回对象 [$this]。这使得链式调用成为可能(第 116 行)。返回类型 [static] (PHP 8.0)指的是调用该方法的对象所属的类:[(new Class1())->setAttr1(21)] 的类型是 [Class1] 而不是 [AbstractClass],这使得接下来可以调用 [setAttr3]——一个 [Class1] 特有的方法;
  • 第 54 行:类 [Class1] 继承抽象类 [AbstractClass] ,因此实现了接口 [Interface1]。它为其父类没有定义的方法 [doSomethingElse] 提供了方法体。它还在其父类的属性之外添加了一个属性;
  • 第 80 行:类 [Class2] 对另一个属性做同样的事;
  • 第 106–110 行:函数 [useInterfaceWith] 接收一个 [Interface1] 类型的参数,并调用该接口的两个方法;
  • 第 113–116 行:先以 [useInterfaceWith] 函数调用 [Class1] 类型,然后再以 [Class2] 类型调用。这是正确的,因为这两个类型都实现了 [Interface1] 接口。

结果

1
2
3
4
5
6
7
> php trait-08.php
AbstractClass::doSomething [11,12]
Class1::doSomethingElse [11,12,13]
AbstractClass::doSomething [11,12]
Class2::doSomethingElse [11,12,14]
AbstractClass::doSomething [21,22]
Class1::doSomethingElse [21,22,23]

现在我们用脚本 [trait-09.php]实现方案 2。这需要把抽象类替换为 trait:

<?php

declare(strict_types=1);

interface Interface1
{
    public function doSomething(): void;

    public function doSomethingElse(): void;
}

trait Trait1
{
    // 属性
    private int $attr1 = 11;
    private int $attr2 = 12;

    // getter 和 setter
    public function getAttr1(): int
    {
        return $this->attr1;
    }

    public function getAttr2(): int
    {
        return $this->attr2;
    }

    public function setAttr1(int $attr1): static
    {
        $this->attr1 = $attr1;
        return $this;
    }

    public function setAttr2(int $attr2): static
    {
        $this->attr2 = $attr2;
        return $this;
    }

    // 已实现的方法
    #[\Override]
    public function doSomething(): void
    {
        print "Trait1::doSomething [$this->attr1,$this->attr2]\n";
    }
}

// 类 1
class Class1 implements Interface1
{
    // 使用 trait
    use Trait1;

    // 属性
    private int $attr3 = 13;

    // getter 和 setter
    public function getAttr3(): int
    {
        return $this->attr3;
    }

    public function setAttr3(int $attr3): static
    {
        $this->attr3 = $attr3;
        return $this;
    }

    // doSomethingElse 的实现
    #[\Override]
    public function doSomethingElse(): void
    {
        print "Class1::doSomethingElse [$this->attr1,$this->attr2,$this->attr3]\n";
    }
}

// 类 2
class Class2 implements Interface1
{
    // 使用 trait
    use Trait1;

    // 属性
    private int $attr4 = 14;

    // getter 和 setter
    public function getAttr4(): int
    {
        return $this->attr4;
    }

    public function setAttr4(int $attr4): static
    {
        $this->attr4 = $attr4;
        return $this;
    }

    // doSomethingElse 的实现
    #[\Override]
    public function doSomethingElse(): void
    {
        print "Class2::doSomethingElse [$this->attr1,$this->attr2,$this->attr4]\n";
    }
}

// 使用该接口的外部函数
function useInterfaceWith(Interface1 $interface): void
{
    $interface->doSomething();
    $interface->doSomethingElse();
}

// 测试
useInterfaceWith(new Class1());
useInterfaceWith(new Class2());
// “流式”setter 可以链式调用
useInterfaceWith((new Class1())->setAttr1(21)->setAttr2(22)->setAttr3(23));

说明

  • 第 5–10 行:[Interface1] 接口没有变化;
  • 第 12–47 行:trait [Trait1] 取代了方案 1 中的抽象类 [AbstractClass] 。除了以下细节外,代码相同:
    • 第 12 行:trait [Trait1] 不实现接口 [Interface1]。这在语法上是不可能的;
    • 第 15–16 行:抽象类 *[AbstractClass] 的属性可见性在这里由 ***[protected] 变为 [private]***。在这两种情况下,目的都是让具体类无需经过 getter 和 setter 就能直接访问这些属性。对于 trait,[private]* 就足够了,因为 trait 的属性会变成类的属性;
    • trait [Trait1] 没有声明抽象方法 [doSomethingElse];
    • 第 42 行:从 PHP 8.3 开始,属性 [#[\Override]] 可以应用于 trait 的方法。这会在每个使用该 trait 的类中进行检查:这里,方法 [doSomething] 必须对应于 [Class1] 和 [Class2] 的某个接口或父类的方法。情况确实如此:它是 [Interface1] 的方法 [doSomething];
  • 第 50 行:方案 2 中的类 *[Class1] 与方案 1 中的类 *[Class1] 完全相同,除了以下细节:
    • 它实现 [Interface1] 接口,而在方案 1 中,它继承的是抽象类 [AbstractClass];
    • 它使用 trait [Trait1] (第 53 行)来实现接口的一部分;
  • 第 79 行:与 [Class1] 相同的说明同样适用;
  • 其余代码保持不变。

结果

1
2
3
4
5
6
7
> php trait-09.php
Trait1::doSomething [11,12]
Class1::doSomethingElse [11,12,13]
Trait1::doSomething [11,12]
Class2::doSomethingElse [11,12,14]
Trait1::doSomething [21,22]
Class1::doSomethingElse [21,22,23]

我们确实得到了相同的结果。

9.7. PHP 8 中的 trait

PHP 8 使 trait 更加可靠和完整。脚本 [trait-10.php] 演示了这些新特性:

<?php

declare(strict_types=1);

// 对使用它的类提出要求的 trait
trait CounterTrait
{
    // trait 常量(PHP 8.2)
    public const int STEP = 10;

    // 静态属性:每个使用它的类都有自己的一份
    private static int $nbInstances = 0;

    // 实例属性
    private int $counter = 0;

    // trait 的静态方法
    public static function getNbInstances(): int
    {
        return self::$nbInstances;
    }

    // 抽象方法:使用它的类必须定义它(自 PHP 8.0 起检查签名)
    abstract protected function getName(): string;

    // 由使用它的类的构造函数调用
    private function register(): void
    {
        self::$nbInstances++;
    }

    // 使用抽象方法和常量的具体方法
    public function increment(): static
    {
        $this->counter += self::STEP;
        print "{$this->getName()}: counter=$this->counter\n";
        return $this;
    }
}

class Car
{
    use CounterTrait;

    public function __construct(private string $registration)
    {
        $this->register();
    }

    // 实现 trait 的抽象方法
    #[\Override]
    protected function getName(): string
    {
        return "Car[$this->registration]";
    }
}

class Bike
{
    use CounterTrait;

    public function __construct()
    {
        $this->register();
    }

    #[\Override]
    protected function getName(): string
    {
        return "Bike";
    }
}

// 测试
(new Car("AB-123-CD"))->increment()->increment();
new Car("EF-456-GH");
(new Bike())->increment();
// 每个类都有自己的静态属性
print "number of cars: " . Car::getNbInstances() . "\n";
print "number of bikes: " . Bike::getNbInstances() . "\n";
// trait 常量通过类访问,而不是通过 trait 访问
print "step: " . Car::STEP . "\n";
try {
    print CounterTrait::STEP . "\n";
} catch (\Error $ex) {
    print $ex::class . ": " . $ex->getMessage() . "\n";
}
// 使用该 trait 的类必须实现抽象方法
// class Plane { use CounterTrait; }  // Fatal error: Class Plane contains 1 abstract method...

说明

  • 第 9 行:从 PHP 8.2 起,trait 可以声明常量。这些常量会成为使用该 trait 的类的常量;
  • 第 12 行:trait 可以声明静态属性。与实例属性一样,它们会被复制到每个使用该 trait 的类中:每个类都有自己的实例计数器;
  • 第 18–21 行:trait 可以声明静态方法。在 trait 的代码中,[self] 指的是使用该 trait 的类;
  • 第 24 行:trait 可以声明抽象方法。任何使用该 trait 的类都必须实现它们;否则它本身必须被声明为抽象类(参见脚本末尾被注释掉的类 [Plane] )。从 PHP 8.0 起,会验证实现的签名(参数类型和返回类型)。这是对使用该 trait 的类提出要求的正确方式,而不是假定它们具有某个特定的属性或方法;
  • 第 33–38 行:一个具体方法 [increment],它使用抽象方法 [getName] 和常量 [STEP]。它返回 [$this] (类型 [static]),以便可以链式调用;
  • 第 41–56 行:类 [Car] 使用该 trait,在其构造函数中调用该 trait 的私有方法 [register] ,并实现抽象方法 [getName]。请注意该实现上的 [#[\Override]] 属性:它是被接受的,因为该类实现了 trait 的抽象方法;
  • 第 58–72 行:类 *[Bike]* 做同样的事;
  • 第 79–80 行:每个类都有自己的静态属性 [$nbInstances];
  • 第 82 行:trait 的常量可以通过使用它的类访问;
  • 第 84 行:但不能直接通过 trait 访问:会发生错误。

结果

1
2
3
4
5
6
7
8
> php trait-10.php
Car[AB-123-CD]: counter=10
Car[AB-123-CD]: counter=20
Bike: counter=10
number of cars: 2
number of bikes: 1
step: 10
Error: Cannot access trait constant CounterTrait::STEP directly

9.8. 结论

从前面的示例可以清楚地看出,使用 trait 能带来净收益的用例并不明显。在我们的示例中,总是可以用类来取代它而不使用 trait。不过,它对于在不同类之间提取公共代码很有用,就好像这些代码属于某个父类一样,而不消耗 PHP 类仅有的单继承名额。这正是我们在应用练习的版本 4 中要做的。