Late static binding azt szabályozza, hogy mely osztályra hivatkozunk statikus kontextusban az öröklés során. A kulcsfontosságú különbség: self:: az osztályra hivatkozik, ahol a kód meg van írva, míg static:: arra az osztályra hivatkozik, amely valójában — ami akkor lényeges, amikor egy gyermekosztály öröklödi egy szülőosztály statikus metódusát.
<?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 ✅
A self:: a definíció időpontjában (mindig az azt definiáló osztály) kerül feloldásra, ezért még akkor is, ha a ChildClass útján hívják meg, a new self() egy ParentClass objektumot hoz létre. A static:: futás időben oldódik fel az valóban meghívott osztályra — tehát a new static() helyesen egy ChildClass objektumot hoz létre.
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
A late static binding az, ami lehetővé teszi az öröklött factory metódusok, fluent builder-ek és ORM minták számára, hogy a helyes alcsalád objektumot adják vissza — ez alapvető a statikus metódus alapú API-k számára, amelyekre a keretrendszerek támaszkodnak.
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)
A late static binding (static:: vs self::) egy fontos és gyakran félreértett PHP koncepció, különösen akkor lényeges az öröklés alapú statikus API-k megértéséhez a keretrendszerek implementációjában.
A döntő különbség — hogy a self:: az osztályhoz kötődik, ahol a kód meg van írva, míg a static:: a futás időben valóban meghívott osztályhoz kötődik — az akkor számít, amikor egy gyermekosztály öröklödi a szülőosztály statikus metódusát, amely objektumokat hoz létre vagy az osztályra hivatkozik: self:: esetén az öröklött factory metódusok mindig szülőtípust adnának vissza (ez egy hiba), míg static:: helyesen a meghívott alcsaládot adja vissza.
Ez pontosan az, ami lehetővé teszi az öröklött factory metódusok, fluent builder-ek és ORM mintákat, amelyekre olyan keretrendszerek támaszkodnak, mint a Laravel Eloquent (pl. User::make() User objektumot ad vissza, nem az alap Model osztályt).
A late static binding megértése fontos mind azért, hogy ezeket a keretrendszer mintákat helyesen használjuk, mind pedig azért, hogy saját öröklés-kompatibilis statikus metódusokat írjunk, amelyek megfelelően működnek az alcsaládokkal. Bár egy haladóbb téma, gyakori forrása a finom hibáknak és zavaroknak ("miért adja ez vissza a szülőosztályt?"), és a self::/static::/parent:: közötti különbség megértése mélyebb tudást tükröz a PHP objektummodelljéről és öröklés viselkedéséről — értékes a modern PHP keretrendszerekben elterjedt statikus metódus alapú, öröklés-intenzív API-kkal való munkavégzéshez.