活动页接入商品数据时出了个笑话:同一个商品,列表接口显示 199 元,详情接口显示 1.99 元。前端同学以为便宜了,赶紧截图发群。查下来两个接口查的是同一张表,只是列表接口把分转成了元,详情接口直接把数据库里的分当元返回。字段都叫 price,谁也没写单位。

这就是「用数组当数据模型」的典型代价。数组本身没有名字,字段名靠大家记忆,类型靠口头约定,单位靠注释。改一个字段名,可能漏掉三个地方;传一个错误的值,运行时也不报错,直到用户看到离谱的价格。

面向对象要解决的正是这类问题:给数据结构一个名字,给字段一个类型,把校验和换算放进一个地方。这篇讲类与对象、构造器提升、readonly、继承与接口的取舍、枚举,最后用一个商品与订单的例子走一遍从数组到对象的过程。

类:给数据结构一个名字

类可以理解成「带行为的模板」,对象是按模板造出来的实例。属性声明了类型,方法负责行为。PHP 7.4 起支持类型属性,PHP 8.0 起支持构造器提升,写起来比旧版本短很多:

<?php
declare(strict_types=1);

final class Product
{
    public function __construct(
        public readonly int $id,
        public readonly string $name,
        public readonly int $priceCents,
    ) {}

    public function priceYuan(): string
    {
        return number_format($this->priceCents / 100, 2, '.', '');
    }
}

$p = new Product(id: 1024, name: '机械键盘', priceCents: 19900);
echo $p->priceYuan(); // 199.00

对比旧写法,同样的类要写一串属性声明,再在构造器里逐个赋值:

<?php
// PHP 7.4 及以前的典型写法,现在不需要这样写
final class ProductOld
{
    private int $id;
    private string $name;
    private int $priceCents;

    public function __construct(int $id, string $name, int $priceCents)
    {
        $this->id = $id;
        $this->name = $name;
        $this->priceCents = $priceCents;
    }
}

构造器提升把「声明属性」和「接收参数」合成一步,属性名就是参数名。它是语法糖,不改变可见性规则:public 表示外部可读写,private 只能在类内部访问,protected 子类也能访问。

类型声明真正值钱的地方不是「写起来规范」,而是把错误提前到发生的那一行。有个订单服务,构造器一开始没收类型:

<?php
final class OrderService
{
    public function __construct(private $repo) {}
}

某次重构,容器里绑定的实现被换成了一个测试用的数组桩,项目照常启动,首页也正常。直到用户点进订单详情,日志里出现 Error: Call to a member function find() on array,位置在 OrderService.php 第 87 行。从这行往上翻,栈追踪是一串框架调用,最外层只写「控制器」。真正的问题在构造器收到的参数类型不对,报错却发生在十几层之后的第一次方法调用上,中间没有任何提示,只能靠猜。

补上类型之后,同一个故障立刻变成这样:

PHP Fatal error:  Uncaught TypeError: App\Order\OrderService::__construct():
Argument #1 ($repo) must be of type App\Order\OrderRepository, array given,
called in /var/www/app/Http/OrderController.php on line 42
and defined in /var/www/app/Order/OrderService.php:12

这条报错的信息密度大得多:哪个类、第几个参数、参数名、期望类型、实际类型、从哪个文件的哪一行传进来。定位顺序也就固定了:先看冒号前的类和方法,确认是构造器;再看 Argument #1 ($repo),确认是依赖注入那一步;最后看 called in ... on line 42,直接跳到调用处。栈追踪里再往下的 #0、#1 是容器和路由,业务代码不用看。没有类型声明时,这些线索全都不存在。

补类型时还有一个容易误判的点:declare(strict_types=1) 按文件生效,管的是这个文件里发起的调用。控制器没写、服务写了,控制器把字符串传进 int 参数照样被弱模式悄悄转换;反过来也一样。同一个参数在一个入口报错、另一个入口不报,不是框架抽风,是两个入口所在文件的声明不同。

提升之后的参数顺序也是新坑。把可选参数写在必填参数前面,PHP 8.0 起会打一条 Deprecated: Optional parameter $name declared before required parameter $id is implicitly treated as a required parameter,那个默认值等于没写。new Product('键盘') 会抛 ArgumentCountError: Too few arguments to function Product::__construct(), 1 passed ... and exactly 2 expected。默认值只该给真正可省的参数。

第二个新坑是参数名变成了公开契约。PHP 8 的命名参数一旦写进代码,new Product(id: 1, priceCents: 19900) 里的名字就不能随便改;改名后,用命名参数的调用抛 Error: Unknown named parameter $priceCents,按位置传参的调用却毫发无伤,报错只出现在一部分文件里。

