PHP 設計模式總結

1.工廠模式

①抽象基類：類中定義抽象一些方法，用以在子類中實現
②繼承自抽象基類的子類：實現基類中的抽象方法
③工廠類：用以實例化所有相對應的子類

常用運算來進行舉列子說明：

   /**
     * 
     * 定義個抽象的類，讓子類去繼承實現它
     *
     */
     abstract class Operation{
         #抽象方法不能包含函數體
         #強烈要求子類必須實現該功能函數
         abstract public function getValue($num1,$num2);
     }
     
     
     
     /**
      * 加法類
      */
     class OperationAdd extends Operation {
         public function getValue($num1,$num2){
             return $num1+$num2;
         }
     }
     /**
      * 減法類
      */
     class OperationSub extends Operation {
         public function getValue($num1,$num2){
             return $num1-$num2;
         }
     }
     /**
      * 乘法類
      */
     class OperationMul extends Operation {
         public function getValue($num1,$num2){
             return $num1*$num2;
         }
     }
     /**
      * 除法類
      */
     class OperationDiv extends Operation {
         public function getValue($num1,$num2){
             try {
                 if ($num2==0){
                     throw new Exception("除數不能爲0");
                 }else {
                     return $num1/$num2;
                 }
             }catch (Exception $e){
                 echo "錯誤信息：".$e->getMessage();
             }
         }
     }

通過採用面向對象的繼承特性，我們可以很容易就能對原有程序進行擴展，比如:‘乘方’，‘開方’，‘對數’，‘三角函數’，‘統計’等，以還可以避免加載沒有必要的代碼。

如果我們現在需要增加一個求餘的類，會非常的簡單

我們只需要另外寫一個類（該類繼承虛擬基類）,在類中完成相應的功能（比如：求乘方的運算）,而且大大的降低了耦合度，方便日後的維護及擴展

接下來使用一個單獨的類來實現實例化的過程，這個類就是工廠

    /**
     * 工廠類，主要用來創建對象
     * 功能：根據輸入的運算符號，工廠就能實例化出合適的對象
     *
     */
    class Factory{
        public static function createObj($operate){
            switch ($operate){
                case '+':
                    return new OperationAdd();
                    break;
                case '-':
                    return new OperationSub();
                    break;
                case '*':
                    return new OperationSub();
                    break;
                case '/':
                    return new OperationDiv();
                    break;
            }
        }
    }
    $test=Factory::createObj('/');
    $result=$test->getValue(23,0);
    echo $result;

總結：把相同的屬性、行爲、方法抽象出來，通過一個工廠去一一實例化！

2.單例模式

單例模式顧名思義，就是隻有一個實例。作爲對象的創建模式，單例模式確保某一個類只有一個實例，而且自行實例化並向整個系統提供這個實例。

單例模式的要點有三個：

一是某個類只能有一個實例；
二是它必須自行創建這個實例；
三是它必須自行向整個系統提供這個實例。

爲什麼要使用PHP單例模式

1. php的應用主要在於數據庫應用, 一個應用中會存在大量的數據庫操作, 在使用面向對象的方式開發時, 如果使用單例模式, 則可以避免大量的new 操作消耗的資源,還可以減少數據庫連接這樣就不容易出現 too many connections情況。
2. 如果系統中需要有一個類來全局控制某些配置信息, 那麼使用單例模式可以很方便的實現. 這個可以參看zend Framework的FrontController部分。
3. 在一次頁面請求中, 便於進行調試, 因爲所有的代碼(例如數據庫操作類db)都集中在一個類中, 我們可以在類中設置鉤子, 輸出日誌，從而避免到處var_dump, echo。

/**
 * 設計模式之單例模式
 * $_instance必須聲明爲靜態的私有變量
 * 構造函數必須聲明爲私有,防止外部程序new類從而失去單例模式的意義
 * getInstance()方法必須設置爲公有的,必須調用此方法以返回實例的一個引用
 * ::操作符只能訪問靜態變量和靜態函數
 * new對象都會消耗內存
 * 使用場景:最常用的地方是數據庫連接。
 * 使用單例模式生成一個對象後，該對象可以被其它衆多對象所使用。
 */
class man
{
    #保存例實例在此屬性中
    private static $_instance;

    #構造函數聲明爲private,防止直接創建對象
    private function __construct()
    {
        echo '我被實例化了！';
    }

    #單例方法
    public static function get_instance()
    {
        var_dump(isset(self::$_instance));
        
        if(!isset(self::$_instance))
        {
            self::$_instance=new self();
        }
        return self::$_instance;
    }

    #阻止用戶複製對象實例
    private function __clone()
    {
        trigger_error('Clone is not allow' ,E_USER_ERROR);
    }

    function test()
    {
        echo("test");

    }
}

#這個寫法會出錯，因爲構造方法被聲明爲private
$test = new man;

#下面將得到Example類的單例對象
$test = man::get_instance();
$test = man::get_instance();
$test->test();

#複製對象將導致一個E_USER_ERROR.
$test_clone = clone $test;

3.觀察者模式

觀察者模式屬於行爲模式，是定義對象間的一種一對多的依賴關係，以便當一個對象的狀態發生改變時，所有依賴於它的對象都得到通知並自動刷新。它完美的將觀察者對象和被觀察者對象分離。可以在獨立的對象（主體）中維護一個對主體感興趣的依賴項（觀察器）列表。讓所有觀察器各自實現公共的 Observer 接口，以取消主體和依賴性對象之間的直接依賴關係。（反正我看不明白）

用到了 spl （standard php library）

