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

Теперь я вспомнил, почему позднее статическое связывание полезно. К сожалению, пример с 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.

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!

Это одна из основ наследования, поскольку она связана с сокрытием информации/инкапсуляция. Это позволяет вам делать такие вещи:

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.

Посетите страницу Видимость в документации по PHP, чтобы получить более подробную информацию о такие вещи.