zoukankan      html  css  js  c++  java
  • PHP面向对象深入研究之【组合模式与装饰模式】

    组合模式

    定义:组合模式定义了一个单根继承体系,使具有截然不同职责的集合可以并肩工作。

    一个军队的案例,

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

    点评:这里有一种递归的感觉,一层调用一层。模式是牛人总结出来用于灵活的解决一些现实问题的。牛!给开发多一点思路。

  • 相关阅读:
    Build 2019 彩蛋
    崂山
    Win10 iot 修改日期时间
    《 结网:改变世界的互联网产品经理 》
    <[你在荒废时间的时候别人都在拼命!]>
    《时间的玫瑰》阅读笔记
    翻石头价值投资手册-科技行业
    No module named flask.ext.sqlalchemy.SQLALchemy
    《寻找伟大的企业》
    <《基金经理投资笔记丛书4-1:投资是一种生活方式》>
  • 原文地址:https://www.cnblogs.com/jiqing9006/p/5183162.html
Copyright © 2011-2022 走看看