當(dāng)在繼承中使用self調(diào)用靜態(tài)方法時(shí)，它始終指向定義方法的類，而非實(shí)際調(diào)用的類，導(dǎo)致無(wú)法按預(yù)期調(diào)用子類重寫(xiě)的方法；而static採(cǎi)用後期靜態(tài)綁定，能在運(yùn)行時(shí)正確解析到實(shí)際調(diào)用的類。 1. self是早期綁定，指向代碼所在類；2. static是後期綁定，指向運(yùn)行時(shí)調(diào)用類；3. 使用static可實(shí)現(xiàn)靜態(tài)工廠方法，自動(dòng)返回子類實(shí)例；4. static支持方法鏈中繼承屬性的正確解析；5. LSB僅適用於靜態(tài)方法和屬性，不適用於常量；6. 在可繼承的類中應(yīng)優(yōu)先使用static以提升靈活性和可擴(kuò)展性，該做法在現(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)綁定的詳細(xì)內(nèi)容。更多資訊請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！