PHP 类和对象：属性、方法和 $this

PHP 类用 class Name { ... } 声明，里面包含属性（变量）和方法（函数）。new Name() 用它创建一个对象，-> 用来读取属性或调用方法：$user->name、$user->greet()。

<?php
class User
{
    public string $name = 'Guest';

    public function greet(): string
    {
        return "Hello, {$this->name}";
    }
}

$user = new User();
echo $user->greet(), "\n";

$user->name = 'Ada';
echo $user->greet(), "\n";

类是蓝图，对象是按蓝图造出来的一个具体东西。同一个类可以创建任意多个对象，每个对象都有自己的属性值。

属性和方法

属性用一个访问控制关键字声明，类型和默认值可写可不写。方法就是类里面的函数。在方法内部，$this 是调用该方法的对象，所以 $this->balance 读取的是这个对象的余额。

<?php
class Account
{
    public string $owner = '';
    public float $balance = 0;

    public function deposit(float $amount): void
    {
        $this->balance += $amount;
    }

    public function summary(): string
    {
        return sprintf('%s has %.2f', $this->owner, $this->balance);
    }
}

$a = new Account();
$a->owner = 'Ada';
$a->deposit(50);
$a->deposit(25.5);

$b = new Account();
$b->owner = 'Linus';
$b->deposit(10);

echo $a->summary(), "\n";
echo $b->summary(), "\n";

每个对象都有自己的 $balance：往 $a 里存钱不会影响 $b。在 new 之后逐个设置属性很繁琐，构造函数可以直接把初始值作为参数接收。

public、private 和 protected

访问控制决定了谁可以访问属性或调用方法：

把属性设为 private，再对外提供方法，类就能保护自己的规则。下面的例子中，余额只能通过 deposit() 和 withdraw() 修改，而这两个方法会拒绝不合法的金额：

<?php
class Wallet
{
    private int $cents = 0;

    public function deposit(int $cents): void
    {
        if ($cents <= 0) {
            throw new InvalidArgumentException('Deposit must be positive');
        }
        $this->cents += $cents;
    }

    public function withdraw(int $cents): bool
    {
        if ($cents > $this->cents) {
            return false;
        }
        $this->cents -= $cents;
        return true;
    }

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

$w = new Wallet();
$w->deposit(500);
var_dump($w->withdraw(800));
var_dump($w->withdraw(200));
echo $w->balance(), "\n";

在类外部读取私有属性不是警告，而是 Error：

<?php
// This throws an Error on purpose: $cents is private
class Wallet
{
    private int $cents = 500;
}

$w = new Wallet();
echo $w->cents;

类型化属性和未初始化的值

没有默认值的类型化属性一开始处于“未初始化”状态，这和 null 不一样。在赋值之前读取它会抛出 Error。解决办法是给它一个默认值、在构造函数中赋值，或者用 ?Type 和 = null 把它变成可为 null 的类型。

<?php
class Product
{
    public string $name;           // no default: uninitialized
    public ?string $sku = null;    // nullable with a default
    public int $stock = 0;
}

$p = new Product();
var_dump($p->sku, $p->stock);

try {
    echo $p->name;
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

$p->name = 'Keyboard';
echo $p->name, "\n";

类型在赋值时检查。在默认的非严格模式下，$p->stock = '7' 会把数字字符串转换成 7，而 $p->stock = 'many' 会抛出 TypeError。

readonly 只读属性

readonly 属性（PHP 8.1）只能在类内部写入一次，之后就再也不能修改。它是构建金额、ID 这类值对象的常用方式。PHP 8.2 新增了 readonly class，让类的所有属性都变成只读。

<?php
class Order
{
    public readonly string $id;

    public function __construct(string $id)
    {
        $this->id = $id;
    }
}

$order = new Order('A-1001');
echo $order->id, "\n";

try {
    $order->id = 'B-2002';
} catch (Error $e) {
    echo $e->getMessage(), "\n";
}

只读属性必须声明类型，并且不能有默认值。如果需要一个修改过的副本，就创建一个新对象（new Order('B-2002')），而不是去改旧的对象。

用 __toString 输出对象

只有类定义了 __toString()，echo $object 才能正常工作。每当对象被当作文本使用时，比如在 echo 中、字符串拼接中或 "{$object}" 中，PHP 就会使用这个方法返回的字符串。

<?php
class Money
{
    public function __construct(
        private int $cents,
        private string $currency = 'EUR',
    ) {}

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

$price = new Money(129900);
echo $price, "\n";
echo 'Total: ' . $price . "\n";
echo "Shipping: " . new Money(450, 'USD') . "\n";

// For debugging, print_r and var_dump show the properties
print_r(new Money(5));

如果没有 __toString，echo $object 会抛出 Error（“Object of class Money could not be converted to string”）。调试时，print_r() 和 var_dump() 适用于任何对象，还会显示私有属性，参见 var_dump 和 print_r。

赋值对象并不会复制它

这是从数组转过来的人最容易踩的坑。赋值数组会复制整个数组，赋值对象只复制句柄：之后两个变量指向同一个对象。

<?php
class Point
{
    public int $x = 0;
    public int $y = 0;
}

$a = new Point();
$b = $a;          // same object
$b->x = 10;
echo "a->x = {$a->x}\n";

$c = clone $a;    // independent copy
$c->x = 99;
echo "a->x = {$a->x}, c->x = {$c->x}\n";

var_dump($a === $b, $a === $c, $a == $c);
var_dump($a instanceof Point);
echo get_class($c), "\n";

clone 做的是浅拷贝：如果某个属性保存着另一个对象，两个副本仍然共享这个内部对象。=== 只有在是同一个对象时才为 true，而 == 比较的是同一个类的两个对象的属性值。把对象传给函数和赋值的效果一样，所以函数可以修改它收到的对象。