readonly 是 PHP 8.1 加的修饰符,表示属性只能在构造时赋值一次,之后不能改。这对值对象特别合适:价格、订单号、创建时间这些一旦确定就不该变的字段,加上 readonly 后,谁也别想在业务代码里偷偷改掉。PHP 8.2 还支持 readonly class,一次性把类里所有属性声明成只读。

readonly 保护的是「属性不能再指向别的值」,不是「值本身不可变」。属性是数组时,往里面加元素同样算修改属性,会报错;属性是对象时,对象内部的状态仍然可以被改。要真正不可变,得让里面的对象也一并不变。

这个保护在热修时最容易撞上:直接在已经建好的金额对象上做减法,报错是 Error: Cannot modify readonly property Money::$cents。前缀是 Error 不是 Exception,两者都实现 Throwable 但互不继承,全局写的 catch (Exception $e) 捕不到它,页面直接 500,日志也常落在单独的致命错误文件里。正确做法是让对象自己产出新值:withDiscount() 返回 new self(...),只能整替换、不能原地改。PHP 8.3 起 __clone 里可以重新给 readonly 属性赋值,8.2 及以前不行,克隆出来还是原值。

继承:只用在「是一种」的关系上

继承的语法很直接,extends 加 parent:: 调用父类实现。但什么时候该继承,判断标准只有一条:子类是不是父类的一种。会员商品是商品的一种,可以继承;订单不是商品的一种,不该继承,哪怕它也需要算价格。

<?php
class Product
{
    public function __construct(
        protected int $priceCents,
    ) {}

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

final class MemberProduct extends Product
{
    public function priceCents(): int
    {
        return intdiv($this->priceCents * 90, 100);
    }
}

这个例子里子类覆盖了父类方法,属于合理的扩展。但继承有几个真实的代价:层级一深,改父类会牵动所有子类;子类只能有一个父类,表达不了多重约束;很多看起来像「是一种」的场景,其实是「用到了」,这时组合更合适。

组合的做法是:在一个类里持有另一个类的实例,需要时调用它的方法。订单需要算价格,就注入一个价格计算器,而不是让订单继承商品。这样两个概念可以各自演化,测试时也能替换计算器。

final 表示这个类不允许再被继承。给业务类加上 final 是一种保护:别人不会因为继承你的类而依赖内部实现,你改内部结构时也更自由。

接口与抽象类:两种「约束」

接口只声明方法签名,不写实现;抽象类可以声明抽象方法,也可以提供部分实现。它们的用途不同:

接口

定义「必须提供什么能力」。一个类可以实现多个接口,适合表达对外契约。实现类可以完全不同,比如数据库仓储和内存仓储。

抽象类

定义「共同骨架加必须补全的步骤」。只能被继承一次,适合多个子类共享一部分实现,再各自补差异。

实际项目里,接口最常用的地方是隔离外部依赖。商品仓储需要一个接口,业务代码只依赖接口,具体用 PDO 还是别的实现由外面决定。这样测试时可以塞一个内存实现,不必连数据库:

<?php
interface ProductRepository
{
    public function findById(int $id): ?Product;
}

final class InMemoryProductRepository implements ProductRepository
{
    /** @var array<int, Product> */
    private array $items = [];

    public function add(Product $product): void
    {
        $this->items[$product->id] = $product;
    }

    public function findById(int $id): ?Product
    {
        return $this->items[$id] ?? null;
    }
}

接口不是越多越好。给每个类都套一层接口,代码量翻倍,收益却为零。判断标准:这个依赖是否需要替换(测试、换实现、接第三方),需要就抽接口,不需要就直接用具体类。

选错这两者,代价通常在半年后一次性付清。有个项目一开始把仓储写成抽象类,共享一个 PDO 和一段公共查询逻辑,所有仓储继承它,抽象方法只要求子类给出表名。当时看起来比接口省事:不用每个类都写一遍构造器。后来要接一个只读的搜索服务,那个 SDK 的客户端类自己必须继承,没法再继承仓储基类;再后来测试里想换一个不连数据库的假仓储,也被迫构造一个 PDO 实例。

这时改造成本已经不是改一个文件:所有仓储的 extends 要换成 implements,公共查询方法要挪进 trait 或新基类,注入点从继承来的 $pdo 改成构造参数,十二个类、二十多个调用点全部要回归。如果一开始抽的是接口,这个改造根本不会发生。判断很直接:需要多种实现互换用接口,需要多个子类共享同一段实现才用抽象类;两者都要时,定义接口,再写一个实现它的抽象基类。

枚举:把状态从字符串里救出来

订单状态在旧代码里是字符串:'paid'、'shiped'、'canceled'。拼错一个字母不会报错,只会在某个页面上显示空白。PHP 8.1 的枚举把这类值收进一个类型:

<?php
enum OrderStatus: string
{
    case Pending = 'pending';
    case Paid = 'paid';
    case Shipped = 'shipped';
    case Cancelled = 'cancelled';

