PHP `static`关键字：静态成员与后期静态绑定

PHP `static` 关键字：静态成员与后期静态绑定，一场关于时间旅行的奇妙冒险

各位观众，各位代码爱好者，欢迎来到今天的PHP魔法课堂！🧙‍♂️ 今天我们要聊聊PHP中一个既神秘又强大的关键字——static。别听到“静态”就觉得枯燥，它可比你想的有趣多了！它就像PHP中的时间旅行者，能让你穿梭于不同的作用域，玩转类的内部结构，甚至影响继承关系！

准备好了吗？让我们一起踏上这场关于静态成员和后期静态绑定的奇妙冒险吧！

第一幕：静态成员——永恒的记忆

首先，我们来认识一下静态成员。你可以把它们想象成类的“集体记忆”。它们不属于类的任何特定实例，而是属于类本身。也就是说，无论你创建多少个类的对象，静态成员都只有一个副本，被所有对象共享。

就像你的银行账户，无论你开多少张银行卡，你的余额始终只有一个。

静态属性（Static Properties）：共享的秘密

静态属性就是类的静态变量，声明时使用 static 关键字。

class MyClass {
    public static $count = 0; // 静态属性，初始值为0

    public function __construct() {
        self::$count++; // 每次创建对象，静态属性 $count 加 1
    }

    public static function getCount() {
        return self::$count; // 静态方法访问静态属性
    }
}

$obj1 = new MyClass();
$obj2 = new MyClass();
$obj3 = new MyClass();

echo MyClass::getCount(); // 输出：3，所有对象共享同一个 $count

在这个例子中，$count 是一个静态属性，它记录了 MyClass 被实例化的次数。注意，我们使用 self::$count 来访问静态属性。self 就像一个指向当前类的指针，它告诉PHP：“嘿，我要访问的是这个类本身拥有的属性，而不是某个对象的属性！”

表格：静态属性与普通属性的对比

特性	静态属性 (`static $property`)	普通属性 (`$property`)
所有权	类本身	类的实例（对象）
存储位置	类的静态存储区	对象的内存空间
访问方式	`ClassName::$property` 或 `self::$property`	`$object->property`
共享性	所有对象共享	每个对象拥有自己的副本
生命周期	脚本开始到结束	对象创建到销毁

静态方法（Static Methods）：类的工具箱

静态方法是类的静态函数，也使用 static 关键字声明。它们不需要通过对象来调用，可以直接通过类名来调用。

class MathHelper {
    public static function add($a, $b) {
        return $a + $b;
    }
}

echo MathHelper::add(5, 3); // 输出：8，直接通过类名调用

静态方法就像类的工具箱，里面装满了各种可以直接使用的工具。它们通常用于执行与类相关的通用任务，而不需要访问任何对象特定的数据。

注意事项：静态方法中不能访问非静态成员

就像你不能用一把锤子修电脑一样，静态方法也不能访问非静态成员。因为静态方法不属于任何对象，所以它不知道要访问哪个对象的非静态属性。

class Example {
    public $name = "Alice";

    public static function greet() {
        // echo "Hello, " . $this->name; // 错误！不能在静态方法中使用 $this 访问非静态属性
        echo "Hello!"; // 正确
    }
}

Example::greet(); // 输出：Hello!

总结：静态成员的优点

资源共享： 静态成员可以被所有对象共享，节省内存空间。
全局访问： 静态成员可以通过类名直接访问，方便快捷。
封装性： 静态成员可以被声明为 private 或 protected，实现更好的封装。

第二幕：后期静态绑定——时间旅行的奥秘

现在，我们要进入更高级的领域——后期静态绑定（Late Static Binding，简称LSB）。这可是一个稍微有点烧脑的概念，但只要你掌握了它，就能在PHP的世界里自由穿梭！

后期静态绑定指的是在运行时确定静态调用的上下文。简单来说，就是当你使用 static:: 关键字来访问静态成员时，PHP会在运行时确定 static 指向的是哪个类。

