在物件導(dǎo)向的程式設(shè)計(jì)（英文：Object-oriented programming，縮寫：OOP）中， 物件是一個由資訊及對資訊進(jìn)行處理的描述所組成的整體，是對現(xiàn)實(shí)世界的抽象。 OOP 達(dá)到了軟體工程的三個目標(biāo)：重複使用性、靈活性和擴(kuò)展性。

PHP 在 4.0 版本之後完善了對 OOP 的支援了。對於小型的應(yīng)用，使用傳統(tǒng)的過程化程式設(shè)計(jì)可能更簡單也更有效率。 然而對於大型的複雜應(yīng)用時，OOP 就是一個必須考慮的選擇。

類別

類別是具有相同屬性和服務(wù)的一組物件的集合。它為屬於該類別的所有物件提供了統(tǒng)一的抽象描述，其內(nèi)部包括屬性和服務(wù)兩個主要部分。 在物件導(dǎo)向的程式語言中，類別是一個獨(dú)立的程式單位，它應(yīng)該有一個類別名稱並包括屬性說明和服務(wù)說明兩個主要部分。

物件

物件是系統(tǒng)中用來描述客觀事物的一個實(shí)體，它是構(gòu)成系統(tǒng)的一個基本單位。一個物件由一組屬性和對這組屬性進(jìn)行操作的一組服務(wù)組成。

在現(xiàn)實(shí)世界裡我們所面對的事情都是對象，如電腦、電視、腳踏車等。

物件的主要三個特性：

物件的行為：可以對 物件施加那些操作，開燈，關(guān)燈就是行為。

物件的形態(tài)：當(dāng)施加那些方法是物件如何回應(yīng)，顏色，尺寸，外型。

物件的表示：物件的表示就相當(dāng)於身分證，具體區(qū)分在相同的行為與狀態(tài)下有什麼不同。

類別與物件的關(guān)係

類別與物件的關(guān)係就如模具和鑄件的關(guān)係，類別的實(shí)例化結(jié)果就是對象，而對一類別物件的抽象就是類別。

例如Animal(動物) 是一個抽象類，我們可以具體到一隻狗跟一隻羊，而狗跟羊就是具體的對象，他們有顏色屬性，可以寫，可以跑等行為狀態(tài)。

物件導(dǎo)向內(nèi)容

類別?? 定義了一件事的抽象特性。類別的定義包含了資料的形式以及資料的操作。

物件?? 是類別的實(shí)例。

成員變數(shù)?? 定義在類別內(nèi)部的變數(shù)。該變數(shù)的值對外是不可見的，但是可以透過成員函數(shù)訪問，在類別被實(shí)例化為物件後，該變數(shù)即可稱為物件的屬性。

成員函數(shù)?? 定義在類別的內(nèi)部，可用來存取物件的資料。

繼承?? 繼承性是子類別自動共享父類別資料結(jié)構(gòu)和方法的機(jī)制，這是類別之間的關(guān)係。在定義和實(shí)作一個類別的時候，可以在一個已經(jīng)存在的類別的基礎(chǔ)之上來進(jìn)行，把這個已經(jīng)存在的類別所定義的內(nèi)容當(dāng)作自己的內(nèi)容，並加入若干新的內(nèi)容。

父類?? 一個類別被其他類別繼承，可將此類別稱為父類，或基底類，或超類別。

子類?? 一個類別繼承其他類別稱為子類，也可稱為衍生類別。

多態(tài)性?? 多態(tài)性是指相同的操作或函數(shù)、過程可作用於多種類型的物件上並獲得不同的結(jié)果。不同的對象，收到相同訊息可以產(chǎn)生不同的結(jié)果，這種現(xiàn)象稱為多態(tài)性。

重載?? 簡單說，就是函數(shù)或方法有同樣的名稱，但是參數(shù)列表不相同的情形，這樣的同名不同參數(shù)的函數(shù)或者方法之間，互相稱之為重載函數(shù)或者方法。

抽象性?? 抽象性是指將具有一致的資料結(jié)構(gòu)（屬性）和行為（操作）的物件抽象化成類別。一個類別就是這樣一種抽象，它反映了與應(yīng)用相關(guān)的重要性質(zhì)，而忽略其他一些無關(guān)內(nèi)容。任何類別的劃分都是主觀的，但必須與具體的應(yīng)用有關(guān)。

