php late binding

The content of this article is PHP late binding. Now I share it with everyone. Friends in need can also refer to this article.

php late static Binding

Since PHP 5.3.0, PHP has added a feature called late static binding, which is used to reference statically called classes in the inheritance scope.

To be precise, the working principle of late static binding is to store the data in the previous "non-forwarding call" (non-forwarding

call) class name. When making a static method call, the class name is the one explicitly specified (usually in ::

operator); when making a non-static method call, it is the class to which the object belongs. The so-called "forwarding call" (forwarding
call) refers to static calls through the following methods: self::, parent::, static:: and
forward_static_call(). You can use the get_called_class() function to get the class name of the called method, static::
points out its scope.

This feature is named "late static binding" from a language internal perspective. "Late binding" means, static::

is no longer parsed into the class in which the current method is defined, but is calculated during actual runtime. It can also be called "static binding" because it can be used for (but is not limited to) calls to static methods.

self

Use self:: or

CLASS

for a static reference to the current class, depending on where the current method is defined Class: Example #1 self:: Usage

<?phpclass 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(); //输出A?>

staticUsage of late static binding

Late static binding originally wanted to be expressed by introducing a new keyword The class that is initially called by the runtime to bypass the restriction. Simply put, this keyword allows you to refer to class B instead of A when calling test() in the above example. It was finally decided not to introduce new keywords, but to use the already reserved static keyword.

<?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();  //输出B?>

Note:

In a non-static environment, the class called is the class to which the object instance belongs. Since $this-> will try to call the private method in the same scope, and static::

may give different results. Another difference is that static:: can only be used with static properties.

Use static::

<?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?>

in a non-static environment. The above routine will output:

success! success! success!

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

Note:

The resolution of late static binding will continue until a fully resolved static call is obtained. On the other hand, if called statically using parent:: or self:: the calling information will be forwarded.

Forwarding and non-forwarding calls

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

The above routine will output:

A C C

Related recommendations:

Late Binding in PHP

Think about the issue of PHP late binding

The above is the detailed content of php late binding. For more information, please follow other related articles on the PHP Chinese website!