當(dāng)在繼承中使用self調(diào)用靜態(tài)方法時，它始終指向定義方法的類，而非實際調(diào)用的類，導(dǎo)致無法按預(yù)期調(diào)用子類重寫的方法；而static采用后期靜態(tài)綁定，能在運行時正確解析到實際調(diào)用的類。1. self是早期綁定，指向代碼所在類；2. static是后期綁定，指向運行時調(diào)用類；3. 使用static可實現(xiàn)靜態(tài)工廠方法，自動返回子類實例；4. static支持方法鏈中繼承屬性的正確解析；5. LSB僅適用于靜態(tài)方法和屬性，不適用于常量；6. 在可繼承的類中應(yīng)優(yōu)先使用static以提升靈活性和可擴展性，該做法在現(xiàn)代PHP中被廣泛推薦。

When working with inheritance in PHP, you’ve probably encountered self and wondered why sometimes it doesn’t behave the way you’d expect — especially when calling static methods from child classes. This is where Late Static Bindings (LSB) come into play, and the difference between self and static becomes crucial.

The Problem with self

self in PHP refers to the class where the method is defined, not necessarily the one that’s calling it. This means it’s early bound — resolved at compile time, not runtime.

Consider this example:

class ParentClass {
    public static function who() {
        echo "ParentClass\n";
    }

    public static function callWho() {
        self::who();
    }
}

class ChildClass extends ParentClass {
    public static function who() {
        echo "ChildClass\n";
    }
}

ChildClass::callWho(); // Outputs: "ParentClass"

Even though we’re calling callWho() on ChildClass, it outputs ParentClass. Why? Because self::who() inside ParentClass always refers to ParentClass::who(), regardless of the calling context.

This behavior is often not what you want when designing extensible class hierarchies.

Enter static: Late Static Bindings

PHP 5.3 introduced Late Static Bindings, allowing static to refer to the class that was called at runtime — not where the method is defined.

Let’s tweak the example using static instead of self:

class ParentClass {
    public static function who() {
        echo "ParentClass\n";
    }

    public static function callWho() {
        static::who(); // Note: static instead of self
    }
}

class ChildClass extends ParentClass {
    public static function who() {
        echo "ChildClass\n";
    }
}

ChildClass::callWho(); // Outputs: "ChildClass"

Now it prints ChildClass. That’s because static::who() is resolved at runtime based on the actual class used in the call — this is late binding.

? Rule of thumb:

• self → refers to the current class (where the code is written)
• static → refers to the called class (which may be a child)

Practical Use Cases for static

1. Static Factory Methods

You can create a base factory method that returns instances of the correct child class:

class Model {
    public static function create() {
        return new static(); // Returns instance of called class
    }
}

class User extends Model {
    // Inherits create(), but returns User instance
}

$user = User::create(); // Actually a User object
var_dump($user instanceof User); // true

Without static, you’d have to override create() in every child class.

2. Method Chaining with Inheritance

class QueryBuilder {
    protected static $table;

    public static function all() {
        echo "Selecting from " . static::$table . "\n";
    }
}

class User extends QueryBuilder {
    protected static $table = 'users';
}

User::all(); // Outputs: "Selecting from users"

Again, static::$table resolves to User::$table, not QueryBuilder::$table.

Caveats and Limitations

• LSB only works with static method and property calls.
• It doesn’t apply to constants (self::CONST vs static::CONST still refers to the class where it’s defined).
• Be cautious when using static in final classes — no inheritance, so self and static behave the same.
• Performance difference is negligible; prioritize clarity and correct behavior.

Summary

Use static when you want inherited methods to respect the calling class’s implementation — especially in abstract bases, factories, or fluent interfaces.

In modern PHP, favor static over self when working with static methods in inheritable classes. It makes your code more flexible and intuitive.

Basically: if you're building something meant to be extended, static is probably the right choice.

以上是靜態(tài)與自我：PHP中的晚期靜態(tài)綁定的詳細內(nèi)容。更多信息請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！