封裝?? 封裝是指將現(xiàn)實(shí)世界中存在的某個客體的屬性與行為綁定在一起，並放置在一個邏輯單元內(nèi)。

建構(gòu)函數(shù)?? 主要用來在創(chuàng)建對象時初始化對象， 即為對象成員變數(shù)賦初始值，總是與new運(yùn)算子一起使用在創(chuàng)建對象的語句中。

析構(gòu)函數(shù)?? 析構(gòu)函數(shù)(destructor) 與建構(gòu)子相反，當(dāng)物件結(jié)束其生命週期時（例如物件所在的函數(shù)已調(diào)用完畢），系統(tǒng)會自動執(zhí)行析構(gòu)函數(shù)。析構(gòu)函數(shù)往往用來做"清理善後" 的工作（例如在建立物件時用new開闢了一片記憶體空間，應(yīng)在退出前在析構(gòu)函數(shù)中用delete釋放）。

下圖中我們透過 Car 類別 創(chuàng)建了三個物件：Mercedes, Bmw, 和 Audi。

$mercedes = new Car ();?
$bmw = new Car ();?
$audi = new Car ();?

#PHP 類別定義

使用關(guān)鍵字class 來宣告一個類，後面緊跟著類別的名字，主體用{} 符號括起來。

語法：

class class_name{?
......?
}?

類別內(nèi)包含了屬性和方法。

透過在類別定義中使用關(guān)鍵字 var 來宣告變數(shù)，也就是建立了類別的屬性，也叫類別的成員屬性。

語法：

class class_name{?
var $var_name;?
}?

透過在類別定義中宣告函數(shù)，即創(chuàng)建了類別的方法。

文法:

