PHP物件導向深入研究之【組合模式與裝飾模式】

桃子紅了吶發表於2016-09-25

組合模式

定義：組合模式定義了一個單根繼承體系，使具有截然不同職責的集合可以並肩工作。

一個軍隊的案例，

<?php

abstract class Unit { // 個體
    abstract function bombardStrength();
}

class Archer extends Unit { // 弓箭手
    function bombardStrength() {
        return 4;
    }
}

class LaserCannonUnit extends Unit { // 火炮手
    function bombardStrength() {
        return 44;
    }
}
?>

軍隊整合成員，輸出火力

<?php

abstract class Unit {
    abstract function bombardStrength();
}

class Archer extends Unit {
    function bombardStrength() {
        return 4;
    }
}

class LaserCannonUnit extends Unit {
    function bombardStrength() {
        return 44;
    }
}


class Army { // 軍隊
    private $units = array(); // 定義私有屬性 個體集

    function addUnit( Unit $unit ) { // 新增成員
        array_push( $this->units, $unit );
    }

    function bombardStrength() { // 火力
        $ret = 0;
        foreach( $this->units as $unit ) {
            $ret += $unit->bombardStrength();
        }
        return $ret;
    }
}

$unit1 = new Archer(); 
$unit2 = new LaserCannonUnit(); 
$army = new Army();
$army->addUnit( $unit1 ); 
$army->addUnit( $unit2 ); 
print $army->bombardStrength(); // 輸出火力
?>
output:
48

軍隊進一步整合其他軍隊

<?php

abstract class Unit {
    abstract function bombardStrength();
}

class Archer extends Unit {
    function bombardStrength() {
        return 4;
    }
}

class LaserCannonUnit extends Unit {
    function bombardStrength() {
        return 44;
    }
}


class Army {
    private $units = array();
    private $armies= array();

    function addUnit( Unit $unit ) {
        array_push( $this->units, $unit );
    }

    function addArmy( Army $army ) {
        array_push( $this->armies, $army );
    }

    function bombardStrength() {
        $ret = 0;
        foreach( $this->units as $unit ) {
            $ret += $unit->bombardStrength();
        }

        foreach( $this->armies as $army ) {
            $ret += $army->bombardStrength();
        }

        return $ret;
    }
}

$unit1 = new Archer(); 
$unit2 = new LaserCannonUnit(); 
$army = new Army();
$army->addUnit( $unit1 ); 
$army->addUnit( $unit2 ); 
print $army->bombardStrength();
print "
";
$army2 = clone $army; // 克隆軍隊
$army->addArmy( $army2 );
print $army->bombardStrength();
print "
";
?>
output:
48
96

更好的方式，支援新增，移除等等其他功能。

<?php
abstract class Unit {
    abstract function addUnit( Unit $unit );
    abstract function removeUnit( Unit $unit );
    abstract function bombardStrength();
}
class Army extends Unit { // 軍隊
    private $units = array();

    function addUnit( Unit $unit ) {
        if ( in_array( $unit, $this->units, true ) ) { // $this用於呼叫正常的屬性或方法，self呼叫靜態的方法，屬性或者常量
            return;
        }
        
        $this->units[] = $unit;
    }

    function removeUnit( Unit $unit ) {
        // >= php 5.3
        $this->units = array_udiff( $this->units, array( $unit ), 
                       function( $a, $b ) { return ($a === $b)?0:1; } );

        // < php 5.3
        // $this->units = array_udiff( $this->units, array( $unit ), 
        //                create_function( `$a,$b`, `return ($a === $b)?0:1;` ) ); 
        // 物件陣列，create_function,建立函式
    }

    function bombardStrength() {
        $ret = 0;
        foreach( $this->units as $unit ) {
            $ret += $unit->bombardStrength();
        }
        return $ret;
    }
}

// quick example classes
class Tank extends Unit {  // 坦克
    function addUnit( Unit $unit ) {}
    function removeUnit( Unit $unit ) {}

    function bombardStrength() {
        return 4;
    }
}

class Soldier extends Unit {  // 士兵
    function addUnit( Unit $unit ) {}
    function removeUnit( Unit $unit ) {}

    function bombardStrength() {
        return 8;
    }
}

$tank =  new Tank();
$tank2 = new Tank();
$soldier = new Soldier();

$army = new Army();
$army->addUnit( $soldier );
$army->addUnit( $tank );
$army->addUnit( $tank2 );

print_r( $army );
print $army->bombardStrength()."
";

$army->removeUnit( $soldier );

