PHP物件導向

PHP 物件導向

在物件導向的程式設計(英文:Object-oriented programming,縮寫:OOP)中,物件是一個由資訊及對資訊進行處理的描述所組成的整體,是對現實世界的抽象化。

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

物件主要的三個功能:

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

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

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

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

QQ图片20161009105306.png


#物件導向內容

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

·         物件 − 是類別的實例。

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

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

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

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

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

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

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

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

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

·         建構子 − 主要用來在建立物件時初始化對象, 即為物件成員變數賦初始值,總和以new運算子一起使用於建立物件的語句中。

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

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

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

QQ图片20161009105253.png


#PHP 類別定義

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 運算子來實例化該類別的物件:######$runoob = new Site;######$taobao = new Site;#######$google = new Site; ######以上程式碼我們創建了三個對象,三個對象各自都是獨立的,接下來我們來看看如何存取成員方法與成員變數。 ###

呼叫成員方法

在實例化物件後,我們可以使用該物件呼叫成員方法,該物件的成員方法只能操作該物件的成員變數:

// 呼叫成員函數,設定標題與URL

$runoob->setTitle( "PHP中文網" );

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

$google->setTitle( "Google 搜尋" );

 

$runoob->setUrl( 'www.ask. php.cn' );

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

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

 

// 呼叫成員函數,取得標題與URL

$runoob->getTitle();

$taobao->getTitle( );

$google->getTitle();

 

$runoob->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; 
   } 
 } 
 
 $runoob = new Site; 
 $taobao = new Site; 
 $google = new Site; 
 
 // 调用成员函数,设置标题和URL 
 $runoob->setTitle( " PHP中文网" ); 
 $taobao->setTitle( "淘宝" ); 
 $google->setTitle( "Google 搜索" ); 
 
 $runoob->setUrl( 'www. ask.php.cn ' ); 
 $taobao->setUrl( 'www.taobao.com' ); 
 $google->setUrl( 'www.google.com' ); 
 
 // 调用成员函数,获取标题和URL 
 $runoob->getTitle(); 
 $taobao->getTitle(); 
 $google->getTitle(); 
 
 $runoob->getUrl(); 
 $taobao->getUrl(); 
 $google->getUrl(); 
 ?>


執行以上程式碼,輸出結果為:

PHP中文網

淘寶

Google 搜尋

www.ask.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 方法了:

實例

$runoob = new Site('www.runoob.com', 'PHP中文网'); 
 $taobao = new Site('www.taobao.com', '淘宝'); 
 $google = new Site('www.google.com', 'Google 搜索'); 
 
 // 调用成员函数,获取标题和URL 
 $runoob->getTitle(); 
 $taobao->getTitle(); 
 $google->getTitle(); 
 
 $runoob->getUrl(); 
 $taobao->getUrl(); 
 $google->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){

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

介面

#使用介面(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

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

 


繼續學習
||
<?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(); ?>