class class_name{?
function function_name(arg1,arg2,…)?
{?
函數(shù)功能代碼?
}?
#}?

#一個定義了屬性和方法的類別就是一個完整的類別了，可以在一個類別裡麵包含一個完整的處理邏輯。 使用 new 關(guān)鍵字來實(shí)例化一個物件以便應(yīng)用類別裡面的邏輯?？梢酝瑫r實(shí)例化多個物件。

語法：

object = new class_name();

實(shí)例化一個物件後，使用?->?運(yùn)算子來存取物件的成員屬性和方法。

語法：

object->var_name;
object->function_name;

如果要在定義的類別裡面存取成員的屬性或方法，可以使用偽變數(shù)$this 。 $this 用來表示 當(dāng)前物件 或 物件本身 。

<?php
class Person { 
//人的成員屬性 
var $name; //人的名字 
var $age; //人的年齡 
//人的成員 say() 方法 
function say() { 
echo "我的名字叫：".$this->name." <br >"; 
echo "我的年齡是：".$this->age; 
} 
} //類定義結(jié)束 
//實(shí)例化一個對象 
$p1 = new Person(); 
//給 $p1 對象屬性賦值 
$p1->name = "張三"; 
$p1->age = 20; 
//調(diào)用對象中的 say()方法 
$p1->say(); 
?>

執(zhí)行這個例子，輸出：

我的名字叫做：張三?
我的年齡是：20

實(shí)例
##

<?php 
class Site { 
/* 成員變量 */ 
var $url; 
var $title; 
/* 成員函數(shù) */ 
function setUrl($par)
{ 
$this->url = $par; 
} 
function getUrl()
{ 
echo $this->url . PHP_EOL; 
} 
function setTitle($par)
{ 
$this->title = $par; 
} 
function getTitle()
{ 
echo $this->title . PHP_EOL; 
} 
} 
$php = new Site; 
$taobao = new Site; 
$google = new Site; 
// 調(diào)用成員函數(shù)，設(shè)置標(biāo)題和URL 
$php->setTitle( "php中文網(wǎng)" ); 
$taobao->setTitle( "淘寶" ); 
$google->setTitle( "Google 搜索" ); 
$php->setUrl( 'ipnx.cn' ); 
$taobao->setUrl( 'www.taobao.com' ); 
$google->setUrl( 'www.google.com' ); 
// 調(diào)用成員函數(shù)，獲取標(biāo)題和URL 
$php->getTitle(); 
$taobao->getTitle(); 
$google->getTitle(); 
$php->getUrl(); 
$taobao->getUrl(); 
$google->getUrl(); 
?>

運(yùn)行實(shí)例?

執(zhí)行上述程式碼，輸出結(jié)果為：

php中文網(wǎng)?淘寶?
Google 搜尋?
ipnx.cn?
www.taobao.com?
www.google.com?

PHP 建構(gòu)函數(shù)

建構(gòu)函數(shù)，是一種特殊的方法。主要用來在建立物件時初始化對象， 即為對象成員變數(shù)賦初始值，總是與new運(yùn)算子一起使用在建立物件的語句中。 當(dāng)使用new 操作符建立一個類別的實(shí)例時，建構(gòu)方法將會自動調(diào)用，其名稱必須是__construct()

在一個類別中只能宣告一個建構(gòu)方法，只有在每次建立對象的時候都會去呼叫一次構(gòu)造方法， 不能主動的呼叫這個方法，所以通常用它來執(zhí)行一些有用的初始化任務(wù)。該方法無傳回值。

語法：

function __construct(arg1,arg2,...)?{?
......?
}?

##在上面的範(fàn)例中我們就可以透過建構(gòu)方法來初始化$url 和$title 變數(shù)：

<?php
function __construct( $ par1, $par2 ) {?
$this->url = $par1;?
$this->title = $par2;?
}?

#?>

#現(xiàn)在我們就不需要再呼叫setTitle 和setUrl 方法了：

實(shí)例

<?php 
$php = new Site('ipnx.cn', 'php中文網(wǎng)'); 
$taobao = new Site('www.taobao.com', '淘寶'); 
$google = new Site('www.google.com', 'Google 搜索'); 
// 調(diào)用成員函數(shù)，獲取標(biāo)題和URL 
$php->getTitle(); 
$taobao->getTitle(); 
$google->getTitle(); 
$php->getUrl(); 
$taobao->getUrl(); 
$google->getUrl(); 
?>

運(yùn)行實(shí)例?

析構(gòu)函數(shù)

與建構(gòu)方法對應(yīng)的就是析構(gòu)方法，析構(gòu)方法允許在銷毀一個類別之前執(zhí)行的一些操作或完成一些功能， 例如關(guān)閉檔案、釋放結(jié)果集等。析構(gòu)函數(shù)不能帶有任何參數(shù)，其名稱必須是 __destruct() 。

PHP 5 引入了析構(gòu)函數(shù)的概念，這類似於其它物件導(dǎo)向的語言，其語法格式如下：

function __destruct()?{?
....?
}?

實(shí)例

<?php 
class MyDestructableClass { 
function __construct() { 
print "構(gòu)造函數(shù)\n"; 
$this->name = "MyDestructableClass"; 
} 
function __destruct() { 
print "銷毀 " . $this->name . "\n"; 
} 
} 
$obj = new MyDestructableClass(); 
?>

#執(zhí)行上述程式碼，輸出結(jié)果為：

建構(gòu)子?
銷毀MyDestructableClass

建構(gòu)子與構(gòu)析函數(shù)同時使用

<?php 
class Person { 
var $name; 
var $age; 
//定義一個構(gòu)造方法初始化賦值 
function __construct($name,$age) { 
$this->name=$name; 
$this->age=$age; 
} 
function say() { 
echo "我的名字叫：".$this->name." <br >"; 
echo "我的年齡是：".$this->age." <br >";; 
} 
function __destruct() 
{ 
echo "再見".$this->name; 
} 
} 
$p1=new Person("張三", 20); 
$p1->say(); 
?>

執(zhí)行上述程式碼，輸出結(jié)果為：

我的名字叫：張三?
的年齡是：20?
再見張三

繼承

PHP 類別的繼承是指建立一個新的派生類，從一個或多個先前定義的類別中繼承資料和方法， 而且可以重新定義或加進(jìn)新資料和方法，從而建立了類別的層次或等級。

我們稱已存在的用來衍生新類別的類別為父類，由已存在的類別衍生出的新類別為子類別。繼承是物件導(dǎo)向的三大特性之一。

透過繼承機(jī)制，可以利用現(xiàn)有的資料型別來定義新的資料型別。所定義的新的資料類型不僅擁有新定義的成員，而且同時擁有舊的成員。

注意：不同於 Java 等語言，在 PHP 中，一個類別只能直接從一個類別繼承數(shù)據(jù)，即單一繼承。

使用?extends?關(guān)鍵字定義類別的繼承：

##class 子類別extends 父類別{?}

實(shí)例

實(shí)例中Child_Site 類別繼承了Site 類，並擴(kuò)展了功能：

<?php 
// 子類擴(kuò)展站點(diǎn)類別 
class Child_Site extends Site { 
var $category; 
function setCate($par){ 
$this->category = $par; 
} 
function getCate(){ 
echo $this->category . PHP_EOL; 
} 
} 
?>

方法重寫##如果從父類繼承的方法不能滿足子類的需求，可以對其進(jìn)行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。

實(shí)例中重寫了getUrl 與getTitle 方法：

function getUrl() {?

echo $this->url . PHP_EOL;?#return $this- >url;?
}?

function getTitle(){?
echo $this->title . PHP_EOL;?
return $this->title;?
}?
#}?
return $this->title;?

}?

