Late Static Binding in PHP: Warum „statisch“ trotz dynamischer Bindung?

PHP’s „Late Static Binding“ (LSB) ist ein mächtiges, aber oft missverstandenes Konzept. Dieser Artikel entschlüsselt die Terminologie und zeigt anhand praktischer Beispiele, warum die Bezeichnung „statisch“ historisch bedingt ist – und wie PHP 8.5 finale Klassen dabei smarter macht.

1. Grundlagen: Was ist Late Static Binding?

LSB ermöglicht den Zugriff auf den zur Laufzeit aufgerufenen Klassekontext – nicht auf die Klasse, in der die Methode definiert wurde.

Beispiel:

class A {
    public static function getClass(): string {
        return static::class; // Späte Bindung
    }
}

class B extends A {}

echo B::getClass(); // "B" (nicht "A"!)

Hier löst static::class erst zur Laufzeit auf, während self::class immer A zurückgeben würde.

2. Terminologie: Warum „static“?

Der Name ist historisch geprägt:

„Late“ (spät): Die Bindung erfolgt zur Laufzeit, nicht beim Kompilieren.
„Static“: Bezieht sich auf das Schlüsselwort static, nicht auf statische Methoden!

Historischer Kontext:

Vor PHP 5.3 gab es nur self und parent.
Für LSB wurde das existierende static-Keyword wiederverwendet, statt neuer Schlüsselwörter wie late oder called.

3. Das Final-Class-Paradoxon

Finale Klassen werfen interessante Fragen auf:

interface Factory {
    public static function create(): static;
}

final class Product implements Factory {
    public static function create(): self { // ← self vs static
        return new self();
    }
}

Problem:

self in finalen Klassen ist identisch mit static (keine Subklassen möglich).
Vor PHP 8.5: Fehler „Return type must be […] static“ trotz logischer Äquivalenz.

PHP 8.5-Lösung:
Mit PR #17724 wird self in finalen Klassen als kompatibel mit static behandelt.

4. Praktische Anwendung von LSB

Factory-Methoden:

abstract class Model {
    public static function factory(): static {
        return new static(); // Instanz der aufrufenden Klasse
    }
}

class User extends Model {}

$user = User::factory(); // User-Instanz

Kettenvererbung:

class Logger {
    protected static string $prefix = '';

    public static function log(string $message): void {
        error_log(static::$prefix . $message);
    }
}

class AuthLogger extends Logger {
    protected static string $prefix = '[AUTH] ';
}

AuthLogger::log('Login failed'); // Loggt "[AUTH] Login failed"

5. Warum der Name verwirrt

Statische Methoden ≠ Static-Bindung:
LSB funktioniert auch für Instanzmethoden.
Semantik vs. Syntax:
Das static-Keyword hat hier nichts mit dem allgemeinen OOP-Konzept von „statisch“ zu tun.

Alternativvorschläge (hypothetisch):

class A {
    public function foo(): called { /*...*/ } // Vorschlag "called"
    public function bar(): late { /*...*/ }   // Vorschlag "late"
}

6. PHP 8.5+: Finale Klassen optimiert

Vorher:

// PHP ≤8.4
final class Config {
    public static function load(): self { /*...*/ } 
}
// Fehler bei Implementierung von Interfaces mit „static“-Return

Nachher (PHP 8.5+):

self in finalen Klassen ist implizit mit static kompatibel.
Keine redundanten PHPDoc-Annotationen mehr nötig:

  /**
   * @return static // ← Nicht mehr nötig!
   */

Fazit

Der Begriff „Late Static Binding“ ist ein historisches Artefakt, das sich tief in PHP verwurzelt hat. Trotz der verwirrenden Terminologie ermöglicht LSB mächtige Vererbungsmuster. Mit PHP 8.5 wird die Logik durch die finale Klassen-Optimierung abgerundet.

„Programmiersprachen sind wie Archäologie – manchmal muss man historische Schichten akzeptieren, um die Gegenwart zu verstehen.“

Referenzen:

Entwickler, der außergewöhnliche CRM- und Laravel-Lösungen liefert