Late static binding regelt welke klasse wordt gerefereerd in statische contexten binnen overerving. Het belangrijkste onderscheid: self:: verwijst naar de klasse waar de code is geschreven, terwijl static:: verwijst naar de klasse die daadwerkelijk — wat belangrijk is wanneer een onderliggende klasse een statische methode van de parent overerft.
<?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:: wordt opgelost op het moment van definitie (altijd de definiërende klasse), dus zelfs als deze via ChildClass wordt aangeroepen, maakt new self() een ParentClass aan. static:: wordt tijdens runtime opgelost naar de werkelijk aangeroepen klasse — dus new static() maakt correct een ChildClass aan.
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 wat ervoor zorgt dat overgeërfde factory methods, fluent builders en ORM-patronen het juiste subklasse-exemplaar retourneren — essentieel voor de statische-methode-gebaseerde API's waarop frameworks vertrouwen.
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 een belangrijk en vaak verkeerd begrepen PHP-concept, met name relevant voor het begrijpen hoe frameworks overerving-gebaseerde statische API's implementeren.
Het cruciale onderscheid — dat self:: gebonden is aan de klasse waar de code is geschreven terwijl static:: gebonden is aan de klasse die werkelijk tijdens runtime is aangeroepen — is belangrijk wanneer een onderliggende klasse een statische methode van de parent overerft die exemplaren aanmaakt of naar de klasse verwijst: met self:: zouden overgeërfde factory methods altijd het parent-type retourneren (een bug), terwijl static:: correct de aanroepende subklasse retourneert.
Dit is precies wat de overgeërfde factory methods, fluent builders en ORM-patronen mogelijk maakt waarop frameworks zoals Laravel's Eloquent vertrouwen (bijv. User::make() retourneert een User, niet de basis Model).
Het begrijpen van late static binding is belangrijk zowel voor het correct gebruiken van deze framework-patronen als voor het schrijven van je eigen overerving-bewuste statische methoden die goed werken met subklassen.
Hoewel een meer geavanceerd onderwerp, is het een veelvoorkomende bron van subtiele bugs en verwarring ("waarom retourneert dit de parent-klasse?"), en het begrijpen van het self::/static::/parent::-onderscheid weerspiegelt dieper inzicht in PHP's objectmodel en overerving gedrag — waardevol voor het werken met en bouwen van de statische-methode-gebaseerde, overerving-zware API's die gebruikelijk zijn in moderne PHP-frameworks.