print_r( $army );
print $army->bombardStrength()."
";
?>
output:
Army Object
(
    [units:Army:private] => Array
        (
            [0] => Soldier Object
                (
                )

            [1] => Tank Object
                (
                )

            [2] => Tank Object
                (
                )

        )

)
16
Army Object
(
    [units:Army:private] => Array
        (
            [1] => Tank Object
                (
                )

            [2] => Tank Object
                (
                )

        )

)
8

新增異常處理

<?php
abstract class Unit {
    abstract function addUnit( Unit $unit );
    abstract function removeUnit( Unit $unit );
    abstract function bombardStrength();
}

class Army extends Unit {
    private $units = array();

    function addUnit( Unit $unit ) {
        if ( in_array( $unit, $this->units, true ) ) {
            return;
        }
        
        $this->units[] = $unit;
    }

    function removeUnit( Unit $unit ) {
        // >= php 5.3
        //$this->units = array_udiff( $this->units, array( $unit ), 
        //                function( $a, $b ) { return ($a === $b)?0:1; } );

        // < php 5.3
        $this->units = array_udiff( $this->units, array( $unit ), 
                        create_function( `$a,$b`, `return ($a === $b)?0:1;` ) );
    }

    function bombardStrength() {
        $ret = 0;
        foreach( $this->units as $unit ) {
            $ret += $unit->bombardStrength();
        }
        return $ret;
    }
}

class UnitException extends Exception {}

class Archer extends Unit {
    function addUnit( Unit $unit ) {
        throw new UnitException( get_class($this)." is a leaf" );
    }

    function removeUnit( Unit $unit ) {
        throw new UnitException( get_class($this)." is a leaf" );
    }

    function bombardStrength() {
        return 4;
    }
}

$archer = new Archer();
$archer2 = new Archer();
$archer->addUnit( $archer2 );

?>

output:
Fatal error: Uncaught exception `UnitException` with message `Archer is a leaf`

點評：組合模式中的一切類都共享同一個父型別，可以輕鬆地在設計中新增新的組合物件或區域性物件，而無需大範圍地修改程式碼。

最終的效果，逐步優化(完美)：

<?php

class UnitException extends Exception {}

abstract class Unit {
    abstract function bombardStrength();

    function addUnit( Unit $unit ) {
        throw new UnitException( get_class($this)." is a leaf" );
    }

    function removeUnit( Unit $unit ) {
        throw new UnitException( get_class($this)." is a leaf" );
    }
}

class Archer extends Unit {
    function bombardStrength() {
        return 4;
    }
}

class LaserCannonUnit extends Unit {
    function bombardStrength() {
        return 44;
    }
}

class Army extends Unit {
    private $units = array();

    function addUnit( Unit $unit ) {
        if ( in_array( $unit, $this->units, true ) ) {
            return;
        }
        
        $this->units[] = $unit;
    }

    function removeUnit( Unit $unit ) {
        // >= php 5.3
        //$this->units = array_udiff( $this->units, array( $unit ), 
        //                function( $a, $b ) { return ($a === $b)?0:1; } );

        // < php 5.3
        $this->units = array_udiff( $this->units, array( $unit ), 
                        create_function( `$a,$b`, `return ($a === $b)?0:1;` ) );
    }

    function bombardStrength() {
        $ret = 0;
        foreach( $this->units as $unit ) {
            $ret += $unit->bombardStrength();
        }
        return $ret;
    }
}

// create an army
$main_army = new Army();

// add some units
$main_army->addUnit( new Archer() );
$main_army->addUnit( new LaserCannonUnit() );

// create a new army
$sub_army = new Army();

// add some units
$sub_army->addUnit( new Archer() );
$sub_army->addUnit( new Archer() );
$sub_army->addUnit( new Archer() );

// add the second army to the first
$main_army->addUnit( $sub_army );

// all the calculations handled behind the scenes
print "attacking with strength: {$main_army->bombardStrength()}
";
?>
output:
attacking with strength: 60

更牛逼的組合處理，

<?php

abstract class Unit {
    function getComposite() {
        return null;
    }

    abstract function bombardStrength();
}


abstract class CompositeUnit extends Unit { // 抽象類繼承抽象類
    private $units = array();

    function getComposite() {
        return $this;
    }

    protected function units() {
        return $this->units;
    }

    function removeUnit( Unit $unit ) {
        // >= php 5.3
        //$this->units = array_udiff( $this->units, array( $unit ), 
        //                function( $a, $b ) { return ($a === $b)?0:1; } );

        // < php 5.3
        $this->units = array_udiff( $this->units, array( $unit ), 
                        create_function( `$a,$b`, `return ($a === $b)?0:1;` ) );
    }

    function addUnit( Unit $unit ) {
        if ( in_array( $unit, $this->units, true ) ) {
            return;
        }
        $this->units[] = $unit;
    }
}
class Army extends CompositeUnit {

