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] 文件夹中:
| 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] 的方法之间没有冲突。
结果
| > 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] 中的方法。
结果
| > 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] 中重复同样的处理。
结果
| > 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] 的属性和方法。因此这类似于多重继承。
结果
| > 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] 方法做的事情与之前相同,但代码更复杂。
结果
| > 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] 接口。
结果
| > 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] 相同的说明同样适用;
- 其余代码保持不变。
结果
| > 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 访问:会发生错误。
结果
| > 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 中要做的。