首页
所有分类
TAGS
文字工具 EMOJI BIBLE
编程 PHP

PHP面向对象程序设计组合模式与装饰模式详解

Posted in PHP onDecember 02, 2016

本文实例讲述了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 "\n";
$army2 = clone $army; // 克隆军队
$army->addArmy( $army2 );
print $army->bombardStrength();
print "\n";
?>

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()."\n";
$army->removeUnit( $soldier );
print_r( $army );
print $army->bombardStrength()."\n";
?>

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()}\n";
?>

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\n";
  }
}
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\n"; // 当前类,有点递归的感觉
    $this->processrequest->process( $req );
  }
}
class AuthenticateRequest extends DecorateProcess { // 认证请求
  function process( RequestHelper $req ) {
    print __CLASS__.": authenticating request\n";
    $this->processrequest->process( $req );
  }
}
class StructureRequest extends DecorateProcess { // 组织结构请求
  function process( RequestHelper $req ) {
    print __CLASS__.": structuring request\n";
    $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
            (
            )
        )
    )
)

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

希望本文所述对大家PHP程序设计有所帮助。

PHP面向对象程序设计组合模式与装饰模式详解

- Author -

牛逼的霍啸林

声明：登载此文出于传递更多信息之目的，并不意味着赞同其观点或证实其描述。

PHP 相关文章推荐
php在服务器执行exec命令失败的解决方法
Mar 03 PHP
解析PHP实现下载文件的两种方法
Jul 05 PHP
php中file_exists函数使用详解
May 08 PHP
PHP使用pear自带的mail类库发邮件的方法
Jul 08 PHP
总结PHP如何获取当前主机、域名、网址、路径、端口和参数等
Sep 09 PHP
PHP判断一个数组是另一个数组子集的方法详解
Jul 31 PHP
PHP5.0 TIDY_PARSE_FILE缓冲区溢出漏洞的解决方案
Oct 14 PHP
Yii2框架控制器、路由、Url生成操作示例
May 27 PHP
Thinkphp自定义生成缩略图尺寸的方法
Aug 05 PHP
php写app用的框架整理
Sep 29 PHP
laravel5.1框架model类查询的实现方法
Oct 08 PHP
PHP如何解决微信文章图片防盗链
Dec 09 PHP
PHP与jquery实时显示网站在线人数实例详解
Dec 02 #PHP
谈谈php对接芝麻信用踩的坑
Dec 01 #PHP
PHP自定义函数获取汉字首字母的方法
Dec 01 #PHP
phpmailer绑定邮箱的实现方法
Dec 01 #PHP
thinkPHP实现多字段模糊匹配查询的方法
Dec 01 #PHP
thinkPHP商城公告功能开发问题分析
Dec 01 #PHP
thinkPHP订单数字提醒功能的实现方法
Dec 01 #PHP
中国购物网站(172) 西班牙购物网站(115) 马来西亚购物网站(41) 韩国购物网站(27) 墨西哥购物网站(16) 瑞士购物网站(28) 日本购物网站(72) 加拿大购物网站(185) 德国购物网站(227) 印度购物网站(45)
You might like
东方红 - 来复式再生机的修复
2021/03/02 无线电
php与paypal整合方法
2010/11/28 PHP
PHP执行批量mysql语句的解决方法
2013/05/02 PHP
PHP文件生成的图片无法使用CDN缓存的解决方法
2015/06/20 PHP
php的socket编程详解
2016/11/20 PHP
PHP CURL采集百度搜寻结果图片不显示问题的解决方法
2017/02/03 PHP
利用 fsockopen() 函数开放端口扫描器的实例
2017/08/19 PHP
laravel如何开启跨域功能示例详解
2017/08/31 PHP
PHP进阶学习之依赖注入与Ioc容器详解
2019/06/19 PHP
javascript 模式设计之工厂模式详细说明
2010/05/10 Javascript
jQuery+ajax实现顶一下,踩一下效果
2010/07/17 Javascript
基于JQuery实现滚动到页面底端时自动加载更多信息
2014/01/31 Javascript
jquery插件方式实现table查询功能的简单实例
2016/06/06 Javascript
jQuery的中 is(':visible') 解析及用法(必看)
2017/02/12 Javascript
js继承的这6种方式！（上）
2019/04/23 Javascript
node使用request请求的方法
2019/12/20 Javascript
[01:17:55]VGJ.T vs Mineski 2018国际邀请赛小组赛BO2 第一场 8.18
2018/08/20 DOTA
Numpy数据类型转换astype,dtype的方法
2018/06/09 Python
django项目搭建与Session使用详解
2018/10/10 Python
详解用Python练习画个美队盾牌
2019/03/23 Python
Python3.5集合及其常见运算实例详解
2019/05/01 Python
Python高级编程之消息队列(Queue)与进程池(Pool)实例详解
2019/11/01 Python
使用Python实现画一个中国地图
2019/11/23 Python
python构造函数init实例方法解析
2020/01/19 Python
英国工具中心：UK Tool Centre
2017/07/10 全球购物
俄罗斯的精英皮具：Wittchen
2018/01/29 全球购物
美国床垫连锁店：Mattress Firm
2021/02/13 全球购物
商务英语专业求职信
2014/06/26 职场文书
安全生产月标语
2014/10/07 职场文书
党员评议思想汇报
2014/10/08 职场文书
小学生安全教育广播稿
2014/10/20 职场文书
离职报告范文
2014/11/04 职场文书
班主任工作实习计划
2015/01/16 职场文书
房租涨价通知
2015/04/23 职场文书
Python获取江苏疫情实时数据及爬虫分析
2021/08/02 Python
nginx代理实现静态资源访问的示例代码
2022/07/07 Servers