PHP 物件導向
在物件導向的程式設計（英文：Object-oriented programming，縮寫：OOP）中，物件是一個由資訊及對資訊進行處理的描述所組成的整體，是對現實世界的抽象。
在現實世界裡我們所面對的事情都是對象，如電腦、電視、腳踏車等。
物件的主要三個特性：
· 物件的行為：可以對物件施加那些操作，開燈，關燈就是行為。
· 物件的形狀：當施加那些方法是物件如何回應，顏色，尺寸，外觀。
· 物件的表示：物件的表示就相當於身分證，具體區分在相同的行為與狀態下有什麼不同。
例如Animal(動物) 是一個抽象類，我們可以具體到一隻狗跟一隻羊，而狗跟羊就是具體的對象，他們有顏色屬性，可以寫，可以跑等行為狀態。
物件導向內容
#· 類別 − 定義了一件事的抽象特性。類別的定義包含了資料的形式以及資料的操作。
· 物件 − 是類別的實例。
· 成員變數 − 定義在類別內的變數。該變數的值對外是不可見的，但是可以透過成員函數訪問，在類別被實例化為物件後，該變數即可稱為物件的屬性。
· 成員函數 − 定義在類別的內部，可用來存取物件的資料。
· 繼承 − 繼承性是子類別自動共享父類別資料結構與方法的機制，這是類別之間的關係。在定義和實作一個類別的時候，可以在一個已經存在的類別的基礎之上來進行，把這個已經存在的類別所定義的內容當作自己的內容，並加入若干新的內容。
· 父類 − 一個類別被其他類別繼承，可將此類別稱為父類，或基底類，或超類別。
· 子類別 − 一個類別繼承其他類別稱為子類，也可稱為衍生類別。
· 多態 − 多態性是指相同的操作或函數、過程可作用於多種類型的物件上並獲得不同的結果。不同的對象，收到相同訊息可以產生不同的結果，這種現象稱為多態性。
· 重載 − 簡單說，就是函數或方法有同樣的名稱，但是參數列表不相同的情形，這樣的同名不同參數的函數或者方法之間，互相稱之為重載函數或者方法。
· 抽象 − 抽象性是指將具有一致的資料結構（屬性）和行為（操作）的物件抽象化成類別。一個類別就是這樣一種抽象，它反映了與應用相關的重要性質，而忽略其他一些無關內容。任何類別的劃分都是主觀的，但必須與具體的應用有關。
· 封裝 − 封裝是指將現實世界中存在的某個客體的屬性與行為綁定在一起，並放置在一個邏輯單元內。
· 建構函數 − 主要用來在建立物件時初始化對象， 即為物件成員變數賦初始值，總是與new運算子一起使用在建立物件的語句中。
· 析構函數 − 析構函數(destructor) 與建構子相反，當物件結束其生命週期時（例如物件所在的函數已調用完畢），系統會自動執行析構函數。析構函數往往用來做"清理善後" 的工作（例如在建立物件時用new開闢了一片記憶體空間，應在退出前在析構函數中用delete釋放）。
下圖中我們透過 Car 類別 創建了三個物件：Mercedes, Bmw, 和 Audi。
$mercedes = new Car ();
$bmw = new Car ();
$audi = new Car () ;
PHP 類別定義
PHP定義類別通常語法格式如下：
<?php
class phpClass {
var $var1;
var $var2 = "constant string";
function myfunc ($arg1, $arg2) {
[..]
}
[..]
}
?>#解析如下：
##· 類別使用class 關鍵字後加上類別名稱定義。 · 類別名稱後的一對大括號({})內可以定義變數與方法。 · 類別的變數使用 var 來宣告, 變數也可以初始化值。 · 函數定義類似 PHP 函數的定義，但函數只能透過該類別及其實例化的物件存取。實例
<?php
class Site {
/* 成员变量 */
var $url;
var $title;
/* 成员函数 */
function setUrl($par){
$this->url = $par;
}
function getUrl(){
echo $this->url ."<br/>";
}
function setTitle($par){
$this->title = $par;
}
function getTitle(){
echo $this->title . "<br/>";
}
}?>#變數 $this 代表自身的物件。
PHP 中建立物件
#類別建立後，我們可以使用 new 運算子來實例化該類別的物件：$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
header("Content-type:text/html;charset=utf-8"); //设置编码
class Site {
/* 成员变量 */
var $url;
var $title;
/* 成员函数 */
function setUrl($par){
$this->url = $par;
}
function getUrl(){
echo $this->url ."<br/>";
}
function setTitle($par){
$this->title = $par;
}
function getTitle(){
echo $this->title . "<br/>";
}
}
$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運算子一起使用在建立物件的語句中。
PHP 5 允行開發者在一個類別中定義一個方法作為建構函數，語法格式如下：
void __construct ([ mixed $args [, $... ]] )
在上面的例子中我們就可以透過建構方法來初始化$url 和$title變項：
function __construct( $par1, $par2 ) {
$this->url = $par1; $ this->title = $par2;}現在我們就不需要再呼叫setTitle 和setUrl 方法了：
實例
#
用建構子簡化上面程式碼：
<?php
header("Content-type:text/html;charset=utf-8"); //设置编码
class Site {
/* 成员变量 */
var $url;
var $title;
/* 成员函数 */
function setUrl($par){
$this->url = $par;
}
function getUrl(){
echo $this->url ."<br/>";
}
function setTitle($par){
$this->title = $par;
}
function getTitle(){
echo $this->title . "<br/>";
}
function __construct( $par1, $par2 ) {
$this->url = $par1;
$this->title = $par2;
}
}
// 调用成员函数，设置标题和URL
$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();
?>程式運行結果：
php中文網
淘寶
Google 搜尋
www.php.cn
www.taobao.com
www.google.com
析構函數
析構函數(destructor) 與建構子相反，當物件結束其生命週期時（例如物件所在的函數已調用完畢），系統自動執行析構函數。
PHP 5 引入了析構函數的概念，這類似於其它物件導向的語言，其語法格式如下：
void __destruct ( void )
實例
<?php
header("Content-type:text/html;charset=utf-8"); //设置编码
class MyDestructableClass {
function __construct() {
print "构造函数\n";
$this->name = "MyDestructableClass";
}
function __destruct() {
print "销毁 " . $this->name . "\n";
}
}
$obj = new MyDestructableClass();
?>#程式運行結果：
建構函數 銷毀MyDestructableClass
繼承
PHP 使用關鍵字 extends 來繼承一個類，PHP 不支援多重繼承，格式如下：
class Child extends Parent {
// 程式碼部分
}
##上面的意思是Child 類別繼承了Parent 類別實例
下面的實例中Child_Site 類別繼承了Site 類，並擴展了功能：<?php
// 子类扩展站点类别
class Child_Site extends Site {
var $category;
function setCate($par){
$this->category = $par;
}
function getCate(){
echo $this->category . "<br/>";
}
}
?>方法重寫
如果從父類別繼承的方法不能滿足子類別的需求，可以對其進行改寫，這個過程叫做方法的覆蓋（override），也稱為方法的重寫。 下面的範例中重寫了 getUrl 與 getTitle 方法： function getUrl() {
echo $this->url . PHP_EOL;
return $this->url;
}
function getTitle(){
echo $this->title . PHP_EOL;
return $this->title;
}
訪問控制
PHP 對屬性或方法的存取控制，是透過在前面新增關鍵字public（公有），protected（受保護）或private（私有）來實現的。 · public（公有）：公有的類別成員可以在任何地方被存取。
· protected（受保護）：受保護的類別成員則可以被自己以及其子類別和父類別存取。
·
private（私有）：私有的類別成員則只能被其定義所在的類別存取。 屬性的存取控制類別屬性必須定義為公有，受保護，私有之一。如果用 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
?>#介面#########使用接口（interface），可以指定某個類別必須實作哪些方法，但不需要定義這些方法的具體內容。 ######介面是透過 interface 關鍵字來定義的，就像定義一個標準的類別一樣，但其中定義所有的方法都是空的。 ######介面中定義的所有方法都必須是公有，這是介面的特性。 ######要實作一個介面，使用 implements 運算子。類別中必須實作介面中定義的所有方法，否則會報一個致命錯誤。類別可以實作多個接口，用逗號來分隔多個接口的名稱。 ############實例#########<?php
// 声明一个'iTemplate'接口
interface iTemplate
{
public function setVariable($name, $var);
public function getHtml($template);
}
// 实现接口
class Template implements iTemplate
{
private $vars = array();
public function setVariable($name, $var)
{
$this->vars[$name] = $var;
}
public function getHtml($template)
{
foreach($this->vars as $name => $value) {
$template = str_replace('{' . $name . '}', $value, $template);
}
return $template;
}
}
?>############################################################################################ #######可以把在類別中始終保持不變的值定義為常數。在定義和使用常數的時候不需要使用 $ 符號。
常數的值必須是一個定值，不能是變量，類別屬性，數學運算的結果或函數呼叫。
自 PHP 5.3.0 起，可以用一個變數來動態呼叫類別。但該變數的值不能為關鍵字（如 self，parent 或 static）。
實例
<?php
class MyClass
{
const constant = '常量值';
function showConstant() {
echo self::constant . "<br/>";
}
}
echo MyClass::constant . "<br/>";
$classname = "MyClass";
echo $classname::constant . "<br/>"; // 自 5.3.0 起
$class = new MyClass();
$class->showConstant();
echo $class::constant . "<br/>"; // 自 PHP 5.3.0 起
?>#抽象類別
##任何一個類，如果它裡面至少有一個方法是被聲明為抽象的，那麼這個類別就必須被宣告為抽象的。 定義為抽象的類別不能被實例化。 被定義為抽象的方法只是宣告了其呼叫方式（參數），不能定義其特定的功能實作。繼承一個抽象類別的時候，子類別必須定義父類別中的所有抽象方法；另外，這些方法的存取控制必須和父類別中一樣（或更為寬鬆）。例如某個抽象方法被宣告為受保護的，那麼
子類別中實作的方法就應該宣告為受保護的或是公有的，而不能定義為私有的。此外方法的呼叫方式必須匹配，即類型和所需參數數量必須一致。例如，子類別定義了一個可選參
數，而父類別抽象方法的宣告裡沒有，則兩者的宣告並無衝突。
實例
<?php
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_') . "<br/>";
$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') . "<br/>";
?>#程式運行結果：
#ConcreteClass1FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2
Static 關鍵字
#聲明類別屬性或方法為static(靜態)，就可以不實例化類別而直接存取。 靜態屬性不能透過一個類別已實例化的物件來存取（但靜態方法可以）。 由於靜態方法不需要透過物件即可調用，所以偽變數 $this 在靜態方法中不可用。 靜態屬性不可以由物件透過 -> 操作符來存取。 自 PHP 5.3.0 起，可以用一個變數來動態呼叫類別。但該變數的值不能為關鍵字 self，parent 或 static。實例
<?php
class Foo {
public static $my_static = 'foo';
public function staticValue() {
return self::$my_static;
}
}
print Foo::$my_static . "<br/>";
$foo = new Foo();
print $foo->staticValue() . "<br/>";
?>程式運行結果：foofoo
Final 關鍵字#
PHP 5 新增了一個 final 關鍵字。如果父類別中的方法被宣告為 final，則子類別無法覆寫該方法。如果一個類別被宣告為 final，則不能被繼承。
實例
以下程式碼執行會錯誤：
<?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()
?>程式執行結果：
Fatal error: Cannot override final method BaseClass::moreTesting() in D:\WWW\Basis\oop\opp_9.php on line 16
呼叫父類別建構方法
PHP 不會在子類別的建構方法中自動的呼叫父類別的建構方法。要執行父類別的建構方法，需要在子類別的建構方法中呼叫 parent::__construct()
#實例
<?php
header("Content-type:text/html;charset=utf-8"); //设置编码
class BaseClass {
function __construct() {
print "BaseClass 类中构造方法" . "<br/>";
}
}
class SubClass extends BaseClass {
function __construct() {
parent::__construct(); // 子类构造方法不能自动调用父类的构造方法
print "SubClass 类中构造方法" . "<br/>";
}
}
class OtherSubClass extends BaseClass {
// 继承 BaseClass 的构造方法
}
// 调用 BaseClass 构造方法
$obj = new BaseClass();
// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();
// 调用 BaseClass 构造方法
$obj = new OtherSubClass();
?>#程式執行結果：
BaseClass 類別中建構方法
BaseClass 類別中建構方法
SubClass 類別中建構方法
BaseClass 類別中建構方法
