PHP后期靜態綁定的示例分析

小編給大家分享一下PHP后期靜態綁定的示例分析，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

基礎知識

1. 范圍解析操作符 （::）

• 可以用于訪問靜態成員，類常量，還可以用于覆蓋類中的屬性和方法。

• self，parent 和 static 這三個特殊的關鍵字是用于在類定義的內部對其屬性或方法進行訪問的。

• parent用于調用父類中被覆蓋的屬性或方法（出現在哪里，就將解析為相應類的父類）。

• self用于調用本類中的方法或屬性（出現在哪里，就將解析為相應的類；注意與$this區別，$this指向當前實例化的對象）。

• 當一個子類覆蓋其父類中的方法時，PHP 不會調用父類中已被覆蓋的方法。是否調用父類的方法取決于子類。
  

2. PHP內核將類的繼承實現放在了"編譯階段"

<?php
class 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之后)在作用域解析符(::)前又表示靜態延遲綁定的特殊類。

例子：

定義靜態局部變量（出現位置：局部函數中）

特征：靜態變量僅在局部函數域中存在，但當程序執行離開此作用域時，其值并不丟失。

<?php
function test()
{
 static $count = 0;

 $count++;
 echo $count;
 if ($count < 10) {
  test();
 }
 $count--;
}

定義靜態方法，靜態屬性

a)聲明類屬性或方法為靜態，就可以不實例化類而直接訪問。

b)靜態屬性不能通過一個類已實例化的對象來訪問（但靜態方法可以）

c)如果沒有指定訪問控制，屬性和方法默認為公有。

d)由于靜態方法不需要通過對象即可調用，所以偽變量 $this 在靜態方法中不可用。

e)靜態屬性不可以由對象通過 -> 操作符來訪問。

f)用靜態方式調用一個非靜態方法會導致一個 E_STRICT 級別的錯誤。

g)就像其它所有的 PHP 靜態變量一樣，靜態屬性只能被初始化為文字或常量，不能使用表達式。所以可以把靜態屬性初始化為整數或數組，但不能初始化為另一個變量或函數返回值，也不能指向一個對象。

a.靜態方法例子（出現位置： 類的方法定義）

<?php
class Foo {
 public static function aStaticMethod() {
  // ...
 }
}

Foo::aStaticMethod();
$classname = 'Foo';
$classname::aStaticMethod(); // 自PHP 5.3.0后，可以通過變量引用類
?>

b.靜態屬性例子（出現位置：類的屬性定義）

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

print 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）中的類名。意思是當我們調用一個轉發調用的靜態調用時，實際調用的類是上一個非轉發調用的類。

例子分析：

<?php
class 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()
A
A
parent::foo()
A
C
self::foo()
A
C

3.更多靜態后期靜態綁定的例子

a)Self, Parent 和 Static的對比

<?php
class 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();

?>

運行結果：
Mango
Orange
Apple

b)使用forward_static_call()

<?php
class 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 is
Orange is my favorite fruit
Apple is my father's favorite fruit

c)使用get_called_class()

<?php


class Mango {
 static public function fruit() {
  echo get_called_class() . "\n";
 }
}

class Orange extends Mango {
 //
}

Mango::fruit();
Orange::fruit();

?>



運行結果：
Mango
Orange

應用

前面已經提到過了，引入后期靜態綁定的目的是：用于在繼承范圍內引用靜態調用的類。
所以， 可以用后期靜態綁定的辦法解決單例繼承問題。

先看一下使用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時出現的單例繼承問題。

以上是“PHP后期靜態綁定的示例分析”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！