AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

PHP面向对象深入研究之【组合模式与装饰模式】

2016-09-25 817
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

组合模式

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

一个军队的案例，

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

                )

        )

)

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



本文转自TBHacker博客园博客，原文链接：http://www.cnblogs.com/jiqing9006/p/5183162.html，如需转载请自行联系原作者

文章标签：
PHP
桃子红了呐
目录
相关文章
码农技术君
|
PHP
PHP快速入门-基础语法及面向对象
PHP快速入门-基础语法及面向对象
码农技术君
144 0
码农技术君
|
PHP
PHP快速入门-基础语法及面向对象
PHP快速入门-基础语法及面向对象
码农技术君
116 0
我不是游客20240119
|
2月前
|
安全 关系型数据库 MySQL
PHP与MySQL交互：从入门到实践
【9月更文挑战第20天】在数字时代的浪潮中，掌握PHP与MySQL的互动成为了开发动态网站和应用程序的关键。本文将通过简明的语言和实例，引导你理解PHP如何与MySQL数据库进行对话，开启你的编程之旅。我们将从连接数据库开始，逐步深入到执行查询、处理结果，以及应对常见的挑战。无论你是初学者还是希望提升技能的开发者，这篇文章都将为你提供实用的知识和技巧。让我们一起探索PHP与MySQL交互的世界，解锁数据的力量！
我不是游客20240119
111 6
小王老师呀
|
2月前
|
NoSQL 关系型数据库 MySQL
不是 PHP 不行了，而是 MySQL 数据库扛不住啊
【9月更文挑战第8天】这段内容讨论了MySQL在某些场景下面临的挑战及其原因，并指出这些问题不能完全归咎于MySQL本身。高并发读写压力、数据量增长以及复杂查询和事务处理都可能导致性能瓶颈。然而，应用程序设计不合理、系统架构不佳以及其他数据库选择和优化策略不足也是重要因素。综合考虑这些方面才能有效解决性能问题，而MySQL通过不断改进和优化，仍然是许多应用场景中的可靠选择。
小王老师呀
127 9
aliyun8599273441-30642
|
3月前
|
存储 SQL 关系型数据库
PHP与MySQL交互的奥秘
【8月更文挑战第29天】在编程的世界里，PHP和MySQL就像是一对默契的舞伴，共同演绎着数据的交响曲。本文将带你探索它们之间的互动，从连接数据库到执行查询，再到处理结果，每一步都充满了节奏与和谐。我们将一起走进这段代码的旅程，感受数据流动的魅力。
aliyun8599273441-30642
44 0
路卿老师
|
1天前
|
SQL 关系型数据库 MySQL
12 PHP配置数据库MySQL
路老师分享了PHP操作MySQL数据库的方法，包括安装并连接MySQL服务器、选择数据库、执行SQL语句（如插入、更新、删除和查询），以及将结果集返回到数组。通过具体示例代码，详细介绍了每一步的操作流程，帮助读者快速入门PHP与MySQL的交互。
路卿老师
7 1
游客sjjs6jgz4gp7m1
|
6天前
|
存储 关系型数据库 MySQL
PHP与MySQL动态网站开发深度解析####
本文作为技术性文章，深入探讨了PHP与MySQL结合在动态网站开发中的应用实践，从环境搭建到具体案例实现，旨在为开发者提供一套详尽的实战指南。不同于常规摘要仅概述内容，本文将以“手把手”的教学方式，引导读者逐步构建一个功能完备的动态网站，涵盖前端用户界面设计、后端逻辑处理及数据库高效管理等关键环节，确保读者能够全面掌握PHP与MySQL在动态网站开发中的精髓。 ####
游客sjjs6jgz4gp7m1
22 3
游客sjjs6jgz4gp7m1
|
7天前
|
关系型数据库 MySQL PHP
PHP与MySQL动态网站开发实战指南####
本文深入探讨了PHP与MySQL在动态网站开发中的应用实践，通过具体案例解析如何高效结合这两大技术构建数据驱动的Web应用。文章将涵盖环境搭建、基础语法回顾、数据库设计与操作、用户注册与登录系统实现等关键步骤，旨在为开发者提供一个从零到一的项目实战路径，展示PHP与MySQL协同工作的强大能力。 ####
游客sjjs6jgz4gp7m1
22 3
游客5fdji2pvmf8888
|
27天前
|
SQL 关系型数据库 MySQL
PHP与MySQL协同工作的艺术：开发高效动态网站
在这个后端技术迅速迭代的时代，PHP和MySQL的组合仍然是创建动态网站和应用的主流选择之一。本文将带领读者深入理解PHP后端逻辑与MySQL数据库之间的协同工作方式，包括数据的检索、插入、更新和删除操作。文章将通过一系列实用的示例和最佳实践，揭示如何充分利用这两种技术的优势，构建高效、安全且易于维护的动态网站。
游客5fdji2pvmf8888
17 1
请看我回答~
|
3月前
|
SQL 关系型数据库 MySQL
PHP与MySQL交互之基础教程
【8月更文挑战第31天】 在数字世界中，数据是推动一切的核心力量。本文将引导你探索PHP与MySQL的协同工作，通过实际代码示例，展示如何建立连接、执行查询以及处理结果集。无论你是初学者还是希望巩固知识的开发者，这篇文章都将为你提供宝贵的实践知识。
请看我回答~
86 0

热门文章

最新文章

  • 1
    让PHP7达到最高性能的几个Tips
  • 2
    PHP设计模式——模板模式
  • 3
    php调用empty出现错误Can't use function return value in write context
  • 4
    PHP 下的SSL加密设置
  • 5
    PHP面向对象深入研究之【命名空间】与【自动加载类】
  • 6
    php-redis扩展模块安装记录
  • 7
    一个实用的PHP缓存类
  • 8
    php安装redis扩展
  • 9
    PHP 魔术方法__set() __get() 方法
  • 10
    PHP关于VC9和VC6以及Thread Safe和Non Thread Safe版本选择的问题
  • 1
    android通过http上传文件，服务器端用php写(原创)
    62
  • 2
    PHP医院安全不良事件管理系统源码（AEMS）前端vue2+element+后端laravel8不良事件上报与闭环管理
    77
  • 3
    深入理解PHP的命名空间与自动加载机制
    54
  • 4
    深入理解PHP的命名空间和自动加载机制
    34
  • 5
    网安之PHP基础练习
    39
  • 6
    1688快速获取整店铺列表 采集接口php Python
    52
  • 7
    PHP基于B/S版 医院不良事件管理系统源码vscode+laravel8医院如何加强不良事件上报系统的管理 AEMS系统源码
    65
  • 8
    【PHP入门】2.2 流程控制
    56
  • 9
    【PHP入门】2.1-运算符
    38
  • 10
    【PHP入门】1.3-数据类型、转换、判断
    54

    • 相关课程

    更多
  • PHP进阶教程 - 由浅入深掌握面向对象开发 - 第二阶段
  • PHP完全自学手册文档教程
  • Java面向对象开发
  • 5天玩转Java面向对象编程
  • Java面向对象编程
  • Python语言基础 - 函数、面向对象、异常处理

    • 相关电子书

    更多
  • PHP运行机制初探
  • PHP与APM_技术内幕和最佳实践
  • CentOS Nginx PHP JAVA 多语言镜像使用手

    • 相关实验场景

    更多
  • 1分钟SAE部署PHP商城小程序
  • 面向对象-1：类的定义
  • 10分钟Serverless部署PHP商城
  • 使用Java面向对象编写网络通信程序应用
    • 下一篇
    阿里云OSS设置跨域访问