PHP 物件導向

在物件導向的程式設計(英文:Object-oriented programming,縮寫:OOP)中, 物件是一個由資訊及對資訊進行處理的描述所組成的整體,是對現實世界的抽象。 OOP 達到了軟體工程的三個目標:重複使用性、靈活性和擴展性。

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

類別

類別是具有相同屬性和服務的一組物件的集合。它為屬於該類別的所有物件提供了統一的抽象描述,其內部包括屬性和服務兩個主要部分。 在物件導向的程式語言中,類別是一個獨立的程式單位,它應該有一個類別名稱並包括屬性說明和服務說明兩個主要部分。

物件

物件是系統中用來描述客觀事物的一個實體,它是構成系統的一個基本單位。一個物件由一組屬性和對這組屬性進行操作的一組服務組成。

在現實世界裡我們所面對的事情都是對象,如電腦、電視、腳踏車等。

物件的主要三個特性:

物件的行為:可以對 物件施加那些操作,開燈,關燈就是行為。

物件的形態:當施加那些方法是物件如何回應,顏色,尺寸,外型。

物件的表示:物件的表示就相當於身分證,具體區分在相同的行為與狀態下有什麼不同。

類別與物件的關係

類別與物件的關係就如模具和鑄件的關係,類別的實例化結果就是對象,而對一類別物件的抽象就是類別。

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

105.png


物件導向內容

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

物件 − 是類別的實例。

成員變數 − 定義在類別內部的變數。該變數的值對外是不可見的,但是可以透過成員函數訪問,在類別被實例化為物件後,該變數即可稱為物件的屬性。

成員函數 − 定義在類別的內部,可用來存取物件的資料。

繼承 − 繼承性是子類別自動共享父類別資料結構和方法的機制,這是類別之間的關係。在定義和實作一個類別的時候,可以在一個已經存在的類別的基礎之上來進行,把這個已經存在的類別所定義的內容當作自己的內容,並加入若干新的內容。

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

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

多態性 − 多態性是指相同的操作或函數、過程可作用於多種類型的物件上並獲得不同的結果。不同的對象,收到相同訊息可以產生不同的結果,這種現象稱為多態性。

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

抽象性 − 抽象性是指將具有一致的資料結構(屬性)和行為(操作)的物件抽象化成類別。一個類別就是這樣一種抽象,它反映了與應用相關的重要性質,而忽略其他一些無關內容。任何類別的劃分都是主觀的,但必須與具體的應用有關。

封裝 − 封裝是指將現實世界中存在的某個客體的屬性與行為綁定在一起,並放置在一個邏輯單元內。

建構函數 − 主要用來在創建對象時初始化對象, 即為對象成員變數賦初始值,總是與new運算子一起使用在創建對象的語句中。

析構函數 − 析構函數(destructor) 與建構子相反,當物件結束其生命週期時(例如物件所在的函數已調用完畢),系統會自動執行析構函數。析構函數往往用來做"清理善後" 的工作(例如在建立物件時用new開闢了一片記憶體空間,應在退出前在析構函數中用delete釋放)。

下圖中我們透過 Car 類別 創建了三個物件:Mercedes, Bmw, 和 Audi。

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

101.jpg


#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,...) 
...... 


##在上面的範例中我們就可以透過建構方法來初始化$url 和$title 變數:

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


#?>

#現在我們就不需要再呼叫setTitle 和setUrl 方法了:

實例

<?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 父類別{ }

實例

實例中Child_Site 類別繼承了Site 類,並擴展了功能:

<?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 類別中建構方法


繼續學習
||
<?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(); ?>
關於我們 免責聲明 Sitemap
PHP中文網:公益線上PHP培訓,幫助PHP學習者快速成長!