Apa iku late static binding (static:: vs self::)?

Question

Accepted Answer

**Late static binding** ngontrol kelas mana sing direferensi ing konteks static ing inheritance. Pembedane kunci: **`self::`** ngreferensi kelas sing *ditulis*, dene **`static::`** ngreferensi kelas sing *ditanggil siji-sijine nalika runtime* — iki penting nalika kelas anak inherite metode static kelas induk.

## Masalahe: self:: iku "early bound"

```php
<?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::` diresolvasi nalika definisi (mesthi kelas sing ndefine), mula sanajan ditanggil liwat `ChildClass`, `new self()` nggawe `ParentClass`. **`static::`** diresolvasi ing *runtime* marang kelas sing bener-bener ditanggil — mula `new static()` bener-bener nggawe `ChildClass`.

## Kenapa kuwi penting: factory methods lan fluent APIs

```php
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 iku sing gawane inherited factory methods, fluent builders, lan ORM patterns bisa bali subclass instance sing bener-bener — penting banget kanggo static-method-based APIs sing diandelaken framework.

## Telu keywords

```text
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)
```

## Kenapa kuwi penting

Late static binding (`static::` vs `self::`) iku konsep PHP sing penting lan asring salah dimangerteni, luwih relevan kanggo paham carane framework ngleksanakake inheritance-based static APIs.

Pebedane kunci — **`self::` terikat marang kelas sing kode ditulis** dene **`static::` terikat marang kelas sing bener-bener ditanggil ing runtime** — iki penting kabeh nalika kelas anak inherite metode static kelas induk sing gawe instances utawa ngreferensi kelas: yen nganggo `self::`, inherited factory methods mesthi bakal bali tipe induk (kuwi cacat), dene **`static::` bener-bener bali subclass sing ngtanggal**.

Iki persis apa sing gawane inherited factory methods, fluent builders, lan ORM patterns sing framework kaya Laravel's Eloquent andelaken (contone `User::make()` bali `User`, dudu base `Model`).

Paham late static binding iku penting sekabehane kanggo nggunakake pola framework iki kanthi bener lan kanggo nulis metode static mu dhéwé sing aware inheritance sing tata laku bener karo subclasses.

Dene topik sing luwih maju, iku sumber umum cacat subtle lan kebingungan ("kenapa iki bali kelas induk?"), lan paham pembedane `self::`/`static::`/`parent::` nglambangake karangembakan ilmu nang luwih jero babagan PHP object model lan inheritance behavior — berharga kanggo gawe lan ngembakake static-method-based, inheritance-heavy APIs sing gampang dijumpai ing modern PHP frameworks.