Late static binding controls which class is referenced in static contexts within inheritance. The key distinction: self:: refers to the class where the code is written, while static:: refers to the class that was actually — which matters when a child class inherits a parent's static method.
<?php
class ParentClass {
public static function create(): self {
return new self(); // self:: ALWAYS means ParentClass (where it's written)
}
public static function createStatic(): static {
return new static(); // static:: means the CALLED class (runtime)
}
}
class ChildClass extends ParentClass {}
get_class(ChildClass::create()); // "ParentClass" — self:: bound to where written ❌
get_class(ChildClass::createStatic()); // "ChildClass" — static:: bound to the call ✅
self:: is resolved at definition time (always the defining class), so even when called via ChildClass, new self() creates a ParentClass. static:: is resolved at runtime to the actually-called class — so new static() correctly creates a ChildClass.
class Model {
public static function make(): static { // static return type + new static()
return new static(); // ✅ returns an instance of whatever subclass called it
}
}
class User extends Model {}
class Post extends Model {}
User::make(); // returns a User (not a Model) — thanks to late static binding
Post::make(); // returns a Post
Late static binding is what makes inherited factory methods, fluent builders, and ORM patterns return the correct subclass instance — essential for the static-method-based APIs frameworks rely on.
self:: → the class where the code is WRITTEN (early/static binding)
static:: → the class CALLED at runtime (late static binding) — for subclass-aware code
parent:: → the parent class (for calling overridden parent methods)
Late static binding (static:: vs self::) is an important and frequently-misunderstood PHP concept, particularly relevant for understanding how frameworks implement inheritance-based static APIs.
The crucial distinction — that self:: binds to the class where the code is written while static:: binds to the class actually called at runtime — matters whenever a child class inherits a parent's static method that creates instances or references the class: with self::, inherited factory methods would always return the parent type (a bug), while static:: correctly returns the calling subclass.
This is exactly what enables the inherited factory methods, fluent builders, and ORM patterns that frameworks like Laravel's Eloquent depend on (e.g. User::make() returning a User, not the base Model).
Understanding late static binding is important both for using these framework patterns correctly and for writing your own inheritance-aware static methods that behave properly with subclasses.
While a more advanced topic, it's a common source of subtle bugs and confusion ("why is this returning the parent class?"), and understanding the self::/static::/parent:: distinction reflects deeper knowledge of PHP's object model and inheritance behavior — valuable for working with and building the static-method-based, inheritance-heavy APIs common in modern PHP frameworks.