self::指向定义时的类，static::指向运行时调用类。例如Base类中test()方法用self::who()始终调用Base的who()，而static::who()在Child类调用时会调用Child的who()，实现静态多态性。
self::和
static::在 PHP 中最核心的区别在于它们引用的“当前类”的定义：
self::总是指向定义当前方法或属性的那个类，而
static::则指向运行时实际调用方法的那个类。这个差异正是 PHP “后期静态绑定”（Late Static Binding）机制的关键，它赋予了静态方法和属性在继承体系中更强的多态性。
解决方案
要理解
self::和
static::的差异，我们需要深入到 PHP 的继承和静态调用的机制中。当我们在一个类中使用
self::引用静态成员（方法或属性）时，这个引用是“硬编码”的，它在编译时就已经确定了，指向的就是
self::所在代码块所属的那个类。它不会因为子类继承并调用了这个方法而改变。
而
static::则不同，它引入了“后期静态绑定”的概念。这意味着
static::的引用是在运行时动态解析的，它会指向最开始发起调用的那个类。如果一个子类继承了父类的一个方法，并且这个方法内部使用了
static::，那么当子类调用这个方法时，
static::就会指向子类本身，而不是父类。
我们来看一个经典的例子，这能最直观地展现它们的行为差异：
立即学习“PHP免费学习笔记（深入）”；
class Base {
public static function who() {
echo __CLASS__; // __CLASS__ 总是返回当前代码所在的类名
}
public static function test() {
echo "self::who() output: ";
self::who(); // 总是调用 Base::who()
echo "\n";
echo "static::who() output: ";
static::who(); // 调用运行时实际发起调用的类的 who() 方法
echo "\n";
}
}
class Child extends Base {
public static function who() {
echo __CLASS__; // 覆盖了父类的 who() 方法
}
}
echo "--- Calling from BaseClass ---\n";
Base::test();
// 预期输出：
// self::who() output: Base
// static::who() output: Base
echo "\n--- Calling from ChildClass ---\n";
Child::test();
// 预期输出：
// self::who() output: Base
// static::who() output: Child从上面的输出你可以清楚地看到：
- 当
Base::test()
被调用时，self::who()
和static::who()
都指向Base
类，因为Base
是原始调用者，且self::
所在的test
方法就在Base
中定义。 - 当
Child::test()
被调用时，self::who()
依然指向Base
类，因为test
方法是在Base
类中定义的，self::
牢牢绑定在那里。但static::who()
则指向了Child
类，因为它追踪到了最初发起调用的类是Child
，并且Child
覆盖了who()
方法。这就是后期静态绑定的魔力。
为什么PHP需要后期静态绑定（Late Static Binding）？
在 PHP 5.3 之前，我们只有
self::这样的引用方式。这在处理继承链中的静态方法时，常常会遇到一个令人头疼的问题，即所谓的“静态方法多态性缺失”。简单来说，如果父类有一个静态方法
A，它内部又调用了另一个静态方法
B（使用
self::B()），而子类覆盖了
B方法。那么当子类调用
A方法时，期望的是调用子类覆盖后的
B方法，但实际上，
self::B()仍然会调用父类的
B方法。这显然违背了面向对象的多态原则，让静态方法在继承体系中显得非常僵硬。
举个例子，假设我们有一个基类
Logger，它有一个
log()方法，内部调用
self::getPrefix()来获取日志前缀。
class OldLogger {
protected static function getPrefix() {
return "LOG: ";
}
public static function log($message) {
echo self::getPrefix() . $message . "\n";
}
}
class ErrorLogger extends OldLogger {
protected static function getPrefix() {
return "ERROR: "; // 期望这个前缀被使用
}
}
echo "OldLogger::log('Message');\n";
OldLogger::log('Message'); // 输出: LOG: Message
echo "ErrorLogger::log('Error Message');\n";
ErrorLogger::log('Error Message'); // 输出: LOG: Error Message (问题所在！)你看，
ErrorLogger::log()竟然输出了 "LOG: Error Message"，而不是我们期望的 "ERROR: Error Message"。这就是
self::的局限性，它使得
getPrefix()的调用始终绑定在
OldLogger类上，无法实现子类对静态方法的“多态”覆盖。
为了解决这个问题，PHP 5.3 引入了后期静态绑定，并提供了
static::关键字。有了
static::，上面的
log方法就可以这样写：
class NewLogger {
protected static function getPrefix() {
return "LOG: ";
}
public static function log($message) {
echo static::getPrefix() . $message . "\n"; // 使用 static::
}
}
class NewErrorLogger extends NewLogger {
protected static function getPrefix() {
return "ERROR: ";
}
}
echo "NewLogger::log('Message');\n";
NewLogger::log('Message'); // 输出: LOG: Message
echo "NewErrorLogger::log('Error Message');\n";
NewErrorLogger::log('Error Message'); // 输出: ERROR: Error Message (这正是我们想要的！)通过
static::，
log()方法现在能够正确地识别出
NewErrorLogger是原始调用者，并调用
NewErrorLogger中覆盖的
getPrefix()方法，从而实现了静态方法的多态性，让继承体系中的代码更加灵活和符合直觉。
在实际项目中，何时优先使用 self::
，何时使用 static::
？
在日常开发中，选择
self::还是
static::并非随意，它取决于你想要实现的行为以及对代码未来可扩展性的考量。我个人在实践中，通常会根据以下原则进行权衡：
优先使用 self::
的场景：
-
明确指向当前定义类： 当你无论如何都希望引用到当前方法定义所在的那个类的成员时，
self::
是最明确的选择。它就像一个硬锚点，确保无论哪个子类调用，它都指向同一个地方。 -
访问常量： 在 PHP 8.2 之前，类常量并不受后期静态绑定影响，
self::CONSTANT_NAME
是访问常量的标准方式。即便在 PHP 8.2 之后static::CONSTANT_NAME
也支持 LSB，但如果你希望常量引用是固定不变的，不随子类调用而改变，那么self::
仍然是更安全、更明确的选择。 -
调用父类特定实现： 如果你在一个子类中，需要明确调用父类中某个静态方法的原始实现，而不是子类可能覆盖的版本，那么
parent::method()
是首选，但如果是在父类内部，需要调用同级方法且不希望被子类影响，self::
也可以达到类似效果。
优先使用 static::
的场景：
实现静态多态性： 这是
static::
最主要的设计目的。当你希望子类能够覆盖父类的静态方法或属性，并且通过父类的方法调用时，能动态地解析到子类的实现，那么static::
是不可或缺的。-
工厂方法（Factory Methods）：
return new static();
是一个非常强大的模式。它允许你在一个父类中定义一个静态的工厂方法，该方法能够创建并返回实际调用这个工厂方法的那个类的实例。这在构建可扩展的类库时非常有用。class Car { public static function create() { return new static(); // 返回 Car 或其子类的实例 } } class Sedan extends Car {} class SUV extends Car {} $sedan = Sedan::create(); // $sedan 是 Sedan 的实例 $suv = SUV::create(); // $suv 是 SUV 的实例 -
动态配置或状态管理： 当你希望静态属性（例如配置项、状态标志）能够在继承链中被子类“覆盖”时，使用
static::$property
可以确保你总是访问到最具体（即调用者）的类定义的那个属性值。class Settings { protected static $theme = 'default'; public static function getTheme() { return static::$theme; // 允许子类覆盖 } } class AdminSettings extends Settings { protected static $theme = 'admin'; } echo Settings::getTheme() . "\n"; // default
