PHP 物件導向
在物件導向的程式設計（英文：Object-oriented programming，縮寫：OOP）中， 物件是一個由資訊及對資訊進行處理的描述所組成的整體，是對現實世界的抽象。 OOP 達到了軟體工程的三個目標：重複使用性、靈活性和擴展性。
PHP 在 4.0 版本之後完善了對 OOP 的支援了。對於小型的應用，使用傳統的過程化程式設計可能更簡單也更有效率。 然而對於大型的複雜應用時，OOP 就是一個必須考慮的選擇。
類別
類別是具有相同屬性和服務的一組物件的集合。它為屬於該類別的所有物件提供了統一的抽象描述，其內部包括屬性和服務兩個主要部分。 在物件導向的程式語言中，類別是一個獨立的程式單位，它應該有一個類別名稱並包括屬性說明和服務說明兩個主要部分。
物件
物件是系統中用來描述客觀事物的一個實體，它是構成系統的一個基本單位。一個物件由一組屬性和對這組屬性進行操作的一組服務組成。
在現實世界裡我們所面對的事情都是對象，如電腦、電視、腳踏車等。
物件的主要三個特性：
物件的行為：可以對 物件施加那些操作，開燈，關燈就是行為。
物件的形態：當施加那些方法是物件如何回應，顏色，尺寸，外型。
物件的表示：物件的表示就相當於身分證，具體區分在相同的行為與狀態下有什麼不同。
類別與物件的關係
類別與物件的關係就如模具和鑄件的關係，類別的實例化結果就是對象，而對一類別物件的抽象就是類別。
例如Animal(動物) 是一個抽象類，我們可以具體到一隻狗跟一隻羊，而狗跟羊就是具體的對象，他們有顏色屬性，可以寫，可以跑等行為狀態。
物件導向內容
類別 − 定義了一件事的抽象特性。類別的定義包含了資料的形式以及資料的操作。
物件 − 是類別的實例。
成員變數 − 定義在類別內部的變數。該變數的值對外是不可見的，但是可以透過成員函數訪問，在類別被實例化為物件後，該變數即可稱為物件的屬性。
成員函數 − 定義在類別的內部，可用來存取物件的資料。
繼承 − 繼承性是子類別自動共享父類別資料結構和方法的機制，這是類別之間的關係。在定義和實作一個類別的時候，可以在一個已經存在的類別的基礎之上來進行，把這個已經存在的類別所定義的內容當作自己的內容，並加入若干新的內容。
父類 − 一個類別被其他類別繼承，可將此類別稱為父類，或基底類，或超類別。
子類 − 一個類別繼承其他類別稱為子類，也可稱為衍生類別。
多態性 − 多態性是指相同的操作或函數、過程可作用於多種類型的物件上並獲得不同的結果。不同的對象，收到相同訊息可以產生不同的結果，這種現象稱為多態性。
重載 − 簡單說，就是函數或方法有同樣的名稱，但是參數列表不相同的情形，這樣的同名不同參數的函數或者方法之間，互相稱之為重載函數或者方法。
抽象性 − 抽象性是指將具有一致的資料結構（屬性）和行為（操作）的物件抽象化成類別。一個類別就是這樣一種抽象，它反映了與應用相關的重要性質，而忽略其他一些無關內容。任何類別的劃分都是主觀的，但必須與具體的應用有關。
封裝 − 封裝是指將現實世界中存在的某個客體的屬性與行為綁定在一起，並放置在一個邏輯單元內。
建構函數 − 主要用來在創建對象時初始化對象， 即為對象成員變數賦初始值，總是與new運算子一起使用在創建對象的語句中。
析構函數 − 析構函數(destructor) 與建構子相反，當物件結束其生命週期時（例如物件所在的函數已調用完畢），系統會自動執行析構函數。析構函數往往用來做"清理善後" 的工作（例如在建立物件時用new開闢了一片記憶體空間，應在退出前在析構函數中用delete釋放）。
下圖中我們透過 Car 類別 創建了三個物件：Mercedes, Bmw, 和 Audi。
$mercedes = new Car ();
$bmw = new Car ();
$audi = new Car ();
#PHP 類別定義
使用關鍵字class 來宣告一個類，後面緊跟著類別的名字，主體用{} 符號括起來。
語法：
class class_name{
......
}
類別內包含了屬性和方法。
透過在類別定義中使用關鍵字 var 來宣告變數，也就是建立了類別的屬性，也叫類別的成員屬性。
語法：
class class_name{
var $var_name;
}
透過在類別定義中宣告函數，即創建了類別的方法。
文法:
class class_name{
function function_name(arg1,arg2,…)
{
函數功能代碼
}
#}
#一個定義了屬性和方法的類別就是一個完整的類別了，可以在一個類別裡麵包含一個完整的處理邏輯。 使用 new 關鍵字來實例化一個物件以便應用類別裡面的邏輯。可以同時實例化多個物件。
語法：
object = new class_name();
實例化一個物件後，使用 -> 運算子來存取物件的成員屬性和方法。
語法：
object->var_name;
object->function_name;
如果要在定義的類別裡面存取成員的屬性或方法，可以使用偽變數$this 。 $this 用來表示 當前物件 或 物件本身 。
<?php
class Person {
//人的成员属性
var $name; //人的名字
var $age; //人的年龄
//人的成员 say() 方法
function say() {
echo "我的名字叫：".$this->name." <br >";
echo "我的年龄是：".$this->age;
}
} //类定义结束
//实例化一个对象
$p1 = new Person();
//给 $p1 对象属性赋值
$p1->name = "张三";
$p1->age = 20;
//调用对象中的 say()方法
$p1->say();
?>執行這個例子，輸出：
我的名字叫做：張三
我的年齡是：20
實例
##
<?php
class Site {
/* 成员变量 */
var $url;
var $title;
/* 成员函数 */
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;
// 调用成员函数，设置标题和URL
$php->setTitle( "php中文网" );
$taobao->setTitle( "淘宝" );
$google->setTitle( "Google 搜索" );
$php->setUrl( 'www.php.cn' );
$taobao->setUrl( 'www.taobao.com' );
$google->setUrl( 'www.google.com' );
// 调用成员函数，获取标题和URL
$php->getTitle();
$taobao->getTitle();
$google->getTitle();
$php->getUrl();
$taobao->getUrl();
$google->getUrl();
?>運行實例»php中文網 淘寶
Google 搜尋
www.php.cn
www.taobao.com
www.google.com
PHP 建構函數
建構函數，是一種特殊的方法。主要用來在建立物件時初始化對象， 即為對象成員變數賦初始值，總是與new運算子一起使用在建立物件的語句中。 當使用new 操作符建立一個類別的實例時，建構方法將會自動調用，其名稱必須是__construct()在一個類別中只能宣告一個建構方法，只有在每次建立對象的時候都會去呼叫一次構造方法， 不能主動的呼叫這個方法，所以通常用它來執行一些有用的初始化任務。該方法無傳回值。 語法：function __construct(arg1,arg2,...) {
......
}
<?php
function __construct( $ par1, $par2 ) {
$this->url = $par1;
$this->title = $par2;
}
#?>
<?php
$php = new Site('www.php.cn', 'php中文网');
$taobao = new Site('www.taobao.com', '淘宝');
$google = new Site('www.google.com', 'Google 搜索');
// 调用成员函数，获取标题和URL
$php->getTitle();
$taobao->getTitle();
$google->getTitle();
$php->getUrl();
$taobao->getUrl();
$google->getUrl();
?>運行實例»析構函數
與建構方法對應的就是析構方法，析構方法允許在銷毀一個類別之前執行的一些操作或完成一些功能， 例如關閉檔案、釋放結果集等。析構函數不能帶有任何參數，其名稱必須是 __destruct() 。 PHP 5 引入了析構函數的概念，這類似於其它物件導向的語言，其語法格式如下：function __destruct() {
....
}
<?php
class MyDestructableClass {
function __construct() {
print "构造函数\n";
$this->name = "MyDestructableClass";
}
function __destruct() {
print "销毁 " . $this->name . "\n";
}
}
$obj = new MyDestructableClass();
?>#執行上述程式碼，輸出結果為：建構子
銷毀MyDestructableClass
建構子與構析函數同時使用
<?php
class Person {
var $name;
var $age;
//定义一个构造方法初始化赋值
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();
?>執行上述程式碼，輸出結果為：
我的名字叫：張三
的年齡是：20
再見張三
繼承
PHP 類別的繼承是指建立一個新的派生類，從一個或多個先前定義的類別中繼承資料和方法， 而且可以重新定義或加進新資料和方法，從而建立了類別的層次或等級。
我們稱已存在的用來衍生新類別的類別為父類，由已存在的類別衍生出的新類別為子類別。繼承是物件導向的三大特性之一。
透過繼承機制，可以利用現有的資料型別來定義新的資料型別。所定義的新的資料類型不僅擁有新定義的成員，而且同時擁有舊的成員。
注意：不同於 Java 等語言，在 PHP 中，一個類別只能直接從一個類別繼承數據，即單一繼承。
使用 extends 關鍵字定義類別的繼承：
##class 子類別extends 父類別{ }
<?php
// 子类扩展站点类别
class Child_Site extends Site {
var $category;
function setCate($par){
$this->category = $par;
}
function getCate(){
echo $this->category . PHP_EOL;
}
}
?>方法重寫##如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。
實例中重寫了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 來實現對屬性或方法的存取控制。
類型的存取修飾符允許開發人員對類別成員的存取進行控制，這是 OOP 語言的特性。
PHP 支援以下三種存取修飾符：
public (公有的)：類別中的成員將沒有存取限制，所有的外部成員都可以存取（讀取和寫入）這個類成員(包括成員屬性和成員方法)。如果類別的成員沒有指定成員存取修飾符，則將被視為 public 。
protected (受保護的)：被定義為 protected 的成員不能被該類別的外部程式碼存取，但該類別的子類別具有存取權限。
private (私有的)：定義為 private 的成員，允許同一類別裡的所有成員訪問，但對於該類別的外部程式碼和子類別都不允許存取。
###修飾符存取權限對照表：### public #相同類別中 √
類別的子類別中 √
所有的外部成員 √
提示： 子類別覆寫父類別的方法時，子類別中方法的存取權限不能低於父類別被覆寫方法的存取權限。
屬性的存取控制
類別屬性必須定義為公有，受保護，私有之一。如果用 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; // 这行能被正常执行
echo $obj->protected; // 这行会产生一个致命错误
echo $obj->private; // 这行也会产生一个致命错误
$obj->printHello(); // 输出 Public、Protected 和 Private
/**
* Define MyClass2
*/
class MyClass2 extends MyClass
{
// 可以对 public 和 protected 进行重定义，但 private 而不能
protected $protected = 'Protected2';
function printHello()
{
echo $this->public;
echo $this->protected;
echo $this->private;
}
}
$obj2 = new MyClass2();
echo $obj2->public; // 这行能被正常执行
echo $obj2->private; // 未定义 private
echo $obj2->protected; // 这行会产生一个致命错误
$obj2->printHello(); // 输出 Public、Protected2 和 Undefined
?>方法的存取控制
類別中的方法可以定義為公有，私有或受保護。如果沒有設定這些關鍵字，則該方法預設為公有。
<?php
/**
* Define MyClass
*/
class MyClass
{
// 声明一个公有的构造函数
public function __construct() { }
// 声明一个公有的方法
public function MyPublic() { }
// 声明一个受保护的方法
protected function MyProtected() { }
// 声明一个私有的方法
private function MyPrivate() { }
// 此方法为公有
function Foo() {
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate();
}
}
$myclass = new MyClass;
$myclass->MyPublic(); // 这行能被正常执行
$myclass->MyProtected(); // 这行会产生一个致命错误
$myclass->MyPrivate(); // 这行会产生一个致命错误
$myclass->Foo(); // 公有，受保护，私有都可以执行
/**
* Define MyClass2
*/
class MyClass2 extends MyClass
{
// 此方法为公有
function Foo2()
{
$this->MyPublic();
$this->MyProtected();
$this->MyPrivate(); // 这行会产生一个致命错误
}
}
$myclass2 = new MyClass2;
$myclass2->MyPublic(); // 这行能被正常执行
$myclass2->Foo2(); // 公有的和受保护的都可执行，但私有的不行
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
?>封裝
封裝，就是把類別（物件）的屬性和服務結合成一個獨立的單位，並儘可能隱藏內部的細節， 只保留必要的介面與外部發生聯繫。這種封裝特性，有效的保證了物件的獨立性， 使軟體錯誤能夠局部化，大大減少查錯和排錯的難度。
使用private 關鍵字來對屬性和方法進行封裝：
<?php
class Person {
//将成员属性定义为 private
private $name;
private $age;
//定义一个构造方法初始化赋值
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 類別是單一繼承，也就是不支援多繼承，當一個類別需要多個類別的功能時，繼承就無能為力了，為此PHP 引入了類別的介面技術。
如果一個抽象類別裡面的所有方法都是抽象方法，且沒有宣告變量，而且介面裡面所有的成員都是 public 權限的， 那麼這種特殊的抽象類別就叫 介面 。
使用介面（interface），可以指定某個類別必須實作哪些方法，但不需要定義這些方法的具體內容。
介面是透過 interface 關鍵字來定義的，就像定義一個標準的類別一樣，但其中定義所有的方法都是空的。
介面中定義的所有方法都必須是公有，這是介面的特性。
要實作一個介面，使用 implements 運算子。類別中必須實作介面中定義的所有方法， 否則會報一個致命錯誤。
<?php
//定义接口
interface User{
function getDiscount();
function getUserType();
}
//VIP用户 接口实现
class VipUser implements User{
// VIP 用户折扣系数
private $discount = 0.8;
function getDiscount() {
return $this->discount;
}
function getUserType() {
return "VIP用户";
}
}
class Goods{
var $price = 100;
var $vc;
//定义 User 接口类型参数，这时并不知道是什么用户
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);//可以是更多其他用户类型
?>結果：
VIP使用者商品價格：80 元
PHP也可以在繼承一個類別的時候同時實作多個介面：class 子類別extends 父類別implemtns 介面1, 介面2, ...
{
......
}
#抽象類別和介面的區別
介面是特殊的抽象類，也可以看做是一個模型的規範。接口與抽象類別大致區別如下：
一個子類別如果implements 一個接口，就必須實現接口中的所有方法（不管是否需要）；如果是繼承一個抽象類，只需要實現需要的方法即可。
如果一個介面中定義的方法名稱改變了，那麼所有實作此介面的子類別需要同步更新方法名稱；而抽象類別中如果方法名稱改變了，其子類別對應的方法名稱將不受影響，只是變成了一個新的方法而已（相對老的方法實現）。
抽象類別只能單繼承，當子類別需要實作的功能需要繼承自多個父類別時，就必須使用介面。
常數
在類別裡面定義常數用 const 關鍵字，而不是通常的 define() 函數。
可以把在類別中始終保持不變的值定義為常數。在定義和使用常數的時候不需要使用 $ 符號。
常數的值必須是一個定值，不能是變量，類別屬性，數學運算的結果或函數呼叫。
自 PHP 5.3.0 起，可以用一個變數來動態呼叫類別。但該變數的值不能為關鍵字（如 self，parent 或 static）。
語法
const constant = "value";
實例:
<?php
Class Person{
// 定义常量
const country = "中国";
public function myCountry() {
//内部访问常量
echo "我是".self::country."人 <br >";
}
}
// 输出常量
echo Person::country." <br >";
// 访问方法
$p1 = new Person();
$p1 -> myCountry();
?>運行輸出:
中國
我是中國人
抽象類別
任何一個類，如果它裡面至少有一個方法是被宣告為抽象的，那麼這個類別就必須被宣告為抽象的。
定義為抽象的類別不能被實例化。
被定義為抽象的方法只是宣告了其呼叫方式（參數），不能定義其特定的功能實作。
繼承一個抽象類別的時候，子類別必須定義父類別中的所有抽象方法；另外，這些方法的存取控制必須和父類別中一樣（或更為寬鬆）。 例如某個抽象方法被宣告為受保護的，那麼子類別中實作的方法就應該宣告為受保護的或公有的，而不能定義為私有的。 此外方法的呼叫方式必須匹配，即類型和所需參數數量必須一致。 例如，子類別定義了一個可選參數，而父類別抽象方法的聲明裡沒有，則兩者的宣告並無衝突。
<?php
abstract class AbstractClass
{
// 强制要求子类定义这些方法
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;
?>執行上述程式碼，輸出結果為：
ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2
Static 關鍵字
#」聲明類別屬性或方法為static(靜態)，就可以不實例化類別而直接存取。 靜態屬性不能透過一個類別已實例化的物件來存取（但靜態方法可以）。 由於靜態方法不需要透過物件即可調用，所以偽變數 $this 在靜態方法中不可用。 靜態屬性不可以由物件透過 -> 操作符來存取。自 PHP 5.3.0 起，可以用一個變數來動態呼叫類別。但該變數的值不能為關鍵字 self，parent 或 static。
<?php
Class Person{
// 定义静态成员属性
public static $country = "中国";
// 定义静态成员方法
public static function myCountry() {
// 内部访问静态成员属性
echo "我是".self::$country."人<br >";
}
}
class Student extends Person {
function study() {
echo "我是". parent::$country."人<br >";
}
}
// 输出成员属性值
echo Person::$country."<br >";// 输出：中国
$p1 = new Person();
//echo $p1->country;// 错误写法
// 访问静态成员方法
Person::myCountry();// 输出：我是中国人
// 静态方法也可通过对象访问：
$p1->myCountry();
// 子类中输出成员属性值
echo Student::$country."<br >";// 输出：中国
$t1 = new Student();
$t1->study();// 输出：我是中国人
?>運行輸出:
中國
我是中國人
我是中國人
中國
我是中國人
#Final 關鍵字
PHP 5 新增了一個final 關鍵字。如果父類別中的方法被宣告為 final，則子類別無法覆寫該方法。如果一個類別被宣告為 final，則不能被繼承。
final class Person
{
......
#}
下列程式碼執行會報錯：
<?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;
}
}
// 报错信息 Fatal error: Cannot override final method BaseClass::moreTesting()
?>呼叫父類別建構方法
PHP 不會在子類別的建構方法中自動的呼叫父類別的建構方法。 要執行父類別的建構方法，需要在子類別的建構方法中呼叫 parent::__construct()。
<?php
class BaseClass {
function __construct() {
print "BaseClass 类中构造方法" . PHP_EOL;
}
}
class SubClass extends BaseClass {
function __construct() {
parent::__construct(); // 子类构造方法不能自动调用父类的构造方法
print "SubClass 类中构造方法" . PHP_EOL;
}
}
class OtherSubClass extends BaseClass {
// 继承 BaseClass 的构造方法
}
// 调用 BaseClass 构造方法
$obj = new BaseClass();
// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();
// 调用 BaseClass 构造方法
$obj = new OtherSubClass();
?>執行上述程序，輸出結果為：
BaseClass 類別中建構方法
BaseClass 類別中建構方法
SubClass 類別中建構方法
BaseClass 類別中建構方法
