PHP 新手入門之面向?qū)ο?/h1>

什么是面向?qū)ο?/p>

對象是一個由信息及對信息進行處理的描述所組成的整體，是對現(xiàn)實世界的抽象

Object-oriented programming   簡稱OOP

在現(xiàn)實社會中，我們所面對的東西都是對象，例如電腦，杯子，房子等等

對象的3個主要特性

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

2.對象的形態(tài)：當施加那些方法是對象如何響應(yīng)，顏色，尺寸，外型。

3.對象的表示：對象的表示就相當于身份證，具體區(qū)分在相同的行為與狀態(tài)下有什么不同

面向?qū)ο蟮膬?nèi)容

1.類：定義了一件事物的抽象特點。類的定義包含了數(shù)據(jù)的形式以及對數(shù)據(jù)的操作

2.對象：是類的實例

3.成員變量：定義在類內(nèi)部的變量。該變量的值對外是不可見的，但是可以通過成員函數(shù)訪問，在類被實例化為對象后，該變量即可稱為對象的屬性

4.成員函數(shù)： 定義在類的內(nèi)部，可用于訪問對象的數(shù)據(jù)

5.繼承：繼承性是子類自動共享父類數(shù)據(jù)結(jié)構(gòu)和方法的機制，這是類之間的一種關(guān)系。在定義和實現(xiàn)一個類的時候，可以在一個已經(jīng)存在的類的基礎(chǔ)之上來進行，把這個已經(jīng)存在的類所定義的內(nèi)容作為自己的內(nèi)容，并加入若干新的內(nèi)容 

6.父類：一個類被其他類繼承，可將該類稱為父類，或基類，或超類

7.子類：一個類繼承其他類稱為子類，也可稱為派生類

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

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

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

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

12.構(gòu)造函數(shù); 主要用來在創(chuàng)建對象時初始化對象， 即為對象成員變量賦初始值，總與new運算符一起使用在創(chuàng)建對象的語句中

13.析構(gòu)函數(shù)：析構(gòu)函數(shù)(destructor) 與構(gòu)造函數(shù)相反，當對象結(jié)束其生命周期時（例如對象所在的函數(shù)已調(diào)用完畢），系統(tǒng)自動執(zhí)行析構(gòu)函數(shù)。析構(gòu)函數(shù)往往用來做"清理善后" 的工作（例如在建立對象時用new開辟了一片內(nèi)存空間，應(yīng)在退出前在析構(gòu)函數(shù)中用delete釋放）

類的定義：

1.類使用 class 關(guān)鍵字后加上類名定義。

2.類名后的一對大括號({})內(nèi)可以定義變量和方法。

3.類的變量使用 var 來聲明, 變量也可以初始化值。

4.函數(shù)定義類似 PHP 函數(shù)的定義，但函數(shù)只能通過該類及其實例化的對象訪問

<?php
class Site {
    /* 成員變量 */
    var $url;
    var $title;
  
    /* 成員函數(shù) */
    function setUrl($par){
       $this->url = $par;
    }  
    function getUrl(){
       echo $this->url;
    } 
    function setTitle($par){
       $this->title = $par;
    } 
    function getTitle(){
       echo $this->title;
    }
}
//注：變量 $this 代表自身的對象。
?>

php 中創(chuàng)建對象

類創(chuàng)建后，我們可以使用 new 運算符來實例化該類的對象

$php = new Site;

$taobao = new Site;

$google = new Site;

以上代碼我們創(chuàng)建了三個對象，三個對象各自都是獨立的

<?php 
header("Content-type: text/html; charset=utf-8");//設(shè)置編碼 
class Site { 
  /* 成員變量 */ 
    var $url; 
    var $title;      
    /* 成員函數(shù) */ 
    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; 


    // 調(diào)用成員函數(shù)，設(shè)置標題和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ù)，獲取標題和URL 
    $php->getTitle(); 
    $taobao->getTitle(); 
    $google->getTitle(); 

