Kasno statičko povezivanje kontrolira koju klasu referencira statički kontekst u nasljeđivanju. Ključna razlika: self:: se odnosi na klasu gdje je kod napisan, dok se static:: odnosi na klasu koja je zapravo — što je važno kada podklasa nasljeđuje statičku metodu roditeljske klase.
<?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:: se razriješi pri definiranju (uvijek je to definirajuća klasa), tako da čak i kada se poziva preko ChildClass, new self() kreira ParentClass. static:: se razriješi tijekom izvršavanja na stvarno pozvanoj klasi — pa new static() ispravno kreira 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
Kasno statičko povezivanje omogućava naslijeđenim factory metodama, fluent builderima i ORM obrascima da vrate ispravnu instancu podklase — bitno za statičke API-je na kojima se frameworki oslanjaju.
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)
Kasno statičko povezivanje (static:: vs `self::``) je važan i često pogrešno shvaćen PHP koncept, posebno relevantan za razumijevanje kako frameworki primjenjuju nasljeđivanja baziranim statičkim API-jima.
Krucijalna razlika — da se self:: veže na klasu gdje je kod napisan dok se static:: veže na klasu koja je stvarno pozvana tijekom izvršavanja — postaje važna kad god podklasa nasljeđuje statičku metodu roditeljske klase koja kreira instance ili referencira klasu: sa self::, naslijeđene factory metode bi uvijek vratile tip roditelja (greška), dok static:: ispravno vraća pozivajuću podklasu.
Ovo je upravo ono što omogućava naslijeđenim factory metodama, fluent builderima i ORM obrascima na kojima se frameworki poput Laravel-ovog Eloquenta oslanjaju (npr. User::make() vraća User, ne baznu Model).
Razumijevanje kasnoga statičkog povezivanja je važno kako za ispravnu upotrebu ovih framework obrazaca tako i za pisanje vlastitih statičkih metoda svjesnih nasljeđivanja koje se pravilno ponašaju sa podklasama.
Mada je naprednija tema, čest je izvor suptilnih greški i zbunjenosti ("zašto ovo vraća roditeljsku klasu?"), a razumijevanje razlike između self::/static::/parent:: odražava dublje znanje o PHP-ovom objektnom modelu i ponašanju nasljeđivanja — dragocjeno za rad sa i izgradnju statičkih API-ja baziranih na nasljeđivanju koji su česti u modernim PHP frameworkima.