class MyObserver1 implements SplObserver {
    public function update(SplSubject $subject) {
        echo __CLASS__ . ' - ' . $subject->getName();
    }
}

class MyObserver2 implements SplObserver {
    public function update(SplSubject $subject) {
        echo __CLASS__ . ' - ' . $subject->getName();
    }
}

class MySubject implements SplSubject {
    private $_observers;
    private $_name;

    public function __construct($name) {
        $this->_observers = new SplObjectStorage();
        $this->_name = $name;
    }

    public function attach(SplObserver $observer) {
        $this->_observers->attach($observer);
    }

    public function detach(SplObserver $observer) {
        $this->_observers->detach($observer);
    }

    public function notify() {
        foreach ($this->_observers as $observer) {
            $observer->update($this);
        }
    }

    public function getName() {
        return $this->_name;
    }
}

$observer1 = new MyObserver1();
$observer2 = new MyObserver2();

$subject = new MySubject("test");

$subject->attach($observer1);
$subject->attach($observer2);
$subject->notify();

4.策略模式

在此模式中，算法是從複雜類提取的，因而可以方便地替換。例如，如果要更改搜索引擎中排列頁的方法，則策略模式是一個不錯的選擇。思考一下搜索引擎的幾個部分 —— 一部分遍歷頁面，一部分對每頁排列，另一部分基於排列的結果排序。在複雜的示例中，這些部分都在同一個類中。通過使用策略模式，您可將排列部分放入另一個類中，以便更改頁排列的方式，而不影響搜索引擎的其餘代碼。

作爲一個較簡單的示例，下面顯示了一個用戶列表類，它提供了一個根據一組即插即用的策略查找一組用戶的方法

//定義接口
interface IStrategy {
    function filter($record);
}
//實現接口方式1
class FindAfterStrategy implements IStrategy {
    private $_name;
    public function __construct($name) {
        $this->_name = $name;
    }
    public function filter($record) {
        return strcmp ( $this->_name, $record ) <= 0;
    }
}
//實現接口方式1
class RandomStrategy implements IStrategy {
    public function filter($record) {
        return rand ( 0, 1 ) >= 0.5;
    }
}
//主類
class UserList {
    private $_list = array ();
    public function __construct($names) {
        if ($names != null) {
            foreach ( $names as $name ) {
                $this->_list [] = $name;
            }
        }
    }
    
    public function add($name) {
        $this->_list [] = $name;
    }
    
    public function find($filter) {
        $recs = array ();
        foreach ( $this->_list as $user ) {
            if ($filter->filter ( $user ))
                $recs [] = $user;
        }
        return $recs;
    }
}
$ul = new UserList ( array (
        "Andy",
        "Jack",
        "Lori",
        "Megan" 
) );
$f1 = $ul->find ( new FindAfterStrategy ( "J" ) );
print_r ( $f1 );
$f2 = $ul->find ( new RandomStrategy () );
print_r ( $f2 );

策略模式非常適合複雜數據管理系統或數據處理系統，二者在數據篩選、搜索或處理的方式方面需要較高的靈活性

5.鏈式模式

鏈模式以鬆散耦合主題爲基礎，發送消息、命令和請求，或通過一組處理程序發送任意內容。每個處理程序都會自行判斷自己能否處理請求。如果可以，該請求被處理，進程停止。您可以爲系統添加或移除處理程序，而不影響其他處理程序。
以下代碼顯示了此模式的一個示例。

#定義命令接口
interface ICommand {
function onCommand($name,$args);
}
#定義維護命令對象列表的類
class CommandChain {
#定義對象列表數組
private $_commands = array();
#定義添加命令方法
public function addCommand($cmd){
$this->_commands[] = $cmd;
}
#定義執行命令的方法
public function runCommand($name,$args){
foreach($this->_commands as $cmd) {
if($cmd->onCommand($name,$args)){
return;
}
}
}
}
#定義一個添加用戶的命令對象
class UserCommand implements ICommand {
public function onCommand($name,$args){
if($name != 'addUser'){
return false;
}
echo 'UserCommand run command addUser<br>';
}
}
#定義一個發送郵件的命令對象
class MailCommand implements ICommand {
public function onCommand($name,$args){
if($name != 'mail'){
return false;
}
echo 'MailCommand run command mail<br>';
}
}
#定義維護命令對象列表的類
$commandChain = new CommandChain();
#實例化命令對象
$user = new UserCommand();
$mail = new MailCommand();
#添加命令對象到列表中
$commandChain->addCommand($user);
$commandChain->addCommand($mail);
#執行命令
$commandChain->runCommand('addUser',null);
$commandChain->runCommand('mail',null);

此代碼定義維護 ICommand 對象列表的 CommandChain 類。兩個類都可以實現 ICommand 接口 —— 一個對郵件的請求作出響應，另一個對添加用戶作出響應。

如果您運行包含某些測試代碼的腳本，則會得到以下輸出：

代碼首先創建 CommandChain 對象，併爲它添加兩個命令對象的實例。然後運行兩個命令以查看誰對這些命令作出了響應。如果命令的名稱不匹配 UserCommand 或 MailCommand，則代碼失敗，不發生任何操作。

爲處理請求而創建可擴展的架構時，命令鏈模式很有價值，使用它可以解決許多問題。

PHP 設計模式總結

Wireshark 安裝+使用（一）

Linux下常用命令總結

深入解讀php中抽象(abstract)類和抽象方法

PHP對象接口分析

PHP 設計模式總結

PHP抽象類與接口的區別

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結