php5學習筆記(轉)

- 中國WEB開發者網絡 (http://www.webasp.net)
-- 技術教程 (http://www.webasp.net/article/)
--- php5學習筆記(轉) (http://www.webasp.net/article/17/16936.htm)
-- 作者:未知
-- 發佈日期: 2005-03-10
作者: whhwq
在phpv.net看到的感覺不錯
/*
+-------------------------------------------------------------------------------+
| = 本文為Haohappy讀<<Core PHP Programming>>
| = 中Classes and Objects一章的筆記
| = 翻譯為主+個人心得
| = 為避免可能發生的不必要的麻煩請勿轉載,謝謝
| = 歡迎批評指正,希望和所有PHP愛好者共同進步!
+-------------------------------------------------------------------------------+
*/

PHP5學習筆記
第一節--面向對像編程
面向對像編程被設計來為大型軟件項目提供解決方案,尤其是多人合作的項目. 當源代碼增長到一萬行甚至更多的時候,每一個更動都可能導致不希望的副作用. 這種情況發生於模塊間結成秘密聯盟的時候,就像第一次世界大戰前的歐洲.
//haohappy注:喻指模塊間的關聯度過高,相互依賴性太強.更動一個模塊導致其它模塊也必須跟著更動.
想像一下,如果有一個用來處理登錄的模塊允許一個信用卡處理模塊來分享它的數據庫連接. 當然出發點是好的,節省了進行另一個數據庫連接的支出.然而有時,登錄處理模塊改變了其中一個變量的名字,就可能割斷了兩者間的協議.導致信用卡模塊的處理出錯,進而導致處理發票的模塊出錯. 很快地,體系中所有無關的模塊都可能由此出錯.
因此,我覺得有點戲劇性地,絕大多數程序員都對耦合和封裝心存感激. 耦合是兩個模塊間依賴程度的量度. 耦合越少越好.我們希望能夠從已有的項目中抽走一個模塊並在另一個新項目中使用.
我們也希望在某個模塊內部大規模的更動而不用擔心對其他模塊的影響. 封裝的原則可以提供這個解決方案.模塊被看待成相對獨立,並且模塊間的數據通信通過接口來進行. 模塊不通過彼此的變量名來窺探另一個模塊,它們通過函數來禮貌地發送請求.
封裝是你可以在任何編程語言中使用的一個原則. 在PHP和許多面向過程的語言中,可以偷懶是很有誘惑的.沒有什麼可以阻止你通過模塊來構建一個假想的WEB. 面向對像編程是使程序員不會違背封裝原則的一種方法.
在面向對像編程中,模塊被組織成一個個對象. 這些對像擁有方法和屬性. 從抽像的角度來看,方法是一個對象的所做的動作,而屬性是對象的特性.從編程角度來看,方法就是函數而屬性是變量. 在一個理想化的面向對像體系中,每個部份都是一個對像. 體系由對象及對像間通過方法來形成的聯繫構成.
一個類定義了對象的屬性. 如果你在烘烤一組甜餅對像,那麼類將會是甜餅機. 類的屬性和方法是被調用的成員. 人們可以通過說出數據成員或者方法成員來表達.
每種語言提供了不同的途徑來訪問對像. PHP從C++中借用概念,提供一個數據類型用來在一個標識符下包含函數和變量。最初設計PHP的時候,甚至PHP3被開發出時,PHP並不打算提供開發超過10萬行代碼的大型項目的能力。隨著PHP和Zend引擎的發展,開發大型項目變得有可能,但無論你的項目規模多大,用類來書寫你的腳本將可以讓代碼實現重用。這是一個好主意,特別當你願意與別人分享你的代碼的時候。
有關對象的想法是計算機科學上最令人興奮的概念之一。開始很難掌握它,但我可以保證,一旦你掌握了它,用它的思維來思考將會非常自然。
第二節--PHP5 的對象模型
PHP5有一個單重繼承的,限制訪問的,可以重載的對象模型. 本章稍後會詳細討論的」繼承」,包含類間的父-子關係. 另外,PHP支持對屬性和方法的限制性訪問. 你可以聲明成員為private,不允許外部類訪問. 最後,PHP允許一個子類從它的父類中重載成員.
//haohappy注:PHP4中沒有private,只有public.private對於更好地實現封裝很有好處.
PHP5的對象模型把對像看成與任何其它數據類型不同,通過引用來傳遞. PHP不要求你通過引用(reference)顯性傳遞和返回對像. 在本章的最後將會詳細闡述基於句柄的對象模型. 它是PHP5中最重要的新特性.
有了更直接的對象模型,基於句柄的體系有附加的優勢: 效率提高, 佔用內存少,並且具有更大的靈活性.
在PHP的前幾個版本中,腳本默認複製對像.現在PHP5只移動句柄,需要更少的時間. 腳本執行效率的提升是由於避免了不必要的複製. 在對像體繫帶來複雜性的同時,也帶來了執行效率上的收益. 同時,減少複製意味著佔用更少的內存,可以留出更多內存給其它操作,這也使效率提高.
//haohappy注:基於句柄,就是說兩個對象可以指向同一塊內存,既減少了複製動作,又減少對內存的佔用.
Zand引擎2具有更大的靈活性. 一個令人高興的發展是允許析構--在對像銷毀之前執行一個類方法. 這對於利用內存也很有好處,讓PHP清楚地知道什麼時候沒有對象的引用,把空出的內存分配到其它用途.
第三節--定義一個類
當你聲明一個類,你需要列出對像應有的所有變量和所有函數—被稱為屬性和方法. 3.1.1中顯示了一個類的構成. 注意在大括號({})內你只能聲明變量或者函數. 3.1.2中顯示了如何在一個類中定義三個屬性和兩個方法.
3.1.1
class Name extends Another Class
{
Access Variable Declaration
Access Function Declaration
}
<?php
//定義一個跟蹤用戶的類
class User
{
//屬性
public $name;
private $password, $lastLogin;

//方法
public function __construct($name, $password)
{
$this->name = $name;
$this->password = $password;
$this->lastLogin = time();
$this->accesses++;
}

// 獲取最後訪問的時間
function getLastLogin()
{
return(date("M d Y", $this->lastLogin));
}
}

//創建一個對象的實例
$user = new User("Leon", "sdf123");

//獲取最後訪問的時間
print($user->getLastLogin() ."<br>\n");

//打印用戶名
print("$user->name<br>\n");
?>
當你聲明屬性,你不需要指明數據類型. 變量可能是整型,字符串或者是另一個對像,這取決於實際情況.在聲明屬性時增加註釋是一個好主意,標記上屬性的含義和數據類型.

當你聲明一個方法,你所做的和在類外部定義一個函數是一樣的. 方法和屬性都有各自的命名空間. 這意味著你可以安全地建立一個與類外部函數同名的方法,兩者不會衝突. 例如,一個類中可以定義一個名為date()的方法. 但是你不能將一個方法命名為PHP的關鍵字,如for或者while.

類方法可能包含PHP中所謂的type hint. Type hint 是另一個傳遞參數給方法的類的名字. 如果你的腳本調用方法並傳遞一個不是類的實例的變量,PHP將產生一個」致命(fatal)錯誤」 . 你可能沒有給其它類型給出type hint,就像整型,字符串,或者布爾值. 在書寫的時候, type hint是否應當包含數組類型仍存在爭議.

Type hint是測試函數參數或者運算符的實例的數據類型的捷徑. 你可能總是返回這個方法. 確認你強制讓一個參數必須是哪種數據類型,如整型. 3.2.1 確保編譯類只產生Widget的實例.

3.2.1
PHP代碼:

<?php
//組件
class Widget
{
public $name='none';
public $created=FALSE;
}

//裝配器
class Assembler
{
public function make(Widget $w)
{
print("Making $w->name<br>\n");
$w->created=TRUE;
}
}

//建立一個組件對像
$thing = new Widget;
$thing->name = 'Gadget';

//裝配組件
Assembler::make($thing);
?>
除了傳遞參數的變量外,方法含有一個特殊的變量. 它代表類的個別實例. 你應當用這個來指向對象的屬性和其它方法.一些面向對象的語言假設一個不合格的變量提交給本地屬性,但在PHP中方法的任何變量只是在方法的一定範圍內. 注意在User類的構造函數中這個變量的使用(3.1.2).

PHP在屬性和方法聲明前定義一個訪問限定語,如public,private和protected. 另外,你可以用」static」來標記一個成員. 你也可以在類中聲明常量. 本章稍後會有不同訪問方式的相關討論.

你可以在一行中列出相同訪問方式的幾個屬性,用逗號來分隔它們. 在3.1.2中,User類有兩個private屬性--$password和$lastLogin.

第四節--構造函數和析構函數

如果你在一個類中聲明一個函數,命名為__construct,這個函數將被當成是一個構造函數並在建立一個對像實例時被執行. 清楚地說,__是兩個下劃線. 就像其它任何函數一樣,構造函數可能有參數或者默認值. 你可以定義一個類來建立一個對象並將其屬性全放在一個語句(statement)中.

你也可以定義一個名為__destruct的函數,PHP將在對像被銷毀前調用這個函數. 它稱為析構函數.

繼承是類的一個強大功能. 一個類(子類/派生類)可以繼承另一類(父類/基類)的功能. 派生類將包含有基類的所有屬性和方法,並可以在派生類中加上其他屬性和方法. 你也可以覆寫基類的方法和屬性. 就像3.1.2中顯示的,你可以用extends關鍵字來繼承一個類.

你可能想知道構造函數是如何被繼承的. 當它們和其它方法一起被繼承時,他們不會在創建對像時被執行.
如果你需要這個功能,你需要用第二章提到的::運算符. 它允許你指向一塊命名空間. parent指向父類命名空間,你可以用parent::__construct來調用父類的構造函數.

一些面向對像語言在類之後命名構造函數. PHP的前幾個版本也是如此,到現在這種方法仍然有效.也就是:如果你把一個類命名為Animal並且在其中建立一個命名也是Animal的方法,則這個方法就是構造函數.如果一個類的同時擁有__construt構造函數和與類名相同的函數,PHP將把__construct看作構造函數.這使得用以前的PHP版本所寫的類仍然可以使用. 但新的腳本(PHP5)應當使用__construct.

PHP的這種新的聲明構造函數的方法可以使構造函數有一個獨一無二的名稱,無論它所在的類的名稱是什麼. 這樣你在改變類的名稱時,就不需要改變構造函數的名稱.

你可能在PHP中給構造函數一個像其它類方法一樣的訪問方式. 訪問方式將會影響從一定範圍內實例化對象的能力. 這允許實現一些固定的設計模式,如Singleton模式.

析構函數,相反於構造函數. PHP調用它們來將一個對像從內存中銷毀. 默認地,PHP僅僅釋放對像屬性所佔用的內存並銷毀對像相關的資源. 析構函數允許你在使用一個對像之後執行任意代碼來清除內存.

當PHP決定你的腳本不再與對像相關時,析構函數將被調用. 在一個函數的命名空間內,這會發生在函數return的時候. 對於全局變量,這發生於腳本結束的時候. 如果你想明確地銷毀一個對像,你可以給指向該對象的變量分配任何其它值. 通常將變量賦值勤為NULL或者調用unset .

下面的例子中,計算從類中實例化的對象的個數. Counter類從構造函數開始增值,在析構函數減值.

一旦你定義了一個類,你可以用new來建立一個這個類的實例. 類的定義是設計圖,實例則是放在裝配線上的元件. New需要類的名稱,並返回該類的一個實例. 如果構造函數需要參數,你應當在new後輸入參數.
PHP代碼:
<?php
class Counter
{
private static $count = 0;

function __construct()
{
self::$count++;
}

function __destruct()
{
self::$count--;
}

function getCount()
{
return self::$count;
}
}

//建立第一個實例
$c = new Counter();

//輸出1
print($c->getCount() . "<br>\n");

//建立第二個實例
$c2 = new Counter();

//輸出2
print($c->getCount() . "<br>\n");

//銷毀實例
$c2 = NULL;

//輸出1
print($c->getCount() . "<br>\n");
?>
當你新建了一個實例,內存會被準備來存儲所有屬性. 每個實例有自己獨有的一組屬性. 但方法是由該類的所有實例共享的.

第五節--克隆

PHP5中的對象模型通過引用來調用對像, 但有時你可能想建立一個對象的副本,並希望原來的對象的改變不影響到副本 . 為了這樣的目的,PHP定義了一個特殊的方法,稱為__clone. 像__construct和__destruct一樣,前面有兩個下劃線.

默認地,用__clone方法將建立一個與原對像擁有相同屬性和方法的對象. 如果你想在克隆時改變默認的內容,你要在__clone中覆寫(屬性或方法).

克隆的方法可以沒有參數,但它同時包含this和that指針(that指向被複製的對象). 如果你選擇克隆自己,你要小心複製任何你要你的對象包含的信息,從that到this. 如果你用__clone來複製. PHP不會執行任何隱性的複製,

下面顯示了一個用系列序數來自動化對象的例子:
PHP代碼:
<?php
class ObjectTracker //對像跟蹤器
{
private static $nextSerial = 0;
private $id;
private $name;

function __construct($name) //構造函數
{
$this->name = $name;
$this->id = ++self::$nextSerial;
}

function __clone() //克隆
{
$this->name = "Clone of $that->name";
$this->id = ++self::$nextSerial;
}

function getId() //獲取id屬性的值
{
return($this->id);
}

function getName() //獲取name屬性的值
{
return($this->name);
}
}

$ot = new ObjectTracker("Zeev's Object");
$ot2 = $ot->__clone();

//輸出: 1 Zeev's Object
print($ot->getId() . " " . $ot->getName() . "<br>");

//輸出: 2 Clone of Zeev's Object
print($ot2->getId() . " " . $ot2->getName() . "<br>");
?>
第六節--訪問屬性和方法

一個對像實例的屬性是變量,就像PHP的其他變量一樣. 但是你必須使用->運算符來引用它們. 不需要在屬性前使用美元符$. 例如, 6.1中打印User對象的name屬性那一行.

可以聯用->,如果一個對象的屬性包含了一個對像,你可以使用兩個->運算符來得到內部對象的屬性. 你甚至可以用雙重引用的字符串來放置這些表達式. 看6.5中的例子,對像House中的屬性room包含了一組Room對像.

訪問方法和訪問屬性類似. ->運算符用來指向實例的方法. 在例子6.1中調用getLastLogin就是. 方法執行起來和類外的函數幾乎相同.

如果一個類從另一類中繼承而來,父類中的屬性和方法將在子類中都有效,即使在子類中沒有聲明. 像以前提到過的,繼承是非常強大的. 如果你想訪問一個繼承的屬性,你只需要像訪問基類自己的屬性那樣引用即可,使用::運算符.
PHP代碼:
<?php
class Room
{
public $name;

function __construct($name="unnamed")
{
$this->name = $name;
}
}

class House
{
//array of rooms
public $room;
}

//create empty house
$home = new house;

//add some rooms
$home->room[] = new Room("bedroom");
$home->room[] = new Room("kitchen");
$home->room[] = new Room("bathroom");

//show the first room of the house
print($home->room[0]->name);
?>
PHP有兩個特殊的命名空間arent命名空間指向父類,self命名空間指向當前的類. 例子6.6中顯示了如何用parent命名空間來調用父類中的構造函數. 同時也用self來在構造函數中調用另一個類方法.
<?php
class Animal //動物
{
public $blood; //熱血or冷血屬性
public $name;
public function __construct($blood, $name=NULL)
{
$this->blood = $blood;
if($name)
{
$this->name = $name;
}
}
}

class Mammal extends Animal //哺乳動物
{
public $furColor; //皮毛顏色
public $legs;

function __construct($furColor, $legs, $name=NULL)
{
parent::__construct("warm", $name);
$this->furColor = $furColor;
$this->legs = $legs;
}
}

class Dog extends Mammal
{
function __construct($furColor, $name)
{
parent::__construct($furColor, 4, $name);

self::bark();
}

function bark()
{
print("$this->name says 'woof!'");
}
}

$d = new Dog("Black and Tan", "Angus");
?>
第四章中介紹了如何調用函數. 對於對象的成員來是這樣調用的:如果你需要在運行時確定變量的名稱,你可以用$this->$Property這樣的表達式. 如果你想調用方法,可以用$obj->$method().

你也可以用->運算符來返回一個函數的值,這在PHP以前的版本中是不允許的. 例如,你可以寫一個像這樣的表達式: $obj->getObject()->callMethod(). 這樣避免了使用一個中間變量,也有助於實現某些設計模式,如Factory模式.
第七節--類的靜態成員

類的靜態成員與一般的類成員不同: 靜態成員與對象的實例無關,只與類本身有關. 他們用來實現類要封裝的功能和數據,但不包括特定對象的功能和數據. 靜態成員包括靜態方法和靜態屬性.

靜態屬性包含在類中要封裝的數據,可以由所有類的實例共享. 實際上,除了屬於一個固定的類並限制訪問方式外,類的靜態屬性非常類似於函數的全局變量

我們在下例中使用了一個靜態屬性Counter::$count. 它屬於Counter類,而不屬於任何Counter的實例.你不能用this來引用它,但可以用self或其它有效的命名表達. 在例子中,getCount方法返回self::$count,而不是Counter::$count.

靜態方法則實現類需要封裝的功能,與特定的對象無關. 靜態方法非常類似於全局函數. 靜態方法可以完全訪問類的屬性,也可以由對象的實例來訪問,不論訪問的限定語是否是什麼.

在6.3例中,getCount是一個普通的方法,用->來調用. PHP建立一個this變量,儘管方法沒有使用到.但是,getCount不屬於任何對像.在有些情況下,我們甚至希望在不存在有效的對象時調用它,那麼就應該使用靜態方法. PHP將不在靜態方法內部建立this變量,即使你從一個對像中調用它們.

例子6.7由6.3改變getCount為靜態方法而來. Static關鍵字不能阻止一個實例用->運算符來調用getCount,但PHP將不在方法內部建立this變量.如果你使用this->來調用,將會出錯.

//6.3例指第四節--構造函數和析構函數中的例子(參看前文),通過兩個例子的比較,你可以很好掌握
//static方法與普通方法之間的區別.

你可以寫一個方法通過判斷this是否建立來顯示是否它被靜態地或者非靜態地調用. 當然,如果你用了static 關鍵字,不管它怎樣被調用,這個方法總是靜態的.

你的類也可以定義常量屬性,不需要使用public static,只需要用const關鍵字即可. 常量屬性總是靜態的.它們是類的屬性,而不是實例化該類的對象的屬性.

Listing 6.7 Static members
PHP代碼:
<?php
class Counter
{
private static $count = 0;
const VERSION = 2.0;

function __construct()
{
self::$count++;
}

function __destruct()
{
self::$count--;
}

static function getCount()
{
return self::$count;
}
};

//創建一個實例,則__construct()將執行
$c = new Counter();

//輸出 1
print(Counter::getCount() . "<br>\n");

//輸出類的版本屬性
print("Version used: " . Counter::VERSION . "<br>\n");
?>
第八節--訪問方式

PHP5的訪問方式允許限制對類成員的訪問. 這是在PHP5中新增的功能,但在許多面向對像語言中都早已存在. 有了訪問方式,才能開發一個可靠的面向對像應用程序,並且構建可重用的面向對像類庫.

像C++和Java一樣,PHP有三種訪問方式ublic,private和protected. 對於一個類成員的訪問方式,可以是其中之一. 如果你沒有指明訪問方式,默認地訪問方式為public. 你也可以為靜態成員指明一種訪問方式,將訪問方式放在static關鍵字之前(如public static).

Public成員可以被毫無限制地訪問.類外部的任何代碼都可以讀寫public屬性. 你可以從腳本的任何地方調用一個public方法. 在PHP的前幾個版本中,所有方法和屬性都是public, 這讓人覺得對象就像是結構精巧的數組.

Private(私有)成員只在類的內部可見. 你不能在一個private屬性所在的類方法之外改變或讀取它的值. 同樣地,只有在同一個類中的方法可以調用一個private方法. 繼承的子類也不能訪問父類中的private 成員.

要注意,類中的任何成員和類的實例都可以訪問private成員. 看例子6.8,equals方法將兩個widget進行比較.==運算符比較同一個類的兩個對像,但這個例子中每個對象實例都有唯一的ID.equals方法只比較name和price. 注意equals方法如何訪問另一個Widget實例的private屬性. Java和C都允許這樣的操作.

Listing 6.8 Private members
PHP代碼:
<?php
class Widget
{
private $name;
private $price;
private $id;

public function __construct($name, $price)
{
$this->name = $name;
$this->price = floatval($price);
$this->id = uniqid();
}
//checks if two widgets are the same 檢查兩個widget是否相同
public function equals($widget)
{
return(($this->name == $widget->name)AND
($this->price == $widget->price));
}
}
$w1 = new Widget('Cog', 5.00);
$w2 = new Widget('Cog', 5.00);
$w3 = new Widget('Gear', 7.00);

//TRUE
if($w1->equals($w2))
{
print("w1 and w2 are the same<br>\n");
}

//FALSE
if($w1->equals($w3))
{
print("w1 and w3 are the same<br>\n");
}

//FALSE, == includes id in comparison
if($w1 == $w2) //不等,因為ID不同
{
print("w1 and w2 are the same<br>\n");
}
?>
如果你對面向對像編程不熟悉,你可能想知道用private成員的目的是什麼. 你可以回憶一下封裝和耦合的想法,這在本章開頭我們有討論過. Private成員有助於封裝數據. 他們可以隱藏在一個類內部而不被類外部的代碼接觸到. 同時他們還有助於實現鬆散的耦合. 如果數據結構外的代碼不能直接訪問內部屬性,那麼就不會產生一個隱性的關聯性.

當然,大部分private屬性仍然可以被外部代碼共享. 解決方法是用一對public方法,一個是get(獲取屬性的值),另一個是set(設置屬性的值). 構造函數也接受屬性的初始值. 這使得成員間的交流通過一個狹窄的,經過良好限定的接口來進行. 這也提供改變傳遞給方法的值的機會. 注意在例子6.8中,構造函數如何強制使price成為一個float數(floadval()).

Protected(受保護的) 成員能被同個類中的所有方法和繼承出的類的中所有方法訪問到. Public屬性有違封裝的精神,因為它們允許子類依賴於一個特定的屬性來書寫.protected方法則不會帶來這方面的擔憂.一個使用protected方法的子類需要很清楚它的父類的結構才行.

例子6.9由例子6.8改進而得到,包含了一個Widget的子類Thing. 注意Widget現在有一個叫作getName的protected方法. 如果Widget的實例試圖調用protected方法將會出錯: $w1->getName()產生了一個錯誤. 但子類Thing中的getName方法可以調用這個protected方法.當然對於證明Widget::getName方法是protected,這個例子顯得過於簡單. 在實際情況下,使用protected方法要依賴於對對象的內部結構的理解.

Listing 6.9 Protected members
PHP代碼:
<?php
class Widget
{
private $name;
private $price;
private $id;

public function __construct($name, $price)
{
$this->name = $name;
$this->price = floatval($price);
$this->id = uniqid();
}

//checks if two widgets are the same
public function equals($widget)
{
return(($this->name == $widget->name)AND
($this->price == $widget->price));
}

protected function getName()
{
return($this->name);
}
}

class Thing extends Widget
{
private $color;

public function setColor($color)
{
$this->color = $color;
}

public function getColor()
{
return($this->color);
}

public function getName()
{
return(parent::getName());
}
}

$w1 = new Widget('Cog', 5.00);
$w2 = new Thing('Cog', 5.00);
$w2->setColor('Yellow');

//TRUE (still!) 結果仍然為真
if($w1->equals($w2))
{
print("w1 and w2 are the same<br>\n");
}

//print Cog 輸出 Cog
print($w2->getName());
?>
一個子類可能改變通過覆寫父類方法來改變方法的訪問方式,儘管如此,仍然有一些限制. 如果你覆寫了一個public類成員,他子類中必須保持public. 如果你覆寫了一個protected成員,它可保持protected或變成public.Private成員仍然只在當前類中可見. 聲明一個與父類的private成員同名的成員將簡單地在當前類中建立一個與原來不同的成員. 因此,在技術上你不能覆寫一個private成員.

Final關鍵字是限制訪問成員方法的另一個方法. 子類不能覆寫父類中標識為final的方法. Final關鍵字不能用於屬性.

//haohappy注:PHP5的面向對像模型仍然不夠完善,如final不像Java中那樣對Data,Method甚至Class都可以用.
第九節--綁定

除了限制訪問,訪問方式也決定哪個方法將被子類調用或哪個屬性將被子類訪問. 函數調用與函數本身的關聯,以及成員訪問與變量內存地址間的關係,稱為綁定.

在計算機語言中有兩種主要的綁定方式—靜態綁定和動態綁定. 靜態綁定發生於數據結構和數據結構間,程序執行之前. 靜態綁定發生於編譯期, 因此不能利用任何運行期的信息. 它針對函數調用與函數的主體,或變量與內存中的區塊. 因為PHP是一種動態語言,它不使用靜態綁定. 但是可以模擬靜態綁定.

動態綁定則針對運行期產生的訪問請求,只用到運行期的可用信息. 在面向對象的代碼中,動態綁定意味著決定哪個方法被調用或哪個屬性被訪問,將基於這個類本身而不基於訪問範圍.

Public和protected成員的動作類似於PHP的前幾個版本中函數的動作,使用動態綁定. 這意味著如果一個方法訪問一個在子類中被覆寫的類成員,並是一個子類的實例,子類的成員將被訪問(而不是訪問父類中的成員).

看例子6.10. 這段代碼輸出」 Hey! I am Son.」 因為當PHP調用getSalutation, 是一個Son的實例,是將Father中的salutation覆寫而來. 如果salutation是public的,PHP將產生相同的結果. 覆寫方法的操作很類似.在Son中,對於identify的調用綁定到那個方法.

即使在子類中訪問方式被從protected削弱成public, 動態綁定仍然會發生. 按照訪問方式使用的原則,增強對於類成員的訪問限制是不可能的. 所以把訪問方式從public改變成protected不可能進行.

Listing 6.10 Dynamic binding 動態綁定
PHP代碼:
<?php
class Father
{
protected $salutation = "Hello there!"; //問候

public function getSalutation()
{
print("$this->salutation\n");
$this->identify();
}

protected function identify()
{
print("I am Father.<br>\n");
}
};

class Son extends Father
{
protected $salutation = "Hey!"; //父類中的protected $salutation 被覆寫

protected function identify() //父類中的protected identify() 被覆寫
{
print("I am Son.<br>\n");
}
};

$obj = new Son();
$obj->getSalutation(); //輸出Hey! I am Son.
?>
//注: 在子類中沒有覆寫getSalutation(),但實際上仍然存在一個getSalutation().這個類中的$salutation和identify()
//與Son子類的實例中的getSalutation()方法動態綁定,所以調用Son的實例的getSalutation()方法,
//將調用Son類中的成員salutation及identify(),而不是父類中的成員salutation及identify().

Private成員只存在於它們所在的類內部. 不像public和protected成員那樣,PHP模擬靜態綁定. 看例子6.11. 它輸出」Hello there! I am Father.」,儘管子類覆寫了salutation的值. 腳本將this->salutation和當前類Father綁定. 類似的原則應用於private方法identify().

Listing 6.11 Binding and private members
PHP代碼:
<?php
class Father
{
private $salutation = "Hello there!";

public function getSalutation()
{
print("$this->salutation\n");
$this->identify();
}

private function identify()
{
print("I am Father.<br>\n");
}
}

class Son extends Father
{
private $salutation = "Hey!";
private function identify()
{
print("I am Son.<br>\n");
}
}

$obj = new Son();
$obj->getSalutation(); //輸出Hello there! I am Father.
?>
動態綁定的好處是允許繼承類來改變父類的行為,同時可以保持父類的接口和功能. 看例子6.12. 由於使用了動態綁定,在deleteUser中被調用的isAuthorized的version 可以由對象的類型來確定. 如果是一個普通的user,PHP調用User::isAuthorized會返回FALSE.如果是一個AuthorizedUser的實例,PHP調用AuthorizedUser::isAuthorized,將允許deleteUser順利執行.

//haohappy注:用一句話說清楚,就是對像類型與方法,屬性綁定. 調用一個父類與子類中都存在的方法或訪問一個屬性時,會先判斷實例屬於哪種對像類型,再調用相應的類中的方法和屬性.

Listing 6.12 動態綁定的好處
PHP代碼:
<?php
class User //用戶
{
protected function isAuthorized() //是否是驗證用戶
{
return(FALSE);
}

public function getName() //獲得名字
{
return($this->name);
}

public function deleteUser($username) //刪除用戶
{
if(!$this->isAuthorized())
{
print("You are not authorized.<br>\n");
return(FALSE);
}

//delete the user
print("User deleted.<br>\n");
}
}

class AuthorizedUser extends User //認證用戶
{
protected function isAuthorized() //覆寫isAuthorized()
{
return(TRUE);
}
}

$user = new User;
$admin = new AuthorizedUser;

//not authorized
$user->deleteUser("Zeev");

//authorized
$admin->deleteUser("Zeev");
?>
為什麼private的類成員模擬靜態綁定? 為了回答這個問題, 你需要回憶一下為什麼需要有private成員.什麼時候用它們來代替protected成員是有意義的?

private成員只有當你不想讓子類繼承改變或特殊化父類的行為時才用到. 這種情況比你想像的要少. 通常來說,一個好的對象分層結構應當允許絕大多數功能被子類特殊化,改進,或改變—這是面向對像編程的基礎之一. 一定的情況下需要private方法或變量,例如當你確信你不想允許子類改變父類中的某個特定的部份.


第十節--抽像方法和抽像類

面向對像程序通過類的分層結構構建起來. 在單重繼承語言如PHP中, 類的繼承是樹狀的. 一個根類有一個或更多的子類,再從每個子類繼承出一個或更多下一級子類. 當然,可能存在多個根類,用來實現不同的功能. 在一個良好設計的體系中,每個根類都應該有一個有用的接口, 可以被應用代碼所使用. 如果我們的應用代碼被設計成與根類一起工作,那麼它也可以和任何一個從根類繼承出來的子類合作.

抽像方法是就像子類中一般的方法的佔位符(佔個地方但不起作用),它與一般方法不同—沒有任何代碼. 如果類中存在一個或更多抽像方法, 那麼這個類就成了抽像類. 你不能實例化抽像類. 你必須繼承它們,然後實例化子類. 你也可以把抽像類看成是子類的一個模板.

如果你覆寫所有的抽像方法, 子類就變成一個普通的類. 如果沒有覆寫所有方法, 子類仍是抽像的. 如果一個類中中包含有抽像方法(哪怕只有一個), 你必須聲明這個類是抽像的, 在class關鍵字前加上abstract.

聲明抽像方法的語法與聲明一般方法不同. 抽像方法的沒有像一般方法那樣包含在大括號{}中的主體部份,並用分號;來結束.

在例子6.13中, 我們定義了一個含有getArea方法的類Shape. 但由於不知道形狀不可能確定圖形的面積,確良我們聲明了getArea方法為抽像方法. 你不能實例化一個Shape對像,但你可以繼承它或在一個表達式中使用它, 就像例6.13中那樣.

如果你建立了一個只有抽像方法的類,你就定義了一個接口(interface). 為了說明這種情況, PHP中有interface 和implements關鍵字. 你可以用interface來代替抽像類, 用implements來代替extends來說明你的類定義或使用一個接口. 例如, 你可以寫一個myClass implements myIterface. 這兩種方法可以依個人偏愛來選擇.

/*注:
兩種方法即指:
1. abstract class aaa{} (注意aaa中只有抽像方法,沒有一般方法)
class bbb extends aaa{} (在bbb中覆寫aaa中的抽像方法)
2. interface aaa{}
class bbb implements aaa{} (在bbb中覆寫aaa中的抽像方法)
*/

Listing 6.13 Abstract classes
PHP代碼:
<?php
//abstract root class 抽像根類
abstract class Shape
{
abstract function getArea(); //定義一個抽像方法
}

//abstract child class 抽像子類
abstract class Polygon extends Shape //多邊形
{
abstract function getNumberOfSides();
}

//concrete class 實體類 三角形類
class Triangle extends Polygon
{
public $base;
public $height;

public function getArea() //覆寫計算面積方法
{
return(($this->base * $this->height)/2);
}

public function getNumberOfSides() //覆寫邊數統計方法
{
return(3);
}
}

//concrete class 實體類四邊形
class Rectangle extends Polygon
{
public $width;
public $height;

public function getArea()
{
return($this->width * $this->height);
}

public function getNumberOfSides()
{
return(4);
}
}

//concrete class 實體類 圓形
class Circle extends Shape
{
public $radius;

public function getArea()
{
return(pi() * $this->radius * $this->radius);
}
}

//concrete root class 定義一個顏色類
class Color
{
public $name;
}

$myCollection = array(); //建立形狀的集合,放入數組

//make a rectangle
$r = new Rectangle;
$r->width = 5;
$r->height = 7;
$myCollection[] = $r;
unset($r);

//make a triangle
$t = new Triangle;
$t->base = 4;
$t->height = 5;
$myCollection[] = $t;
unset($t);

//make a circle
$c = new Circle;
$c->radius = 3;
$myCollection[] = $c;
unset($c);

//make a color
$c = new Color;
$c->name = "blue";
$myCollection[] = $c;
unset($c);

foreach($myCollection as $s)
{
if($s instanceof Shape) //如果$s是Shape類的實例
{
print("Area: " . $s->getArea() .
"<br>\n");
}

if($s instanceof Polygon)
{
print("Sides: " .
$s->getNumberOfSides() .
"<br>\n");
}

if($s instanceof Color)
{
print("Color: $s->name<br>\n");
}

print("<br>\n");
}

?>
第十一節--重載

PHP4中已經有了重載的語法來建立對於外部對像模型的映射,就像Java和COM那樣. PHP5帶來了強大的面向對像重載,允許程序員建立自定義的行為來訪問屬性和調用方法.

重載可以通過__get, __set, and __call幾個特殊方法來進行. 當Zend引擎試圖訪問一個成員並沒有找到時,PHP將會調用這些方法.

在例6.14中,__get和__set代替所有對屬性變量數組的訪問. 如果必要,你可以實現任何類型你想要的過濾. 例如,腳本可以禁止設置屬性值, 在開始時用一定的前綴或包含一定類型的值.

__call方法說明了你如何調用未經定義的方法. 你調用未定義方法時,方法名和方法接收的參數將會傳給__call方法, PHP傳遞__call的值返回給未定義的方法.

Listing 6.14 User-level overloading
PHP代碼:
<?php
class Overloader
{
private $properties = array();

function __get($property_name)
{
if(isset($this->properties[$property_name]))
{
return($this->properties[$property_name]);
}
else
{
return(NULL);
}
}

function __set($property_name, $value)
{
$this->properties[$property_name] = $value;
}

function __call($function_name, $args)
{
print("Invoking $function_name()<br>\n");
print("Arguments: ");
print_r($args);

return(TRUE);
}
}
$o = new Overloader();

//invoke __set() 給一個不存在的屬性變量賦值,激活__set()
$o->dynaProp = "Dynamic Content";

//invoke __get() 激活__get()
print($o->dynaProp . "<br>\n");

//invoke __call() 激活__call()
$o->dynaMethod("Leon", "Zeev");
?>
第十二節--類的自動加載

當你嘗試使用一個未定義的類時,PHP會報告一個致命錯誤. 解決方法就是添加一個類,可以用include包含一個文件. 畢竟你知道要用到哪個類. 但是,PHP提供了類的自動加載功能, 這可以節省編程的時間. 當你嘗試使用一個PHP沒有組織到的類, 它會尋找一個__autoload的全局函數. 如果存在這個函數,PHP會用一個參數來調用它,參數即類的名稱.

例子6.15說明了__autoload是如何使用的. 它假設當前目錄下每個文件對應一個類. 當腳本嘗試來產生一個類User的實例,PHP會執行__autoload. 腳本假設class_User.php中定義有User類.. 不管調用時是大寫還是小寫,PHP將返回名稱的小寫.

Listing 6.15 Class autoloading
PHP代碼:
<?php
//define autoload function
function __autoload($class)
{
include("class_" . ucfirst($class) . ".php");
}

//use a class that must be autoloaded
$u = new User;
$u->name = "Leon";
$u->printName();
?>
第十三節--對像串行化

串行化可以把變量包括對像,轉化成連續bytes數據. 你可以將串行化後的變量存在一個文件裡或在網絡上傳輸. 然後再反串行化還原為原來的數據. 你在反串行化類的對象之前定義的類,PHP可以成功地存儲其對象的屬性和方法. 有時你可能需要一個對像在反串行化後立即執行. 為了這樣的目的,PHP會自動尋找__sleep和__wakeup方法.

當一個對像被串行化,PHP會調用__sleep方法(如果存在的話). 在反串行化一個對像後,PHP 會調用__wakeup方法. 這兩個方法都不接受參數. __sleep方法必須返回一個數組,包含需要串行化的屬性. PHP會拋棄其它屬性的值. 如果沒有__sleep方法,PHP將保存所有屬性.

例子6.16顯示了如何用__sleep和__wakeup方法來串行化一個對像. Id屬性是一個不打算保留在對像中的臨時屬性. __sleep方法保證在串行化的對象中不包含id屬性. 當反串行化一個User對像,__wakeup方法建立id屬性的新值. 這個例子被設計成自我保持. 在實際開發中,你可能發現包含資源(如圖像或數據流)的對象需要這些方法.

Listing 6.16 Object serialization
PHP代碼:
<?php

class User
{
public $name;
public $id;

function __construct()
{
//give user a unique ID 賦予一個不同的ID
$this->id = uniqid();
}

function __sleep()
{
//do not serialize this->id 不串行化id
return(array("name"));
}

function __wakeup()
{
//give user a unique ID
$this->id = uniqid();
}
}

//create object 建立一個對像
$u = new User;
$u->name = "Leon";

//serialize it 串行化 注意不串行化id屬性,id的值被拋棄
$s = serialize($u);

//unserialize it 反串行化 id被重新賦值
$u2 = unserialize($s);

//$u and $u2 have different IDs $u和$u2有不同的ID
print_r($u);
print_r($u2);
?>
第十四節--命名空間

命名變量,函數和類是挺困難的,除了要考慮到變量的名稱要易於理解,還要擔心是否這個名稱在其它某個地方已經使用過. 在一小段腳本中,第二個問題是基本問題. 當你考慮重用你的代碼, 在這之後的項目代碼必須避免使用你用過的命名. 通常來說,可重用的代碼總是包含在函數或類中, 需要處理許多可能發生的命名衝突. 但函數和類之間也可能發生命名衝突. 你可以嘗試避免出現這種情況,通過在所有類前添加前綴的方法,或者你可以使用namespace語句.

Namespace關鍵字給一塊代碼命名. 在這個代碼塊外部,腳本必須用操作符::加上命名空間的名稱來引用這個代碼塊. 引用靜態的類成員也是用相同的方法. 在命名空間內代碼不需要聲明命名空間, 它本身就是默認的. 這種方法比添加前綴的方法好. 你的代碼可由此變得更加緊湊和可讀.

你可能想知道是否可以建立分層的(嵌套的)命名空間. 答案是不可以. 但你可以在命名空間名稱後加上冒號, 你可以再次調用在名稱中不包含冒號的變量,函數和類. 命名空間允許存在冒號,只要不是第一個字符和最後一個字符或接著另一個冒號. 命名空間的名稱中的冒號對於PHP來說沒有任何意義, 但如果你用他們來區分邏輯上的區塊, 他們可以很好地說明你的代碼中的父子(parent-child)關係.


/* 注: 即可以使用這樣:
namespace animal:dog {}
namespace animalig {}

用冒號來說明parent-child關係.
*/


你可能在一個命名空間語句內沒有包含函數,類或常量定義以外的任何東西. 這將阻止你使用他們來改進舊的使用全局變量的函數庫. 命名空間最適合於面向對像. 命名空間內的常量與類中的常量使用相同的語法.

例子6.17顯示了如何使用命名空間.

Listing 6.17 Using a namespace
PHP代碼:
<?php
namespace core_php:utility
{
class textEngine
{
public function uppercase($text) //大寫
{
return(strtoupper($text));
}
}

//make non-OO interface 建立一個非OO的接口
function uppercase($text)
{
$e = new textEngine;
return($e->uppercase($text));
}

}

//test class in namespace 測試命名空間中的類
$e = new core_php:utility::textEngine;
print($e->uppercase("from object") . "<br>");

//test function in namespace 測試命名空間中的函數
print(core_php:utility::uppercase("from function") . "<br>");

//bring class into global namespace 把類導入全局命名空間
import class textEngine from core_php:utility;
$e2 = new textEngine;
?>
Import語句把命名空間中的某個部份導入全局的命名空間.
要導入單一的命名空間的成員,可以指定類型為constant,function或class,接著寫上成員的名稱;
//如import class XXX
如果你想導入某一特定類型的所有成員,你可以用*來代替名稱;
//如 import constant * 導入所有常量
如果你想導入所有類型的所有成員,用*即可.
//如 import *

在成員之後,用from關鍵字加上命名空間的名稱.
//如 import class textEngine from core_php:utility;

總之你要寫成像import * from myNamespace或 import class textEngine from core_php:utility這樣的語句,就像例6.17中那樣.

第十五節--Zend引擎的發展

本章的最後一節,Zeev討論了Zend引擎帶來的對象模型,特別提到它與PHP的前幾個版本中的模型有什麼不同.
當1997年夏天,我們開發出PHP3, 我們沒有計劃要使PHP具備面向對象的能力. 當時沒有任何與類和對像有關的想法. PHP3是一個純粹面向過程的語言. 但是,在1997.8.27的晚上PHP3 alpha版中增加了對類的支持. 增加一個新特性給PHP,當時僅需要極少的討論,因為當時探索PHP的人太少. 於是從1997年八月起, PHP邁出了走向面向對像編程語言的第一步.

確實,這只是第一步. 因為在這個設計中只有極少的相關的想法,對於對象的支持不夠強大. 這個版本中使用對像僅是訪問數組的一個很酷的方法而已. 取代使用$foo[「bar」],你可以使用看起來更漂亮的$foo->bar. 面向對像方法的主要的優勢是通過成員函數或方法來儲存功能. 例子6.18中顯示了一個典型的代碼塊. 但是它和例6.19中的做法其實並沒有太大不同.

Listing 6.18 PHP 3 object-oriented programming PHP3中的面向對像編程
PHP代碼:
<?php
class Example
{
var $value = "some value";
function PrintValue()
{
print $this->value;
}
}
$obj = new Example();
$obj->PrintValue();
?>
Listing 6.19 PHP 3 structural programming PHP3 PHP3中的結構化編程
PHP代碼:
<?php
function PrintValue($arr)
{
print $arr["value"];
}

function CreateExample()
{
$arr["value"] = "some value";
$arr["PrintValue"] = "PrintValue";

return $arr;
}

$arr = CreateExample();

//Use PHP's indirect reference
$arr["PrintValue"]($arr);
?>
以上我們在類中寫上兩行代碼,或者顯示地傳遞數組給函數. 但考慮到PHP3中這兩種選擇並沒有任何不同,我們仍然可以僅把對像模型當成一種」語法上的粉飾」來訪問數組.

想要用PHP來進行面向對像開發的人們,特別是想使用設計模式的人,很快就發現他們碰壁了. 幸運地,當時(PHP3時代)沒有太多人想用PHP來進行面向對像開發.

PHP4改變了這種情況. 新的版本帶來了引用(reference)的概念, 它允許PHP的不同標識符指向內存中的同一個地址. 這意味著你可以使用兩個或更多的名稱來給同一個變量命名,就像例6.20那樣.

Listing 6.20 PHP 4 references PHP4中的引用
PHP代碼:
<?php
$a = 5;

//$b points to the same place in memory as $a $b與$a指向內存中同個地址
$b = &$a;

//we're changing $b, since $a is pointing to 改變$b,指向的地址改變
//the same place - it changes too $a指向的地址也改變
$b = 7;

//prints 7 輸出7
print $a;
?>
由於構建一個指向彼此的對象網絡是所有面向對像設計模式的基礎,這個改進具有非常重大的意義.當引用允許建立更多強大的面向對像應用程序, PHP對待對像和其它類型數據相同的做法帶給開發者極大的痛苦.就像任何PHP4的程序員將會告訴你的, 應用程序將會遭遇WTMA(Way Too Many Ampersands過多&)綜合症. 如果你想構建一個實際應用,你會感到極為痛苦,看看例6.21你就明白.

Listing 6.21 Problems with objects in PHP 4 PHP4中使用對象的問題

1 class MyFoo {
2 function MyFoo()
3 {
4 $this->me = &$this;
5 $this->value = 5;
6 }
7
8 function setValue($val)
9 {
10 $this->value = $val;
11 }
12
13 function getValue()
14 {
15 return $this->value;
16 }
17
18 function getValueFromMe()
19 {
20 return $this->me->value;
21 }
22 }
23
24 function CreateObject($class_type)
25 {
26 switch ($class_type) {
27 case "foo":
28 $obj = new MyFoo();
29 break;
30 case "bar":
31 $obj = new MyBar();
32 break;
33 }
34 return $obj;
35 }
36
37 $global_obj = CreateObject ("foo");
38 $global_obj->setValue(7);
39
40 print "Value is " . $global_obj->getValue() . "\n";
41 print "Value is " . $global_obj->getValueFromMe() . "\n";





讓我們一步步來討論. 首先,有一個MyFoo類.在構造函數里,我們給$this->me一個引用,並設定
我們有其它三個成員函數: 一個設定this->value的值;一個返回this->value的值;另一個返回this->value->me的值. 但是--$this不是相同的東西嗎? MyFoo::getValue()和MyFoo::getValueFromMe()返回的值不是一樣的嗎?

首先,我們調用CreateObject("foo"),這會返回一個MyFoo類型的對象. 然後我們調用MyFoo::setValue(7). 最後,我們調用MyFoo::getValue() 和MyFoo::getValueFromMe(), 期望得到返回值7.
當然,如果我們在任何情況下都得到7, 以上這個例子將不是本書中最沒有意義的例子. 所以我相信你已經猜到—我們得不到兩個7這樣的結果.

但是我們將得到什麼結果,並且更重要地,為什麼呢?

我們將得到的結果分別是7和5. 至於為什麼—--有三個很好的理由.

首先,看構造函數. 當在構造函數內部,我們在this和this->me間建立引用. 換句話說,this和this->me是同個東西. 但是我們是在構造函數內. 當構造函數結束,PHP要重新建立對像(new MyFoo的結果,第28行)分配給$obj. 因為對像沒有特殊化對待,就像其它任何數據類型一樣,賦值X給Y意味著Y是X的一個副本. 也就是說,obj將是new MyFoo的一個副本,而new MyFoo是一個存在於構造函數的對象. Obj->me怎麼樣呢? 因為它是一個引用,它原封不動仍然指向原來的對象—this. Voila-obj和obj->me不再是同個東西了—改變其中一個另一個不變.

以上是第一條理由. 還有其它類似於第一條的理由. 奇跡般地我們打算克服實例化對像這個問題(第28行). 一旦我們把CreateObject返回的值賦給global_object,我們仍然要撞上相同的問題—global_object將變成返回值的一個副本,並且再次地,global_object和global_object->me將不再相同. 這就是第二條理由.

但是,事實上我們還走不了那麼遠— 一旦CreateObject返回$obj,我們將破壞引用(第34行) . 這就是第三條理由.

那麼,我們如何改正這些? 有兩個選擇. 一是在所有地方增加&符號,就像例6.22那樣(第24, 28, 31, 37行). 二.如果你幸運地使用上了PHP5,你可以忘了以上這一切,PHP5會自動為你考慮這些. 如果你想知道PHP5是如何考慮這些問題的,繼續閱讀下去.

Listing 6.22 WTMA syndrome in PHP 4 PHP4中的WTMA綜合症

1 class MyFoo {
2 function MyFoo()
3 {
4 $this->me = &$this;
5 $this->value = 2;
6 }
7
8 function setValue($val)
9 {
10 $this->value = $val;
11 }
12
13 function getValue()
14 {
15 return $this->value;
16 }
17
18 function getValueFromMe()
19 {
20 return $this->me->value;
21 }
22 };
23
24 function &CreateObject($class_type)
25 {
26 switch ($class_type) {
27 case "foo":
28 $obj =& new MyFoo();
29 break;
30 case "bar":
31 $obj =& new MyBar();
32 break;
33 }
34 return $obj;
35 }
36
37 $global_obj =& CreateObject ("foo");
38 $global_obj->setValue(7);
39
40 print "Value is " . $global_obj->getValue() . "\n";
41 print "Value is " . $global_obj->getValueFromMe() . "\n";




PHP5是第一個把對像看成與其它類型數據不同的PHP版本. 從用戶的角度看,這證明它非常明白的方式—在PHP5中,對像總是通過引用來傳遞,而其它類型數據(如integer,string,array)都是通過值來傳遞. 最顯著地,沒有必要再用&符號來表示通過引用來傳遞對象了.

面向對像編程廣泛利用了對象網絡和對像間的複雜關係,這些都需要用到引用. 在PHP的前些版本中,需要顯示地指明引用. 因此, 現在默認用引用來移動對像,並且只有在明確要求複製時才複製對像,這樣比以前更好.

它是如何實現的呢?

在PHP5之前,所有值都存在一個名為zval(Zend Value)的特殊結構裡. 這些值可以存入簡單的值,如數字和字符串,或複雜的值如數組和對像. 當值傳給函數或從函數返回時,這些值會被複製,在內存的另一個地址建立一個帶有相同內容的結構.

在PHP5中,值仍存為zval結構中,但對像除外. 對像存在一個叫做Object Store的結構裡,並且每個對象有一個不同的ID. Zval中,不儲存對像本身,而是存著對象的指針. 當複製一個持有對象的zval結構,例如我們把一個對像當成參數傳給某個函數,我們不再複製任何數據. 我們僅僅保持相同的對象指針並由另一個zval通知現在這個特定的對象指向的Object Store. 因為對像本身位於Object Store,我們對它所作的任何改變將影響到所有持有該對像指針的zval結構.這種附加的間接作用使PHP對像看起來就像總是通過引用來傳遞,用透明和有效率的方式.

使用PHP5,我們現在可以回到示例6.21,除去所有的&符號, 一切代碼都仍然可以正常工作.當我們在構造函數(第4行)中持有一個引用時一個&符號都不用.

webasp.net