Quels sont exactement résolution statique à la volée en PHP?

Depuis PHP 5.3.0, PHP implémente une fonctionnalité appelée late static binding qui peut être utilisé pour faire référence à la classe appelée dans le contexte de l'héritage statique.

Late static binding tente de résoudre cette limitation par l'introduction d'un mot-clé qui fait référence à la classe qui a été appelée lors de l'exécution. Il a été décidé de ne pas introduire un nouveau mot-clé, mais plutôt d'utiliser static qui était déjà réservé.

Voyons un exemple:

<?php
    class Car
    {
        public static function run()
        {
            return static::getName();
        }

        private static function getName()
        {
            return 'Car';
        }
    }

    class Toyota extends Car
    {
        public static function getName()
        {
            return 'Toyota';
        }
    }

    echo Car::run(); //Output: Car
    echo Toyota::run(); //Output: Toyota
?>

late static bindings travail en stockant le nom de la classe dans le dernier "non-renvoi d'appel". Dans le cas de la statique des appels de méthode, c'est la classe explicitement nommés (généralement l'un sur la gauche de l'opérateur::); en cas de non-statique des appels de méthode, c'est la classe de l'objet.

Un "renvoi d'appel" est statique qui est introduit par self::, parent::, static::, ou, si en remontant dans la hiérarchie de classe, forward_static_call().

La fonction get_called_class() peut être utilisé pour récupérer une chaîne de caractères avec le nom de la classe et static:: introduit son champ d'application.

Je suis en citant le livre: "PHP Maître d'écriture de pointe de code".

Late static binding est une fonctionnalité introduite avec php 5.3. Il permet
nous héritent des méthodes statiques d'une classe parent, et de faire référence à
l'enfant de la classe qui est appelée.

Cela signifie que vous pouvez avoir une classe abstraite avec des méthodes statiques, et
référence de l'enfant de la classe des implémentations concrètes à l'aide de la
statique::methode() notation au lieu de la self::methode().

N'hésitez pas à jeter un coup d'oeil à la documentation officielle de php ainsi:
http://php.net/manual/en/language.oop5.late-static-bindings.php

---

La façon la plus claire d'expliquer les Late Static Binding est avec un exemple simple. Regardez les deux définitions de classe ci-dessous, et continuez à lire.

class Vehicle {
    public static function invokeDriveByStatic() {
        return static::drive(); //Late Static Binding
    }
    public static function invokeStopBySelf() {
        return self::stop(); //NOT Late Static Binding
    }
    private static function drive(){
        return "I'm driving a vehicle";
    }
    private static function stop(){
        return "I'm stopping a vehicle";
    }
}

class Car extends Vehicle  {
    protected static function drive(){
        return "I'm driving a CAR";
    }
    private static function stop(){
        return "I'm stopping a CAR";
    }
}

Nous voyons une Classe Parent (Véhicule) et d'un Enfant de la Classe (Voiture).
La Classe Parent a 2 méthodes publiques:

• invokeDriveByStatic
• invokeStopBySelf

La Classe Parente a aussi 2 méthodes privées:

• drive
• stop

L'Enfant de la Classe remplace 2 méthodes:

• drive
• stop

Maintenant, nous allons invoquer les méthodes publiques:

• invokeDriveByStatic
• invokeStopBySelf

Demandez-vous: Qui classe appelle invokeDriveByStatic /invokeStopBySelf? Le Parent ou l'Enfant de la classe?

Prendre un coup d'oeil ci-dessous:

//This is NOT Late Static Binding
//Parent class invokes from Parent. In this case Vehicle.
echo Vehicle::invokeDriveByStatic(); //I'm driving a vehicle
echo Vehicle::invokeStopBySelf(); //I'm stopping a vehicle

//This is Late Static Binding.
//Child class invokes an inherited method from Parent.
//Child class = Car, Inherited method = invokeDriveByStatic().
//...
//The inherited method invokes a method that is overridden by the Child class.
//Overridden method = drive()
echo Car::invokeDriveByStatic(); //I'm driving a CAR

//This is NOT Late Static Binding
//Child class invokes an inherited method from Parent.
//The inherited method invokes a method inside the Vehicle context.
echo Car::invokeStopBySelf(); //I'm stopping a vehicle

---

La static mot-clé est utilisé dans un modèle de conception Singleton.
Voir le lien: https://refactoring.guru/design-patterns/singleton/php/example

Par exemple:

abstract class Builder {
    public static function build() {
        return new static;
    }
}

class Member extends Builder {
    public function who_am_i() {
         echo 'Member';
    }
}

Member::build()->who_am_i();

Aussi, regarder si vous mettez à jour les variables statiques dans les classes enfant. J'ai trouvé ceci (un peu) résultat inattendu où l'enfant B mises à jour enfant C:

class A{
    protected static $things;
}

class B extends A {
    public static function things(){
        static::$things[1] = 'Thing B';
        return static::$things; 
    }
}

class C extends A{
    public static function things(){
        static::$things[2] = 'Thing C';
        return static::$things;        
    }
}

print_r(C::things());
//Array (
//  [2] => Thing C
//)

B::things();

print_r(C::things()); 
//Array (
//   [2] => Thing C
//   [1] => Thing B
//)

Vous pouvez résoudre le problème en déclarant la même variable dans chaque enfant de la classe, par exemple:

class C extends A{
    protected static $things; //add this and B will not interfere!

    public static function things(){
        static::$things[2] = 'Thing C';
        return static::$things;        
    }
}