In PHP, late static binding solves the limitations of self:: in inheritance through the static:: keyword. When using self::, it always points to the class that defines the method, not to call or inherit it; while static:: determines the target class at runtime, thus correctly referring to the subclass that is actually called. For example, if a method defined in the parent class is called by a subclass, self::class returns the parent class name, and static::class returns the child class name. 1. Use self:: to strictly refer to the current class definition; 2. Use static:: to support inheritance and allow subclass rewriting behavior; 3. Common application scenarios include factory pattern, ORM model base classes, and inheritable configuration settings; 4. Notes include using static:: only in static contexts, and possible behavior differences when rewriting methods. In short, delayed static binding improves the flexibility and scalability of object-oriented design.

In PHP, late static binding referers 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.

The above is the detailed content of What is late static binding in PHP, and how does it differ from self::?. For more information, please follow other related articles on the PHP Chinese website!