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 . PHP_EOL;
  }
  
  function setTitle($par){
     $this->title = $par;
  }
  
  function getTitle(){
     echo $this->title . PHP_EOL;
  }
}
?>

變量 $this 代表自身的對象。 PHP_EOL 為換行符。

PHP 中創建對象

類創建后，我們可以使用 new 運算符來實例化該類的對象：

$dyf = new Site;

$taobao = new Site;

$google = new Site;

以上代碼我們創建了三個對象，三個對象各自都是獨立的，接下來我們來看看如何訪問成員方法與成員變量。

調用成員方法 在實例化對象后，我們可以使用該對象調用成員方法，該對象的成員方法只能操作該對象的成員變量：

 // 調用成員函數，設置標題和URL 

 $dyf->setTitle( "dyf" ); 

 $taobao->setTitle( "淘寶" );

 $google->setTitle( "Google " );

 

 $dyf->setUrl( 'www.dyf.com' ); 

 $taobao->setUrl( 'www.taobao.com' );

 $google->setUrl( 'www.google.com' );

 

 // 調用成員函數，獲取標題和URL 

 $dyf->getTitle(); 

 $taobao->getTitle();

 $google->getTitle();

 

 $dyf->getUrl();

  $taobao->getUrl(); 

  $google->getUrl();

完整代碼如下：

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

$baidu= new Site;
$taobao = new Site;
$google = new Site;

// 調用成員函數，設置標題和URL
$baidu->setTitle( "百度" );
$taobao->setTitle( "淘寶" );
$google->setTitle( "Google 搜索" );

$baidu->setUrl( 'www.baidu.com' );
$taobao->setUrl( 'www.taobao.com' );
$google->setUrl( 'www.google.com' );

// 調用成員函數，獲取標題和URL
$baidu->getTitle();
$taobao->getTitle();
$google->getTitle();

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

執行以上代碼，輸出結果為：

百度 淘寶 Google 搜索 www.baidu.com www.taobao.com www.google.com

PHP 構造函數

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

PHP 5 允許開發者在一個類中定義一個方法作為構造函數，語法格式如下：

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

在上面的例子中我們就可以通過構造方法來初始化 和???和title 變量：

function __construct( $par1, $par2 ) {

   $this->url = $par1;

   $this->title = $par2;

}

現在我們就不需要再調用 setTitle 和 setUrl 方法了：

$baidu= new Site('www.baidu.com', '百度');
$taobao = new Site('www.taobao.com', '淘寶');
$google = new Site('www.google.com', 'Google 搜索');

// 調用成員函數，獲取標題和URL
$baidu->getTitle();
$taobao->getTitle();
$google->getTitle();

$baidu->getUrl();
$taobao->getUrl();
$google->getUrl();

析構函數

析構函數(destructor) 與構造函數相反，當對象結束其生命周期時（例如對象所在的函數已調用完畢），系統自動執行析構函數。

PHP 5 引入了析構函數的概念，這類似于其它面向對象的語言，其語法格式如下：

void __destruct ( void )

實例

<?php
class MyDestructableClass {
   function __construct() {
       print "構造函數
";
       $this->name = "MyDestructableClass";
   }

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

$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
";
    }
    
    private function testPrivate() {
        echo "Bar::testPrivate
";
    }
}

class Foo extends Bar 
{
    public function testPublic() {
        echo "Foo::testPublic
";
    }
    
    private function testPrivate() {
        echo "Foo::testPrivate
";
    }
}

$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 . PHP_EOL;
    }
}

echo MyClass::constant . PHP_EOL;

$classname = "MyClass";
echo $classname::constant . PHP_EOL; // 自 5.3.0 起

$class = new MyClass();
$class->showConstant();

echo $class::constant . PHP_EOL; // 自 PHP 5.3.0 起
?>

抽象類

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

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

被定義為抽象的方法只是聲明了其調用方式（參數），不能定義其具體的功能實現。

繼承一個抽象類的時候，子類必須定義父類中的所有抽象方法；另外，這些方法的訪問控制必須和父類中一樣（或者更為寬松）。例如某個抽象方法被聲明為受保護的，那么子類中實現的方法就應該聲明為受保護的或者公有的，而不能定義為私有的。

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

此外，子類方法可以包含父類抽象方法中不存在的可選參數。

例如，子類定義了一個可選參數，而父類抽象方法的聲明里沒有，則也是可以正常運行的。

<?php
abstract class AbstractClass
{
    // 我們的抽象方法僅需要定義需要的參數
    abstract protected function prefixName($name);

}

class ConcreteClass extends AbstractClass
{

    // 我們的子類可以定義父類簽名中不存在的可選參數
    public function prefixName($name, $separator = ".") {
        if ($name == "Pacman") {
            $prefix = "Mr";
        } elseif ($name == "Pacwoman") {
            $prefix = "Mrs";
        } else {
            $prefix = "";
        }
        return "{$prefix}{$separator} {$name}";
    }
}

$class = new ConcreteClass;
echo $class->prefixName("Pacman"), "
";
echo $class->prefixName("Pacwoman"), "
";
?>

輸出結果為：

Mr. Pacman Mrs. Pacwoman

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 . PHP_EOL;
$foo = new Foo();

print $foo->staticValue() . PHP_EOL;
?>    

執行以上程序，輸出結果為：

foo foo

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

調用父類構造方法

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 類中構造方法

說下繼承，子類繼承父類的屬性和方法，也就是說子類擁有父類所有的東西，包括 public(公有)、protected(保護)和private(私有)的。但是父類私有的屬性和方法不能讓子類直接調用，并不是說沒有繼承過來，而是繼承過來了，但是要調用父類的私有屬性和方法的話還是需要通過父類的 public、protected 方法調用。

<?php

class father {

    public function __construct(){
        echo "父類構造函數，如果子類沒有重寫構造函數將會調用這里。如果子類重寫了構造函數則子類不用自動調用這個函數，而需要顯示調用父類構造函數。";
    }

    public $m_fa="fa";
    protected $m_fb="fb";
    private $m_fc="fc";

    public function getFa(){return $m_fa;}
    protected function getFb(){return $m_fb;}
    private function getFc(){return $m_fc;}
    public function getFaPrivate_1(){return $m_fc;}
    public function getFaPrivate_2(){return $m_fc;}

    public function getAll(){
        echo $this->m_fa, $this->m_fb, $this->m_fc;
        echo  $this->getFa(), $this->getFb(), $this->getFc();
    }

}

class son extends father{
    public function __construct(){
        parent::__construct(); //顯示調用父類構造函數。
        echo "子類構造函數調用";
    }
}

$class_fa = 'father';
$class_son = 'son';
$fa = new $class_fa();
$fa->getAll();
$son = new $class_son();
$son->getFa();
// 執行以下方法回報錯，protected 無法在類外面進行調用的
// 報錯信息：Fatal error: Uncaught Error: Call to protected method father::getFb()...
// $son->getFb();
// 執行以下方法回報錯，private 無法被繼承，也無法在類外面進行調用的
// 報錯信息：Fatal error: Uncaught Error: Call to private method father::getFc()...
// $son->getFc();

$son->getFaPrivate_2();
?>

子類繼承帶有參數的父類的構造方法：

class students{
    var $name,$age,$sex;
    function __construct($name,$age,$sex){
        $this->name = $name;
        $this->age = $age;
        $this->sex = $sex;
    }
}

class master extends students{
    var $hobby,$address;
    function __construct($name, $age, $sex,$hobby,$address){
        parent::__construct($name, $age, $sex);
        $this->hobby = $hobby;
        $this->address = $address;
    }
}