PHP的后期静态绑定static

自 PHP 5.3.0 起，PHP 增加了一个叫做后期静态绑定的功能，用于在继承范围内引用静态调用的类。准确说，后期静态绑定工作原理是存储了在上一个“非转发调用”（non-forwarding call）的类名。

当进行静态方法调用时，该类名即为明确指定的那个（通常在 :: 运算符左侧部分）；当进行非静态方法调用时，即为该对象所属的类。

所谓的“转发调用”（forwarding call）指的是通过以下几种方式进行的静态调用：self::，parent::，static:: 以及 forward_static_call()。可用 get_called_class() 函数来得到被调用的方法所在的类名，static:: 则指出了其范围。该功能从语言内部角度考虑被命名为“后期静态绑定”。

“后期绑定”的意思是说，static:: 不再被解析为定义当前方法所在的类，而是在实际运行时计算的。也可以称之为“静态绑定”，因为它可以用于（但不限于）静态方法的调用。

上面是PHP文档里对后期静态绑定的解释里面有几个重点：
1，后期静态绑定原理是存储了在上一个”非转发调用”的类名。
2，转发调用是通过self::，parent::，static:: 以及 forward_static_call()实现的
3，static::不再被解析为方法的当前类，而是通过实际运算计算出来的。
4，当进行静态方法调用时，该类名即为明确指定的那个如（C::getName）类名就是C
5，；当进行非静态方法调用时，即为该对象所属的类如($this->getName)类这时候指的应该是$this所属的实例化对象。

转发调用 :

指的是通过以下几种方式进行的静态调用：self::，parent::，static:: 以及 forward_static_call()。
非转发调用：

明确指定类名的静态调用（例如A::test()）
非静态调用（例如$A->test()）

场景一：

class 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
分析：B::test时A类的test方法会通过 static::who 进修转发调用，这时候static::指向的是B类而不是A类

场景二

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();
输出：
success!
success!
$c = new C();
$c->test();   //fails
输出：
success!


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

总结：在非静态环境下，所调用的类即为该对象实例所属的类。由于 $this-> 会在同一作用范围内尝试调用私有方法（即A类中的foo方法），而 static:: 则可能给出不同结果会转发调用（这时候会调用到C中的foo方法，由于它是私有的于是报错）。另一个区别是 static:: 只能用于静态属性。

场景三：

class 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();//A C C

总结：后期静态绑定的解析会一直到取得一个完全解析了的静态调用为止。另一方面，如果静态调用使用 parent:: 或者 self:: 将转发调用信息，如上面场景三，他最终实际上转发给了C这个类。static关键字最终先会转发到他第一个调用的类（如这里的C），然后再一层层的往上找，假如这时候把C中的who方法注释，这时候结果就会变成（ABB）。

获取实例化对象的使用self和static的对比

<?php
class Base
{
    private static $instance;
    public $name;

    public static function getInstance()
    {
        $class = get_called_class(); //动态获取调用类
        if (!isset(self::$instance[$class]))
        {
            self::$instance[$class] = new self(); //获取的当前类即base类
        }
        return self::$instance[$class];
    }

}

class A extends Base
{
    public function who()
    {
        return __class__;
    }
}
class B extends Base
{
    public function who()
    {
        return __class__;
    }
}

var_dump(A::getInstance()); //
// D:\www\my_project\test\a.php:34:
// object(Base)[1]
//   public 'name' => null
var_dump(B::getInstance());
// D:\www\my_project\test\a.php:34:
// object(Base)[1]
//   public 'name' => null

<?php
class Base
{
    private static $instance;
    public $name;

    public static function getInstance()
    {
        $class = get_called_class(); //动态获取调用类
        if (!isset(self::$instance[$class]))
        {
            self::$instance[$class] = new static();
 //由于转发调用所以会通过实际的调用计算来获取当前的对象
        }
        return self::$instance[$class];
    }

}

class A extends Base
{
    public function who()
    {
        return __class__;
    }
}
class B extends Base
{
    public function who()
    {
        return __class__;
    }
}

//


var_dump(A::getInstance()); //
// D:\www\my_project\test\a.php:34:
// object(A)[1]
//   public 'name' => null
var_dump(B::getInstance());
// D:\www\my_project\test\a.php:38:
// object(B)[2]
//   public 'name' => null

上面可以发现当我们使用self的时候永远获取的都是Base这个类，而使用static的时候就可以动态的获取调用对象了。