    public function label(): string
    {
        return match ($this) {
            self::Pending => '待付款',
            self::Paid => '待发货',
            self::Shipped => '已发货',
            self::Cancelled => '已取消',
        };
    }
}

$status = OrderStatus::from('paid');
echo $status->label(); // 待发货

BackedEnum(带值的枚举)可以用 from() 从数据库值恢复,值不存在时抛异常;tryFrom() 返回 null,适合处理不可信输入。cases() 返回所有成员,生成下拉选项很方便。

枚举成员是单例,OrderStatus::Paid === OrderStatus::Paid 恒为真,比较时不用再担心字符串相等。match ($this) 配合枚举还能让「新增状态必须补文案」这件事在编译期就暴露出来——没覆盖的分支会抛 UnhandledMatchError。

静态成员与常量:能少用就少用

类常量用 const 声明,属于类而不属于某个对象;静态属性用 static,整个进程内共享。它们方便,但也容易变成全局状态。

典型误用是单例:用一个静态方法返回全局唯一的数据库连接或配置对象。单例在小型脚本里省事,到了测试和并发场景就麻烦——测试之间会串数据,一个用例改了状态,下一个用例看到的是脏数据;想在同一个进程里跑两套配置也做不到。

更稳的做法是显式传递依赖:需要仓储就通过构造器传进去,依赖在签名里看得见,测试时也能换假的实现。

常量适合放真正不变的值,比如状态码、表名、税率。注意 const 在类里默认是 public,PHP 7.1 起可以写 private const。真正需要运行时计算才能得到的值,不要硬塞进常量。

场景走查:商品价格从数组到对象

回到开头。需求是:商品有 id、名称、价格(分)、上下架状态;会员价是原价的九折;列表和详情两个接口都要输出一致的结构。

第一版用数组,两个控制器各自拼:列表接口把分除以 100,详情接口直接返回分,字段都叫 price。于是有了 199 和 1.99 的笑话。第二版引入 Product 类,价格统一存分,输出时由类提供方法:

<?php
declare(strict_types=1);

final class Product
{
    public function __construct(
        public readonly int $id,
        public readonly string $name,
        public readonly int $priceCents,
        public readonly bool $onSale,
    ) {}

    public function memberPriceCents(bool $isMember): int
    {
        return $isMember ? intdiv($this->priceCents * 90, 100) : $this->priceCents;
    }

    /** @return array{id: int, name: string, priceCents: int, onSale: bool} */
    public function toArray(): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'priceCents' => $this->priceCents,
            'onSale' => $this->onSale,
        ];
    }
}

第二版仍然有一个隐患:两个控制器各自 new Product(...),从数据库取出的字段如果是字符串,priceCents 会因为严格类型直接报错,或者被悄悄转成 0。第三版把「从数据库行构造商品」也收进类里,叫工厂方法:

<?php
public static function fromRow(array $row): self
{
    return new self(
        id: (int) $row['id'],
        name: (string) $row['name'],
        priceCents: (int) $row['price_cents'],
        onSale: (bool) $row['on_sale'],
    );
}

这样单位、类型、字段映射都只有一份。列表和详情都调用 fromRow(),输出都调用 toArray(),再也不会出现一边元一边分。订单状态也从字符串换成了 OrderStatus 枚举,数据库里仍存字符串,进出各转换一次。

上线前补了两个测试:一个断言 19900 分的会员价是 17910 分,一个断言非法状态值 tryFrom() 返回 null 并能给出提示。这两个测试不需要数据库,跑得很快,改价格规则时能立刻发现问题——这正是把规则放进对象的好处。

上线两个月后,订单多了退款和部分发货,处理入口按事件类型分了好几支。原来的写法是一串 if (get_class($event) === '...'),加一种类型要同时改两处,忘了就静默落进默认分支。换成 instanceof 配 match (true) 之后,漏掉的分支会直接抛错:

<?php
$handler = match (true) {
    $event instanceof OrderPaid => new PaidHandler(),
    $event instanceof OrderRefunded => new RefundHandler(),
    $event instanceof OrderShipped => new ShipHandler(),
    default => throw new InvalidArgumentException(
        '没有对应的事件处理器:' . $event::class
    ),
};

几个细节值得记。第一,match (true) 的每个分支必须是布尔表达式,instanceof 正好返回布尔,比 match ($event::class) 抗重构——后者把类名字符串写死,改命名空间就断。第二,分支自上而下命中,父类写在子类前面会把子类截走,一个类实现多个接口时谁写前面谁生效。第三,match 严格比较且必须有值,没有 default 又没命中时会抛 UnhandledMatchError,所以事件分发这种开放输入处永远写 default,并把实际类名带进异常消息。

