Late static binding mengontrol kelas mana yang direferensikan dalam konteks statis dalam inheritance. Perbedaan kunci: self:: merujuk ke kelas di mana kode ditulis, sementara static:: merujuk ke kelas yang benar-benar — yang penting ketika kelas anak mewarisi metode statis 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:: diselesaikan pada waktu definisi (selalu kelas yang mendefinisikan), jadi bahkan ketika dipanggil melalui ChildClass, new self() membuat ParentClass. static:: diselesaikan saat runtime ke kelas yang benar-benar dipanggil — jadi new static() dengan benar membuat 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 adalah apa yang membuat inherited factory methods, fluent builders, dan pola ORM mengembalikan instance subclass yang benar — penting untuk API berbasis metode statis yang framework andalkan.
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::) adalah konsep PHP yang penting dan sering disalahpahami, terutama relevan untuk memahami bagaimana framework mengimplementasikan API statis berbasis inheritance.
Perbedaan krusial — bahwa self:: bind ke kelas di mana kode ditulis sementara static:: bind ke kelas yang benar-benar dipanggil saat runtime — penting setiap kali kelas anak mewarisi metode statis parent yang membuat instance atau mereferensikan kelas: dengan self::, inherited factory methods akan selalu mengembalikan tipe parent (bug), sementara static:: dengan benar mengembalikan subclass yang memanggil.
Ini adalah apa yang memungkinkan inherited factory methods, fluent builders, dan pola ORM yang framework seperti Laravel's Eloquent andalkan (contohnya User::make() mengembalikan User, bukan base Model).
Memahami late static binding penting baik untuk menggunakan pola framework ini dengan benar maupun untuk menulis metode statis Anda sendiri yang aware terhadap inheritance dan berperilaku tepat dengan subclass.
Meskipun topik yang lebih advanced, ini adalah sumber umum bug halus dan kebingungan ("mengapa ini mengembalikan parent class?"), dan memahami perbedaan self::/static::/parent:: mencerminkan pengetahuan yang lebih dalam tentang object model PHP dan perilaku inheritance — berharga untuk bekerja dengan dan membangun API berbasis metode statis dan inheritance-heavy yang umum dalam framework PHP modern.