看到php裡面有關於後期靜態繫結的內容，雖然沒有完全看懂，但是也收穫不少東西。

不存在繼承的時候

不存在繼承的意思就是，就書寫一個單獨的類來使用的時候。self和static在範圍解析操作符 （::） 的使用上，並無區別。

• 在靜態函式中，self和static可以呼叫靜態屬性和靜態函式（沒有例項化類，因此不能呼叫非靜態的屬性和函式）。
• 在非靜態函式中，self和static可以呼叫靜態屬性和靜態函式以及非靜態函式

此時，self和static的表現是一樣的，可以替換為該類名::的方式呼叫。

<?php
class Demo{
    public static $static
 
;
    public $Nostatic; 
    public function __construct(){
        self::$static = "static";
        $this->Nostatic = "Nostatic";
    }
    public static function get(){
        return __CLASS__;
    }
    public function show(){
        return "this is function show with ".$this->Nostatic;
    }
    public
 
 function test(){
        echo Demo::$static."<br/>";  //使用類名呼叫靜態屬性
        echo Demo::get()."<br/>";  //使用類名呼叫靜態屬性
        echo Demo::show()."<br/>";  //使用類名呼叫靜態屬性
        echo self::$static."<br/>";  //self呼叫靜態屬性
        echo self::show()."<br/>";  //self呼叫非靜態方法
        echo self::get()."<br/>"
 
;   //self呼叫靜態方法
        echo static::$static."<br/>";//static呼叫靜態屬性
        echo static::show()."<br/>";//static呼叫非靜態方法
        echo static::get()."<br/>"; //static呼叫靜態方法
    }
}
$obj = new Demo();
$obj->test();

輸出結果：

static
Demo
this is function show with Nostatic
static
this is function show with Nostatic
Demo
static
this is function show with Nostatic
Demo

繼承的時候

在繼承時，self和static在範圍解析操作符 （::） 的使用上有差別。parent也是在繼承的時候使用的。

<?php
class A{
    static function getClassName(){
        return "this is class A";
    }
    static function testSelf(){
        echo self::getClassName();
    }
    static function testStatic(){
        echo static::getClassName();
    }
}
class B extends A{
    static function getClassName(){
        return "this is class B";
    }
}
B::testSelf();
echo "<br/>";
B::testStatic();

輸出結果：

this is class A
this is class B

self呼叫的靜態方法或屬性始終表示其在使用的時候的當前類（A）的方法或屬性，可以替換為其類名，但是在類名很長或者有可能變化的情況下，使用self::的方式無疑是更好的選擇。
static呼叫的靜態方法或屬性會在繼承中被其子類重寫覆蓋，應該替換為對應的子類名（B）。

parent關鍵字用於呼叫父類的方法和屬性。在靜態方法中，可以呼叫父類的靜態方法和屬性；在非靜態方法中，可以呼叫父類的方法和屬性。

<?php
class A{
    public static $static;
    public $Nostatic; 
    public function __construct(){
        self::$static = "static";
        $this->Nostatic = "Nostatic";
    }
    public static function staticFun(){
        return self::$static;
    }
    public function noStaticFun(){
        return "this is function show with ".$this->Nostatic;
    }
}
class B extends A{
    static function testS(){
        echo parent::staticFun();
    }
    function testNoS(){
        echo parent::noStaticFun();
    }
}
$obj = new B();
$obj->testS();
echo "<br/>";
$obj->testNoS();

輸出結果

static
this is function show with Nostatic

在文章的最後，我們分析一個手冊上的例子

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

我們單獨拿出test方法進行分析：

public static function test() {
        A::foo();
        parent::foo();
        self::foo();
    }

1）A::foo();這個語句是可以在任何地方執行的，它表示使用A去呼叫靜態方法foo()得到’A’。
2）parent::foo();C的parent是B，B的parent是A，回溯找到了A的foo方法；static::who();語句中的static::呼叫的方法會被子類覆蓋，所以優先呼叫C的who()方法，如果C的who方法不存在會呼叫B的who方法，如果B的who方法不存在會呼叫A的who方法。所以，輸出結果是’C’。[注1]
3）self::foo();這個self::是在B中使用的，所以self::等價於B::，但是B沒有實現foo方法，B又繼承自A，所以我們實際上呼叫了A::foo()這個方法。foo方法使用了static::who()語句，導致我們又呼叫了C的who函式。[注2]

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

<?php
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 foo() {
        echo "fooB"."\n";
    }
    public static function who() {
        echo __CLASS__."\n";
    }
}
class C extends B {
    public static function foo() {
        echo "fooC"."\n";
    }
    public static function who() {
        echo __CLASS__."\n";
    }
}

C::test();
?> 

輸出結果：

A C fooB