    function bombardStrength() {
        $ret = 0;
        foreach( $this->units as $unit ) {
            $ret += $unit->bombardStrength();
        }
        return $ret;
    }

}

class Archer extends Unit {
    function bombardStrength() {
        return 4;
    }
}

class LaserCannonUnit extends Unit {
    function bombardStrength() {
        return 44;
    }
}

class UnitScript {
    static function joinExisting( Unit $newUnit,
                                  Unit $occupyingUnit ) { // 靜態方法，直接通過類名來使用
        $comp;

        if ( ! is_null( $comp = $occupyingUnit->getComposite() ) ) { // 軍隊合併處理
            $comp->addUnit( $newUnit ); 
        } else { // 士兵合併處理
            $comp = new Army(); 
            $comp->addUnit( $occupyingUnit );
            $comp->addUnit( $newUnit );
        }
        return $comp;
    }
}

$army1 = new Army();
$army1->addUnit( new Archer() );
$army1->addUnit( new Archer() );

$army2 = new Army();
$army2->addUnit( new Archer() );
$army2->addUnit( new Archer() );
$army2->addUnit( new LaserCannonUnit() );

$composite = UnitScript::joinExisting( $army2, $army1 );
print_r( $composite );

?>

output:
Army Object
(
    [units:CompositeUnit:private] => Array
        (
            [0] => Archer Object
                (
                )

            [1] => Archer Object
                (
                )

            [2] => Army Object
                (
                    [units:CompositeUnit:private] => Array
                        (
                            [0] => Archer Object
                                (
                                )

                            [1] => Archer Object
                                (
                                )

                            [2] => LaserCannonUnit Object
                                (
                                )

                        )

                )

        )

)

點評：Unit 基礎，CompositeUnit複合中實現add與remove。軍隊繼承Composite，射手繼承Archer。這樣射手中就不會有多餘的add與remove方法了。

裝飾模式

裝飾模式幫助我們改變具體元件的功能。

看例子

<?php
abstract class Tile { // 磚瓦
    abstract function getWealthFactor(); // 獲取財富
}

class Plains extends Tile { // 平原
    private $wealthfactor = 2;
    function getWealthFactor() {
        return $this->wealthfactor;
    }
}

class DiamondPlains extends Plains { // 鑽石地段
    function getWealthFactor() {
        return parent::getWealthFactor() + 2;
    }
}

class PollutedPlains extends Plains { // 汙染地段
    function getWealthFactor() {
        return parent::getWealthFactor() - 4;
    }
}
$tile = new PollutedPlains();
print $tile->getWealthFactor();
?>
output:
-2

點評：不具有靈活性，我們不能同時獲得鑽石與被汙染的土地的資金情況。

裝飾模式使用組合和委託而不是隻使用繼承來解決功能變化的問題。

看例子：

<?php

abstract class Tile {
    abstract function getWealthFactor();
}

class Plains extends Tile {
    private $wealthfactor = 2;
    function getWealthFactor() {
        return $this->wealthfactor;
    }
}

abstract class TileDecorator extends Tile { // 裝飾
    protected $tile;
    function __construct( Tile $tile ) {
        $this->tile = $tile;
    }
}

class DiamondDecorator extends TileDecorator { // 鑽石裝飾
    function getWealthFactor() {
        return $this->tile->getWealthFactor()+2;
    }
}

class PollutionDecorator extends TileDecorator { // 汙染裝飾
    function getWealthFactor() {
        return $this->tile->getWealthFactor()-4;
    }
}

$tile = new Plains();
print $tile->getWealthFactor(); // 2

$tile = new DiamondDecorator( new Plains() );
print $tile->getWealthFactor(); // 4

$tile = new PollutionDecorator(
             new DiamondDecorator( new Plains() ));
print $tile->getWealthFactor(); // 0
?>
output:
2
4
0

點評：這個模型具有擴充套件性。我們不需要建立DiamondPollutionPlains物件就可以構建一個鑽石被汙染的物件。

一個更逼真的例子

<?php

class RequestHelper{} // 請求助手

abstract class ProcessRequest { // 程式請求
    abstract function process( RequestHelper $req );
}

class MainProcess extends ProcessRequest { // 主程式
    function process( RequestHelper $req ) {
        print __CLASS__.": doing something useful with request
";
    }
}

abstract class DecorateProcess extends ProcessRequest { // 裝飾程式
    protected $processrequest;
    function __construct( ProcessRequest $pr ) { // 引用物件，委託
        $this->processrequest = $pr;
    }
}

class LogRequest extends DecorateProcess { // 日誌請求
    function process( RequestHelper $req ) {
        print __CLASS__.": logging request
"; // 當前類,有點遞迴的感覺
        $this->processrequest->process( $req );
    }
}

