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( 'm.sbmmt.com' ); $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 搜尋
m.sbmmt.com
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('m.sbmmt.com', '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 類別中建構方法