Explication détaillée des exemples de liaisons statiques tardives de PHP

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 » (

) fait référence aux appels statiques effectués de la manière suivante : forwarding  call, self::, parent:: et static::. Vous pouvez utiliser la fonction forward_static_call() pour obtenir le nom de classe de la méthode appelée, et get_called_class() indique sa portée. Limitations de static::

self ::

Utilisez soit

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

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

déjà réservés. static

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

essaiera d'appeler des méthodes privées dans la même portée, $this-> 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::. 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

ou parent::, les informations de l'appel seront transférées. self::

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 :

Partage d'exemples de liaison statique tardive 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!