Skip to content

6. 接口

接口是定义方法原型的结构。实现某个接口的类必须实现该接口所有方法的代码。接口是一种契约:它规定了对象能做什么,而不规定如何去做。

6.1. 脚本目录结构

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

1
2
3
4
5
6
7
8
php8-oct-2026/scripts-console/interfaces
├── ICalculation.php
├── IExample.php
├── IExample2.php
├── interface-01.php
├── interface-02.php
├── interface-03.php
└── interface-04.php

6.2. 第一个接口

我们在名为 [IExample] 的脚本 [IExample.php]中定义一个接口。在同一个脚本中,我们定义两个实现 [IExample] 接口的类:

<?php

// 严格遵守所声明的函数参数的类型
declare(strict_types=1);

// 命名空间
namespace Examples;

// 一个接口
interface IExample
{
    // 接口的方法
    public function add(int $i, int $j): int;

    public function subtract(int $i, int $j): int;
}

// IExample 接口的实现 1
class Class1 implements IExample
{
    public function add(int $a, int $b): int
    {
        return $a + $b + 10;
    }

    public function subtract(int $a, int $b): int
    {
        return $a - $b + 20;
    }
}

// IExample 接口的实现 2
class Class2 implements IExample
{
    public function add(int $a, int $b): int
    {
        return $a + $b + 100;
    }

    public function subtract(int $a, int $b): int
    {
        return $a - $b + 200;
    }
}

说明

  • 第 10–15 行:[IExample] 接口定义了两个方法:[add] 函数(第 13 行)和 [subtract] 函数(第 15 行)。接口并不定义这些方法的代码,由实现该接口的类来定义。接口的方法必须是 public 的;
  • 第 19 行:类 [Class1] 实现([implements])了接口 [IExample]。因此它为方法 [add] (第 21 行)和 [subtract] (第 26 行)定义了代码。参数名可以与接口中的不同([$a] 而不是 [$i]),但它们的类型必须兼容。不过请注意:对于 PHP 8 的 命名参数,调用 [add(i: 1, j: 2)] 在 [Class1] 上将无法工作。因此最好保持与接口相同的参数名;
  • 第 33–44 行:类 [Class2] 同理。

我们在下面的 [IExample] 脚本 [interface-01.php]中使用这个接口:

<?php

// 严格遵守所声明的函数参数的类型
declare(strict_types=1);

// 引入并声明脚本所使用的类和接口
require_once __DIR__ . "/IExample.php";
use Examples\Class1;
use Examples\Class2;
use Examples\IExample;

// 函数
function calculate(int $a, int $b, IExample $interface): void
{
    print $interface->add($a, $b) . "\n";
    print $interface->subtract($a, $b) . "\n";
}

// 主程序
// 创建 Class1 和 Class2 类型的 2 个对象
$c1 = new Class1();
$c2 = new Class2();
// 调用 calculate 函数
calculate(4, 3, $c1);
calculate(14, 13, $c2);
// 接口不能被实例化
try {
    new IExample();
} catch (\Error $e) {
    print "Error: " . $e->getMessage() . "\n";
}

结果:

1
2
3
4
5
6
> php interface-01.php
17
21
127
201
Error: Cannot instantiate interface Examples\IExample

说明

  • 第 7–10 行:包含并声明脚本所用的类和接口。文件 [IExample.php] 通过语句 [require_once] 引入:即使项目中有多个脚本包含它,它也只会被包含一次;
  • 第 13–17 行:定义了一个函数;
  • 第 13 行:这里我们声明了三个参数的类型。如果运行时实际参数不是期望的类型,就会抛出 [TypeError] 错误。第三个参数的类型是 [IExample]。这意味着实际参数必须是实现了 [IExample] 接口的类的实例;因此在我们的示例中,就是类 [Class1] 或 [Class2]的实例。函数 [calculate] 并不知道这些类,它只认识接口。我们可以向它传递以后编写的类的对象,只要这些类实现了 [IExample] 接口;
  • 第 15–16 行:我们使用 [add, subtract] 方法,它们属于 [IExample] 接口;
  • 第 24 行:第三个实际参数的类型是 [Class1],它与 函数第三个形式参数的类型 [IExample] 兼容;
  • 第 25 行:类 [Class2] 同理;
  • 第 28 行:接口不能被实例化;会返回一个错误(结果的第 6 行)。

6.3. 派生接口

正如子类可以继承父类一样,子接口也可以继承父接口。

考虑在文件 [IExample2.php] 中定义的接口 [IExample2]:

<?php

// 严格遵守所声明的函数参数的类型
declare(strict_types=1);

// 命名空间
namespace Examples;

// 引入 IExample 接口的定义
require_once __DIR__ . "/IExample.php";

// 派生自 IExample 的接口
interface IExample2 extends IExample
{
    // 该接口新增的方法
    public function multiply(int $i, int $j): int;
}

// IExample2 接口的实现
class Class3 extends Class2 implements IExample2
{
    // [Override] 检查该方法确实存在于接口中
    #[\Override]
    public function multiply(int $a, int $b): int
    {
        return $a * $b;
    }
}

