5. 类
术语:类(关键字 [class])是 PHP 的一种类型。这种类型的变量称为对象。对象是类的实例。
正是在本章,PHP 从第 7 版到第 8 版的演进表现得最为明显。PHP 8 引入了一系列新特性,使类的编写更加简洁和安全:类型化属性、构造函数参数提升、只读属性([readonly])、枚举([enum])、属性钩子和非对称可见性(PHP 8.4)、带修改的克隆(PHP 8.5)……我们通过示例引入这些概念,并沿用 PHP 7 课程的讲解顺序:从最基本的类开始,逐步过渡到按当前最佳实践编写的类。
5.1. 脚本的目录结构
本章的脚本位于 [scripts-console/classes] 文件夹中:
| php8-oct-2026/scripts-console/classes
├── json
│ ├── json-01.php
│ ├── json-02.php
│ ├── json-03.php
│ ├── json-04.php
│ ├── Person.php
│ ├── Person2.php
│ ├── Person3.php
│ └── Person4.php
├── classes-01.php
├── classes-02.php
├── ...
├── classes-26.php
├── Gender.php
├── Person.php
├── Student.php
└── Teacher.php
|
与前面几章一样,控制台脚本在 [VS Code] 中、于脚本所在文件夹打开的终端里,使用 [php script-name.php] 命令运行。
5.2. 任何变量都能变成带属性的对象吗?
在 PHP 7 中,可以对一个不存在的变量 [$obj1->attr1 = "one";] 写入 [$obj1]:PHP 随后会悄悄地(只给出一个简单的警告)创建一个 [stdClass] 类型的对象,并带有 [attr1] 属性。这在 PHP 8 中不再可能。脚本 [classes-01.php] 如下:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 在 PHP 8 中,不存在的变量不再会神奇地变成对象
try {
$obj0->attr1 = "one";
} catch (\Error $e) {
print "Error: " . $e->getMessage() . "\n";
}
// 必须显式创建通用对象
$obj1 = new \stdClass();
// [stdClass] 对象可以接收动态创建的属性
$obj1->attr1 = "one";
$obj1->attr2 = 100;
// 显示对象
print "object1=[$obj1->attr1,$obj1->attr2]\n";
// 修改对象
$obj1->attr2 += 100;
// 显示对象
print "object1=[$obj1->attr1,$obj1->attr2]\n";
// 将 object1 的值(所指向对象的地址)复制到 object2
// 这两个变量随后是不同的,但指向同一个对象
$obj2 = $obj1;
// 修改 obj2
$obj2->attr2 = 0;
// 显示这两个对象
print "object1=[$obj1->attr1,$obj1->attr2]\n";
print "object2=[$obj2->attr1,$obj2->attr2]\n";
// 更改 obj1 所指向的对象
$obj1 = new \stdClass();
print "obj1:\n";
print_r($obj1);
print "obj2:\n";
print_r($obj2);
// 将 object2 的引用(地址)赋给 object3
// 此时 $obj2 和 $obj3 是同一个变量
$obj3 = &$obj2;
print "obj2:\n";
print_r($obj2);
print "obj3:\n";
print_r($obj3);
// 修改 obj3
$obj3->attr2 = 10;
// 显示这两个对象
print "object2=[$obj2->attr1,$obj2->attr2]\n";
print "object3=[$obj3->attr1,$obj3->attr2]\n";
// 更改 obj2 所指向的对象
$obj2 = new \stdClass();
$obj2->attr3 = "two";
$obj2->attr4 = 20;
// 显示两个对象 $obj2 和 $obj3
print "obj2:\n";
print_r($obj2);
print "obj3:\n";
print_r($obj3);
// 对象是字典吗?
try {
print count($obj3) . "\n";
} catch (\TypeError $e) {
print "Error: " . $e->getMessage() . "\n";
}
// 属性的个数通过 [get_object_vars] 获得
print "number of attributes: " . count(get_object_vars($obj3)) . "\n";
// 可以用 [foreach] 遍历对象
foreach ($obj3 as $attribute => $value) {
print "obj3[$attribute]=$value\n";
}
// 关联数组可以转换为 [stdClass] 对象,反之亦然
$obj4 = (object) ["name" => "Langevin", "age" => 48];
print "obj4=[$obj4->name,$obj4->age]\n";
print_r((array) $obj4);
// 结束
exit;
|
结果:
| > php classes-01.php
Error: Attempt to assign property "attr1" on null
object1=[one,100]
object1=[one,200]
object1=[one,0]
object2=[one,0]
obj1:
stdClass Object
(
)
obj2:
stdClass Object
(
[attr1] => one
[attr2] => 0
)
obj2:
stdClass Object
(
[attr1] => one
[attr2] => 0
)
obj3:
stdClass Object
(
[attr1] => one
[attr2] => 0
)
object2=[one,10]
object3=[one,10]
obj2:
stdClass Object
(
[attr3] => two
[attr4] => 20
)
obj3:
stdClass Object
(
[attr3] => two
[attr4] => 20
)
Error: count(): Argument #1 ($value) must be of type Countable|array, stdClass given
number of attributes: 2
obj3[attr3]=two
obj3[attr4]=20
obj4=[Langevin,48]
Array
(
[name] => Langevin
[age] => 48
)
|
说明
- 第 7–9 行:在 PHP 8 中,变量 [$obj0] 不存在,操作 [$obj0->attr1 = "one"] 会抛出 [\Error] 类型的错误(结果的第 2 行),而不是创建一个对象。我们将在异常一章中讲解 [try / catch] 结构。现在只需注意,它允许你捕获错误并继续执行脚本;
- 第 13 行:必须使用 [new] 运算符显式地创建通用对象。预定义类 [stdClass] 是一个空类;
- 第 15–16 行:记法 [$obj->attr] 指属性 [attr] ,其所属的对象是 [$obj]。如果它不存在,就会被创建;这称为动态属性。类 [stdClass] 就是为此而设计的:你可以随意向其中添加任意多个属性;
- 第 25 行:当 [$obj2 = $obj1] 中的 [$obj1] 是对象时,该表达式是引用的复制:[$obj2] 和 [$obj1] 是指向同一个对象的引用(地址)。这个对象本身可以通过任一引用修改;
- 第 27–30 行:旨在表明 [$obj1] 和 [$obj2] 是指向同一个对象的两个不同变量。[$obj2 = $obj1] 把 [$obj1] 的值复制到变量 [$obj2] 中(下面的操作 1)。[$obj1] 的值是一个对象的地址。因此,[$obj1] 和 [$obj2] 指向同一个对象。操作指向某个对象的变量 [$obj] 时,PHP 操作的是它所指向的那个对象。如下图所示,我们既可以通过 [$obj1] 也可以通过 [$obj2] 修改被引用的对象。结果的第 5 行和第 6 行说明了这一点;

- 第 39 行:表达式 [$obj3 = &$obj2] 使 [$obj2] 和 [$obj3] 位于同一地址,如下面的 [1 below] 所示。可以说这两个变量是同一内存位置的别名。它们都指向一个对象,即下面的对象 A:[2];
- 第 50 行:操作 [$obj2 = new \stdClass()] 创建一个新对象,即对象 B [3 below],并把这个新对象的地址赋给变量 [$obj2] [4]。由于 [$obj2] 和 [$obj3] 是同一内存位置的两个别名,[$obj3] 也指向新的对象 B。结果的第 31–42 行显示了这一点;

