Late static binding hudhibiti ni class gani inarejelewa katika muktadha wa static ndani ya urithi. Tofauti muhimu: self:: hurejelea class ambapo msimbo umeandikwa, wakati static:: hurejelea class ambayo — jambo linalo na umuhimu wakati child class inarithi static method ya parent.
<?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:: hutatuliwa wakati wa ufafanuzi (daima class inayofafanua), hivyo hata inapoitwa kupitia ChildClass, new self() huunda ParentClass. static:: hutatuliwa wakati wa runtime kwa class iliyoitwa kweli — hivyo new static() huunda ChildClass ipasavyo.
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 ndiyo inayofanya inherited factory methods, fluent builders, na ORM patterns kurudisha instance ya subclass sahihi — muhimu kwa APIs zinazotegemea static method ambazo frameworks hutegemea.
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:: dhidi ya self::) ni dhana muhimu ya PHP na inayoeleweka vibaya mara kwa mara, hasa inayohusiana na kuelewa jinsi frameworks hutekeleza static APIs zinazotegemea urithi.
Tofauti muhimu — kwamba self:: hufungamana na class ambapo msimbo umeandikwa wakati static:: hufungamana na class iliyoitwa kweli wakati wa runtime — ina umuhimu wakati wowote child class inaporithi static method ya parent inayounda instances au kurejelea class: kwa self::, inherited factory methods zingerudisha daima aina ya parent (hitilafu), wakati static:: hurudisha ipasavyo subclass inayoita.
Hii ndiyo hasa inayowezesha inherited factory methods, fluent builders, na ORM patterns ambazo frameworks kama Eloquent ya Laravel hutegemea (k.m. User::make() ikirudisha User, si Model ya msingi).
Kuelewa late static binding ni muhimu kwa kutumia patterns hizi za framework ipasavyo na kwa kuandika static methods zako zenye uelewa wa urithi zinazotenda ipasavyo na subclasses.
Ingawa ni mada ya hali ya juu zaidi, ni chanzo cha kawaida cha hitilafu na utata wa hila ("kwa nini hii inarudisha parent class?"), na kuelewa tofauti ya self::/static::/parent:: huonyesha ujuzi wa kina wa object model na tabia ya urithi ya PHP — ni muhimu kwa kufanya kazi na kujenga static APIs zinazotegemea urithi na zilizojaa urithi ambazo ni za kawaida katika frameworks za kisasa za PHP.