在面向物件的程式設計（英語：Object-oriented programming，縮寫：OOP）中，物件是一個由資訊及對資訊進行處理的描述所組成的整體，是對現實世界的抽象，然而在現實世界裡我們所面對的事情都是物件，如計算機、電視機、自行車等，我們來看下物件的三個主要特徵：

• 物件的行為：可以對 物件施加那些操作，開燈，關燈就是行為。
• 物件的形態：當施加那些方法是物件如何響應，顏色，尺寸，外型。
• 物件的表示：物件的表示就相當於身份證，具體區分在相同的行為與狀態下有什麼不同。

舉個栗子，比如 Animal(動物) 是一個抽象類，我們可以具體到一隻狗跟一隻羊，而狗跟羊就是具體的物件，他們有顏色屬性，可以寫，可以跑等行為狀態，來看張圖片感受下：

來看下面向物件的主要內容：

• 類 − 定義了一件事物的抽象特點。類的定義包含了資料的形式以及對資料的操作。

• 物件 − 是類的例項。

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

• 成員函式 − 定義在類的內部，可用於訪問物件的資料。

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

• 父類

  − 一個類被其他類繼承，可將該類稱為父類，或基類，或超類。

• 子類 − 一個類繼承其他類稱為子類，也可稱為派生類。

• 多型 − 多型性是指相同的函式或方法可作用於多種型別的物件上並獲得不同的結果。不同的物件，收到同一訊息可以產生不同的結果，這種現象稱為多型性。

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

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

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

• 建構函式 − 主要用來在建立物件時初始化物件， 即為物件成員變數賦初始值，總與new運算子一起使用在建立物件的語句中。

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

接下來，咱們通過通過 Car 類 建立了三個物件，Mercedes, Bmw, 和 Audi ，看下程式碼：

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

看了程式碼是不是一臉懵，不要緊，咱們看下圖片感受下：

到了這裡呢，咱們對於物件有了一個簡單的認知了已經，接下來咱們就看下這個類，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 . PHP_EOL;
  }
  
  function setTitle($par){
     $this->title = $par;
  }
  
  function getTitle(){
     echo $this->title . PHP_EOL;
  }
}
?>

當類建立後，我們可以使用 new 運算子來例項化該類的物件，如下：

$luyaran = new Site;
$cuijinpeng = new Site;

通過以上程式碼，我們已經建立了兩個物件，並且兩個物件各自都是獨立的，接下來我們來看看如何訪問成員方法與成員變數。

首先，在例項化物件後，我們可以使用該物件呼叫成員方法，該物件的成員方法只能操作該物件的成員變數，如下：

// 呼叫成員函式，設定標題和URL
$luyaran->setTitle( "luyaran" );
$cuijinpeng->setTitle( "cuijinpeng" );

$luyaran->setUrl( 'www.luyaran.com' );
$cuijinpeng->setUrl( 'www.cuijinpeng.com' );

// 呼叫成員函式，獲取標題和URL
$luyaran->getTitle();
$cuijinpeng->getTitle();

$luyaran->getUrl();
$cuijinpeng->getUrl();

咱們接下來就要繼續完善咱們剛剛建立的類了。

先來看建構函式，它是一種特殊的方法。主要用來在建立物件時初始化物件， 即為物件成員變數賦初始值，在建立物件的語句中與 new 運算子一起使用。PHP 5 允許開發者在一個類中定義一個方法作為建構函式，語法格式如下：

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

接下來我們來通過構造方法來初始化 $url 和 $title 變數，以晚上Site類，如下：

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

到了這裡呢，我們如果要設定url和title值，就不需要再呼叫 setTitle 和 setUrl 方法了，具體設定方法如下：

$luyaran = new Site('www.luyaran.com', 'luyaran');
$cuijinpeng = new Site('www.cuijinpeng.com', 'cuijinpeng');


// 呼叫成員函式，獲取標題和URL
$luyaran->getTitle();
$cuijinpeng->getTitle();
$google->getTitle();

$luyaran->getUrl();
$cuijinpeng->getUrl(); 

完事來看解構函式(destructor)，它與建構函式相反，當物件結束其生命週期時（例如物件所在的函式已呼叫完畢），系統自動執行解構函式。PHP 5 引入了解構函式的概念，這類似於其它面向物件的語言，其語法格式如下：

void __destruct ( void )

來看例項：

<?php
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_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;
}

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
?>

好啦，本次記錄就到這裡了。

如果感覺不錯的話，請多多點贊支援哦。。。