PHP implémente une liaison statique tardive

La liaison statique tardive fonctionne en stockant le nom de classe de "l'appel non transféré" précédent (non-forwarding call). Lors d'un appel de méthode statique, le nom de la classe est celui explicitement spécifié (généralement sur le côté gauche de l'opérateur :: lors d'un appel de méthode non statique, il s'agit de la classe à laquelle appartient l'objet) ;

Le soi-disant « appel avant » (forwarding  call) fait référence aux appels statiques effectués des manières suivantes : self::, parent::, static:: et forward_static_call(). Vous pouvez utiliser la fonction get_called_class() pour obtenir le nom de classe de la méthode appelée, et static:: indique sa portée. Limitations de

self ::

Utilisez soit self:: soit __CLASS__ pour une référence statique à la classe actuelle, selon la classe dans laquelle la méthode actuelle est défini :

Exemple :

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 ();

Résultat :

A

statique (liaison statique tardive)

tardive idée originale de liaison statique La limitation est contournée en introduisant un nouveau mot-clé représentant la classe initialement appelée par le runtime. En termes simples, ce mot-clé vous permet de faire référence à la classe B au lieu de A lors de l'appel de test() dans l'exemple ci-dessus. Il a finalement été décidé de ne pas introduire de nouveaux mots-clés, mais d'utiliser les mots-clés static déjà réservés.

Exemple :

<?phpclass A {
    public static function who() {
        echo __CLASS__;
    }    public static function test() {
        static::who(); // 后期静态绑定从这里开始
    }
}class B extends A {
    public static function who() {
        echo __CLASS__;
    }
}

B::test();?>

Résultat :

B

La différence entre static et $this

Dans un non -environnement statique, la classe appelée est la classe à laquelle appartient l'instance d'objet. Puisque $this-> essaiera d'appeler des méthodes privées dans la même portée, static:: peut donner des résultats différents. Une autre différence est que les propriétés statiques ne peuvent être appelées qu'avec static::.

Exemple : Méthode d'appel privée

<?phpclass A {
    private function foo() {
        echo "success!\n";
    }    public function test() {
        $this->foo();        static::foo();
    }
}class B extends A {
   /* foo() will be copied to B, hence its scope will still be A and
    * the call be successful */}class C extends A {
    private function foo() {
        /* original method is replaced; the scope of the new one is C */
    }
}$b = new B();$b->test();$c = new C();$c->test();   //fails

Résultat :

success!
success!
success!
Fatal error:  Call to private method C::foo() from context 'A' in /tmp/test.php on line 9

Appels renvoyés et non transférés

Publier La résolution de liaison statique se poursuit jusqu'à ce qu'un message d'appel statique entièrement résolu soit obtenu. En revanche, si un appel statique est effectué à l'aide de parent:: ou self::, les informations de l'appel seront transférées.

Exemple :

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();

Résultat :

ACC

Recommandations associées :

Explication détaillée de la liaison statique tardive de php exemples

Explication détaillée de la liaison statique php

Explication détaillée de la définition et de l'utilisation de la liaison post-statique php

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!