php后静态绑定,详解PHP后期静态绑定分析与应用
基礎知識
1. 范圍解析操作符 (::)
可以用于訪問靜態成員，類常量，還可以用于覆蓋類中的屬性和方法。
self，parent 和 static 這三個特殊的關鍵字是用于在類定義的內部對其屬性或方法進行訪問的。
parent用于調用父類中被覆蓋的屬性或方法(出現在哪里，就將解析為相應類的父類)。
self用于調用本類中的方法或屬性(出現在哪里，就將解析為相應的類；注意與$this區別，$this指向當前實例化的對象)。
當一個子類覆蓋其父類中的方法時，PHP 不會調用父類中已被覆蓋的方法。是否調用父類的方法取決于子類。
2. 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之后)在作用域解析符(::)前又表示靜態延遲綁定的特殊類。
例子：
定義靜態局部變量(出現位置：局部函數中)
特征：靜態變量僅在局部函數域中存在，但當程序執行離開此作用域時，其值并不丟失。
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.靜態方法例子(出現位置： 類的方法定義)
class Foo {
public static function aStaticMethod() {
// ...
}
}
Foo::aStaticMethod();
$classname = 'Foo';
$classname::aStaticMethod(); // 自PHP 5.3.0后，可以通過變量引用類
?>
b.靜態屬性例子(出現位置：類的屬性定義)
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)中的類名。意思是當我們調用一個轉發調用的靜態調用時，實際調用的類是上一個非轉發調用的類。
例子分析：
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的對比
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()
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()
class Mango {
static public function fruit() {
echo get_called_class() . "\n";
}
}
class Orange extends Mango {
//
}
Mango::fruit();
Orange::fruit();
?>
運行結果：
Mango
Orange
應用
前面已經提到過了，引入后期靜態綁定的目的是：用于在繼承范圍內引用靜態調用的類。
所以， 可以用后期靜態綁定的辦法解決單例繼承問題。
先看一下使用self是一個什么樣的情況：
// 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會得到什么樣的結果
// 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后静态绑定,详解PHP后期静态绑定分析与应用的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 信用卡审核完成是不是就是批了 信用卡审核
- 下一篇： 银行告借款人要求偿还24%的利息，被法院