#}

存取控制和封裝

#PHP 中透過在前面新增存取修飾符public、protected 或private 來實(shí)現(xiàn)對屬性或方法的存取控制。

類型的存取修飾符允許開發(fā)人員對類別成員的存取進(jìn)行控制，這是 OOP 語言的特性。

PHP 支援以下三種存取修飾符：

public?(公有的)：類別中的成員將沒有存取限制，所有的外部成員都可以存?。ㄗx取和寫入）這個類成員(包括成員屬性和成員方法)。如果類別的成員沒有指定成員存取修飾符，則將被視為 public 。

protected?(受保護(hù)的)：被定義為 protected 的成員不能被該類別的外部程式碼存取，但該類別的子類別具有存取權(quán)限。

private?(私有的)：定義為 private 的成員，允許同一類別裡的所有成員訪問，但對於該類別的外部程式碼和子類別都不允許存取。

###修飾符存取權(quán)限對照表：###

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? public ? ? ?#相同類別中? ? ? ? ? ? ? ? ? ?√ ? ? ? ? ? ? ? ? ? ? ? ?? ?

類別的子類別中? ? ? ? ? ? ? ? ? ?√ ? ? ? ? ? ? ??
所有的外部成員? ? ? ? ? ? ?√ ? ?

提示： 子類別覆寫父類別的方法時，子類別中方法的存取權(quán)限不能低於父類別被覆寫方法的存取權(quán)限。

屬性的存取控制

類別屬性必須定義為公有，受保護(hù)，私有之一。如果用 var 定義，則視為公有。

<?php 
/** 
* Define MyClass 
*/ 
class MyClass 
{ 
public $public = 'Public'; 
protected $protected = 'Protected'; 
private $private = 'Private'; 
function printHello()
{ 
echo $this->public; 
echo $this->protected; 
echo $this->private; 
} 
} 
$obj = new MyClass(); 
echo $obj->public; // 這行能被正常執(zhí)行 
echo $obj->protected; // 這行會產(chǎn)生一個致命錯誤 
echo $obj->private; // 這行也會產(chǎn)生一個致命錯誤 
$obj->printHello(); // 輸出 Public、Protected 和 Private 
/** 
* Define MyClass2 
*/ 
class MyClass2 extends MyClass 
{ 
// 可以對 public 和 protected 進(jìn)行重定義，但 private 而不能 
protected $protected = 'Protected2'; 
function printHello() 
{ 
echo $this->public; 
echo $this->protected; 
echo $this->private;
} 
} 
$obj2 = new MyClass2(); 
echo $obj2->public; // 這行能被正常執(zhí)行 
echo $obj2->private; // 未定義 private 
echo $obj2->protected; // 這行會產(chǎn)生一個致命錯誤 
$obj2->printHello(); // 輸出 Public、Protected2 和 Undefined 
?>

方法的存取控制

類別中的方法可以定義為公有，私有或受保護(hù)。如果沒有設(shè)定這些關(guān)鍵字，則該方法預(yù)設(shè)為公有。