- 第 61 行:对象是字典吗?在 PHP 7 中,函数 [count] 接受一个对象(并给出警告),返回 1,这毫无意义。在 PHP 8 中,它会抛出错误 [TypeError]:[count] 只接受数组或实现了 [Countable] 接口的对象(结果的第 43 行);
- 第 66 行:函数 [get_object_vars] 以关联数组的形式返回对象的属性。数组中的元素个数等于对象的属性个数;
- 第 68–69 行:对象可以像字典一样用 [foreach] 进行遍历。键是属性的名称,值是这些属性的值。因此,对象与字典有相似之处,但并不是字典。在 PHP 7 中,这种遍历是使用 [each] 函数完成的,该函数后来已被移除;
- 第 72–74 行:转换运算符 [(object)] 把关联数组转换为 [stdClass] 对象,而运算符 [(array)] 执行相反的操作。
5.3. 没有声明属性的 Person 类
在 PHP 7 中,类可以使用它没有声明的属性:只需写 [$p->firstName = "Paul";] 就能创建属性 [firstName] ,该属性位于对象 [$p] 中,就像对 [stdClass] 所做的那样。普通类的对象上的这些动态属性自 PHP 8.2 起已被弃用:每次创建这样的属性时,都会显示消息“Deprecated: Creation of dynamic property Person::$firstName is deprecated”。它们将在 PHP 的未来版本中被移除。原因很简单:属性名中的拼写错误([$p->firstNam = "Paul"])会悄悄地创建一个新属性,而不是报告错误。
这条规则有三个例外:
- 我们刚才用过的 [stdClass] 类仍然接受动态属性;
- 前面带有属性(注解)[#[\AllowDynamicProperties]] 的类也接受它们。这个属性(注解)是为了方便迁移遗留代码而设计的。我们在本课程中不会使用它;
- 定义了魔术方法 [__get] 和 [__set] 的类,会自行决定如何处理未声明的属性。
脚本 [classes-02.php] 展示的正是这第三种办法:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
class Person
{
// 属性不是逐个声明的:
// 它们存放在一个私有数组中
private array $attributes = [];
// 在写入未声明的属性时调用:$p->x = value
public function __set(string $name, mixed $value): void
{
$this->attributes[$name] = $value;
}
// 在读取未声明的属性时调用:$p->x
public function __get(string $name): mixed
{
return $this->attributes[$name] ?? null;
}
// 由 isset($p->x) 调用
public function __isset(string $name): bool
{
return isset($this->attributes[$name]);
}
// 方法
public function identity(): string
{
// 使用未声明的属性
return "[$this->firstName,$this->lastName,$this->age]";
}
}
// 测试
// 属性由魔术方法 [__set] 创建
$p = new Person();
$p->firstName = "Paul";
$p->lastName = "Langevin";
$p->age = 48;
// 调用方法
print "person=" . $p->identity() . "\n";
// isset
print "isset(\$p->age): " . var_export(isset($p->age), true) . "\n";
print "isset(\$p->address): " . var_export(isset($p->address), true) . "\n";
// 结束
exit;
|
结果:
| > php classes-02.php
person=[Paul,Langevin,48]
isset($p->age): true
isset($p->address): false
|
说明
- 第 6–38 行:定义一个名为 [Person] 的类。类是用于创建对象的模板。它由属性和称为方法的函数组成;
- 第 10 行:该类声明的唯一属性是一个私有数组(我们很快就会看到关键字 [private] 的含义)。这个数组用来存放“未声明”的属性;
- 第 13–16 行:魔术方法 [__set] 在写入不存在(或不可访问)的属性时由 PHP 自动调用。它接收属性的名称和要赋给它的值。这里,它把该值存入数组 [$attributes] 中。名称以两个下划线开头的方法称为魔术方法:它们不会被显式调用,而是由 PHP 来调用;
- 第 19–22 行:魔术方法 [__get] 在读取不存在的属性时被调用。它返回所存储的值或 [null]。运算符 [??] 在左操作数存在且不为 [null] 时返回左操作数;否则返回右操作数;
- 第 25 行:魔术方法 [__isset] 由函数 [isset] 调用;
- 第 31 行:方法 [identity] 使用了三个在类中没有声明的属性。关键字 [$this] 指向该方法所作用的对象。每次调用 [$this->firstName] 都会触发对 [__get] 的调用;
- 第 40 行:创建一个 [$p] 对象,其类型为 [Person] 。关键字 [new] 用于创建新对象。该操作返回对所创建对象的引用(即一个地址)。可以有多种写法:[new Person()], [new Person], [new person]。类名不区分大小写;
- 第 41–43 行:[identity] 方法所需的三个属性,在 [$p] 对象中创建,创建者是 [__set] 方法;
- 第 45 行:把 [identity] 方法(属于 [Person] 类)应用于对象 [$p]。在 [identity] 方法的代码中,[$this] 引用的对象与 [$p] 相同。
这种技术有其用途(配置对象、封装从文件读取的数据),但它不是编写类的标准方式。在常规的类中,你要声明它的属性。
5.4. 声明了属性的 Person 类
脚本 [classes-03.php] 如下:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
class Person
{
// 类的属性,公共且带类型
public string $firstName;
public string $lastName;
public int $age;
// 方法
public function identity(): string
{
return "[$this->firstName,$this->lastName,$this->age]";
}
}
// 测试
// 属性是公共的
$p = new Person();
$p->firstName = "Paul";
$p->lastName = "Langevin";
$p->age = 48;
// 调用方法
print "person=" . $p->identity() . "\n";
// 带类型的属性只接受其类型的值
try {
$p->age = "forty-eight";
} catch (\TypeError $e) {
print "Error 1: " . $e->getMessage() . "\n";
}
// 未初始化的带类型属性不能被读取
$p2 = new Person();
try {
print "person=" . $p2->identity() . "\n";
} catch (\Error $e) {
print "Error 2: " . $e->getMessage() . "\n";
}
// 结束
exit;
|
结果:
| > php classes-03.php
person=[Paul,Langevin,48]
Error 1: Cannot assign string to property Person::$age of type int
Error 2: Typed property Person::$firstName must not be accessed before initialization
|
说明
- 第 9–11 行:类的属性被显式声明。关键字 [public] 表示它们可以从类的外部访问。在 PHP 7 课程中,使用的是关键字 [var],它继承自 PHP 4,是 [public] 的同义词,如今已不再使用;
- 每个属性前面都有其类型:名和姓用 [string] ,年龄用 [int] 。这些是类型化属性,随 PHP 7.4 引入。可用的类型与函数参数的类型相同:[int]、[float]、[string]、[bool]、[array]、类名或接口名、可空类型 [?string]、联合类型 [int|float]……;
- 第 30 行:类型化属性只接受其类型的值。任何其他值都会导致错误 [TypeError] (结果的第 3 行);
- 第 35–37 行:没有默认值的类型化属性在被赋值之前处于“未初始化”状态。读取它会导致错误(结果的第 4 行)。相反,无类型的属性的默认值为 [null]。这是在对象创建时就初始化其所有属性的原因之一:这正是构造函数的作用。
5.5. 带构造函数的 Person 类
前面的示例展示了像 PHP 4 中那样的非常规的类。不建议照着这些例子去做。现在我们给出一个 [Person] [classes-04.php] 类,它遵循标准的最佳实践,这些实践在所有面向对象语言(Java、C# 等)中都能见到:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
class Person
{
// 类的属性
private string $firstName;
private string $lastName;
private int $age;
// getter 和 setter
public function getFirstName(): string
{
return $this->firstName;
}
public function getLastName(): string
{
return $this->lastName;
}
public function getAge(): int
{
return $this->age;
}
public function setFirstName(string $firstName): void
{
$this->firstName = $firstName;
}
public function setLastName(string $lastName): void
{
$this->lastName = $lastName;
}
public function setAge(int $age): void
{
$this->age = $age;
}
// 构造函数
public function __construct(string $firstName, string $lastName, int $age)
{
// 我们通过 setter 来赋值
$this->setFirstName($firstName);
$this->setLastName($lastName);
$this->setAge($age);
}
// toString 方法
public function __toString(): string
{
return "[$this->firstName,$this->lastName,$this->age]";
}
}
// 测试
// 创建一个 Person 对象
$p = new Person("Paul", "Langevin", 48);
// 此人的身份信息
print "person=$p\n";
// 我们修改年龄
$p->setAge(14);
// 此人的身份信息
print "person=$p\n";
// 具有 [__toString] 方法的类实现了 [Stringable] 接口
print "Stringable: " . var_export($p instanceof \Stringable, true) . "\n";
// 私有属性不能从类的外部访问
try {
print $p->lastName;
} catch (\Error $e) {
print "Error: " . $e->getMessage() . "\n";
}
// 结束
exit;
|
结果:
| > php classes-04.php
person=[Paul,Langevin,48]
person=[Paul,Langevin,14]
Stringable: true
Error: Cannot access private property Person::$lastName
|
说明
- 第 4 行:我们指定必须严格遵守函数参数的声明类型。没有这个声明,PHP 会尝试转换类型错误的值(例如把字符串 ["48"] 转换为整数 [48]);
- 第 6–60 行:类 [Person];
- 第 9–11 行:类的私有属性([private])。这些属性只在类的内部可见。可以使用的其他关键字有:
- [public]:使属性成为从类外部可见的公有属性;
- [protected]:使属性成为从类内部及其派生类中可见的受保护属性;
- 由于属性是私有的,因此不能从类的外部访问它们。所以,我们不能写 [$p->lastName = "Landru"]:我们处在类 [Person] 之外,而属性 [lastName] 是私有的。第 72–74 行验证了这一点:试图读取 [$p->lastName] 会导致错误(结果的第 5 行)。要初始化对象 [$p] 的私有属性,有两种办法:
- 使用第 14–39 行中的公有方法 [set] 和 [get] (这些方法的名称可以任取)。这时,我们写:[$p->setLastName("Landru")];
- 使用第 45–50 行中的构造函数。这时你会写:[$p = new Person("Michel", "Landru", 44)]。这种语法会自动调用 [Person] 类中名为 [__construct] 的方法;
- 第 64 行:这一行把人员 [$p] 以字符串的形式显示。为此,要使用 [Person] 类中名为 [__toString] 的方法(第 54 行);
- 第 70 行:从 PHP 8.0 起,任何定义了名为 [__toString] 的方法的类都会自动实现预定义接口 [Stringable] (我们将在下一章介绍接口)。运算符 [instanceof] 用于检查对象是否属于给定的类型。因此,函数可以声明类型为 [string|Stringable] 的参数:这样它就接受字符串或任何可以转换为字符串的对象;
- 类的所有方法前面都加了关键字 [public],表示该方法在类的外部可见。可以使用的其他关键字与属性的相同,含义也相同,即 [private] 和 [protected]。没有显式的可见性关键字时,方法隐式为 [public]。本课程的脚本所遵循的 PSR-12 风格指南要求始终显式指定可见性。
5.6. 构造函数参数提升
前面的类很冗长:每个属性被写了四遍(声明、构造函数参数、构造函数中的赋值、getter)。自 PHP 8.0 起,构造函数参数提升允许你直接在构造函数的参数列表中声明并初始化属性。脚本 [classes-22.php] 演示了这一点:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
class Person
{
// 带参数提升的构造函数:
// 每个带可见性修饰的参数都会成为类的属性
public function __construct(
private string $firstName,
private string $lastName,
private int $age = 0,
) {
// 无需再做别的事:属性已经初始化
}
// getter
public function getFirstName(): string
{
return $this->firstName;
}
public function getLastName(): string
{
return $this->lastName;
}
public function getAge(): int
{
return $this->age;
}
// setter
public function setAge(int $age): void
{
$this->age = $age;
}
// toString 方法
public function __toString(): string
{
return "[$this->firstName,$this->lastName,$this->age]";
}
}
// 测试
// 经典调用:参数按形参的顺序传递
$p1 = new Person("Paul", "Langevin", 48);
print "p1=$p1\n";
// 命名参数:顺序不再重要
$p2 = new Person(lastName: "Lefur", age: 70, firstName: "Sylvie");
print "p2=$p2\n";
// [age] 参数有默认值:可以省略
$p3 = new Person(firstName: "Steve", lastName: "Boer");
print "p3=$p3\n";
// 被提升的属性是真正的属性
var_dump($p3);
// 结束
exit;
|
结果:
| > php classes-22.php
p1=[Paul,Langevin,48]
p2=[Sylvie,Lefur,70]
p3=[Steve,Boer,0]
object(Person)#3 (3) {
["firstName":"Person":private]=>
string(5) "Steve"
["lastName":"Person":private]=>
string(4) "Boer"
["age":"Person":private]=>
int(0)
}
|
说明
- 第 10–14 行:前面带有可见性关键字([private]、[protected]、[public])的每个构造函数参数都被“提升”:PHP 会声明一个同名同类型的属性,并把参数的值赋给它。这三行取代了前一个类中的属性声明和赋值;
- 第 13 行:被提升的参数可以有默认值。自 PHP 8.0 起,允许在最后一个参数后面加逗号;这使得以后添加参数更加容易;
- 第 15 行:构造函数的主体可以包含代码(例如验证)。这里无事可做;
- 第 52 行:命名参数(PHP 8.0)允许通过参数名称引用实参,从而以任意顺序传递实参。这使得代码更易读,特别是当函数有很多参数时;
- 第 55 行:参数 [age] 被省略;它取默认值;
- 第 58 行:函数 [var_dump] 表明被提升的属性是该类真正的私有属性(结果的第 5–12 行)。
5.7. 在构造函数中进行有效性检查的 Person 类
类的构造函数是验证对象的初始化值是否正确的合适位置。不过,对象也可以通过其 [set] 方法或等价方法来初始化。为了避免在两个不同的地方重复同样的检查,可以把这些检查放在 [set] 方法中。如果对象的初始化值被证明不正确,就会抛出异常。下面是一个示例。
首先,把 [Person] 类的定义移到它自己的文件 [Person.php] 中:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 命名空间
namespace Examples;
// Person 类
class Person
{
// 类的属性
private string $firstName;
private string $lastName;
private int $age;
// getter 和 setter
public function getFirstName(): string
{
return $this->firstName;
}
public function getLastName(): string
{
return $this->lastName;
}
public function getAge(): int
{
return $this->age;
}
public function setFirstName(string $firstName): void
{
// 名字不能为空
$firstName = trim($firstName);
if ($firstName === "") {
throw new \Exception("The first name must not be empty");
}
$this->firstName = $firstName;
}
public function setLastName(string $lastName): void
{
// 姓氏不能为空
$lastName = trim($lastName);
if ($lastName === "") {
throw new \Exception("The last name must not be empty");
}
$this->lastName = $lastName;
}
public function setAge(int $age): void
{
// 年龄必须有效
if ($age < 0) {
throw new \Exception("The age must be a positive or zero integer");
}
$this->age = $age;
}
// 构造函数
public function __construct(string $firstName, string $lastName, int $age)
{
// 我们通过 setter 来赋值
$this->setFirstName($firstName);
$this->setLastName($lastName);
$this->setAge($age);
}
// 充当第二个构造函数的方法
public function initWithPerson(Person $p): void
{
// 用一个人 $p 初始化当前对象
$this->__construct($p->firstName, $p->lastName, $p->age);
}
// 静态工厂方法(命名构造函数)
public static function fromPerson(Person $p): self
{
// 创建一个新的人,是人 $p 的副本
return new self($p->firstName, $p->lastName, $p->age);
}
// toString 方法
public function __toString(): string
{
return "[$this->firstName,$this->lastName,$this->age]";
}
}
|
说明
- 第 4 行:指定必须按声明遵守函数参数的类型;
- 第 7 行:定义一个命名空间。因此类 [Person] 的完整(限定)名称是 [\Examples\Person]。请注意限定名称开头的字符 [\] :它使名称成为绝对限定名称。如果没有这个字符,该名称就是相对限定名称(相对于当前命名空间)。因此,如果类 A 和类 B 属于同一个命名空间 E,那么在类 A 的代码中,可以用相对写法 B 访问类 B。如果类 A 属于命名空间 E1,而类 B 属于命名空间 E2,那么在类 A 的代码中,可以用绝对写法 [\E2\B] 访问类 B。在命名空间中定义类不是强制的,但被视为最佳实践:这样两个库就可以各自定义一个名为 [Person] 的类而不会冲突;
- 命名空间通常与文件目录结构相对应。因此,命名空间 E1 中的类 A 通常位于名为 [E1/A.php] 的文件中。这是 [Composer] 工具用来自动加载类的 PSR-4 约定,我们将在后面的章节中使用它。[PHP Intelephense] 扩展(用于 [VS Code])并不要求这样做。不要把文件树与命名空间混淆:类的完全限定名使用的是命名空间,与包含该类的 PHP 文件的文件树毫无关系。这里,类 [\Examples\Person] 位于文件 [scripts-console/classes/Person.php] 中;
- 第 13–15 行:类的三个私有属性;
- 第 33–41 行:初始化 [firstName] 属性并验证初始化值;
- 第 36 行:函数 [trim($string)] 删除 [$string] 开头和结尾的空格。因此,[trim(" abcd ")] 是字符串 ["abcd"],而 [trim(" ")] 是空字符串。;
- 第 37 行:如果名字为空,就抛出异常(第 38 行);否则,保存该名字(第 40 行)。要抛出异常,这里使用预定义类 [Exception]。在这里,我们必须使用它的绝对名称 [\Exception]。如果我们使用它的相对名称 [Exception],那么就会在当前命名空间中查找这个类,即在命名空间 [Examples] 中查找,该命名空间属于类 [Person]。这样,PHP 解释器就会去查找绝对名称为 [\Examples\Exception] 的类,而这个类并不存在;
- 第 63–69 行:构造函数使用 [set] 方法来初始化属性:验证只需写一次;
- 第 72 行和第 79 行的方法将在下一段中介绍。
类 [Person] 被下面的脚本 [classes-05.php] 使用:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 引入 Person 类的定义
require_once __DIR__ . "/Person.php";
// 用于演示
print __DIR__ . "/Person.php\n";
// Person 类的限定名
use Examples\Person;
// 测试
// 创建一个 Person 对象
$p = new Person("Paul", "Langevin", 48);
// 此人的身份信息
print "Example1, person=$p\n";
// 创建一个无效的 Person 对象
try {
$p = new Person("xx", "yy", "zz");
} catch (\Exception $e1) {
print "Example2, error: " . $e1->getMessage() . "\n";
} catch (\TypeError $e2) {
print "Example2, error: " . $e2->getMessage() . "\n";
}
// 创建一个无效的 Person 对象
try {
$p = new Person("", "yy", 10);
} catch (\Exception $e1) {
print "Example3, error: " . $e1->getMessage() . "\n";
} catch (\TypeError $e2) {
print "Example3, error: " . $e2->getMessage() . "\n";
}
// 结束
exit;
|
结果:
| > php classes-05.php
.../php8-oct-2026/scripts-console/classes/Person.php
Example1, person=[Paul,Langevin,48]
Example2, error: Examples\Person::__construct(): Argument #3 ($age) must be of type int, string given, called in .../php8-oct-2026/scripts-console/classes/classes-05.php on line 21
Example3, error: The first name must not be empty
|
说明
- 第 7 行:脚本将使用 [Person] 类。因此你必须告诉 PHP 解释器到哪里去找这个类的定义。这就是 [include file] 和 [require file] 语句的作用。这两个语句的区别如下:如果 [include file] 语句在加载 [file] 时遇到错误,会发出一个 [E_WARNING] 级别的错误,但执行会继续;而 [require],在同样的情况下会产生致命错误,并使脚本停止运行。这两条指令各有一个变体:[include_once] 和 [require_once]。这两个变体用于处理同一个文件被多次包含的情况。例如,考虑一个由多个 PHP 脚本组成的项目,其中一些脚本引用了 [Person] 类。执行这些脚本就会导致文件 [Person.php] 被多次包含,从而产生错误,因为一个类不能被定义两次。解决办法是使用 [_once] 变体,它们确保该文件在项目的全局脚本中只被包含一次;
- 常量 [__DIR__] 是 PHP 的一个常量,它指向包含 [__DIR__] 常量的脚本所在文件夹的完整名称。第 9 行显示了它(结果的第 2 行)。在读者的机器上,结果将类似于 [C:\laragon\www\php8-oct-2026\scripts-console\classes/Person.php]。在 Windows 上,文件路径中可以互换地使用 [/] 或 [\] 。使用 [__DIR__] 使脚本与执行时的当前文件夹无关;
- 第 12 行:脚本 [classes-05.php] 没有命名空间。当代码使用相对名称 [Person] 时,会在根命名空间 [\] 中查找它,因此找不到。这个问题有两种解决办法:
- 使用完整的类名 [\Examples\Person];
- 使用语句 [use],它指明在后面的代码中,名称 [Person] 指的是类 [\Examples\Person]。在 [use] 语句中,名称始终是绝对的:开头的 [\] 是不必要的(这是推荐的写法)。该语句等价于 [use Examples\Person as Person;],它指明别名 [Person] 指的是类 [\Examples\Person];
- 指令 [use] 告诉解释器,类 [Person] 实际上就是类 [\Examples\Person]。话虽如此,解释器到哪里去找这个类的代码呢?指令 [require_once] 会告诉它。这两条指令的作用截然不同:[use] 作用于名称,[require_once] 加载文件;
- 第 16 行:创建一个 [Person] 对象。这里将隐式执行 [__construct] 方法,它属于 [Person] 类;
- 第 18 行:显示人员 [$p]。要显示它,变量 [$p] 的值必须被转换为字符串。这时会隐式地执行方法 [Person::__toString] 。因此这个方法必须返回字符串;
- 我们已经看到,[Person] 类的构造函数可能抛出 [\Exception] 异常。因此必须处理这个异常。所以,创建人员时始终应当把它放在
***[try / catch] 结构中,如第 20–34 行所示。这里,我们故意传入一个不是整数的年龄来触发错误。在这个具体的例子中,错误是由 PHP 解释器抛出的,而不是由 [Person] 类中的代码抛出的。这是因为 [Person::__construct]* 方法的签名是 [__construct(string $firstName, string $lastName, int $age)]。因此,传给构造函数的 [age] 参数必须是整数类型。如果不是,PHP 解释器就会抛出 [TypeError] 类型的错误。此外,类 [set] 的方法 [Person]* 会抛出 [\Exception] 类型的异常。由于调用它们的构造函数没有 [try / catch] 结构,异常会向上传播一层,传到调用该构造函数的代码,即脚本 [classes-05.php] 中的代码。最终,脚本 [classes-05.php]* 可能收到两种类型的错误:[\Exception] 或 [\TypeError]。因此,[try] 结构有两个 [catch] 子句,分别处理这两种类型的错误。当开发者确定某些错误不可能发生时,就不会使用相应的 [catch]** 子句。这里系统地使用它们,纯粹是为了演示;
- 第 22 行:你可以写 [Exception] 或 [\Exception]。第一种写法使用的是相对于脚本命名空间的相对类名。由于脚本没有命名空间,它的命名空间就是命名空间的根:[\]。因此,在这里写 [Exception] 等价于写 [\Exception]。在没有自己命名空间的脚本中,最好使用 PHP 预定义类的绝对名称。这样,如果你决定给这个脚本指定一个命名空间,使用绝对类名仍然有效;而在另一种情况下,更改命名空间会导致相对类名出错;
- 第 23 行:当出现异常时,[Exception::getMessage] 方法获取该异常的错误消息。对于 [TypeError] 类型的错误也是如此。在 [Person::setFirstName] 方法中,写了 [throw new \Exception("The first name must not be empty")]。这就是示例 3 中由 [getMessage] 方法获取的消息(结果的第 5 行);
- 结果的第 4 行:[TypeError] 的错误消息。自 PHP 8.0 起,它通过编号和名称标识出有问题的参数:“Argument #3 ($age) must be of type int, string given.”PHP 8 的错误消息比 PHP 7 的更具体。
5.8. 添加一个充当第二个构造函数的方法
在 PHP 中,不可能拥有多个参数不同的构造函数,以便用不同的方式构造对象。因此,可以使用方法来充当构造函数。[Person] 类有两个这样的方法:
| public function initWithPerson(Person $p): void
{
// 用一个人 $p 初始化当前对象
$this->__construct($p->firstName, $p->lastName, $p->age);
}
// 静态工厂方法(命名构造函数)
public static function fromPerson(Person $p): self
{
// 创建一个新的人,是人 $p 的副本
return new self($p->firstName, $p->lastName, $p->age);
}
|
说明
- 第 72–76 行:方法 [initWithPerson] 允许把另一个 [Person] 对象的属性值赋给当前对象。这里,它调用了构造函数 [__construct],但这不是必须的。它也可以自行初始化类 [Person] 的属性。请注意,[Person] 类的方法可以访问所有 [Person] 对象的私有属性,而不仅仅是 [$this] 的私有属性;
- 第 79–83 行:方法 [fromPerson] 是做到这一点的另一种方式,如今更为常见。它是一个静态方法(关键字 [static]):它不作用于对象,而是作用于类。它使用记法 [Person::fromPerson($p)] 调用。它使用 [new self(...)] 创建一个新对象:关键字 [self] 指代代码所在的类,这里是 [Person]。返回类型 [self] 表示该方法返回这个类的对象。这样的方法称为命名构造函数或工厂方法。稍后我们会再回到静态方法。
新的类 [Person] 被下面的脚本 [classes-06.php] 使用:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 引入 Person 类的定义
require_once __DIR__ . "/Person.php";
// 声明 Person 类的限定名
use Examples\Person;
// 测试
// 创建一个 Person 对象
try {
$p = new Person("Paul", "Langevin", 48);
} catch (\Exception $e) {
print "error: " . $e->getMessage() . "\n";
exit;
}
// 此人的身份信息
print "person=$p\n";
// 创建第二个人
try {
$p2 = new Person("Laure", "Adeline", 67);
} catch (\Exception $e) {
print "error: " . $e->getMessage() . "\n";
exit;
}
// 用第二个人的值初始化第一个人
try {
$p->initWithPerson($p2);
} catch (\Exception $e) {
print "error: " . $e->getMessage() . "\n";
exit;
}
// 检查
print "person=$p\n";
// 用命名构造函数创建第三个人
$p3 = Person::fromPerson($p2);
print "person=$p3\n";
// $p3 和 $p2 是两个不同的对象,但值相同
print "same object: " . var_export($p3 === $p2, true) . "\n";
print "same values: " . var_export($p3 == $p2, true) . "\n";
// 结束
exit;
|
结果:
| > php classes-06.php
person=[Paul,Langevin,48]
person=[Laure,Adeline,67]
person=[Laure,Adeline,67]
same object: false
same values: true
|
说明
- 第 17 行、第 26 行、第 33 行:如果遇到的错误无法恢复,那么在异常之后必须停止控制台脚本的执行,这是常见的做法。在 Web 脚本中则不是这样:你不会停止脚本的执行,而是显示一个错误页面。如果你位于函数内部,就不会使用 [exit] 语句,而是使用 [return]:脚本的执行不会被中止([exit]),而是在设置好错误之后退出函数([return]);
- 第 39 行:调用命名构造函数;
- 第 42 行:应用于两个对象的 [===] 运算符,当它们是同一个对象(同一个地址)时结果为真。[$p3] 和 [$p2] 是两个不同的对象(结果的第 5 行);
- 第 43 行:应用于同一个类的两个对象的运算符 [==],当它们的属性值相同时结果为真(结果的第 6 行)。函数 [var_export] 返回其参数的 PHP 表示,这里是 [true] 或 [false]。
5.9. 使用属性钩子进行有效性检查(PHP 8.4)
前面的类 [Person] 通过把属性设为私有、并要求外部代码使用 [get] 和 [set] 方法来保护它的属性。PHP 8.4 提供了另一种解决办法:属性钩子。公有属性可以附带一个 [set] 钩子(每次写入该属性时执行的代码)和一个 [get] 钩子(每次读取该属性时执行的代码)。这样既保留了 [$p->age = 49] 这种写法的简洁,又保持了对值的控制。脚本 [classes-23.php] 演示了这一点:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
class Person
{
// 带 [set] 钩子的公共属性:每次写入都会进行验证
public string $firstName {
set(string $value) {
$value = trim($value);
if ($value === "") {
throw new \InvalidArgumentException("The first name must not be empty");
}
$this->firstName = $value;
}
}
public string $lastName {
set(string $value) {
$value = trim($value);
if ($value === "") {
throw new \InvalidArgumentException("The last name must not be empty");
}
$this->lastName = $value;
}
}
// 没有显式参数时,接收到的值称为 [$value]
public int $age {
set {
if ($value < 0) {
throw new \InvalidArgumentException("The age must be a positive or zero integer");
}
$this->age = $value;
}
}
// 虚拟属性:它只有 [get] 钩子,不占用对象的空间
public string $identity {
get => "[$this->firstName,$this->lastName,$this->age]";
}
// 构造函数:赋值会经过 [set] 钩子
public function __construct(string $firstName, string $lastName, int $age)
{
$this->firstName = $firstName;
$this->lastName = $lastName;
$this->age = $age;
}
}
// 测试
$p = new Person(" Paul ", "Langevin", 48);
print "person=$p->identity\n";
// 属性是公共的:可以直接读写
$p->age = 49;
print "age=$p->age\n";
// 但写入总是会经过 [set] 钩子
foreach (["firstName" => " ", "age" => -4] as $attribute => $value) {
try {
$p->$attribute = $value;
} catch (\InvalidArgumentException $e) {
print "Error: " . $e->getMessage() . "\n";
}
}
// 没有 [set] 钩子的虚拟属性不能被写入
try {
$p->identity = "?";
} catch (\Error $e) {
print "Error: " . $e->getMessage() . "\n";
}
// 对象依然有效
print "person=$p->identity\n";
var_dump($p);
|
结果:
| > php classes-23.php
person=[Paul,Langevin,48]
age=49
Error: The first name must not be empty
Error: The age must be a positive or zero integer
Error: Property Person::$identity is read-only
person=[Paul,Langevin,49]
object(Person)#1 (3) {
["firstName"]=>
string(4) "Paul"
["lastName"]=>
string(8) "Langevin"
["age"]=>
int(49)
}
|
说明
- 第 9–17 行:公有属性 [firstName] 后面跟着一个用花括号括起来的块,其中包含它的钩子。这里只有一个钩子,即 [set];
- 第 10 行:钩子 [set] 接收要赋给该属性的值。它使用 [trim] 对其进行清理,进行检查,如果值不正确就抛出异常;
- 第 15 行:在它的钩子内部,[$this->firstName] 指定该属性的内存位置:值就存放在那里。在其他任何地方,[$this->firstName] 都要经过钩子;
- 第 13 行:抛出类型为 [\InvalidArgumentException] 的异常;这是一个预定义类,派生自 [\Exception] ,比它更具体,表示参数无效。我们将在异常一章中介绍 PHP 的预定义异常;
- 第 31 行:当钩子 [set] 没有声明参数时,接收到的值可以通过隐式变量 [$value], 获得,其类型就是该属性的类型;
- 第 40–42 行:只有一个钩子 [get],并且从不引用自己的内存位置的属性是一个 虚拟属性:它在每次读取时计算,不占用对象中的任何空间。记法 [get => expression] 是钩子 [get] 的简写形式,其值为该表达式的值;
- 第 45–50 行:构造函数为属性赋值;这些赋值是通过钩子 [set] 执行的。因此,验证在构造时执行,在之后的任何修改时也会执行,而无需使用 [set] 方法;
- 第 54 行:名字 [" Paul "] 由钩子 [set] 清理;
- 第 57 行:属性 [age] 被直接修改,但是经由其钩子 [set] 进行;
- 第 60–66 行:尝试赋入无效的值。记法 [$p->$attribute] 把变量 [$attribute] 的内容用作属性名。[set] 钩子抛出它们的异常(结果的第 4–5 行);
- 第 69 行:虚拟属性 [identity] 没有 [set] 钩子:它是只读的(结果的第 6 行);
- 第 75 行:对象保留了有效的值。[var_dump] 只显示三个属性:虚拟属性 [identity] 并不存在于内存中。
属性钩子在其他语言(C#、Kotlin、Swift)中早已存在。它们免除了“以防万一”而编写 getter 和 setter 的必要:你从一个简单的公有属性开始,当需要验证时再添加钩子,而无需修改使用该类的代码。
5.10. 非对称可见性(PHP 8.4)
常见的情况是,某个属性需要让所有人都能读取,但只有类自己才能修改。过去,我们会写一个私有属性和一个公有的 getter。PHP 8.4 允许你为读取和写入一个属性分别设置不同的可见性级别:这称为非对称可见性。脚本 [classes-24.php] 用一个银行账户演示了这一点:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
class BankAccount
{
// 非对称可见性:公共读取,私有写入
public private(set) float $balance = 0.0;
// 参数提升也接受非对称可见性
public function __construct(public private(set) string $holder)
{
}
// 只有类的方法才能修改余额
public function deposit(float $amount): void
{
if ($amount <= 0) {
throw new \InvalidArgumentException("The amount must be positive");
}
$this->balance += $amount;
}
public function withdraw(float $amount): void
{
if ($amount <= 0 || $amount > $this->balance) {
throw new \InvalidArgumentException("Withdrawal of $amount impossible");
}
$this->balance -= $amount;
}
}
// 测试
$account = new BankAccount("Paul Langevin");
$account->deposit(100);
$account->withdraw(30);
// 直接读取属性,无需 getter
print "{$account->holder}: {$account->balance} euros\n";
// 禁止从类的外部写入
try {
$account->balance = 1_000_000;
} catch (\Error $e) {
print "Error: " . $e->getMessage() . "\n";
}
// 类始终控制着余额的有效性
try {
$account->withdraw(500);
} catch (\InvalidArgumentException $e) {
print "Error: " . $e->getMessage() . "\n";
}
print "{$account->holder}: {$account->balance} euros\n";
|
结果:
| > php classes-24.php
Paul Langevin: 70 euros
Error: Cannot modify private(set) property BankAccount::$balance from global scope
Error: Withdrawal of 500 impossible
Paul Langevin: 70 euros
|
说明
- 第 9 行:属性 [balance] 读取时是公有的([public]),写入时是私有的([private(set)])。外部代码可以读取 [$account->balance],但只有类的方法才能修改它。你也可以写成 [protected(set)]:这时,派生类可以修改该属性;
- 第 12 行:被提升的参数也可以使用非对称可见性;
- 第 17–25 行:方法 [deposit] 和 [withdraw] 是修改余额的唯一途径。它们会验证操作的有效性;
- 第 39 行:直接读取属性,不用 getter。在用引号括起来的字符串中,记法 [{$expression}] 允许插入比简单变量更复杂的表达式;
- 第 42 行:在类的外部写入余额会导致错误(结果的第 3 行)。字符 [_] 可以在数字字面量中用作千位分隔符(PHP 7.4);
- 第 48 行:取款被 [withdraw] 方法拒绝(结果的第 4 行)。余额没有变化(第 5 行)。
5.11. 只读属性与只读类([readonly])
状态在创建之后不能改变的对象称为不可变对象。不可变对象大大简化了编程:它们可以在代码的多个部分之间共享,而不必担心其中任何一部分会修改它们。PHP 8.1 引入了只读属性(关键字 [readonly]):这样的属性只能在类的内部初始化一次。PHP 8.2 引入了只读类:它们的所有属性随即都是 [readonly]。脚本 [classes-25.php] 给出了一个不可变的类 [Person]:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 只读类:它的所有属性都是 [readonly]
final readonly class Person
{
public function __construct(
public string $firstName,
public string $lastName,
public int $age,
) {
if ($age < 0) {
throw new \InvalidArgumentException("The age must be a positive or zero integer");
}
}
// “修改”不可变对象 = 创建一个修改后的副本
public function withAge(int $age): static
{
// 克隆并修改属性(PHP 8.5)
return clone($this, ["age" => $age]);
}
public function __toString(): string
{
return "[$this->firstName,$this->lastName,$this->age]";
}
}
// 测试
$p1 = new Person("Paul", "Langevin", 48);
print "p1=$p1\n";
// [readonly] 属性只能初始化一次
try {
$p1->age = 49;
} catch (\Error $e) {
print "Error 1: " . $e->getMessage() . "\n";
}
// 也不能向 [readonly] 类添加属性
try {
$p1->address = "Paris";
} catch (\Error $e) {
print "Error 2: " . $e->getMessage() . "\n";
}
// 一个新的人,是第一个人的副本,只是年龄不同
$p2 = $p1->withAge(49);
print "p1=$p1\n";
print "p2=$p2\n";
|
结果:
| > php classes-25.php
p1=[Paul,Langevin,48]
Error 1: Cannot modify readonly property Person::$age
Error 2: Cannot create dynamic property Person::$address
p1=[Paul,Langevin,48]
p2=[Paul,Langevin,49]
|
说明
- 第 7 行:该类被声明为 [readonly]:它的三个被提升的属性是只读的。关键字 [final](我们稍后会讲到)禁止该类被继承;
- 第 10–12 行:属性是公有的:可以直接读取,不需要 getter。它们不能被修改:getter 没有任何用处;
- 第 14 行:构造函数检查年龄的有效性。不可变对象在构造时就必须是有效的,因为它永远不会改变;
- 第 20–24 行:“修改”一个不可变对象,就是创建该对象的一个修改后的副本。这正是 [withAge] 方法所做的。它的返回类型 [static] (PHP 8.0)表示“调用该方法的那个类的对象”。它与 [self] 的区别只有在派生类中才会显现:如果派生类继承了该方法,类型 [static] 就指向派生类;
- 第 23 行:运算符 [clone] 创建对象 [$this] 的副本。从 PHP 8.5 起,[clone] 可以作为函数使用,并接受一个数组作为第二个参数,该数组包含要在副本中修改的属性(clone with)。在 PHP 8.5 之前,你必须使用“魔术”方法 [__clone] 或使用 [new] 重新构建对象;
- 第 37 行:修改 [readonly] 属性会导致错误(结果的第 3 行);
- 第 43 行:[readonly] 类同样不接受动态属性:这是一个错误,而不是简单的弃用警告(结果的第 4 行);
- 第 48 行:[$p2] 是一个新的人员;[$p1] 没有改变(结果的第 5–6 行)。
在后面的章节中,我们经常会使用 [readonly] 类来表示数据(政府的税务数据、税额计算的结果等)。
5.12. [Person] 对象的数组
下面的示例 [classes-07.php], 表明对象数组是可行的:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
require_once __DIR__ . "/Person.php";
use Examples\Person;
// 测试
// 创建一个 Person 对象数组
// 为了使代码更易理解,不处理可能出现的异常
$group = [new Person("Paul", "Langevin", 48), new Person("Sylvie", "Lefur", 70)];
// 这些人的身份信息
for ($i = 0; $i < count($group); $i++) {
print "group[$i]=$group[$i]\n";
}
// 结束
exit;
|
结果:
| > php classes-07.php
group[0]=[Paul,Langevin,48]
group[1]=[Sylvie,Lefur,70]
|
说明
- 第 12 行:创建一个包含 2 个人员的数组;
- 第 15 行:遍历该数组;
- 第 16 行:[$group[$i]] 是 [Person] 类型的对象。使用 [Person::__toString] 方法来显示它。
5.13. 创建派生自 Person 类的类
创建如下的类 [Teacher],放在名为 [Teacher.php] 的文件中:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 命名空间
namespace Examples;
// 派生自 Person 的类
class Teacher extends Person
{
// 属性:所教授的科目
private string $subject;
// getter 和 setter
public function getSubject(): string
{
return $this->subject;
}
public function setSubject(string $subject): void
{
$this->subject = $subject;
}
// 构造函数
public function __construct(string $firstName, string $lastName, int $age, string $subject)
{
// 父类的属性
parent::__construct($firstName, $lastName, $age);
// 其他属性
$this->setSubject($subject);
}
// 重新定义父类的 __toString 方法
#[\Override]
public function __toString(): string
{
return "[" . parent::__toString() . ",$this->subject]";
}
}
|
说明
- 第 7 行:类 [Teacher] 同样属于 [Examples] 命名空间;
- 第 10 行:类 [Teacher] 派生([extends])自类 [Person]。派生类 [Teacher] 继承其父类的属性和方法;
- 第 13 行:类 [Teacher] 添加了一个它独有的新属性 [subject],;
- 第 27 行:[Teacher] 类的构造函数接受 4 个参数:
- 3 个用于初始化其父类(名、姓、年龄),第 30 行;
- 1 个用于它自己的初始化(学科),第 32 行;
- 第 30 行:派生类可以通过关键字 [parent::] 访问其父类的方法和构造函数。这里,参数(名、姓、年龄)被传给父类的构造函数;
- 第 36 行:[#[\Override]] 是一个 PHP 属性(注解)(PHP 8.3)。属性(注解)写成 [#[] and []],是与类、方法、参数等相关联的信息,PHP 或其他工具可以使用它。这个属性(注解)声明下面的方法重写了父类的某个方法。如果事实并非如此(例如方法名拼写错误,或者该方法已从父类中移除),PHP 就会报告致命错误。稍后我们会看到一个例子;
- 第 37–40 行:派生类的 [__toString] 方法使用了父类的 [__toString] 方法。
类 [Teacher] 被下面的脚本 [classes-08.php] 使用:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 引入这两个类的定义
require_once __DIR__ . "/Person.php";
require_once __DIR__ . "/Teacher.php";
// 声明所使用的两个类
use Examples\Person;
use Examples\Teacher;
// 测试
// 创建一个由 Person 对象和派生对象组成的数组
// 为简化示例,不处理异常
$group = [new Teacher("Paul", "Langevin", 48, "English"), new Person("Sylvie", "Lefur", 70)];
// 这些人的身份信息
for ($i = 0; $i < count($group); $i++) {
print "group[$i]=$group[$i]\n";
}
// 结束
exit;
|
结果:
| > php classes-08.php
group[0]=[[Paul,Langevin,48],English]
group[1]=[Sylvie,Lefur,70]
|
说明
- 第 7–8 行:我们需要告诉 PHP 解释器 [Teacher, Person] 这两个类位于何处。顺序很重要:父类 [Person] 必须在定义类 [Teacher] 之前定义;
- 第 10–11 行:声明这两个类的完整名称。这样我们在代码中就可以只用类名来引用它们,而不必带命名空间前缀;
- 第 16 行:我们创建一个数组,其中包含一个 [Teacher] 类型的对象和一个 [Person] 类型的对象;
- 第 19–21 行:显示数组的各个元素;
- 第 20 行:将调用 [__toString] 方法,它属于每个 [$group[$i]] 元素。[Person] 类有一个 [__toString] 方法。[Teacher] 类有两个:一个来自它的父类,一个是它自己的。人们可能会问究竟调用的是哪一个。执行表明,调用的是 [Teacher] 类的那个。情况总是如此:当在对象上调用方法时,会按以下顺序查找它:先在对象的类中,如果有父类就在其父类中,然后在父类的父类中,依此类推。一找到该方法,查找就停止。
5.14. 创建第二个派生自 Person 类的类
下面的示例创建一个名为 [Student] 的类,派生自类 [Person],放在文件 [Student.php] 中:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 命名空间
namespace Examples;
// 派生自 Person 的第二个类
class Student extends Person
{
// 属性:所学专业
private string $course;
// getter 和 setter
public function getCourse(): string
{
return $this->course;
}
public function setCourse(string $course): void
{
$this->course = $course;
}
// 构造函数
public function __construct(string $firstName, string $lastName, int $age, string $course)
{
// 父类的属性
parent::__construct($firstName, $lastName, $age);
// 其他属性
$this->setCourse($course);
}
// 重新定义父类的 __toString 方法
#[\Override]
public function __toString(): string
{
return "[" . parent::__toString() . ",$this->course]";
}
}
|
这个类被下面的脚本 [classes-09.php] 使用:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 引入并声明脚本所使用的类
require_once __DIR__ . "/Person.php";
require_once __DIR__ . "/Teacher.php";
require_once __DIR__ . "/Student.php";
use Examples\{Person, Teacher, Student};
// 测试
// 创建一个由 Person 对象和派生对象组成的数组
// 为了使示例更易理解,不处理异常
$group = [
new Teacher("Paul", "Langevin", 48, "English"),
new Person("Sylvie", "Lefur", 70),
new Student("Steve", "Boer", 23, "iup2 quality"),
];
// 这些人的身份信息
foreach ($group as $i => $person) {
print "group[$i]=$person (" . $person::class . ")\n";
}
// 结束
exit;
|
结果:
| > php classes-09.php
group[0]=[[Paul,Langevin,48],English] (Examples\Teacher)
group[1]=[Sylvie,Lefur,70] (Examples\Person)
group[2]=[[Steve,Boer,23],iup2 quality] (Examples\Student)
|
说明
- 第 10 行:一条 [use] 语句可以通过把它们括在花括号中,声明来自同一个命名空间的多个类;
- 第 22 行:使用 [foreach] 遍历数组,它同时返回索引 [$i] 和元素 [$person];
- 第 23 行:记法 [$object::class] (PHP 8.0)返回对象所属类的完整名称。它取代了 [get_class] 函数,该函数在不带参数使用时自 PHP 8.3 起已被弃用。
5.15. 派生类的构造函数与父类构造函数之间的关系
在某些面向对象语言中,派生类的构造函数会自动调用其父类的构造函数。下面的代码 [classes-16.php] 表明,在 PHP 中并非如此:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
class Class1
{
// 构造函数
public function __construct()
{
print "constructor of the Class1 class\n";
}
}
class Class2 extends Class1
{
// 构造函数
public function __construct()
{
// 父类的构造函数不会被隐式调用
print "constructor of the Class2 class\n";
}
}
class Class3 extends Class1
{
// 构造函数
public function __construct()
{
// 显式调用父类的构造函数
parent::__construct();
// Class3 特有的代码
print "constructor of the Class3 class\n";
}
}
class Class4 extends Class1
{
// 没有构造函数:使用父类的构造函数
}
// 测试
print "test1---------\n";
new Class2();
print "test2---------\n";
new Class3();
print "test3---------\n";
new Class4();
|
结果:
| > php classes-16.php
test1---------
constructor of the Class2 class
test2---------
constructor of the Class1 class
constructor of the Class3 class
test3---------
constructor of the Class1 class
|
说明
- 第 15–23 行:[Class2] 的构造函数没有调用其父类的构造函数;父类的构造函数没有被执行(结果的第 3 行);
- 第 31 行:[Class3] 的构造函数显式地调用了其父类的构造函数(结果的第 5–6 行);
- 第 37–40 行:类 [Class4] 没有构造函数。因此它继承了父类的构造函数,并执行该构造函数(结果的第 8 行)。
5.16. 重写父类的方法
我们已经看到,父类的方法可以在子类中被重写。例如,方法 [__toString] 属于类 [Person] ,它在子类 [Teacher] 和 [Student] 中被重写了。脚本 [classes-13.php] 再次说明了这个概念:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 主类
class Class1
{
public function f(): int
{
return 1;
}
public function g(): int
{
return 2;
}
}
// 派生类
class Class2 extends Class1
{
// 我们重新定义父类的函数 f
#[\Override]
public function f(): int
{
return parent::f() + 10;
}
}
// 代码
$c2 = new Class2();
print $c2->f() . "\n";
print $c2->g() . "\n";
$c1 = new Class1();
print $c1->f() . "\n";
|
结果:
| > php classes-13.php
11
2
1
|
说明
- 第 7–18 行:类 [Class1] 定义了两个方法 f 和 g;
- 第 21–29 行:类 [Class2] 继承类 [Class1] 并重新定义了它的方法 f。属性(注解)[#[\Override]] 记录了这次重新定义;
- 第 32 行:创建一个 [$c2] 对象,其类型为 [Class2];
- 第 33 行:调用 [$c2] 对象的 f 方法。由于这个方法存在于 [Class2] 类中,所以它被执行。它接着又使用记法 [parent::f()] 调用父类的 f 方法;
- 第 34 行:调用 [$c2] 对象的 g 方法。由于这个方法不存在于 [Class2] 类中,所以在父类中查找,在那里找到并执行;
- 第 35 行:创建一个 [$c1] 对象,其类型为 [Class1];
- 第 36 行:调用 [$c1] 对象的 f 方法。执行的是 [Class1] 类的 f 方法。
现在来看看 [#[\Override]] 属性(注解)的用途。在脚本 [classes-10.php] 中,开发者本想重新定义 f 方法,却用错了名字:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 主类
class Class1
{
public function f(): int
{
return 1;
}
}
// 派生类
class Class2 extends Class1
{
// 我们以为在重新定义父类的方法 f
// 但名称写错了:[Override] 属性(注解)会检测出来
#[\Override]
public function F2(): int
{
return parent::f() + 10;
}
}
// 代码
$c2 = new Class2();
print $c2->f() . "\n";
|
结果:
| > php classes-10.php
Fatal error: Class2::F2() has #[\Override] attribute, but no matching parent method exists in .../php8-oct-2026/scripts-console/classes/classes-10.php on line 21
Stack trace:
#0 {main}
|
如果没有 [#[\Override]] 属性(注解),[F2] 方法就只是 [Class2] 的一个新方法,脚本会显示 [1] 而不会标出任何异常:这个错误将不会被察觉。有了这个属性(注解),PHP 在加载该类时就会立即拒绝它(结果的第 3 行)。在本课程的其余部分,我们将始终在重新定义的方法上使用 [#[\Override]] 。
5.17. 把对象作为函数参数传递
我们来看下面的脚本 [classes-14.php]:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 主类
class Class1
{
public function f(): int
{
return 1;
}
public function g(): int
{
return 2;
}
}
// 派生类
class Class2 extends Class1
{
// 我们重新定义父类的函数 f
#[\Override]
public function f(): int
{
return parent::f() + 10;
}
}
// 该函数的参数类型是 Class1 或其派生类
function doSomething(Class1 $c1): void
{
print $c1->f() + $c1->g() . "\n";
}
// 代码
// 我们创建一个派生自 Class1 的 Class2 类型的对象
$c2 = new Class2();
// 我们用一个 Class2 类型的对象调用 doSomething
doSomething($c2);
// 其他类型的对象会被拒绝
try {
doSomething(new \stdClass());
} catch (\TypeError $e) {
print "Error: " . $e->getMessage() . "\n";
}
|
结果:
| > php classes-14.php
13
Error: doSomething(): Argument #1 ($c1) must be of type Class1, stdClass given, called in .../php8-oct-2026/scripts-console/classes/classes-14.php on line 44
|
说明
- 第 7–18 行:类 [Class1];
- 第 21–29 行:类 [Class2] 派生自 [Class1];
- 第 32 行:一个期望类型为 [Class1] 的参数的函数。当期望的类型是一个类时,实参可以是期望类型的对象,也可以是其派生类型的对象;
- 第 41 行:函数 [doSomething] 被传入类型为 [Class2] 的参数,尽管期望的类型是 [Class1]。这是被接受的,因为 [Class2] 派生自 [Class1] (结果的第 2 行);
- 第 44 行:类型为 [stdClass] 的对象不属于类型 [Class1]:该调用会导致 [TypeError] 类型的错误(结果的第 3 行)。
5.18. 抽象类
抽象类是不能被实例化的不完整的类。必须从它派生出子类才能使用。
抽象类有什么用?有时,我们有一些类,它们共享一个或多个方法,但在其他方法或属性上有所不同。在这种情况下,最好把它们共有的一切归入一个父类。目前我们还不需要抽象类。但假设子类只在一个方法 M 上有差异:该方法的签名在所有子类中都相同,但其实现各不相同。为了要求子类实现方法 M:
- 我们将在父类中声明方法 M 的签名。由于父类不知道如何实现它,我们在该方法前加上关键字 [abstract]:这意味着方法 M 的实现被推迟到子类中;
- 由于父类没有被完全实现,所以也要用同一个关键字 [abstract] 把它声明为抽象的。这意味着该类不能再被实例化。必须创建一个子类来定义方法 M 的实现,这样才能使用父类的主体。
下面是一个示例 [classes-15.php]:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 抽象主类
abstract class Class1
{
// 所有派生类都知道的方法
public function f(): int
{
return 1;
}
// 抽象方法 g - 将由派生类定义
abstract public function g(): int;
}
// 派生类
class Class2 extends Class1
{
// 必须定义父类的方法 g
#[\Override]
public function g(): int
{
return parent::f() + 10;
}
}
// 派生类
class Class3 extends Class1
{
// 必须定义父类的方法 g
#[\Override]
public function g(): int
{
return parent::f() + 20;
}
// 我们可以重新定义父类的方法 f
#[\Override]
public function f(): int
{
return 2;
}
}
// 代码
$c2 = new Class2();
print $c2->f() . "\n";
print $c2->g() . "\n";
$c3 = new Class3();
print $c3->f() . "\n";
print $c3->g() . "\n";
// 抽象类不能被实例化
try {
new Class1();
} catch (\Error $e) {
print "Error: " . $e->getMessage() . "\n";
}
|
结果:
| > php classes-15.php
1
11
2
21
Error: Cannot instantiate abstract class Class1
|
说明
- 第 7–17 行:类 [Class1] 是抽象的,因为它没有实现第 16 行的 g 方法。因此必须从另一个类派生出它的子类才能使用;
- 第 20–28 行:类 [Class2] 继承类 [Class1] 并定义了其父类的
g 方法。属性(注解)[#[\Override]] 同样适用于抽象方法的实现;
- 第 31–46 行:类 [Class3] 继承类 [Class1] 并定义了其父类的 g 方法;
- 第 40–44 行:类 [Class3] 还重新定义了其父类的 f 方法;
- 第 49–54 行:创建类型为 [Class2] 和 [Class3] 的两个对象,并调用它们的 f 和 g 方法;
- 第 57 行:抽象类不能被实例化;会发生错误(结果的第 6 行)。
5.19. final 类
final 类是不能被派生子类的类。请看下面的脚本 [classes-11.php]:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 命名空间
namespace Examples;
// 不能被派生的类
final class Class1
{
}
// 派生类 - 会导致错误
class Class2 extends Class1
{
}
// 代码
new Class2();
|
结果:
| > php classes-11.php
Fatal error: Class Examples\Class2 cannot extend final class Examples\Class1 in .../php8-oct-2026/scripts-console/classes/classes-11.php on line 15
Stack trace:
#0 {main}
|
说明
- 第 10 行:关键字 [final] 使类 [Class1] 成为不能被派生子类的 final 类;
- 第 15 行:类 [Class2] 继承了 final 类 [Class1],这是错误的;
- PHP 解释器一加载 [Class2] 类的定义就会报告这个错误:这是一个无法被 [try / catch] 拦截的致命错误。脚本不会被执行。
当一个类并非为被派生而设计时,把它声明为 [final] 是一种最佳实践;这可以防止其他开发者依赖该类的内部细节。
5.20. final 方法
final 方法是不能被子类重写的方法。下面是一个示例 [classes-12.php]:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 命名空间
namespace Examples;
// 主类
class Class1
{
// 此方法不能在派生类中重新定义
final public function f(): int
{
return 1;
}
}
// 派生类
class Class2 extends Class1
{
// 禁止的重新定义 - 会导致错误
public function f(): int
{
return 2;
}
}
// 代码
new Class2();
|
结果:
| > php classes-12.php
Fatal error: Cannot override final method Examples\Class1::f() in .../php8-oct-2026/scripts-console/classes/classes-12.php on line 23
Stack trace:
#0 {main}
|
说明
- 第 13 行:类
[Class1] 的方法 f 使用关键字 ***[final]*** 声明为 final;
- 第 20 行:类 [Class2] 继承类 [Class1];
- 第 23 行:父类
[Class1] 的方法 f 被重新定义了。这会导致致命错误,一旦类 [Class2] 被加载就会报告。
5.21. 静态方法和静态属性
静态方法是与定义它的类相关联的方法,而不是与类的实例对象相关联的方法。因此,如果类 C 声明了一个静态方法 M,要在类的外部使用它,就要写成:
- [C::M] 如果你在类的外部;
- [self::M] 如果你在类的内部。
下面是一个示例:[classes-17.php]:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
class Class1
{
// 静态方法
public static function say(string $message): void
{
print "$message\n";
}
// 使用类的另一个静态方法的静态方法
public static function sayTwice(string $message): void
{
self::say($message);
self::say($message);
}
}
// 测试
Class1::say("hello");
Class1::sayTwice("good morning");
// 一等可调用语法:[Class1::say(...)] 是一个函数
$speak = Class1::say(...);
$speak("hi");
// 可以传递给另一个函数
array_map($speak, ["one", "two"]);
|
结果:
| > php classes-17.php
hello
good morning
good morning
hi
one
two
|
说明
- 第 9 行:方法 [say] 使用关键字 [static] 声明为静态方法;
- 第 17 行:在类的内部,静态方法 [say] 使用记法 [self::say] 调用;
- 第 23 行:静态方法 [say] 使用记法 [Class1::say] 调用;
- 第 26 行:一等可调用语法(PHP 8.1):在调用的实参位置写上 [(...)] 并不会发起调用,而是以 [Closure] 对象的形式返回函数本身。变量 [$speak] 随后包含一个函数,可以像普通函数一样调用它(第 27 行)。同样的语法适用于函数([strlen(...)])和对象的方法([$p->identity(...)]);
- 第 29 行:这样的函数可以作为实参传给另一个函数。函数 [array_map] 把函数 [$speak] 应用于数组的每个元素(结果的第 6–7 行)。
现在来看下面的代码 [classes-18.php]:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
class Class1
{
// 静态属性
private static int $nbObjects = 0;
public function __construct()
{
print "Class1 constructor\n";
self::$nbObjects++;
}
// 静态方法
public static function say(): void
{
print self::$nbObjects . " objects of type [Class1] have been built\n";
}
}
// 测试
new Class1();
new Class1();
Class1::say();
|
结果:
| > php classes-18.php
Class1 constructor
Class1 constructor
2 objects of type [Class1] have been built
|
说明
- 第 9 行:声明一个静态属性,用来统计已创建的 [Class1] 类实例的数量。这不是可以属于类的某个实例的属性。事实上,如果创建了两个对象 O1 和 O2,它们彼此并不知道对方的存在。把计数器放在实例中没有意义:创建新对象时,计数器要在哪个实例中递增呢?静态属性是类的属性,而不是类的实例属性;
- 第 11–15 行:构造函数是我们统计已创建对象的地方,因为每创建一个新对象都会触发构造函数的执行;
- 第 14 行:请注意记法 [self::$nbObjects],它表明我们引用的是被执行代码所在类的静态属性;
- 第 18–21 行:静态方法 [say] 负责显示已创建对象的数量;
- 第 25–27 行:创建两个对象,并显示对象计数器。
5.22. 父类与子类之间的可见性
我们来看下面的脚本 [classes-19.php]:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
class SomeParent
{
// 属性
private int $attributeOfParent = 4;
// 方法
public function doTest(): void
{
// 谁在调用?
print "parent:\n";
var_dump($this);
// 父类显示
print "parent: attributeOfParent={$this->attributeOfParent}\n";
print "parent: attributeOfChild={$this->attributeOfChild}\n";
}
}
class SomeChild extends SomeParent
{
// 属性
private int $attributeOfChild = 14;
// 方法
#[\Override]
public function doTest(): void
{
// 子类显示
print "child: attributeOfParent={$this->attributeOfParent}\n";
print "child: attributeOfChild={$this->attributeOfChild}\n";
// 父类
parent::doTest();
}
}
// 主脚本
print "---------------------------test1\n";
(new SomeParent())->doTest();
print "---------------------------test2\n";
(new SomeChild())->doTest();
|
说明
- 第 6–21 行:类 [SomeParent];
- 第 23–38 行:子类 [SomeChild]。可以看到它继承类 [SomeParent];
- 第 9 行:类 [SomeParent] 只有一个属性;
- 第 12–20 行:方法 [SomeParent::doTest] 旨在显示两个属性:
- [$attributeOfParent],它属于类 [SomeParent];
- [$attributeOfChild],它属于类 [SomeChild];
- 第 15–16 行:显示调用者的身份;该方法将以两种不同的方式被调用:
- 从父类 [SomeParent];
- 从子类 [SomeChild];
- 第 18–19 行:显示这两个属性;
- 第 26 行:类 [SomeChild] 只有一个属性;
- 第 30 行:方法 [SomeChild::doTest] 旨在显示两个属性:
- [$attributeOfParent],它属于类 [SomeParent];
- [$attributeOfChild],它属于类 [SomeChild];
- 第 33–34 行:显示这两个属性;
- 第 36 行:调用父类的 [doTest] 方法,该方法接着显示这两个属性;
- 第 42 行:调用方法 [SomeParent::doTest] ;
- 第 44 行:调用 [SomeChild::doTest] 方法。
在第一个测试中,两个属性的可见性都是 [private]。因此我们可以预期子类看不到其父类的属性。那个属性至少需要具有 [protected] 的可见性。但子类的属性呢?它在父类中可见吗?
下面是第一个测试的结果:
| > php classes-19.php
---------------------------test1
parent:
object(SomeParent)#1 (1) {
["attributeOfParent":"SomeParent":private]=>
int(4)
}
parent: attributeOfParent=4
Warning: Undefined property: SomeParent::$attributeOfChild in .../php8-oct-2026/scripts-console/classes/classes-19.php on line 19
parent: attributeOfChild=
---------------------------test2
Warning: Undefined property: SomeChild::$attributeOfParent in .../php8-oct-2026/scripts-console/classes/classes-19.php on line 33
child: attributeOfParent=
child: attributeOfChild=14
parent:
object(SomeChild)#1 (2) {
["attributeOfParent":"SomeParent":private]=>
int(4)
["attributeOfChild":"SomeChild":private]=>
int(14)
}
parent: attributeOfParent=4
Fatal error: Uncaught Error: Cannot access private property SomeChild::$attributeOfChild in .../php8-oct-2026/scripts-console/classes/classes-19.php:19
Stack trace:
#0 .../php8-oct-2026/scripts-console/classes/classes-19.php(36): SomeParent->doTest()
#1 .../php8-oct-2026/scripts-console/classes/classes-19.php(44): SomeChild->doTest()
#2 {main}
thrown in .../php8-oct-2026/scripts-console/classes/classes-19.php on line 19
|
说明
- 第 2–11 行:调用 [SomeParent::doTest] 方法的第一个测试的结果;
- 第 3–7 行:可以看到调用该方法的对象的类型是 [SomeParent];
- 第 8 行:显示 [$attributeOfParent] 属性;
- 第 10–11 行:可以看到属性 [SomeParent::$attributeOfChild] 不存在。因此它没有被显示。在 PHP 8 中,读取不存在的属性会触发一个 [Warning] 级别的警告(在 PHP 7 中只是一个简单的 [Notice] );
- 第 12–31 行:调用 [SomeChild::doTest] 方法的第二个测试的结果;
- 第 14–15 行:可以看到属性 [SomeChild::$attributeOfParent] 不存在。因此它没有被显示。这是正常的:属性 [SomeParent::$attributeOfParent] 是 [private] 的,因此在子类中无法识别;
- 第 16 行:显示属性 [$attributeOfChild];
- 第 17–31 行:我们处于由子类调用的 [SomeParent::doTest] 方法中;
- 第 18–23 行:我们看到 [$this] 的类型是 [SomeChild] ,带有两个私有属性;
- 第 24 行:令人惊讶的是,[$this]——其类型为 [SomeChild]——能够看到其父类的私有属性 [$attributeOfParent];
- 第 26–31 行:同样令人惊讶的是,[$this],其类型为 [SomeChild],却无法访问它自己的属性 [$attributeOfChild]:试图访问它会导致致命错误。
这个结果非常出人意料:尽管第 18–23 行表明 [$this] 的类型是 [SomeChild],但这个 [$this] 在 [SomeParent::doTest] 方法内部的行为,就好像它是 [SomeParent] 类的实例,而不是 [SomeChild] 类的实例。事实上,可见性是相对于代码所在的类(这里是 [SomeParent])来检查的,而不是相对于对象的类。
让我们用脚本 [classes-20.php] 做一个新的测试。属性 [$attributeOfParent] 现在的可见性是 [protected]:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
class SomeParent
{
// 属性
protected int $attributeOfParent = 4;
// 方法
public function doTest(): void
{
// 谁在调用?
print "parent:\n";
var_dump($this);
// 父类显示
print "parent: attributeOfParent={$this->attributeOfParent}\n";
print "parent: attributeOfChild={$this->attributeOfChild}\n";
}
}
class SomeChild extends SomeParent
{
// 属性
private int $attributeOfChild = 14;
// 方法
#[\Override]
public function doTest(): void
{
// 子类显示
print "child: attributeOfParent={$this->attributeOfParent}\n";
print "child: attributeOfChild={$this->attributeOfChild}\n";
// 父类
parent::doTest();
}
}
// 主脚本
print "---------------------------test1\n";
(new SomeParent())->doTest();
print "---------------------------test2\n";
(new SomeChild())->doTest();
|
结果:
| > php classes-20.php
---------------------------test1
parent:
object(SomeParent)#1 (1) {
["attributeOfParent":protected]=>
int(4)
}
parent: attributeOfParent=4
Warning: Undefined property: SomeParent::$attributeOfChild in .../php8-oct-2026/scripts-console/classes/classes-20.php on line 19
parent: attributeOfChild=
---------------------------test2
child: attributeOfParent=4
child: attributeOfChild=14
parent:
object(SomeChild)#1 (2) {
["attributeOfParent":protected]=>
int(4)
["attributeOfChild":"SomeChild":private]=>
int(14)
}
parent: attributeOfParent=4
Fatal error: Uncaught Error: Cannot access private property SomeChild::$attributeOfChild in .../php8-oct-2026/scripts-console/classes/classes-20.php:19
Stack trace:
#0 .../php8-oct-2026/scripts-console/classes/classes-20.php(36): SomeParent->doTest()
#1 .../php8-oct-2026/scripts-console/classes/classes-20.php(44): SomeChild->doTest()
#2 {main}
thrown in .../php8-oct-2026/scripts-console/classes/classes-20.php on line 19
|
说明
- 第 13 行:类 [SomeChild] 现在可以看到其父类的属性 [$attributeOfParent]。这是正常的,因为父类的属性现在的作用域是 [protected];
- 在 [SomeParent::doTest] 方法中,[$this] 对象的类型是 [SomeChild] (第 16–21 行)。它可以看到其父类的属性 [$attributeOfParent] (第 22 行),但仍然看不到它自己的私有属性 [$attributeOfChild] (第 24–29 行)。
在第三次尝试 [classes-21.php] 中,属性 [$attributeOfChild] 的作用域也是 [protected]:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
class SomeParent
{
// 属性
protected int $attributeOfParent = 4;
// 方法
public function doTest(): void
{
// 谁在调用?
print "parent:\n";
var_dump($this);
// 父类显示
print "parent: attributeOfParent={$this->attributeOfParent}\n";
print "parent: attributeOfChild={$this->attributeOfChild}\n";
}
}
class SomeChild extends SomeParent
{
// 属性
protected int $attributeOfChild = 14;
// 方法
#[\Override]
public function doTest(): void
{
// 子类显示
print "child: attributeOfParent={$this->attributeOfParent}\n";
print "child: attributeOfChild={$this->attributeOfChild}\n";
// 父类
parent::doTest();
}
}
// 主脚本
print "---------------------------test1\n";
(new SomeParent())->doTest();
print "---------------------------test2\n";
(new SomeChild())->doTest();
|
执行结果如下:
| > php classes-21.php
---------------------------test1
parent:
object(SomeParent)#1 (1) {
["attributeOfParent":protected]=>
int(4)
}
parent: attributeOfParent=4
Warning: Undefined property: SomeParent::$attributeOfChild in .../php8-oct-2026/scripts-console/classes/classes-21.php on line 19
parent: attributeOfChild=
---------------------------test2
child: attributeOfParent=4
child: attributeOfChild=14
parent:
object(SomeChild)#1 (2) {
["attributeOfParent":protected]=>
int(4)
["attributeOfChild":protected]=>
int(14)
}
parent: attributeOfParent=4
parent: attributeOfChild=14
|
- 第 23 行:这一次,在父类内部,[$this],其类型为 [SomeChild] (第 16–21 行),能看到受保护的属性 [$attributeOfChild] ,该属性属于它自己的类 [SomeChild]。
从这些测试中我们能学到什么?
- 在父类的方法中使用的父类的 [$this] 实例,可以看到:
- 父类的属性和方法,不论其可见性如何;
- 看不到其子类的任何属性或方法;
- 这是预期的行为;
- 在子类的方法中使用的子类的 [$this] 实例,可以看到:
- 父类的属性和方法,如果它们至少具有 [protected] 可见性。具有 [private] 可见性的则不可见;
- 子类的属性和方法,不论其可见性如何;
- 这是预期的行为;
- 在父类的方法中使用的子类的 [$this] 实例,可以看到:
- 父类的属性和方法,不论其可见性如何;
- 其自身类的属性和方法,仅当它们至少具有 [protected] 可见性时才可见。具有 [private] 可见性的则不可见;
- 这是出乎意料的行为,可以用上面陈述的规则来解释:可见性取决于代码所在的类。
5.23. 枚举(PHP 8.1)
一个人有性别:女性或男性。如何表示这一信息?在 PHP 7 中,使用的是字符串(["F"]、["M"])或类常量。当时没有任何东西能阻止传入不正确的值(["X"]、["female"]……)。PHP 8.1 引入了枚举 (关键字 [enum]):枚举是一种只有有限个可能取值的类型,这些取值称为成员(case)。我们定义枚举 [Gender] ,放在文件 [Gender.php] 中:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 命名空间
namespace Examples;
// 以字符串为后备值的枚举(backed enum)
enum Gender: string
{
case Female = "F";
case Male = "M";
// 枚举可以有方法
public function label(): string
{
return match ($this) {
Gender::Female => "Madam",
Gender::Male => "Sir",
};
}
}
|
说明
- 第 10 行:枚举 [Gender]。其名称后面的类型 [string] 使它成为“带值的”枚举:每个成员都关联一个标量值,这里是字符串。这个值可用于把成员存入文件或数据库。没有这个类型时,它是纯枚举,其成员没有关联的值;
- 第 12–13 行:枚举的两个成员及其值;
- 第 16–22 行:枚举可以有方法(以及常量和静态方法)。在方法内部,
***[$this]*** 指的是调用该方法的那个成员;
- 第 18–21 行:表达式 [match] (PHP 8.0)使用运算符 [===] 把它的参数与每个分支的值进行比较,并返回第一个匹配分支的值。如果没有分支匹配,就会抛出 [UnhandledMatchError] 错误。这里,所有的分支都已定义。
该枚举被脚本 [classes-26.php] 使用:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
require_once __DIR__ . "/Gender.php";
use Examples\Gender;
// 有性别的人
final readonly class Person
{
public function __construct(
public string $firstName,
public string $lastName,
public Gender $gender,
) {
}
public function __toString(): string
{
return "{$this->gender->label()} $this->firstName $this->lastName";
}
}
// 测试
$p1 = new Person("Paul", "Langevin", Gender::Male);
$p2 = new Person("Sylvie", "Lefur", Gender::Female);
print "$p1\n$p2\n";
// 枚举的 case 有名称和值
print "name={$p2->gender->name}, value={$p2->gender->value}\n";
// 这些 case 是唯一的对象:用 === 进行比较
print "p1 is a man: " . var_export($p1->gender === Gender::Male, true) . "\n";
// case 列表
foreach (Gender::cases() as $gender) {
print "$gender->name ($gender->value): {$gender->label()}\n";
}
// 从一个值(从文件、数据库等读取)得到一个 case
print "from('F'): " . Gender::from("F")->name . "\n";
print "tryFrom('X'): " . var_export(Gender::tryFrom("X"), true) . "\n";
try {
Gender::from("X");
} catch (\ValueError $e) {
print "Error: " . $e->getMessage() . "\n";
}
// [Gender] 类型只接受该枚举的 case
try {
new Person("Steve", "Boer", "M");
} catch (\TypeError $e) {
print "Error: " . $e->getMessage() . "\n";
}
|
结果:
| > php classes-26.php
Sir Paul Langevin
Madam Sylvie Lefur
name=Female, value=F
p1 is a man: true
Female (F): Madam
Male (M): Sir
from('F'): Female
tryFrom('X'): NULL
Error: "X" is not a valid backing value for enum Examples\Gender
Error: Person::__construct(): Argument #3 ($gender) must be of type Examples\Gender, string given, called in .../php8-oct-2026/scripts-console/classes/classes-26.php on line 47
|
说明
- 第 15 行:属性 [gender] 属于类 [Person] ,其类型是 [Gender];
- 第 21 行:调用 [label] 方法,该方法属于存放在 [gender] 属性中的实例;
- 第 26 行:成员用记法 [Gender::Male] 表示;
- 第 30 行:每个成员都有一个属性 [name],即它的名称,而对于带值的枚举,还有一个属性 [value],即它的值(结果的第 4 行);
- 第 32 行:每个成员都是唯一的对象:成员用运算符 [===] 进行比较;
- 第 34 行:静态方法 [cases] 返回枚举中的成员列表(结果的第 6–7 行);
- 第 38 行:静态方法 [from] 返回与某个值相关联的成员。这是 [value] 的逆过程:从数据库读取 ["F"],就得到成员 [Gender::Female];
- 第 39 行:如果值与任何成员都不匹配,方法 [tryFrom] 就返回 [null] ;
- 第 41 行:方法 [from] 则相反,会抛出错误 [ValueError] (结果的第 10 行);
- 第 47 行:类型 [Gender] 只接受枚举的成员,不接受它们的值:["M"] 被拒绝(结果的第 11 行)。这正是枚举的意义所在:不正确的值会被立即检测到。
5.24. 类的 JSON 编码
在类中,[__toString] 方法经常出现:它应当返回表示调用它的对象的字符串。人们可能会想把这个字符串做成 JSON 字符串。我们现在就来探讨这种做法。脚本位于 [scripts-console/classes/json] 文件夹中:
| php8-oct-2026/scripts-console/classes/json
├── json-01.php
├── json-02.php
├── json-03.php
├── json-04.php
├── Person.php
├── Person2.php
├── Person3.php
└── Person4.php
|
我们将使用以下[Person]类:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
class Person
{
// 属性
private ?string $lastName = null;
private ?string $firstName = null;
private ?int $age = null;
private ?array $children = null;
// 全局 setter
public function setFromArray(array $arrayOfAttributes): static
{
// 初始化类的部分属性
foreach ($arrayOfAttributes as $attribute => $value) {
// 类中未声明的属性会被拒绝
if (!property_exists($this, $attribute)) {
throw new \InvalidArgumentException("Unknown attribute [$attribute]");
}
$this->$attribute = $value;
}
// 我们返回该对象
return $this;
}
// getter
public function getLastName(): ?string
{
return $this->lastName;
}
public function getFirstName(): ?string
{
return $this->firstName;
}
public function getAge(): ?int
{
return $this->age;
}
public function getChildren(): ?array
{
return $this->children;
}
// __toString
public function __toString(): string
{
// 我们标识该对象
var_dump($this);
// 我们获取其属性
$attributes = \get_object_vars($this);
var_dump($attributes);
// 我们返回属性的 JSON 字符串
return \json_encode($attributes, JSON_UNESCAPED_UNICODE);
}
}
|
说明
- 第 9–12 行:类的四个属性。它们是可空类型([?string] 表示 [string] 或 [null]),初始值为 [null];
- 第 30–45 行:用于获取这些属性值的 getter;
- 第 15–27 行:一个全局 setter,它根据关联数组
***[$arrayOfAttributes],***来初始化各属性,该数组的键与类的属性名一致;
- 第 20 行:函数 [property_exists] 用于验证该属性是否已在类中声明。如果没有这一验证,未知的键会创建动态属性,而动态属性自 PHP 8.2 起已被弃用;
- 第 23 行:写法 [$this->$attribute] 表示名称为变量 [$attribute]的值的那个属性;
- 第 15 行:该方法返回当前对象 [$this]。其返回类型为 [static],即“调用该方法的那个类的对象”。这使得链式调用成为可能:[(new Person())->setFromArray([...])];
- 第 52–61 行:类的 [__toString] 方法;
- 第 57 行:PHP 函数 [get_object_vars] 以关联数组的形式获取对象各属性的值 [['lastName'=>'lastName1', 'firstName'=>'firstName1', 'age'=>age1, 'children'=>[...]]]。在类内部调用时,它也会返回私有属性;
- 第 60 行:返回由该属性数组生成的 JSON 字符串。选项 [JSON_UNESCAPED_UNICODE] 指定带重音的字符不要被转换为 [\u00e9]这样的序列。
我们来看脚本 [json-01.php],它使用了类 [Person]:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// Person 类
require_once __DIR__ . "/Person.php";
// 实例化父亲
$father = new Person();
// 初始化父亲
$father->setFromArray([
"lastName" => "Bertholomé",
"firstName" => "Dieudonné",
"age" => 58,
]);
// 实例化并初始化 child1
$child1 = (new Person())->setFromArray([
"lastName" => "Bertholomé",
"firstName" => "Sylvain",
"age" => 17,
]);
// 实例化并初始化 child2
$child2 = (new Person())->setFromArray([
"lastName" => "Bertholomé",
"firstName" => "Géraldine",
"age" => 12,
]);
// 初始化父亲的子女
$father->setFromArray([
"children" => [$child1, $child2],
]);
// 显示父亲的各个元素
$child1 = $father->getChildren()[0];
$child2 = $father->getChildren()[1];
print "------------------------child1\n";
print "child1=$child1\n";
print "------------------------child2\n";
print "child2=$child2\n";
print "------------------------father\n";
print "father=$father\n";
|
说明
- 第 10–16 行:类型为 [Person] 的对象 [$father] 通过 [Person::setFromArray] 方法进行初始化;
- 第 18–22 行:对象 [Person] [$child1] 以同样的方式初始化;
- 第 24–28 行:初始化一个 [Person] [$child2] 对象;
- 第 31 行:父亲的 [children] 属性用包含两个孩子的数组初始化;
- 第 35–36 行:获取父亲的两个孩子;
- 第 38 行:[print] 操作尝试把 [$child1] 对象转换为字符串。为此,它使用该对象的 [__toString] 方法。因此我们期望看到该对象的 JSON 字符串;
- 第 42 行:对父亲做同样的操作。
执行结果如下:
| > php json-01.php
------------------------child1
object(Person)#2 (4) {
["lastName":"Person":private]=>
string(11) "Bertholomé"
["firstName":"Person":private]=>
string(7) "Sylvain"
["age":"Person":private]=>
int(17)
["children":"Person":private]=>
NULL
}
array(4) {
["lastName"]=>
string(11) "Bertholomé"
["firstName"]=>
string(7) "Sylvain"
["age"]=>
int(17)
["children"]=>
NULL
}
child1={"lastName":"Bertholomé","firstName":"Sylvain","age":17,"children":null}
------------------------child2
object(Person)#3 (4) {
["lastName":"Person":private]=>
string(11) "Bertholomé"
["firstName":"Person":private]=>
string(10) "Géraldine"
["age":"Person":private]=>
int(12)
["children":"Person":private]=>
NULL
}
array(4) {
["lastName"]=>
string(11) "Bertholomé"
["firstName"]=>
string(10) "Géraldine"
["age"]=>
int(12)
["children"]=>
NULL
}
child2={"lastName":"Bertholomé","firstName":"Géraldine","age":12,"children":null}
------------------------father
object(Person)#1 (4) {
["lastName":"Person":private]=>
string(11) "Bertholomé"
["firstName":"Person":private]=>
string(10) "Dieudonné"
["age":"Person":private]=>
int(58)
["children":"Person":private]=>
array(2) {
[0]=>
object(Person)#2 (4) {
["lastName":"Person":private]=>
string(11) "Bertholomé"
["firstName":"Person":private]=>
string(7) "Sylvain"
["age":"Person":private]=>
int(17)
["children":"Person":private]=>
NULL
}
[1]=>
object(Person)#3 (4) {
["lastName":"Person":private]=>
string(11) "Bertholomé"
["firstName":"Person":private]=>
string(10) "Géraldine"
["age":"Person":private]=>
int(12)
["children":"Person":private]=>
NULL
}
}
}
array(4) {
["lastName"]=>
string(11) "Bertholomé"
["firstName"]=>
string(10) "Dieudonné"
["age"]=>
int(58)
["children"]=>
array(2) {
[0]=>
object(Person)#2 (4) {
["lastName":"Person":private]=>
string(11) "Bertholomé"
["firstName":"Person":private]=>
string(7) "Sylvain"
["age":"Person":private]=>
int(17)
["children":"Person":private]=>
NULL
}
[1]=>
object(Person)#3 (4) {
["lastName":"Person":private]=>
string(11) "Bertholomé"
["firstName":"Person":private]=>
string(10) "Géraldine"
["age":"Person":private]=>
int(12)
["children":"Person":private]=>
NULL
}
}
}
father={"lastName":"Bertholomé","firstName":"Dieudonné","age":58,"children":[{},{}]}
|
说明
- 第 3–12 行:对象 [$child1];
- 第 13–22 行:对象 [$child1]的属性数组。所有属性都在其中;
- 第 23 行:我们得到了对象 [$child1]的 JSON 字符串;
- 第 24–45 行:对象 [$child2]同理;
- 第 46–113 行:对于父亲,情况略有不同,因为它的属性 [children] 不是 [null], 而孩子们的该属性则是;
- 第 113 行:我们看到,在父亲的 JSON 字符串中,孩子们是空对象 [{}];
- 第 80–112 行:我们看到,在父亲的属性数组中,孩子 1 仍是对象,孩子 2 也是。总之,表达式 [\get_object_vars($this)]——其中 [$this] 代表父亲——不是递归的:如果类 [Person] 的某个属性本身是对象,表达式 [\get_object_vars($this)] 并不会尝试获取该对象的属性数组。而函数 [json_encode] 只编码对象的公共属性:孩子们的所有属性都是私有的,因此变成了空的 JSON 对象。
我们可以改进这一点。把 [Person] 类修改为下面的 [Person2] 类:
| // __toString
public function __toString(): string
{
// 我们获取对象的属性
$attributes = $this->getAttributes();
$children = $attributes["children"];
if ($children !== null) {
$attributes["children"] = [$children[0]->getAttributes(), $children[1]->getAttributes()];
}
// 我们返回属性的 JSON 字符串
return \json_encode($attributes, JSON_UNESCAPED_UNICODE);
}
public function getAttributes(): array
{
return \get_object_vars($this);
}
}
|
说明
- 第 64–67 行:[getAttributes] 方法返回调用它的对象的属性数组;
- 第 52–62 行:[__toString] 方法;
- 第 55 行:我们从数组 [$attributes]中获取对象的属性;
- 第 56 行:根据前面的示例,我们知道 [$attributes["children"]] 是由两个 [Person2]类型的对象组成的数组;
- 第 57–59 行:这两个对象被替换为它们的属性数组;
- 第 61 行:剩下的就是把构建好的属性数组编码为 JSON。
脚本 [json-02.php] 按如下方式使用 [Person2] 类:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// Person2 类
require_once __DIR__ . "/Person2.php";
// 实例化父亲
$father = new Person2();
// 初始化父亲
$father->setFromArray([
"lastName" => "Bertholomé",
"firstName" => "Dieudonné",
"age" => 58,
]);
// 实例化并初始化 child1
$child1 = (new Person2())->setFromArray([
"lastName" => "Bertholomé",
"firstName" => "Sylvain",
"age" => 17,
]);
// 实例化并初始化 child2
$child2 = (new Person2())->setFromArray([
"lastName" => "Bertholomé",
"firstName" => "Géraldine",
"age" => 12,
]);
// 初始化父亲的子女
$father->setFromArray([
"children" => [$child1, $child2],
]);
// 显示父亲
print "------------------------father\n";
print "father=$father\n";
|
脚本 [json-02.php] 与脚本 [json-01.php]相同,只是用类 [Person2] 替换了类 [Person] ,并且只显示父亲。执行结果如下:
| > php json-02.php
------------------------father
father={"lastName":"Bertholomé","firstName":"Dieudonné","age":58,"children":[{"lastName":"Bertholomé","firstName":"Sylvain","age":17,"children":null},{"lastName":"Bertholomé","firstName":"Géraldine","age":12,"children":null}]}
|
这一次,孩子们与父亲一起被正确地显示出来。
前面的解决方案并不令人满意,因为孩子们也可能有自己的孩子,这又回到了前面的问题。类 [Person3] 按如下方式解决这个问题:
| // __toString
public function __toString(): string
{
// 我们返回属性的 JSON 字符串
$attributes = [];
$this->getRecursiveAttributes($attributes, $this, []);
// 属性的 JSON 字符串
return \json_encode($attributes, JSON_UNESCAPED_UNICODE);
}
public function getAttributes(): array
{
return \get_object_vars($this);
}
private function getRecursiveAttributes(array &$attributes, mixed $value, array $keys): void
{
// 分析值 [$value]
// $keys 是数组 [key1, key2, .., keyn]
// $value=$attributes[key1][key2]...[keyn]
// 如果 [$value] 是对象,我们使用它的 [getAttributes] 方法
if (\is_object($value)) {
// 对象 [$value] 的属性
$objectAttributes = $value->getAttributes();
// 有键吗?
if ($keys) {
// 在 [$attributes] 中,我们要把 $value 替换为其属性数组
// 我们必须构建元素 $attributes[key1][key2]...[keyn]
// 其中 $keys 是数组 [key1, key2, .., keyn]
// 我们取数组 [$attributes] 的引用
$attribute = &$attributes;
// 我们遍历键数组
foreach ($keys as $key) {
// 我们取该属性的引用
$attribute = &$attribute[$key];
}
// 此处 $attribute 与 $attributes[key1][key2]...[keyn] 是同一个东西
// 它们共享同一内存位置
// 对象 [$value] 被其属性数组替换:
// 我们必须写 $attributes[key1][key2]...[keyn]=$objectAttributes
// 这等价于 $attribute = $objectAttributes
$attribute = $objectAttributes;
} else {
// 没有键 - 我们处于对象探索的起点
// $objectAttributes 表示类的第 1 层属性
$attributes += $objectAttributes;
}
// [$objectAttributes] 中可能还有对象
// 我们探索 [$objectAttributes] 的属性
$this->getRecursiveAttributes($attributes, $objectAttributes, $keys);
} elseif (\is_array($value)) {
// 我们得到一个数组 - 分析它的每个元素
foreach ($value as $key => $element) {
// 我们把当前键添加到数组 $keys
$keys[] = $key;
// 我们分析 $element
$this->getRecursiveAttributes($attributes, $element, $keys);
// 我们从数组 $keys 中删除刚刚分析过的键
\array_pop($keys);
}
}
}
}
|
说明
- 第 56 行:这一次,方法 [__toString] 获取其所在类的属性,并要求以递归方式进行:如果某个属性是对象或对象数组,那么每个对象都必须在该类最终的属性数组中被替换为它的属性数组;
- 第 66–112 行:[getRecursiveAttributes] 方法完成这项任务。我们已为其代码添加了注释。编写递归函数往往很复杂,这里也是如此。读者即使不理解它也不会错过什么:我们很快就会看到,PHP 提供了简单得多的解决方案。递归调用出现在第 100 行和第 107 行;
- 这段代码的优点是,它并非仅为 [Person3] 类编写。它适用于任何属性值为各种不同类型对象的类,只要主类所使用的那些类也像主类本身一样,具有第 61–64 行中的 [getAttributes] 方法即可。
脚本 [json-03.php] 按如下方式使用类 [Person3] :
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// Person3 类
require_once __DIR__ . "/Person3.php";
// 实例化父亲
$father = new Person3();
// 初始化父亲
$father->setFromArray([
"lastName" => "Bertholomé",
"firstName" => "Dieudonné",
"age" => 58,
]);
// 实例化并初始化 child1
$child1 = (new Person3())->setFromArray([
"lastName" => "Bertholomé",
"firstName" => "Sylvain",
"age" => 27,
]);
// 实例化并初始化 child2
$child2 = (new Person3())->setFromArray([
"lastName" => "Bertholomé",
"firstName" => "Géraldine",
"age" => 12,
]);
// 初始化父亲的子女
$father->setFromArray([
"children" => [$child1, $child2],
]);
// 实例化并初始化 child11
$child11 = (new Person3())->setFromArray([
"lastName" => "Bertholomé",
"firstName" => "Gaëtan",
"age" => 2,
]);
// 实例化并初始化 child12
$child12 = (new Person3())->setFromArray([
"lastName" => "Bertholomé",
"firstName" => "Mathilde",
"age" => 1,
]);
// 初始化 child1 的子女
$child1->setFromArray([
"children" => [$child11, $child12],
]);
// 显示父亲
print "------------------------father\n";
print "father=$father\n";
|
- 第 34–47 行:[$child1] 被赋予两个孩子。
执行结果如下:
| > php json-03.php
------------------------father
father={"lastName":"Bertholomé","firstName":"Dieudonné","age":58,"children":[{"lastName":"Bertholomé","firstName":"Sylvain","age":27,"children":[{"lastName":"Bertholomé","firstName":"Gaëtan","age":2,"children":null},{"lastName":"Bertholomé","firstName":"Mathilde","age":1,"children":null}]},{"lastName":"Bertholomé","firstName":"Géraldine","age":12,"children":null}]}
|
组成父亲的所有 [Person3] 对象的 JSON 字符串都已成功获取。
5.24.1. [JsonSerializable] 接口
PHP 提供了一个简单得多的解决方案:预定义接口 [JsonSerializable]。我们将在下一章介绍接口。目前只需注意:“实现”[JsonSerializable] 接口的类必须定义一个 [jsonSerialize(): mixed] 方法。当函数 [json_encode] 遇到该类的对象时,会调用它的方法 [jsonSerialize] ,并用返回值取代该对象进行编码。它在数据树的每一层都这样处理。类 [Person4] 使用了这个接口:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// 该类实现了预定义接口 [JsonSerializable]
class Person4 implements \JsonSerializable
{
// 带参数提升的构造函数
public function __construct(
private string $lastName,
private string $firstName,
private int $age,
// [Person4] 对象数组
private array $children = [],
) {
}
// 添加一个子女,并返回当前对象以便链式调用
public function addChild(Person4 $child): static
{
$this->children[] = $child;
return $this;
}
// [JsonSerializable] 接口的方法:
// 返回 [json_encode] 应当编码的值,以代替该对象
#[\Override]
public function jsonSerialize(): mixed
{
return \get_object_vars($this);
}
// __toString:对象的 JSON 字符串
public function __toString(): string
{
return \json_encode($this, JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR);
}
}
|
说明
- 第 7 行:该类实现了 [JsonSerializable] 接口;
- 第 10–16 行:带参数提升的构造函数取代了全局 setter。孩子数组默认为空;
- 第 20–24 行:添加一个孩子,并返回当前对象(返回类型 [static]),以便进行链式调用;
- 第 29 行:接口所要求的方法。其返回类型为 [mixed] (PHP 8.0),表示“任意类型”。这里它返回对象的属性数组。孩子们仍然是 [Person4] 对象:[json_encode] 会调用它们各自的方法 [jsonSerialize]。递归由 PHP 处理;
- 第 28 行:属性 [#[\Override]] 也适用于由接口强制要求的方法;
- 第 37 行:直接对对象调用 [json_encode] 。用 [|] 运算符组合了三个选项:
- [JSON_UNESCAPED_UNICODE]:带重音的字符按原样写出;
- [JSON_PRETTY_PRINT]:JSON 字符串被格式化为多行并带缩进;
- [JSON_THROW_ON_ERROR] (PHP 7.3):出错时,[json_encode] 抛出 [JsonException] 异常,而不是返回 [false]。这在这里很重要:[__toString] 方法必须返回字符串,不能返回 [false]。
脚本 [json-04.php] 使用类 [Person4]:
| <?php
// 严格遵守所声明的函数参数的类型
declare(strict_types=1);
// Person4 类
require_once __DIR__ . "/Person4.php";
// 父亲、他的子女和他的孙辈
$child1 = (new Person4("Bertholomé", "Sylvain", 27))
->addChild(new Person4("Bertholomé", "Gaëtan", 2))
->addChild(new Person4("Bertholomé", "Mathilde", 1));
$father = (new Person4("Bertholomé", "Dieudonné", 58))
->addChild($child1)
->addChild(new Person4("Bertholomé", "Géraldine", 12));
// 显示父亲:[json_encode] 对遇到的每个对象调用 [jsonSerialize]
print "------------------------father\n";
print "father=$father\n";
// 紧凑的 JSON 字符串,不转义带重音的字符
print "------------------------json_encode\n";
print json_encode($child1, JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR) . "\n";
// 解码:得到的是关联数组(第 2 个参数设为 true),而不是 [Person4] 对象
print "------------------------json_decode\n";
$data = json_decode((string) $father, true, flags: JSON_THROW_ON_ERROR);
print "first name of the 1st grandchild: {$data['children'][0]['children'][0]['firstName']}\n";
// 不正确的 JSON 字符串会引发 [JsonException] 异常
print "------------------------error\n";
try {
json_decode('{"lastName": "Bertholomé"', flags: JSON_THROW_ON_ERROR);
} catch (\JsonException $e) {
print "Error: " . $e->getMessage() . "\n";
}
// 没有 [JSON_THROW_ON_ERROR] 时,错误是静默的
var_dump(json_decode('{"lastName": "Bertholomé"'));
print "json_last_error_msg: " . json_last_error_msg() . "\n";
|
结果:
| > php json-04.php
------------------------father
father={
"lastName": "Bertholomé",
"firstName": "Dieudonné",
"age": 58,
"children": [
{
"lastName": "Bertholomé",
"firstName": "Sylvain",
"age": 27,
"children": [
{
"lastName": "Bertholomé",
"firstName": "Gaëtan",
"age": 2,
"children": []
},
{
"lastName": "Bertholomé",
"firstName": "Mathilde",
"age": 1,
"children": []
}
]
},
{
"lastName": "Bertholomé",
"firstName": "Géraldine",
"age": 12,
"children": []
}
]
}
------------------------json_encode
{"lastName":"Bertholomé","firstName":"Sylvain","age":27,"children":[{"lastName":"Bertholomé","firstName":"Gaëtan","age":2,"children":[]},{"lastName":"Bertholomé","firstName":"Mathilde","age":1,"children":[]}]}
------------------------json_decode
first name of the 1st grandchild: Gaëtan
------------------------error
Error: Syntax error
NULL
json_last_error_msg: Syntax error
|
说明
- 第 10–12 行:通过链式调用构造 [$child1] 及其两个孩子;
- 第 19 行:父亲的 [__toString] 方法生成包含所有后代的格式化 JSON 字符串(结果的第 3–34 行)。我们没有编写任何递归代码;
- 第 22 行:不使用 [JSON_PRETTY_PRINT] 时,JSON 字符串是紧凑的(结果的第 36 行);
- 第 25 行:函数 [json_decode] 执行相反的操作:把 JSON 字符串转换为 PHP 值。当第二个参数设为 [true]时,JSON 对象会变成关联数组。注意,返回的是数组而不是 [Person4] 对象:要根据 JSON 字符串重建对象,需要额外的代码(或使用库,例如 Symfony 的 [Serializer] 组件)。命名参数 [flags:] 使我们无需传递第三个参数 [depth];
- 第 30 行:该 JSON 字符串不正确(缺少右花括号)。使用 [JSON_THROW_ON_ERROR] 时,会抛出 [JsonException] 异常(结果的第 40 行);
- 第 35 行:不使用 [JSON_THROW_ON_ERROR] 时,[json_decode] 返回 [null] 而不报告任何错误(第 41 行)。这时需要检查 [json_last_error_msg] 函数,以了解是否发生了错误。因此,在本课程的其余部分,我们将始终使用 [JSON_THROW_ON_ERROR] 选项。