class AuthenticateRequest extends DecorateProcess { // 認證請求
    function process( RequestHelper $req ) {
        print __CLASS__.": authenticating request
";
        $this->processrequest->process( $req );
    }
}

class StructureRequest extends DecorateProcess { // 組織結構請求
    function process( RequestHelper $req ) {
        print __CLASS__.": structuring request
";
        $this->processrequest->process( $req );
    }
}

$process = new AuthenticateRequest( new StructureRequest(
                                    new LogRequest (
                                    new MainProcess()
                                    ))); // 這樣可以很靈活的組合程式的關係，省去很多重複的繼承

$process->process( new RequestHelper() );
print_r($process);
?>

output:
AuthenticateRequest: authenticating request
StructureRequest: structuring request
LogRequest: logging request
MainProcess: doing something useful with request
AuthenticateRequest Object
(
    [processrequest:protected] => StructureRequest Object
        (
            [processrequest:protected] => LogRequest Object
                (
                    [processrequest:protected] => MainProcess Object
                        (
                        )

                )

        )

)

點評：這裡有一種遞迴的感覺，一層呼叫一層。模式是牛人總結出來用於靈活的解決一些現實問題的。牛！給開發多一點思路。

本文轉自TBHacker部落格園部落格，原文連結：http://www.cnblogs.com/jiqing9006/p/5183162.html，如需轉載請自行聯絡原作者

【物件導向的PHP】之模式：目錄
2019-02-16
物件PHP模式
PHP設計模式之裝飾者模式
2019-02-16
PHP設計模式
PHP 設計模式之組合模式
2020-06-22
PHP設計模式
PHP設計模式之裝飾器模式（Decorator）
2021-01-20
PHP設計模式
《JavaScript物件導向精要》之六：物件模式
2019-02-27
JavaScript物件模式
Javascript 設計模式之物件導向與 UML 類圖
2019-07-11
JavaScript設計模式物件
設計模式第七章橋接模式、裝飾者模式、組合模式
2020-11-24
設計模式橋接
1.設計模式與物件導向
2024-03-26
設計模式物件
PHP設計模式- Decorator 裝飾器模式
2019-02-16
PHP設計模式
PHP物件導向之&引用
2021-09-09
PHP物件
設計模式系列之「裝飾模式」
2019-03-04
設計模式
設計模式之-裝飾器模式
2020-09-18
設計模式
設計模式之裝飾者模式
2023-02-04
設計模式
設計模式之【裝飾器模式】
2022-03-16
設計模式
js-物件導向-設計模式-命令模式
2020-12-06
JS物件設計模式
組合模式-統一的處理個別物件與組合物件
2021-01-13
模式物件
JS物件導向設計模式
2019-04-12
JS物件設計模式
物件導向 -- 類的組合
2019-03-26
物件
python物件導向之抽象工廠設計模式
2018-12-12
Python物件抽象設計模式
JavaScript設計模式之物件導向程式設計
2018-09-01
JavaScript設計模式物件程式設計
php中的程式導向與物件導向
2020-12-25
PHP物件
Go 設計模式之裝飾器模式
2019-04-05
Go設計模式
設計模式之裝飾者模式（二）
2019-04-08
設計模式
設計模式之裝飾者模式（一）
2019-04-03
設計模式
java設計模式之裝飾器模式
2020-11-15
Java設計模式
Java設計模式之裝飾者模式
2020-12-13
Java設計模式
PHP 物件導向（一）許可權修飾符
2020-01-18
PHP物件
結構型模式之介面卡模式、橋接模式與裝飾器模式（一）
2021-10-28
模式橋接
物件導向-設計模式-建立型
2021-07-24
物件設計模式
設計模式之——物件導向5大基本原則
2018-03-24
設計模式物件
使用組合的設計模式 | 美顏相機中的裝飾者模式
2019-05-27
設計模式
Java學設計模式之裝飾器模式
2024-05-09
Java設計模式
【趣味設計模式系列】之【裝飾器模式】
2020-09-13
設計模式
設計模式之裝飾器模式（decorator pattern）
2019-06-30
設計模式
Golang 常見設計模式之裝飾模式
2022-09-08
Golang設計模式
設計模式系列之「組合模式」
2018-03-08
設計模式
設計模式系列之建造者模式(Builder Pattern)——複雜物件的組裝與建立
2020-06-07
設計模式UI物件
PHP物件導向
2019-02-16
PHP物件
PHP基礎之物件導向篇
2020-09-19
PHP物件

PHP物件導向深入研究之【組合模式與裝飾模式】

組合模式

裝飾模式

相關文章