When a static method is called using self in inheritance, it always points to the class that defines the method, rather than the actually called class, resulting in the inability to call the subclass overridden method as expected; while static uses late static binding, which can correctly parse to the actually called class at runtime. 1. Self is an early binding, pointing to the class where the code is located; 2. static is a late binding, pointing to the runtime calling class; 3. Use static to implement static factory methods and automatically return subclass instances; 4. static supports correct parsing of inherited attributes in the method chain; 5. LSB is only suitable for static methods and attributes, not for constants; 6. Static should be used first in inheritable classes to improve flexibility and scalability, which is widely recommended in modern 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 cruel.

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 refer to ParentClass::who() , regardless of the calling context.

This behavior is often not what you want when designing excessive 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 refer 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 means to be extended, static is probably the right choice.

The above is the detailed content of Static vs. Self: Unraveling Late Static Bindings in PHP. For more information, please follow other related articles on the PHP Chinese website!