真正让这节多出一个案例的,是上线后的一次热修。大促当天满减金额算错,值班同学在结算流程里加了一行,改掉了订单里已经放好的金额对象。本地跑通了,因为本地那份代码的 Money 还没加 readonly;线上是 8.2,属性早就只读。发布后结算接口整片 500,日志每隔几秒一条 Error: Cannot modify readonly property App\Domain\Money::$cents。定位顺序:按错误文本全局搜,只命中一行;看这行的变量来自哪个类;再用 git log 查这个类的 readonly 是什么时候加的——两周前,和这次热修不是同一个分支。热修是从旧代码拉的,缺了那次改动。处理是回滚发布,把热修改到最新主干,用 withDiscount() 生成新对象再赋值。后来这条进了发布检查单:看到 ->属性 = ,先问一句这个属性是不是 readonly。

本地验证不需要框架。写一个小脚本故意传错类型,第一次不加 strict_types、第二次加上,对比报错;再把对 readonly 属性的赋值跑一遍:

php check-run.php
# Fatal error: Uncaught TypeError: OrderService::__construct():
# Argument #1 ($repo) must be of type OrderRepository, array given,
# called in C:\tools\php-work\demo\check-run.php on line 9

php money-run.php
# Fatal error: Uncaught Error: Cannot modify readonly property Money::$cents
# in C:\tools\php-work\demo\Money.php:9

本机 PHP 8.3.36 实测两条都以退出码 255 结束,都打印完整类名和属性名:第一条同时出现 Argument #1 ($repo) 和实际类型 array,说明类型声明真的生效;第二条报 Cannot modify readonly property Money::$cents,说明只读属性在构造完成后拒绝写入。如果只是白屏、日志里没有这两类错误,说明传进去的值恰好兼容,这个测试没测到点上。

现象、原因与第一步

现象真实原因第一步查什么
同一商品两个接口价格差 100 倍字段单位没约定,一个返回元一个返回分全局搜索 price,确认写入和读取的单位
改字段名后某个页面空白数组结构散落在多个文件,漏改一处搜索旧字段名;把结构收进类并统一出口
传错类型却没报错没开严格类型,字符串被悄悄转换看入口文件是否有 strict_types,打印实际类型
子类改了行为,父类也跟着坏继承层级过深,子类依赖父类内部实现画出继承关系,确认是否真的「是一种」
测试用例之间互相影响用了单例或静态属性保存状态搜 static 和单例入口,改成构造器注入
状态字符串拼错导致页面空白魔法字符串没有类型约束换成枚举,用 match 强制覆盖所有分支
8.2 环境报动态属性 Deprecated给未声明的属性赋值看日志行号,补属性声明,别用 #[AllowDynamicProperties] 遮盖
Class not found没有自动加载,文件没被引入确认命名空间与目录;下一篇讲 Composer 自动加载

边界与代价

面向对象不是越多越好。一个只有三个字段的 DTO 写成一堆 getter/setter,代码量是数组的三倍,收益却接近零。判断要不要建类:是否在多处出现、是否有必须守住的不变量、是否需要行为,三条占一条就值得。

继承最容易过度。三层以上的继承链,读代码要在脑子里拼出一个完整的子类,改父类又怕影响别人;多数场景用组合表达得更清楚。

版本门槛要记:readonly 属性 8.1、readonly 类 8.2、枚举 8.1。落地前先确认服务器版本,别在本地写完才发现线上跑不起来。

对象比数组重,属性多了内存开销也大;业务系统的瓶颈通常在数据库和网络,真要处理几十万条记录还是用数组或生成器。

当天能自己验证的练习

  1. 写一个 Product 类,价格存分,提供 priceYuan() 和 toArray(),实例化两个商品并打印。
  2. 给 Product 加一个 readonly 属性,尝试在构造后修改它,看报什么错。
  3. 定义 OrderStatus 枚举,用 from() 和 tryFrom() 分别处理合法与非法值。
  4. 写一个内存版 ProductRepository 实现接口,用它给业务函数提供数据,确认不连数据库也能跑。

小结

三句话:类给数据结构一个名字,顺带固定字段、类型和单位;继承只用于「是一种」,其余优先组合;接口隔离依赖,枚举消灭魔法字符串。

下一篇讲 Composer。今天写的 Product 类,如果要被另一个文件使用,还得先 require 进来;项目里类一多,引入语句会变成一片。Composer 解决的不只是装第三方库,还包括「类怎么被自动找到」。下一篇会从「线上 vendor 目录是手动传上去的」这个事故讲起。