Späte statische Bindung
Beginnend mit PHP 5.3.0 unterstützt PHP späte statische Bindung ("Late static binding"). Hiermit kann die aufgerufene Klasse im Kontext statischer Vererbung referenziert werden.
Genauer gesagt funktioniert späte statische Bindung durch das Speichern der Klasse, die im letzten "nicht weiterleitenden Aufruf" angegeben wurde. Im Fall von statischen Methodenaufrufen, ist dies die explizit angegebene Klasse (üblicherweise diejenige auf der linken Seite des :: Operators); im Fall von nicht statischen Methodenaufrufen, ist es die Klasse des Objekts. Ein "weiterleitender Aufruf" ist ein statischer, der durch self::, parent::, static::, oder, in der Klassenhierarchie nach oben gehend, durch forward_static_call(), eingeleitet wurde. Die Funktion get_called_class() kann benutzt werden, um eine Zeichenkette mit dem Namen der aufgerufenen Klasse abzufragen, und static:: führt ihren Geltungsbereich ein.
Diese Funktionalität wurde in Hinblick auf die interne Perspektive als "späte statische Bindung" benannt. "Späte Bindung" bezieht sich auf die Tatsache, dass static:: nicht über die Klasse, in der die aufgerufene Methode definiert ist, aufgelöst wird, stattdessen wird diese mit Hilfe von Laufzeitinformationen bestimmt. Die Benennung als "statische Bindung" beruht darauf, dass dieser Mechanismus unter anderem für statische Methodenaufrufe genutzt werden kann.
Beschränkungen von self::
Statische Referenzen auf die aktuelle Klasse wie self:: oder __CLASS__ werden mit Hilfe der Klasse, zu der die Methode gehört, also in welcher sie definiert ist, aufgelöst.
Beispiel #1 Nutzung von self::
<?php
class A {
public static function who() {
echo __CLASS__;
}
public static function test() {
self::who();
}
}
class B extends A {
public static function who() {
echo __CLASS__;
}
}
B::test();
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
A
Nutzung später statischer Bindung
Späte statische Bindung versucht diese Beschränkung zu umgehen, indem ein neues Schlüsselwort eingeführt wird, dass die Klasse referenziert, die tatsächlich zur Laufzeit genutzt wurde, also im Wesentlichen ein Schlüsselwort, das es Ihnen gestattet im vorangegangenen Beispiel aus der aufgerufenen Methode test() die Klasse B zu referenzieren. Es wurde entschieden, kein neues Schlüsselwort einzuführen sondern statt dessen static zu verwenden, das bereits als reserviertes Schlüsselwort existierte.
Beispiel #2 Einfache Nutzung von static::
<?php
class A {
public static function who() {
echo __CLASS__;
}
public static function test() {
static::who(); // statische Bindung
}
}
class B extends A {
public static function who() {
echo __CLASS__;
}
}
B::test();
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
B
Hinweis:
In nicht statischen Kontexten ist die aufgerufene Klasse die Klasse des Objekt-Exemplars. Da $this-> versucht private Methoden im gleichen Geltungsbereich aufzurufen, kann die Verwendung von static:: andere Ergebnisse liefern. Ein weiterer Unterschied ist, dass static:: sich nur auf statische Eigenschaften beziehen kann.
Beispiel #3 Nutzung von static:: außerhalb eines statischen Kontexts
<?php
class A {
private function foo() {
echo "Erfolg!\n";
}
public function test() {
$this->foo();
static::foo();
}
}
class B extends A {
/* foo() wird nach B kopiert, weshalb ihr Geltungsbreich immer noch A ist,
* und der Aufruf wird erfolgreich sein */
}
class C extends A {
private function foo() {
/* ursprüngliche Methode wird ersetzt; der Geltungsbereich der neuen ist C */
}
}
$b = new B();
$b->test();
$c = new C();
$c->test(); //scheitert
?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Erfolg! Erfolg! Erfolg! Fatal error: Call to private method C::foo() from context 'A' in /tmp/test.php on line 9
Hinweis:
Die Auflösung später statischer Bindungen endet mit einem vollständig aufgelösten statischen Aufruf ohne Alternative. Statische Aufrufe, die Schlüsselworte wie parent:: oder self:: nutzen, geben dagegen die Aufrufinformationen weiter.
Beispiel #4 Weitergegebene und nicht weitergegebene Aufrufe
<?php
class A {
public static function foo() {
static::who();
}
public static function who() {
echo __CLASS__."\n";
}
}
class B extends A {
public static function test() {
A::foo();
parent::foo();
self::foo();
}
public static function who() {
echo __CLASS__."\n";
}
}
class C extends B {
public static function who() {
echo __CLASS__."\n";
}
}
C::test();
?>Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
A C C
Deutsche Übersetzung
Sie haben gebeten, diese Seite auf Deutsch zu besuchen. Momentan ist nur die Oberfläche übersetzt, aber noch nicht der gesamte Inhalt.Wenn Sie mir bei Übersetzungen helfen wollen, ist Ihr Beitrag willkommen. Alles, was Sie tun müssen, ist, sich auf der Website zu registrieren und mir eine Nachricht zu schicken, in der Sie gebeten werden, Sie der Gruppe der Übersetzer hinzuzufügen, die Ihnen die Möglichkeit gibt, die gewünschten Seiten zu übersetzen. Ein Link am Ende jeder übersetzten Seite zeigt an, dass Sie der Übersetzer sind und einen Link zu Ihrem Profil haben.
Vielen Dank im Voraus.
Dokument erstellt 30/01/2003, zuletzt geändert 26/10/2018
Quelle des gedruckten Dokuments:https://www.gaudry.be/de/php-rf-language.oop5.late-static-bindings.html
Die Infobro ist eine persönliche Seite, deren Inhalt in meiner alleinigen Verantwortung liegt. Der Text ist unter der CreativeCommons-Lizenz (BY-NC-SA) verfügbar. Weitere Informationen auf die Nutzungsbedingungen und dem Autor.
Referenzen
Diese Verweise und Links verweisen auf Dokumente, die während des Schreibens dieser Seite konsultiert wurden, oder die zusätzliche Informationen liefern können, aber die Autoren dieser Quellen können nicht für den Inhalt dieser Seite verantwortlich gemacht werden.
Der Autor Diese Website ist allein dafür verantwortlich, wie die verschiedenen Konzepte und Freiheiten, die mit den Nachschlagewerken gemacht werden, hier dargestellt werden. Denken Sie daran, dass Sie mehrere Quellinformationen austauschen müssen, um das Risiko von Fehlern zu reduzieren.
