Was ist Late Static Binding (static:: vs self::)?

Question

Accepted Answer

**Late Static Binding** steuert, auf welche Klasse in statischen Kontexten innerhalb von Vererbung verwiesen wird. Der Schlüsselunterschied: **`self::`** verweist auf die Klasse, in der der Code *geschrieben* ist, während **`static::`** auf die Klasse verweist, die tatsächlich *zur Laufzeit aufgerufen* wurde — was relevant ist, wenn eine Kindklasse eine statische Methode der Elternklasse erbt.

## Das Problem: self:: ist "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::` wird zur Definitionszeit aufgelöst (immer die definierende Klasse), sodass auch bei Aufruf über `ChildClass` `new self()` eine `ParentClass` erstellt. **`static::`** wird zur *Laufzeit* auf die tatsächlich aufgerufene Klasse aufgelöst — daher erstellt `new static()` korrekt eine `ChildClass`.

## Warum es wichtig ist: Factory-Methoden und 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 ermöglicht es vererbten Factory-Methoden, Fluent Buildern und ORM-Mustern, die *richtige Subklassen*-Instanz zurückzugeben — essentiell für die statischen-Methoden-basierten APIs, auf die Frameworks angewiesen sind.

## Die drei Schlüsselwörter

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

## Warum es wichtig ist

Late Static Binding (`static::` vs `self::`) ist ein wichtiges und häufig missverstandenes PHP-Konzept, besonders relevant zum Verständnis, wie Frameworks vererbungsbasierte statische APIs implementieren.

Der entscheidende Unterschied — dass **`self::` an die Klasse gebunden ist, in der der Code geschrieben ist** während **`static::` an die zur Laufzeit tatsächlich aufgerufene Klasse gebunden ist** — ist relevant, wenn eine Kindklasse eine statische Methode der Elternklasse erbt, die Instanzen erstellt oder die Klasse referenziert: Mit `self::` würden vererbte Factory-Methoden immer den Elterntyp zurückgeben (ein Bug), während **`static::` korrekt die aufgerufene Subklasse zurückgibt**.

Dies ermöglicht genau die vererbten Factory-Methoden, Fluent Builder und ORM-Muster, auf die Frameworks wie Laravels Eloquent angewiesen sind (z.B. `User::make()` gibt einen `User` zurück, nicht das Basis-`Model`).

Late Static Binding zu verstehen ist wichtig sowohl für die korrekte Nutzung dieser Framework-Muster als auch für das Schreiben eigener vererbungsbewusster statischer Methoden, die sich mit Subklassen richtig verhalten.

Obwohl ein fortgeschrittenes Thema, ist es eine häufige Quelle subtiler Bugs und Verwirrung ("warum gibt das die Elternklasse zurück?"), und das Verständnis der `self::`/`static::`/`parent::`-Unterscheidung zeigt tiefere Kenntnisse des PHP-Objektmodells und des Vererbungsverhaltens — wertvoll für die Arbeit mit und das Erstellen der statischen-Methoden-basierten, vererbungsheavy APIs, die in modernen PHP-Frameworks verbreitet sind.