<?php 
/** 
* Define MyClass 
*/ 
class MyClass 
{ 
// 聲明一個公有的構(gòu)造函數(shù) 
public function __construct() { } 
// 聲明一個公有的方法 
public function MyPublic() { } 
// 聲明一個受保護(hù)的方法 
protected function MyProtected() { } 
// 聲明一個私有的方法 
private function MyPrivate() { } 
// 此方法為公有 
function Foo() { 
$this->MyPublic(); 
$this->MyProtected(); 
$this->MyPrivate();
} 
} 
$myclass = new MyClass; 
$myclass->MyPublic(); // 這行能被正常執(zhí)行 
$myclass->MyProtected(); // 這行會產(chǎn)生一個致命錯誤 
$myclass->MyPrivate(); // 這行會產(chǎn)生一個致命錯誤 
$myclass->Foo(); // 公有，受保護(hù)，私有都可以執(zhí)行 

/** 
* Define MyClass2 
*/ 
class MyClass2 extends MyClass 
{ 
// 此方法為公有 
function Foo2() 
{ 
$this->MyPublic(); 
$this->MyProtected(); 
$this->MyPrivate(); // 這行會產(chǎn)生一個致命錯誤 
} 
} 
$myclass2 = new MyClass2; 
$myclass2->MyPublic(); // 這行能被正常執(zhí)行 
$myclass2->Foo2(); // 公有的和受保護(hù)的都可執(zhí)行，但私有的不行 
class Bar 
{ 
public function test() 
{ 
$this->testPrivate(); 
$this->testPublic(); 
} 
public function testPublic() 
{ 
echo "Bar::testPublic\n"; 
} 
private function testPrivate() 
{ 
echo "Bar::testPrivate\n"; 
} 
} 
class Foo extends Bar 
{ 
public function testPublic() 
{ 
echo "Foo::testPublic\n"; 
} 
private function testPrivate() 
{ 
echo "Foo::testPrivate\n"; 
} 
} 
$myFoo = new foo(); 
$myFoo->test(); // Bar::testPrivate 
// Foo::testPublic 
?>

封裝

封裝，就是把類別（物件）的屬性和服務(wù)結(jié)合成一個獨(dú)立的單位，並儘可能隱藏內(nèi)部的細(xì)節(jié)， 只保留必要的介面與外部發(fā)生聯(lián)繫。這種封裝特性，有效的保證了物件的獨(dú)立性， 使軟體錯誤能夠局部化，大大減少查錯和排錯的難度。

使用private 關(guān)鍵字來對屬性和方法進(jìn)行封裝：

<?php 
class Person { 
//將成員屬性定義為 private 
private $name; 
private $age; 
//定義一個構(gòu)造方法初始化賦值 
function __construct($name, $age) { 
$this->name=$name; 
$this->age=$age; 
} 
function say() { 
echo "我的名字叫：".$this->name." <br >"; 
echo "我的年齡是：".$this->age; 
} 
} 
$p1=new Person("張三", 20); 
$p1->say(); 
?>

#介面

PHP 類別是單一繼承，也就是不支援多繼承，當(dāng)一個類別需要多個類別的功能時，繼承就無能為力了，為此PHP 引入了類別的介面技術(shù)。
如果一個抽象類別裡面的所有方法都是抽象方法，且沒有宣告變量，而且介面裡面所有的成員都是 public 權(quán)限的， 那麼這種特殊的抽象類別就叫 介面 。

使用介面（interface），可以指定某個類別必須實(shí)作哪些方法，但不需要定義這些方法的具體內(nèi)容。

介面是透過?interface?關(guān)鍵字來定義的，就像定義一個標(biāo)準(zhǔn)的類別一樣，但其中定義所有的方法都是空的。

介面中定義的所有方法都必須是公有，這是介面的特性。

要實(shí)作一個介面，使用?implements?運(yùn)算子。類別中必須實(shí)作介面中定義的所有方法， 否則會報(bào)一個致命錯誤。

<?php 
//定義接口 
interface User{ 
function getDiscount(); 
function getUserType(); 
} 
//VIP用戶 接口實(shí)現(xiàn) 
class VipUser implements User{ 
// VIP 用戶折扣系數(shù) 
private $discount = 0.8; 
function getDiscount() { 
return $this->discount; 
} 
function getUserType() { 
return "VIP用戶"; 
} 
} 
class Goods{ 
var $price = 100; 
var $vc; 
//定義 User 接口類型參數(shù)，這時并不知道是什么用戶 
function run(User $vc){ 
$this->vc = $vc; 
$discount = $this->vc->getDiscount(); 
$usertype = $this->vc->getUserType(); 
echo $usertype."商品價格：".$this->price*$discount; 
} 
} 
$display = new Goods(); 
$display ->run(new VipUser);//可以是更多其他用戶類型 
?>

