PHP static binding and dynamic binding_PHP tutorial

除了限制访问,访问方式也决定哪个方法将被子类调用或哪个属性将被子类访问. 函数调用与函数本身的关联,以及成员访问与变量内存地址间的关系,称为绑定.

在计算机语言中有两种主要的绑定方式?静态绑定和动态绑定. 静态绑定发生于数据结构和数据结构间,程序执行之前. 静态绑定发生于编译期, 因此不能利用任何运行期的信息. 它针对函数调用与函数的主体,或变量与内存中的区块. 因为PHP是一种动态语言,它不使用静态绑定. 但是可以模拟静态绑定.

动态绑定则针对运行期产生的访问请求,只用到运行期的可用信息. 在面向对象的代码中,动态绑定意味着决定哪个方法被调用或哪个属性被访问,将基于这个类本身而不基于访问范围.

Public和protected成员的动作类似于PHP的前几个版本中函数的动作,使用动态绑定. 这意味着如果一个方法访问一个在子类中被覆写的类成员,并是一个子类的实例,子类的成员将被访问(而不是访问父类中的成员).

看图1. 这段代码输出” Hey! I am Son.” 因为当PHP调用getSalutation, 是一个Son的实例,是将Father中的salutation覆写而来. 如果salutation是public的,PHP将产生相同的结果. 覆写方法的操作很类似.在Son中,对于identify的调用绑定到那个方法.

即使在子类中访问方式被从protected削弱成public, 动态绑定仍然会发生. 按照访问方式使用的原则,增强对于类成员的访问限制是不可能的. 所以把访问方式从public改变成protected不可能进行.

动态绑定

＜?php
   class Father
   {
       protected $salutation = "Hello there!"; //问候

       public function getSalutation()
       {
           print("$this->salutation ");
           $this->identify();
       }

       protected function identify()
       {
           print("I am Father. ");
       }
   };

   class Son extends Father
   {
       protected $salutation = "Hey!";  //父类中的protected $salutation 被覆写

       protected function identify()    //父类中的protected identify() 被覆写
       {
           print("I am Son. ");
       }
   };

   $obj = new Son();
   $obj->getSalutation();  //输出Hey! I am Son.
?＞

//注: 在子类中没有覆写getSalutation(),但实际上仍然存在一getSalutation().这个类中的$salutation和identify()

//与Son子类的实例中的getSalutation()方法动态绑定,所以调用Son的实例的getSalutation()方法,

//将调用Son类中的成员salutation及identify(),而不是父类中的成员salutation及identify().

Private成员只存在于它们所在的类内部. 不像public和protected成员那样,PHP模拟静态绑定. 看例子图2 . 它输出”Hello there! I am Father.”,尽管子类覆写了salutation的值. 脚本将this->salutation和当前类Father绑定. 类似的原则应用于private方法identify().

Binding and private members

＜?php
   class Father
   {
       private $salutation = "Hello there!";

       public function getSalutation()
       {
           print("$this->salutation ");
           $this->identify();
       }

       private function identify()
       {
           print("I am Father. ");
       }
   }

class Son extends Father
{
private $salutation = "Hey!";
private function identify()
print("I am Son. ");
} }
}

$obj = new Son();

$obj->getSalutation(); //Output Hello there! I am Father.
?＞

The advantage of dynamic binding is that it allows inherited classes to change the behavior of the parent class while maintaining the interface and functions of the parent class. See example Figure 3. Due to the use of dynamic binding, the version of isAuthorized called in deleteUser It can be determined by the type of object. If it is an ordinary user, PHP calling User::isAuthorized will return FALSE. If it is an instance of AuthorizedUser, PHP calling AuthorizedUser::isAuthorized will allow deleteUser to execute smoothly.

//haohappy Note: To put it clearly in one sentence, it is object type, method, and attribute binding. When calling a method that exists in both the parent class and the subclass or accessing an attribute, it will first determine which object type the instance belongs to. , and then call the methods and attributes in the corresponding class.

Benefits of dynamic binding

＜?php

class User //User
{
protected function isAuthorized() //Is it a verified user?
return(FALSE);
}

public function getName() //Get the name

{

return($this->name);

public function deleteUser($username) //Delete user
{

if(!$this->isAuthorized())

");
               return(FALSE);
                                                                                                     //delete the user ");
} }
}

class AuthorizedUser extends User //Authentication user

{

protected function isAuthorized() //Override isAuthorized()
{
return(TRUE);
}

}

$user = new User;
$admin = new AuthorizedUser;

//not authorized
$user->deleteUser("Zeev");

//authorized

$admin->deleteUser("Zeev");
?＞

Why do private class members simulate static binding? To answer this question, you need to recall why private members are needed. When does it make sense to use them instead of protected members?

Private members are only used when you don’t want the child class to inherit the behavior of changing or specializing the parent class. This situation is rarer than you think. Generally speaking, a good object hierarchy should allow absolute Most functionality is specialized, improved, or changed by subclasses? This is one of the fundamentals of object-oriented programming. Private methods or variables are needed in certain situations, such as when you are sure that you do not want to allow subclasses to change a specific function in the parent class. part.

http://www.bkjia.com/PHPjc/486581.html

www.bkjia.com

true