Home > Article > Backend Development > 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.
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
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.
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::self
Use self:: or
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
<?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 9Note:
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:
Late Binding in PHPThink about the issue of PHP late bindingA C C
Related recommendations:
The above is the detailed content of php late binding. For more information, please follow other related articles on the PHP Chinese website!