static::、self:: 和 parent:: 的区别

self::： 始终指向定义该方法的类。就像一个固执的老顽固，无论你跑到哪里，它都只认自己的家。
parent::： 指向父类。顾名思义，它永远指向你的长辈。
static::： 指向运行时调用该方法的类。就像一个灵活的间谍，伪装成任何调用它的类。

举个例子：

class A {
    public static function who() {
        echo "An";
    }

    public static function test() {
        self::who();   // 始终指向 A::who()
        static::who(); // 指向运行时调用 test() 的类
    }
}

class B extends A {
    public static function who() {
        echo "Bn";
    }
}

B::test(); // 输出：A B

在这个例子中，B::test() 调用了 A::test()。在 A::test() 中，self::who() 始终调用 A::who()，而 static::who() 则会调用运行时调用 test() 的类，也就是 B 类中的 who() 方法。

表格：self::、parent:: 和 static:: 的对比

关键字	指向的类	作用
`self::`	定义该方法的类	访问当前类（定义类）的静态成员
`parent::`	父类	访问父类的静态成员
`static::`	运行时调用该方法的类	访问运行时调用类的静态成员，实现多态

后期静态绑定的应用场景：

实现多态： 通过 static:: 关键字，可以在继承关系中实现多态，让子类拥有自己的静态行为。
工厂模式： 后期静态绑定可以简化工厂模式的实现，让子类可以决定创建哪个类的实例。
链式调用： 后期静态绑定可以用于实现链式调用，让代码更加简洁易读。

一个更复杂的例子：工厂模式

abstract class Factory {
    protected static $type;

    public static function create() {
        return new static::$type(); // 使用后期静态绑定创建对象
    }
}

class ProductA {
    public function __construct() {
        echo "Product A created!n";
    }
}

class ProductB {
    public function __construct() {
        echo "Product B created!n";
    }
}

class FactoryA extends Factory {
    protected static $type = ProductA::class;
}

class FactoryB extends Factory {
    protected static $type = ProductB::class;
}

$productA = FactoryA::create(); // 输出：Product A created!
$productB = FactoryB::create(); // 输出：Product B created!

在这个例子中，Factory 类是一个抽象工厂，它使用 static::$type 来决定创建哪个类的实例。FactoryA 和 FactoryB 分别继承自 Factory 类，并定义了自己的 $type 属性。通过后期静态绑定，我们可以轻松地创建不同类型的对象，而无需修改 Factory 类的代码。

第三幕：静态成员与后期静态绑定的最佳实践

掌握了静态成员和后期静态绑定，我们就可以更加灵活地使用PHP了。但是，就像任何强大的工具一样，它们也需要谨慎使用。

使用静态成员的注意事项：

避免过度使用： 静态成员虽然方便，但过度使用会导致代码耦合度过高，难以维护。
注意并发问题： 在多线程或并发环境下，静态成员可能会引发竞争条件，需要进行适当的同步处理。
谨慎使用单例模式： 单例模式是一种常用的设计模式，它使用静态成员来保证只有一个实例。但是，单例模式可能会隐藏依赖关系，增加测试难度。

使用后期静态绑定的建议：

理解其原理： 只有真正理解了后期静态绑定的原理，才能正确地使用它。
避免滥用： 后期静态绑定虽然强大，但过度使用会使代码难以理解。
注意性能： 后期静态绑定在运行时确定调用上下文，可能会带来一定的性能开销。

总结：

static 关键字是PHP中一个非常重要的特性，它允许我们创建静态成员，实现资源共享和全局访问。后期静态绑定则更进一步，它允许我们在继承关系中实现多态，让子类拥有自己的静态行为。

掌握了静态成员和后期静态绑定，你就掌握了PHP中的时间旅行能力，可以更加灵活地设计和实现你的应用程序。

希望今天的课程对你有所帮助！下次再见！👋