基礎知識
1. 范圍解析操作符 （::）
2. PHP內核將類的繼承實現放在了"編譯階段"
<?phpclass A{ const H = 'A'; const J = 'A'; static function testSelf(){ echo self::H; //在編譯階段就確定了 self解析為 A }}class B extends A{ const H = "B"; const J = 'B'; static function testParent(){ echo parent::J; //在編譯階段就確定了 parent解析為A } /* 若重寫testSelf則能輸出“B”, 且C::testSelf()也是輸出“B” static function testSelf(){ echo self::H; } */}class C extends B{ const H = "C"; const J = 'C';}B::testParent();B::testSelf();echo "/n";C::testParent();C::testSelf();運行結果：
AA
AA
結論：
self::和parent::出現在某個類X的定義中，則將被解析為相應的類X，除非在子類中覆蓋父類的方法。
3.Static（靜態）關鍵字
作用：
- 在函數體內的修飾變量的static關鍵字用于定義靜態局部變量。
- 用于修飾類成員函數和成員變量時用于聲明靜態成員。
- (PHP5.3之后)在作用域解析符(::)前又表示靜態延遲綁定的特殊類。
例子：
定義靜態局部變量（出現位置：局部函數中）
特征：靜態變量僅在局部函數域中存在，但當程序執行離開此作用域時，其值并不丟失。
<?phpfunction test(){ static $count = 0; $count++; echo $count; if ($count < 10) { test(); } $count--;}定義靜態方法，靜態屬性
a)聲明類屬性或方法為靜態，就可以不實例化類而直接訪問。
b)靜態屬性不能通過一個類已實例化的對象來訪問（但靜態方法可以）
c)如果沒有指定訪問控制，屬性和方法默認為公有。
d)由于靜態方法不需要通過對象即可調用，所以偽變量 $this 在靜態方法中不可用。
e)靜態屬性不可以由對象通過 -> 操作符來訪問。
f)用靜態方式調用一個非靜態方法會導致一個 E_STRICT 級別的錯誤。
g)就像其它所有的 PHP 靜態變量一樣，靜態屬性只能被初始化為文字或常量，不能使用表達式。所以可以把靜態屬性初始化為整數或數組，但不能初始化為另一個變量或函數返回值，也不能指向一個對象。
a.靜態方法例子（出現位置： 類的方法定義）
<?phpclass Foo { public static function aStaticMethod() { // ... }}Foo::aStaticMethod();$classname = 'Foo';$classname::aStaticMethod(); // 自PHP 5.3.0后，可以通過變量引用類?> b.靜態屬性例子（出現位置：類的屬性定義）
<?phpclass Foo{ public static $my_static = 'foo'; public function staticValue() { return self::$my_static; //self 即 FOO類 }}class Bar extends Foo{ public function fooStatic() { return parent::$my_static; //parent 即 FOO類 }}print Foo::$my_static . "/n";$foo = new Foo();print $foo->staticValue() . "/n";print $foo->my_static . "/n"; // Undefined "Property" my_static print $foo::$my_static . "/n";$classname = 'Foo';print $classname::$my_static . "/n"; // As of PHP 5.3.0print Bar::$my_static . "/n";$bar = new Bar();print $bar->fooStatic() . "/n";?>c.用于后期靜態綁定（出現位置： 類的方法中，用于修飾變量或方法）
下面詳細分析
后期靜態綁定（late static binding）
自 PHP 5.3.0 起，PHP 增加了一個叫做后期靜態綁定的功能，用于在繼承范圍內引用靜態調用的類。
1.轉發調用與非轉發調用
轉發調用 :
指的是通過以下幾種方式進行的靜態調用：self::，parent::，static:: 以及 forward_static_call()。
非轉發調用 ：
明確指定類名的靜態調用（例如Foo::foo()）
非靜態調用（例如$foo->foo()）
2.后期靜態綁定工作原理
原理：存儲了在上一個“非轉發調用”（non-forwarding call）中的類名。意思是當我們調用一個轉發調用的靜態調用時，實際調用的類是上一個非轉發調用的類。
例子分析：
<?phpclass A { public static function foo() { echo __CLASS__."/n"; static::who(); } public static function who() { echo __CLASS__."/n"; }}class B extends A { public static function test() { echo "A::foo()/n"; A::foo(); echo "parent::foo()/n"; parent::foo(); echo "self::foo()/n"; self::foo(); } public static function who() { echo __CLASS__."/n"; }}class C extends B { public static function who() { echo __CLASS__."/n"; }}C::test();/* * C::test(); //非轉發調用 ，進入test()調用后，“上一次非轉發調用”存儲的類名為C * * //當前的“上一次非轉發調用”存儲的類名為C * public static function test() { * A::foo(); //非轉發調用， 進入foo()調用后，“上一次非轉發調用”存儲的類名為A，然后實際執行代碼A::foo(), 轉 0-0 * parent::foo(); //轉發調用， 進入foo()調用后，“上一次非轉發調用”存儲的類名為C， 此處的parent解析為A ,轉1-0 * self::foo(); //轉發調用， 進入foo()調用后，“上一次非轉發調用”存儲的類名為C， 此處self解析為B, 轉2-0 * } * * * 0-0 * //當前的“上一次非轉發調用”存儲的類名為A * public static function foo() { * static::who(); //轉發調用， 因為當前的“上一次非轉發調用”存儲的類名為A， 故實際執行代碼A::who(),即static代表A，進入who()調用后，“上一次非轉發調用”存儲的類名依然為A，因此打印 “A” * } * * 1-0 * //當前的“上一次非轉發調用”存儲的類名為C * public static function foo() { * static::who(); //轉發調用， 因為當前的“上一次非轉發調用”存儲的類名為C， 故實際執行代碼C::who(),即static代表C，進入who()調用后，“上一次非轉發調用”存儲的類名依然為C，因此打印 “C” * } * * 2-0 * //當前的“上一次非轉發調用”存儲的類名為C * public static function foo() { * static::who(); //轉發調用， 因為當前的“上一次非轉發調用”存儲的類名為C， 故實際執行代碼C::who(),即static代表C，進入who()調用后，“上一次非轉發調用”存儲的類名依然為C，因此打印 “C” * } */故最終結果為：A::foo()AAparent::foo()ACself::foo()AC3.更多靜態后期靜態綁定的例子
a)Self, Parent 和 Static的對比
<?phpclass Mango { function classname(){ return __CLASS__; } function selfname(){ return self::classname(); } function staticname(){ return static::classname(); }}class Orange extends Mango { function parentname(){ return parent::classname(); } function classname(){ return __CLASS__; }}class Apple extends Orange { function parentname(){ return parent::classname(); } function classname(){ return __CLASS__; }}$apple = new Apple();echo $apple->selfname() . "/n";echo $apple->parentname() . "/n";echo $apple->staticname();?>運行結果：MangoOrangeAppleb)使用forward_static_call()
<?phpclass Mango{ const NAME = 'Mango is'; public static function fruit() { $args = func_get_args(); echo static::NAME, " " . join(' ', $args) . "/n"; }}class Orange extends Mango{ const NAME = 'Orange is'; public static function fruit() { echo self::NAME, "/n"; forward_static_call(array('Mango', 'fruit'), 'my', 'favorite', 'fruit'); forward_static_call('fruit', 'my', 'father/'s', 'favorite', 'fruit'); }}Orange::fruit('NO');function fruit() { $args = func_get_args(); echo "Apple is " . join(' ', $args). "/n";}?>運行結果：Orange isOrange is my favorite fruitApple is my father's favorite fruitc)使用get_called_class()
<?phpclass Mango { static public function fruit() { echo get_called_class() . "/n"; }}class Orange extends Mango { //}Mango::fruit();Orange::fruit();?>運行結果：MangoOrange應用
前面已經提到過了，引入后期靜態綁定的目的是：用于在繼承范圍內引用靜態調用的類。
所以， 可以用后期靜態綁定的辦法解決單例繼承問題。
先看一下使用self是一個什么樣的情況：
<?php// new self 得到的單例都為A。class A{ protected static $_instance = null; protected function __construct() { //disallow new instance } protected function __clone(){ //disallow clone } static public function getInstance() { if (self::$_instance === null) { self::$_instance = new self(); } return self::$_instance; }}class B extends A{ protected static $_instance = null;}class C extends A{ protected static $_instance = null;}$a = A::getInstance();$b = B::getInstance();$c = C::getInstance();var_dump($a);var_dump($b);var_dump($c);運行結果：E:/code/php_test/apply/self.php:37:class A#1 (0) {}E:/code/php_test/apply/self.php:38:class A#1 (0) {}E:/code/php_test/apply/self.php:39:class A#1 (0) {}通過上面的例子可以看到，使用self，實例化得到的都是類A的同一個對象
再來看看使用static會得到什么樣的結果
<?php// new static 得到的單例分別為D，E和F。class D{ protected static $_instance = null; protected function __construct(){} protected function __clone() { //disallow clone } static public function getInstance() { if (static::$_instance === null) { static::$_instance = new static(); } return static::$_instance; }}class E extends D{ protected static $_instance = null;}class F extends D{ protected static $_instance = null;}$d = D::getInstance();$e = E::getInstance();$f = F::getInstance();var_dump($d);var_dump($e);var_dump($f);運行結果：E:/code/php_test/apply/static.php:35:class D#1 (0) {}E:/code/php_test/apply/static.php:36:class E#2 (0) {}E:/code/php_test/apply/static.php:37:class F#3 (0) {}可以看到，使用static可以解決self時出現的單例繼承問題。
新聞熱點
疑難解答
圖片精選