結(jié)果：

VIP使用者商品價格：80 元

PHP也可以在繼承一個類別的時候同時實(shí)作多個介面：

class 子類別extends 父類別implemtns 介面1, 介面2, ...
{?
......?
}?

#抽象類別和介面的區(qū)別

介面是特殊的抽象類，也可以看做是一個模型的規(guī)範(fàn)。接口與抽象類別大致區(qū)別如下：

一個子類別如果implements 一個接口，就必須實(shí)現(xiàn)接口中的所有方法（不管是否需要）；如果是繼承一個抽象類，只需要實(shí)現(xiàn)需要的方法即可。

如果一個介面中定義的方法名稱改變了，那麼所有實(shí)作此介面的子類別需要同步更新方法名稱；而抽象類別中如果方法名稱改變了，其子類別對應(yīng)的方法名稱將不受影響，只是變成了一個新的方法而已（相對老的方法實(shí)現(xiàn)）。

抽象類別只能單繼承，當(dāng)子類別需要實(shí)作的功能需要繼承自多個父類別時，就必須使用介面。

常數(shù)

在類別裡面定義常數(shù)用 const 關(guān)鍵字，而不是通常的 define() 函數(shù)。

可以把在類別中始終保持不變的值定義為常數(shù)。在定義和使用常數(shù)的時候不需要使用 $ 符號。

常數(shù)的值必須是一個定值，不能是變量，類別屬性，數(shù)學(xué)運(yùn)算的結(jié)果或函數(shù)呼叫。

自 PHP 5.3.0 起，可以用一個變數(shù)來動態(tài)呼叫類別。但該變數(shù)的值不能為關(guān)鍵字（如 self，parent 或 static）。

語法

const constant = "value";

實(shí)例:

<?php 
Class Person{ 
// 定義常量 
const country = "中國"; 
public function myCountry() { 
//內(nèi)部訪問常量 
echo "我是".self::country."人 <br >"; 
} 
} 
// 輸出常量 
echo Person::country." <br >"; 
// 訪問方法 
$p1 = new Person(); 
$p1 -> myCountry(); 
?>

運(yùn)行輸出:

中國?
我是中國人

抽象類別

任何一個類，如果它裡面至少有一個方法是被宣告為抽象的，那麼這個類別就必須被宣告為抽象的。

定義為抽象的類別不能被實(shí)例化。

被定義為抽象的方法只是宣告了其呼叫方式（參數(shù)），不能定義其特定的功能實(shí)作。

繼承一個抽象類別的時候，子類別必須定義父類別中的所有抽象方法；另外，這些方法的存取控制必須和父類別中一樣（或更為寬鬆）。 例如某個抽象方法被宣告為受保護(hù)的，那麼子類別中實(shí)作的方法就應(yīng)該宣告為受保護(hù)的或公有的，而不能定義為私有的。 此外方法的呼叫方式必須匹配，即類型和所需參數(shù)數(shù)量必須一致。 例如，子類別定義了一個可選參數(shù)，而父類別抽象方法的聲明裡沒有，則兩者的宣告並無衝突。

<?php 
abstract class AbstractClass 
{ 
// 強(qiáng)制要求子類定義這些方法 
abstract protected function getValue(); 
abstract protected function prefixValue($prefix); 
// 普通方法（非抽象方法） 
public function printOut() { 
print $this->getValue() . PHP_EOL; 
} 
} 
class ConcreteClass1 extends AbstractClass 
{ 
protected function getValue() { 
return "ConcreteClass1"; 
} 
public function prefixValue($prefix) { 
return "{$prefix}ConcreteClass1"; 
} 
} 
class ConcreteClass2 extends AbstractClass 
{ 
public function getValue() { 
return "ConcreteClass2"; 
} 
public function prefixValue($prefix) { 
return "{$prefix}ConcreteClass2"; 
} 
} 
$class1 = new ConcreteClass1; 
$class1->printOut(); 
echo $class1->prefixValue('FOO_') . PHP_EOL; 
$class2 = new ConcreteClass2; 
$class2->printOut(); 
echo $class2->prefixValue('FOO_') . PHP_EOL; 
?>