说明

  • 第 7 行:[IExample2] 接口与 [IExample] 接口位于同一个命名空间;
  • 第 10 行:包含 [IExample] 接口的定义文件;
  • 第 13–17 行:定义 [IExample2] 接口,它扩展([extends])[IExample] 接口并为其添加一个新方法(第 16 行)。一个接口甚至可以扩展多个接口:[interface I3 extends I1, I2];
  • 第 20–28 行:类 [Class3] 继承类 [Class2]。由于后者实现了 [IExample] 接口,[Class3] 类也同样实现了它。实际上,[Class3] 继承了 [Class2] 类所有的公共方法和受保护方法,包括 [add] 和 [subtract] 方法。此外,还声明了 [Class3] 实现 [IExample2] 接口。因此,它还必须实现 [multiply] 方法,而 [Class2] 并没有这个方法。这正是第 24–27 行所做的;
  • 第 23 行:从 PHP 8.3 开始,上一章讨论过的属性 [#[\Override]] 也适用于实现接口方法的方法。如果方法 [multiply] 从接口 [IExample2] 中消失,PHP 会对此发出提示。

[IExample2] 接口由下面的 [interface-02.php] 脚本使用:

<?php

// 严格遵守所声明的函数参数的类型
declare(strict_types=1);

// 引入并声明脚本所需的类和接口
require_once __DIR__ . "/IExample2.php";
use Examples\IExample2;
use Examples\Class3;

// 函数
function calculate(int $a, int $b, IExample2 $interface): void
{
    print $interface->add($a, $b) . "\n";
    print $interface->subtract($a, $b) . "\n";
    print $interface->multiply($a, $b) . "\n";
}

// 主程序
// 创建 1 个实现 IExample2 的 Class3 类型的对象
$c3 = new Class3();
// 调用 calculate 函数
calculate(4, 3, $c3);

结果:

1
2
3
4
> php interface-02.php
107
201
12

说明

  • 第 12 行:[calculate] 函数的第三个参数类型为 [IExample2];
  • 第 14–16 行:使用了 [IExample2] 接口的三个方法:从 [IExample] 继承的两个方法和它自己的方法;
  • 第 23 行:调用函数 [calculate],其第三个参数是一个 [Class3] 类型的对象,该类实现了 [IExample2] (第 21 行)。

6.4. 将接口作为函数参数传递

我们在上一章(“将对象作为函数参数传递”一节)中看到,当函数参数的期望类型是类时,实际参数可以是该期望类型或其派生类型的对象。接口也是如此,如下面的脚本 [interface-03.php]所示:

<?php

// 严格遵守所声明的函数参数的类型
declare(strict_types=1);

// 引入并声明脚本所需的类和接口
require_once __DIR__ . "/IExample.php";
require_once __DIR__ . "/IExample2.php";
use Examples\IExample;
use Examples\IExample2;
use Examples\Class1;
use Examples\Class3;

// 函数
function calculate(int $a, int $b, IExample $interface): void
{
    print $interface->add($a, $b) . "\n";
    print $interface->subtract($a, $b) . "\n";
}

// 主程序
// 创建 1 个实现 IExample2 因而也实现 IExample 的 Class3 类型的对象
$c3 = new Class3();
// 调用 calculate 函数
calculate(4, 3, $c3);
// [instanceof] 运算符测试对象是否实现了某个接口
foreach ([new Class1(), $c3] as $object) {
    print $object::class . ": IExample=" . var_export($object instanceof IExample, true)
        . ", IExample2=" . var_export($object instanceof IExample2, true) . "\n";
}
// Class3 类所实现的接口
print_r(class_implements($c3));

结果:

> php interface-03.php
107
201
Examples\Class1: IExample=true, IExample2=false
Examples\Class3: IExample=true, IExample2=true
Array
(
    [Examples\IExample] => Examples\IExample
    [Examples\IExample2] => Examples\IExample2
)

说明

  • 第 15 行:函数 [calculate] 期望其第三个参数的类型为 [IExample]。这意味着实际参数可以是 [IExample] 类型或其派生类型;
  • 第 23 行:从实现了接口 [$c3] 的类 [Class3] 实例化了一个对象,而 [IExample2], 该接口又扩展了接口 [IExample]。因此最终,[$c3] 实现了 [IExample] 接口;
  • 第 25 行:调用函数 [calculate],以对象 [$c3] (类型为 [Class3])作为第三个参数。通过类的继承和实现,我们已经看到对象 [$c3] 实现了类型 [IExample]。因此可以把它用作第三个参数;
  • 第 27–30 行:[instanceof] 运算符检查对象是否实现了某个接口。类型为 [Class1] 的对象实现了 [IExample] ,但没有实现 [IExample2] (结果的第 4 行)。类型为 [Class3] 的对象两者都实现了(第 5 行);
  • 第 32 行:[class_implements] 函数返回对象或类直接实现或通过继承而实现的接口列表(结果的第 6–10 行)。

6.5. 接口常量、多接口与交集类型

接口还可以声明常量,一个类也可以实现多个接口。我们在文件 [ICalculation] 中定义两个接口 [INameable], 以及两个实现它们的类 [ICalculation.php]:

<?php

// 严格遵守所声明的函数参数的类型
declare(strict_types=1);

// 命名空间
namespace Examples;

// 接口可以声明常量
interface ICalculation
{
    // 带类型的常量(PHP 8.3)
    public const int PRECISION = 2;

    public function calculate(float $a, float $b): float;
}

// 第二个接口
interface INameable
{
    public function getName(): string;
}

// 一个类可以实现多个接口
final class Addition implements ICalculation, INameable
{
    #[\Override]
    public function calculate(float $a, float $b): float
    {
        return round($a + $b, self::PRECISION);
    }

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

final class Division implements ICalculation, INameable
{
    #[\Override]
    public function calculate(float $a, float $b): float
    {
        // [ICalculation::PRECISION] 和 [self::PRECISION] 指向同一个常量
        return round($a / $b, ICalculation::PRECISION);
    }

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

说明

  • 第 13 行:[ICalculation] 接口声明了一个常量。所有实现该接口的类都会继承它。从 PHP 8.3 起,类常量或接口常量可以带类型(这里是 [int]);
  • 第 19–22 行:第二个接口,只有一个方法;
  • 第 25 行:类 [Addition] 同时实现这两个接口:接口名之间用逗号分隔。它必须定义两个接口的方法;
  • 第 30 行:从接口继承的常量通过 [self::PRECISION]访问。函数 [round] 将数字四舍五入到指定的小数位数;
  • 第 46 行:该常量也可以通过接口名引用:[ICalculation::PRECISION]。

这些接口由脚本 [interface-04.php]使用:

<?php

// 严格遵守所声明的函数参数的类型
declare(strict_types=1);

// 引入并声明脚本所需的类和接口
require_once __DIR__ . "/ICalculation.php";
use Examples\ICalculation;
use Examples\INameable;
use Examples\Addition;
use Examples\Division;

// [$calculation] 参数有默认值:由 [new] 创建的对象(PHP 8.1)
function execute(float $a, float $b, ICalculation $calculation = new Addition()): float
{
    return $calculation->calculate($a, $b);
}

// 交叉类型(PHP 8.1):[$operation] 必须同时实现两个接口
function display(float $a, float $b, ICalculation&INameable $operation): void
{
    print $operation->getName() . "($a, $b)=" . $operation->calculate($a, $b) . "\n";
}

// 主程序
// 接口的常量
print "precision: " . ICalculation::PRECISION . " decimal places\n";
// 第 3 个参数的默认值
print "execute(1.234, 2.345)=" . execute(1.234, 2.345) . "\n";
// 显式参数
print "execute(10, 3, new Division())=" . execute(10, 3, new Division()) . "\n";
// 交叉类型
display(10, 4, new Division());
display(10, 4, new Addition());
// 这些类实现了两个接口
print_r(class_implements(Division::class));

结果:

> php interface-04.php
precision: 2 decimal places
execute(1.234, 2.345)=3.58
execute(10, 3, new Division())=3.33
division(10, 4)=2.5
addition(10, 4)=14
Array
(
    [Examples\ICalculation] => Examples\ICalculation
    [Examples\INameable] => Examples\INameable
)

说明

  • 第 14 行:[execute] 函数的第三个参数类型为 [ICalculation] 并带有默认值——用 [Addition] 对象,通过 [new] 创建。直到 PHP 8.0,参数的默认值只能是常量。从 PHP 8.1 起,表达式 [new] 可用于参数默认值(“new in initializers”),也可用于 PHP 属性([#[...]])的实参、静态变量和全局常量。它仍然不能用于类属性的默认值。每次调用省略该参数时,都会创建该对象;
  • 第 20 行:类型 [ICalculation&INameable] 是一个 交集类型 (PHP 8.1):实际参数必须同时实现 [ICalculation] 和 [INameable]。这样函数就可以调用两个接口中的方法。不要将其与联合类型 [ICalculation|INameable] (二者之一)混淆;
  • 第 27 行:该常量可以在外部通过接口名访问(结果的第 2 行);
  • 第 29 行:省略第三个参数;执行计算的是一个 [Addition] 对象(第 3 行);
  • 第 31 行:显式传入一个 [Division] 对象(第 4 行)。请注意,整数 10 和 3 被接受用于类型为 [float] 的参数,尽管声明了 [strict_types=1]:把 ***[int] 转换为 [float]*** 是严格模式下唯一允许的自动转换;
  • 第 33–34 行:两个类都实现了这两个接口;它们被 [display] 函数接受(第 5–6 行);
  • 第 36 行:写法 [Division::class] 表示完整的类名,这里是 [Examples\Division]。函数 [class_implements] 既接受类名也接受对象。

接口在 PHP 本身中无处不在。我们在上一章已经遇到了两个:[Stringable],任何带有 [__toString] 方法的类都会自动实现它;以及 [JsonSerializable],它让你控制对象的 JSON 编码。在下一章中,我们将介绍 [Throwable] 接口,所有错误和异常都实现了它。枚举也可以实现接口。最后,本课程后面我们会看到,接口是应用分层架构的基础:每一层只了解相邻层的接口。