在PHP中，延遲靜態(tài)綁定（late static binding）通過static::關(guān)鍵字解決了self::在繼承中的局限性。當(dāng)使用self::時(shí)，它始終指向定義方法的類，而非調(diào)用或繼承它的類；而static::則在運(yùn)行時(shí)確定目標(biāo)類，從而正確引用實(shí)際調(diào)用的子類。例如，在父類中定義的方法若被子類調(diào)用，self::class返回父類名，而static::class返回子類名。 1. 使用self::適用於嚴(yán)格引用當(dāng)前類定義；2. 使用static::可支持繼承並允許子類重寫行為；3. 常見應(yīng)用場景包括工廠模式、ORM模型基類及可繼承的配置設(shè)置；4. 注意事項(xiàng)包括僅在靜態(tài)上下文中使用static::，以及在重寫方法時(shí)可能的行為差異?？傊舆t靜態(tài)綁定提升了面向?qū)ο笤O(shè)計(jì)的靈活性與可擴(kuò)展性。

In PHP, late static binding refers to the ability to reference the called class in a context of inheritance. It was introduced in PHP 5.3 to solve a limitation with self:: , which always refers to the class in which it is defined, not the one that's actually calling or extending it.

The key difference?

• self:: resolves to the class where the method is defined.
• static:: (used with late static binding) resolves to the class that was initially called at runtime.

This distinction becomes important when working with inheritance and static methods or properties.

How Late Static Binding Works

When you use static:: inside a parent class method, PHP delays figuring out which class you're referring to until the code runs. That means if a child class calls an inherited method, static:: will point to the child class, not the parent.

Here's a basic example:

 class ParentClass {
    public static function who() {
        echo static::class;
    }
}

class ChildClass extends ParentClass {}

ChildClass::who(); // Outputs: ChildClass

In this case, even though who() is defined in ParentClass , static::class correctly outputs ChildClass .

Why self:: Falls Short

Using self:: doesn't behave the same way — it's "early bound", meaning it always refers to the class that defines the method:

 class ParentClass {
    public static function who() {
        echo self::class;
    }
}

class ChildClass extends ParentClass {}

ChildClass::who(); // Outputs: ParentClass

Even though we're calling the method on ChildClass , self:: still points to ParentClass . This can lead to unexpected behavior when building reusable or extendable code.

So:

• Use self:: when you want to strictly refer to the current class definition.
• Use static:: when you want to respect inheritance and allow child classes to override behavior.

Practical Use Cases for Late Static Binding

Late static binding really shines in situations like:

• Factory patterns where child classes should return instances of themselves.
• Base model classes in ORMs that need to know the actual child class name.
• Inheritable configuration settings or constants.

Example:

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

class User extends Model {}

$user = User::create(); // $user is an instance of User, not Model

Without late static binding, this wouldn't work as intended — new static() would have to be replaced with hard-coded references in each child class.

Caveats and Things to Watch For

• Late static binding only works with static:: , not self:: or $this .
• It applies to static methods and properties, but also affects things like constants and method calls.
• If you're overriding a method in a child class, static:: might resolve differently than expected — test carefully.

A few common gotchas:

• Using get_called_class() with static:: used to be the workaround before late static binding.
• Magic methods like __callStatic() may behave differently depending on how they're implemented.

That's basically how late static binding works in PHP and why it's different from using self:: . It's a small feature that makes a big difference when designing flexible, object-oriented code that supports inheritance.

以上是PHP中的晚期靜態(tài)綁定是什麼，它與self ::有何不同？的詳細(xì)內(nèi)容。更多資訊請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！