執(zhí)行上述程式碼，輸出結(jié)果為：

ConcreteClass1?
FOO_ConcreteClass1?
ConcreteClass2?
FOO_ConcreteClass2

Static 關(guān)鍵字

#」聲明類別屬性或方法為static(靜態(tài))，就可以不實(shí)例化類別而直接存取。

靜態(tài)屬性不能透過一個類別已實(shí)例化的物件來存?。ǖo態(tài)方法可以）。

由於靜態(tài)方法不需要透過物件即可調(diào)用，所以偽變數(shù) $this 在靜態(tài)方法中不可用。

靜態(tài)屬性不可以由物件透過 -> 操作符來存取。

自 PHP 5.3.0 起，可以用一個變數(shù)來動態(tài)呼叫類別。但該變數(shù)的值不能為關(guān)鍵字 self，parent 或 static。

<?php 
Class Person{ 
// 定義靜態(tài)成員屬性 
public static $country = "中國"; 
// 定義靜態(tài)成員方法 
public static function myCountry() { 
// 內(nèi)部訪問靜態(tài)成員屬性 
echo "我是".self::$country."人<br >"; 
} 
} 
class Student extends Person { 
function study() { 
echo "我是". parent::$country."人<br >"; 
} 
} 
// 輸出成員屬性值 
echo Person::$country."<br >";// 輸出：中國 
$p1 = new Person(); 
//echo $p1->country;// 錯誤寫法 
// 訪問靜態(tài)成員方法 
Person::myCountry();// 輸出：我是中國人 
// 靜態(tài)方法也可通過對象訪問： 
$p1->myCountry(); 
// 子類中輸出成員屬性值 
echo Student::$country."<br >";// 輸出：中國 
$t1 = new Student(); 
$t1->study();// 輸出：我是中國人 
?>

運(yùn)行輸出:

中國?
我是中國人?
我是中國人?
中國?
我是中國人

#Final 關(guān)鍵字

PHP 5 新增了一個final 關(guān)鍵字。如果父類別中的方法被宣告為 final，則子類別無法覆寫該方法。如果一個類別被宣告為 final，則不能被繼承。

final class Person?
{?
......?
#}?

下列程式碼執(zhí)行會報(bào)錯：

<?php 
class BaseClass { 
public function test() { 
echo "BaseClass::test() called" . PHP_EOL; 
} 
final public function moreTesting() { 
echo "BaseClass::moreTesting() called" . PHP_EOL; 
} 
} 
class ChildClass extends BaseClass { 
public function moreTesting() { 
echo "ChildClass::moreTesting() called" . PHP_EOL; 
} 
} 
// 報(bào)錯信息 Fatal error: Cannot override final method BaseClass::moreTesting() 
?>

呼叫父類別建構(gòu)方法

PHP 不會在子類別的建構(gòu)方法中自動的呼叫父類別的建構(gòu)方法。 要執(zhí)行父類別的建構(gòu)方法，需要在子類別的建構(gòu)方法中呼叫?parent::__construct()。

<?php 
class BaseClass { 
function __construct() { 
print "BaseClass 類中構(gòu)造方法" . PHP_EOL; 
} 
} 
class SubClass extends BaseClass { 
function __construct() { 
parent::__construct(); // 子類構(gòu)造方法不能自動調(diào)用父類的構(gòu)造方法 
print "SubClass 類中構(gòu)造方法" . PHP_EOL; 
} 
} 
class OtherSubClass extends BaseClass { 
// 繼承 BaseClass 的構(gòu)造方法 
} 
// 調(diào)用 BaseClass 構(gòu)造方法 
$obj = new BaseClass(); 
// 調(diào)用 BaseClass、SubClass 構(gòu)造方法 
$obj = new SubClass(); 
// 調(diào)用 BaseClass 構(gòu)造方法 
$obj = new OtherSubClass(); 
?>

執(zhí)行上述程序，輸出結(jié)果為：

BaseClass 類別中建構(gòu)方法?
BaseClass 類別中建構(gòu)方法?
SubClass 類別中建構(gòu)方法?
BaseClass 類別中建構(gòu)方法