Позднее статическое связывание в PHP 5.3

Question

Перейди через ниже приведенный код это от PHP Manual

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

может любой объяснить, что именно здесь происходит?

Каким образом foo() будет скопирован в B?

Answer 1

foo не копируется в B как таковой (он унаследован, но невидим, см. Комментарий Гордона ниже). B наследует A->foo, который вызывает A->test. Чтобы продемонстрировать, посмотрите на то, что происходит, когда вы echo __CLASS__ изнутри test и foo (и удалить static::foo() вызов, который вызывает ошибку):

class A { 
    private function foo() { 
     echo __CLASS__."->foo\n"; 
     echo "success!\n"; 
    } 
    public function test() { 
     echo __CLASS__."->test\n"; 
     $this->foo(); 
    } 
} 

Выход:

A->test 
A->foo 
success! 
A->test 
A->foo 
success! 

Это один из основы наследования, поскольку он относится к information hiding/encapsulation. Это позволяет делать такие вещи:

class ListOfThings { 
    // internal structure (top secret!) 
    private $_list = array(); 

    // add item to list 
    public function add($item) { 
     $this->_list[] = $item; 
    } 

    // return number of items in list 
    public function count() { 
     return count($this->_list); 
    } 
} 

class ListOfStates extends ListOfThings { 

    // do we have all 50 states? 
    public function allStatesListed() { 
     return $this->count() === 50; 
    } 

    // try to access internal structure of ListOfThings 
    public function accessInternalStructure() { 
     sort($this->_list); 
    } 
} 

$states = new ListOfStates; 
$states->add('ME'); 
$states->add('NH'); 
$states->add('VT'); 
$states->add('RI'); 
$states->add('CT'); 
var_dump($states->count()); 
var_dump($states->allStatesListed()); 
$states->accessInternalStructure(); 

Выход:

int(5) 
bool(false) 

Warning: sort() expects parameter 1 to be array, null given... 

Как вы можете видеть, ListOfStates может использовать всю общественную функциональность в ListOfThings, даже если эти функции все зависят от частная переменная $_list. При этом ListOfStates не может непосредственно манипулировать $_list; он может действовать только на $_list через публичные функции, определенные в ListOfThings.

Просмотрите страницу Visibility в документации PHP для получения более подробной информации о таких вещах.

Answer 2

Я помню, почему поздняя статическая привязка полезна. К сожалению, пример php.net плохо объяснен. Смотрите этот (модифицированный) пример:

<?php 
class A { 
    private function foo() { 
     echo __CLASS__; 
    } 
    public function test() { 
     $this->foo(); 
     static::foo(); 
    } 
} 

class B extends A { 
    public function foo() 
    { 
     echo __CLASS__; 
    } 
} 

$b = new B(); 
$b->test(); 
?> 

Если запустить приведенный выше код, вы увидите, что это работает, и вы получите AB. Зачем?

• Это работает, потому что test() является публичным геттером для foo(), так что это не имеет значения, если вы звоните test() из объекта типа A или от объекта типа B, который наследуется от A, потому что test() всегда будут имеют доступ к частным членам класса, в котором он определен.
• В первом случае $this->foo(); всегда будет звонить A::foo(), потому что привязка выполняется локально, внутри области A, что иногда является нежелательным. См. Этот комментарий: http://www.php.net/manual/en/language.oop5.late-static-bindings.php#83502
• Во втором случае static::foo(); инструктирует переводчика, чтобы определить тип $b и посмотреть, в каком классе можно найти foo(). В этом случае B::foo() рассматривается как метод переопределения для A::foo(), поэтому, в принципе, если существует B::foo(), он будет вызываться, в противном случае интерпретатор будет искать A::foo().
• Постарайтесь отметить B::foo() как конфиденциальный и запустите пример, который я предоставил, чтобы узнать, что произойдет. Я думаю, что этот тест и мои фразы выше прояснят вопрос для вас;)

Кроме того, я принимаю любые комментарии к моим вышеуказанным пунктам, потому что я не использовал PHP в течение долгого времени.