    $php->getUrl(); 
    $taobao->getUrl(); 
    $google->getUrl(); 
?>

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

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

PHP 5 允行開發(fā)者在一個類中定義一個方法作為構(gòu)造函數(shù)，語法格式如下：

void __construct ([ mixed $args [, $... ]] )

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

析構(gòu)函數(shù)(destructor) 與構(gòu)造函數(shù)相反，當對象結(jié)束其生命周期時（例如對象所在的函數(shù)已調(diào)用完畢），系統(tǒng)自動執(zhí)行析構(gòu)函數(shù)

PHP 5 引入了析構(gòu)函數(shù)的概念，這類似于其它面向?qū)ο蟮恼Z言，其語法格式如下：void __destruct ( void )

<?php
	header("Content-type: text/html; charset=utf-8");//設(shè)置編碼 
	class MyDestructableClass {
	   function __construct() {
	       print "構(gòu)造函數(shù)</br>";
	       $this->name = "MyDestructableClass";
	   }

	   function __destruct() {
	       print "銷毀 " . $this->name;
	   }
	}

	$obj = new MyDestructableClass();
?>

繼承

PHP 使用關(guān)鍵字 extends 來繼承一個類，PHP 不支持多繼承，格式如下：

class Child extends Parent {

       // 代碼部分

}

<?php 
// 子類擴展站點類別
class Child_Site extends Site {
   	var $category;

	function setCate($par){
		$this->category = $par;
	}
  
	function getCate(){
		echo $this->category;
	}
}
?>

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

實例中重寫了 getUrl 與 getTitle 方法：

<?php
    function getUrl() {
       echo $this->url . PHP_EOL;
       return $this->url;
    }
       
    function getTitle(){
       echo $this->title . PHP_EOL;
       return $this->title;
    }
?>

訪問控制

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; // 這行能被正常執(zhí)行
//echo $obj->protected; // 這行會產(chǎn)生一個致命錯誤
//echo $obj->private; // 這行也會產(chǎn)生一個致命錯誤
$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; // 這行能被正常執(zhí)行
//echo $obj2->private; // 未定義 private
//echo $obj2->protected; // 這行會產(chǎn)生一個致命錯誤
$obj2->printHello(); // 輸出 Public、Protected2 和 Undefined

?>

方法的訪問控制

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

<?php
/**
 * Define MyClass
 */
class MyClass
{
    // 聲明一個公有的構(gòu)造函數(shù)
    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(); // 這行能被正常執(zhí)行
//$myclass->MyProtected(); // 這行會產(chǎn)生一個致命錯誤
//$myclass->MyPrivate(); // 這行會產(chǎn)生一個致命錯誤
$myclass->Foo(); // 公有，受保護，私有都可以執(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(); // 公有的和受保護的都可執(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
?>

常量

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

常量的值必須是一個定值，不能是變量，類屬性，數(shù)學運算的結(jié)果或函數(shù)調(diào)用。

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

抽象類

任何一個類，如果它里面至少有一個方法是被聲明為抽象的，那么這個類就必須被聲明為抽象的。

定義為抽象的類不能被實例化。

被定義為抽象的方法只是聲明了其調(diào)用方式（參數(shù)），不能定義其具體的功能實現(xiàn)。

繼承一個抽象類的時候，子類必須定義父類中的所有抽象方法；另外，這些方法的訪問控制必須和父類中一樣（或者更為寬松）。例如某個抽象方法被聲明為受保護的，那么子類中實現(xiàn)的方法就應(yīng)該聲明為受保護的或者公有的，而不能定義為私有的。此外方法的調(diào)用方式必須匹配，即類型和所需參數(shù)數(shù)量必須一致。例如，子類定義了一個可選參數(shù)，而父類抽象方法的聲明里沒有，則兩者的聲明并無沖突

接口

使用接口（interface），可以指定某個類必須實現(xiàn)哪些方法，但不需要定義這些方法的具體內(nèi)容。

接口是通過 interface 關(guān)鍵字來定義的，就像定義一個標準的類一樣，但其中定義所有的方法都是空的。

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

要實現(xiàn)一個接口，使用 implements 操作符。類中必須實現(xiàn)接口中定義的所有方法，否則會報一個致命錯誤。類可以實現(xiàn)多個接口，用逗號來分隔多個接口的名稱。