PHP static：静态方法、静态属性与 self 和 static 的区别

static 方法或属性属于类本身，而不属于任何对象。用 ClassName::method() 调用静态方法，用 ClassName::$property 读取静态属性，不需要先创建对象。在类的内部，self:: 指向同样的成员。

<?php
class Temperature
{
    public static int $conversions = 0;

    public static function toFahrenheit(float $c): float
    {
        self::$conversions++;
        return $c * 9 / 5 + 32;
    }
}

echo Temperature::toFahrenheit(20), "\n";
echo Temperature::toFahrenheit(37.5), "\n";
echo 'Conversions so far: ', Temperature::$conversions, "\n";

整段代码里没有一处 new Temperature()。静态成员适合不需要对象状态的辅助方法（转换、工厂、校验），也适合属于整个类的数据，比如计数器。

静态属性由所有对象共享

普通属性每个对象各有一个值。静态属性整个类只有一个值，所以每个对象看到的都是同一个。下面每新建一个 User，就让共享计数器加一，并拿到下一个 ID：

<?php
class User
{
    private static int $nextId = 1;
    public readonly int $id;

    public function __construct(public string $name)
    {
        $this->id = self::$nextId++;
    }

    public static function created(): int
    {
        return self::$nextId - 1;
    }
}

$a = new User('Ada');
$b = new User('Grace');
$c = new User('Linus');

echo "{$a->name} #{$a->id}, {$b->name} #{$b->id}, {$c->name} #{$c->id}\n";
echo User::created(), " users created\n";

注意 self::$nextId 里的 $：静态属性在 :: 后面保留 $，而常量（self::MAX）没有。静态属性只在一次 PHP 请求内有效。在常见的网站环境（PHP-FPM 或 Apache）中，每次加载页面它都会重新开始，所以不能用它在不同访问者之间保存数据。

静态方法没有 $this

静态方法在没有对象的情况下运行，所以里面不存在 $this。静态方法可以用 self:: 调用其他静态方法，但不能读取普通属性。以静态方式调用普通方法同样会失败：

<?php
class Slug
{
    private string $separator = '-';

    public static function make(string $text): string
    {
        $text = strtolower(trim($text));
        return trim(preg_replace('/[^a-z0-9]+/', '-', $text), '-');
    }

    public function withSeparator(string $text): string
    {
        return str_replace('-', $this->separator, self::make($text));
    }
}

echo Slug::make('  Hello, Static World! '), "\n";
echo (new Slug())->withSeparator('Objects can call static methods'), "\n";

try {
    echo Slug::withSeparator('no object here');
} catch (Error $e) {
    echo get_class($e), ': ', $e->getMessage(), "\n";
}

反过来没问题：普通方法可以调用静态方法，就像 withSeparator() 调用 self::make() 那样。

self 和 static：后期静态绑定

self:: 指向代码所在的类。static:: 指向运行时方法被调用的那个类。只有在继承中才能看出两者的区别，而对工厂方法来说这一点最重要：

<?php
class Model
{
    public static function createWithSelf(): Model
    {
        return new self();
    }

    public static function createWithStatic(): static
    {
        return new static();
    }

    public static function table(): string
    {
        return strtolower(static::class) . 's';
    }

    public static function tableWithSelf(): string
    {
        return strtolower(self::class) . 's';
    }
}

class Post extends Model {}
class Comment extends Model {}

echo get_class(Post::createWithSelf()), "\n";    // Model
echo get_class(Post::createWithStatic()), "\n";  // Post
echo Post::table(), ', ', Comment::table(), "\n";
echo Post::tableWithSelf(), "\n";

Post::createWithSelf() 返回的是 Model，这几乎从来不是调用者想要的。static 解析为 Post，因为调用时写的就是这个类，PHP 把这叫作后期静态绑定。在打算被继承的方法里用 static:: 和 new static()，真正指这个类本身时才用 self::。常量也是同样的规则：static::TABLE 会取到子类自己的 TABLE，而 self::TABLE 始终读取代码所在类里的那个。

继承来的静态属性是共享的

子类会共享父类的静态属性，除非它自己声明一个。这是 static 最典型的意外：两个子类往同一个数字上累加。

<?php
class Counter
{
    public static int $count = 0;

    public static function increment(): void
    {
        static::$count++;
    }
}

class Apples extends Counter {}

class Pears extends Counter
{
    public static int $count = 0;   // its own copy
}

Apples::increment();
Apples::increment();
Pears::increment();

echo 'Counter: ', Counter::$count, "\n";
echo 'Apples: ', Apples::$count, "\n";
echo 'Pears: ', Pears::$count, "\n";

Apples 没有自己的 $count，所以 Apples::$count 就是 Counter::$count，两者都打印 2。Pears 重新声明了这个属性，自己单独计数。在 trait 里声明的静态属性表现不同：每个使用该 trait 的类都会得到一份独立的副本。

函数内的静态变量

在函数体里，static 还有第二种含义：静态变量在多次调用之间保留它的值。初始值只在函数第一次运行时赋予：

<?php
function nextTicket(): string
{
    static $number = 0;
    $number++;
    return sprintf('T-%04d', $number);
}

echo nextTicket(), "\n";
echo nextTicket(), "\n";
echo nextTicket(), "\n";

// A simple cache: computed once, reused afterwards
function slowSquare(int $n): int
{
    static $cache = [];
    if (!isset($cache[$n])) {
        echo "(computing $n) ";
        $cache[$n] = $n * $n;
    }
    return $cache[$n];
}

echo slowSquare(12), "\n";
echo slowSquare(12), "\n";

第二次 slowSquare(12) 跳过了计算。和静态属性一样，这些值在每次请求结束时重置。变量作用域的整体介绍见变量页面。

什么时候不该用 static

静态方法很方便，所以也很容易被滥用。一个所有方法都在读写静态属性的类，其实就是挂着类名的全局状态：每个调用者都共享它，测试拿不到一份干净的副本，你也无法换成另一种实现。

<?php
// Static: one shared cart for the whole program
class StaticCart
{
    private static array $items = [];

    public static function add(string $item): void { self::$items[] = $item; }
    public static function items(): array { return self::$items; }
}

// Object: each cart is separate
class Cart
{
    private array $items = [];

    public function add(string $item): void { $this->items[] = $item; }
    public function items(): array { return $this->items; }
}

StaticCart::add('book');
StaticCart::add('pen');     // a "second customer" adds to the same cart
print_r(StaticCart::items());

$ada = new Cart();
$linus = new Cart();
$ada->add('book');
$linus->add('pen');
print_r($ada->items());
print_r($linus->items());

static 的合适用法：没有状态的纯辅助方法（Slug::make()）、命名构造函数（Color::fromHex()）和整个类共用的常量。如果一个方法需要的数据在两次使用之间可能不同，那它需要的是一个对象。