分类： 技术

示例1：

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();
//echo $tile->getWealthFactor();

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

$tile = new PollutionDecorator(new DiamondDecorator( new Plains() ));
echo $tile->getWealthFactor();

示例2：

class RequestHelper{}

//抽象基类
abstract class ProcessRequest{
    abstract function process( RequestHelper $req );
}

//具体组件
class MainProcess extends ProcessRequest{
    function process( RequestHelper $req ){
        echo __CLASS__."doing somthing useful with request<br />";
    }
}

//抽象装饰类
//为子类保存了一个ProcessRequest对象
abstract class DecorateProcess extends ProcessRequest{
    protected $processrequest;
    function __construct(ProcessRequest $pr){
        $this->processrequest = $pr;
    }
}

class LogRequest extends DecorateProcess{
    function process( RequestHelper $req){
        echo __CLASS__.":logging request <br />";
        $this->processrequest->process($req);
    }
}

class AuthenticateRequest extends DecorateProcess{
    function process( RequestHelper $req){
        echo __CLASS__.":authenticate request <br />";
        $this->processrequest->process($req);
    }
}

class StrucureRequest extends DecorateProcess{
    function process( RequestHelper $req){
        echo __CLASS__.":strucure request <br />";
        $this->processrequest->process($req);
    }
}

$process = new AuthenticateRequest(new StrucureRequest( new LogRequest ( new MainProcess())));
$process->process( new RequestHelper());


//AuthenticateRequest:authenticate request
//StrucureRequest:strucure request
//LogRequest:logging request
//MainProcessdoing somthing useful with request

装饰者模式可以用来透明地把对象包装在具有同样接口的另一个对象中。这样一来，你可以给一个方法加一些行为，然后将方法调用传递给原始对象。

相对于创建子类来说，使用装饰者对象是一种更灵活的选择。

装饰者模式和组合模式两者很像，那么这二者之间又有什么区别呢？

1、组合模式是一种结构型模式，用于把众多子对象组织为一个整体，及此程序员与大批对象打交道时可以将他们当作一个对象来对待，并将它们组织为层次性的树。通常它并不修改方法调用，

而只是将其沿组合对象与子对象的链向下传递，直到到达并落实在叶对象上。

2、装饰者模式也是一种结构型模式，但它并非用于组织对象，而是用于在不修改现有对象或从其派生子类的前提下为其增添职责。在一些较简单的例子中，装饰者模式会透明而不加修改地传递所有方法调用，

不过，创建装饰者模式的目的就在于对方法进行修改。

尽管简单的组合对象与简单的装饰者对象是相同的，但二者却有着不同的焦点。组合对象并不修改方法调用，其着眼在点于组织子对象。而装饰者模式存在的唯一目的就是修改方法调用而不是组织子对象，因为子对象只有一个。

这个···我就懒得自己敲代码了

找了些代表性强的例子 可能也不是php写的

模式嘛用其他语言也没有啥关系 理解模式就好

组合模式的原则是局部类和组合类具有同样的接口。

特殊对象越来越多，组合模式开始渐渐显得弊大于利。

在大部分局部对象可互换的情况下，组合模式才最适用。

虽然组合模式是一个优雅的模式，但是它并不能将自身轻松的存储到关系数据库里。

如果你想像对待单个对象一样对待组合对象，那么组合模式才十分有用。

组合模式又依赖于其他组成部分的简单性。

随着我们引入复杂的规则，代码会变得越来越难以维护。

组合模式不能很好地在关系数据库中保存数据，但却非常合适使用XML持久化。

==============================

定义：将对象组合成树形结构，表示层次结构关系，并且让对象能够以同样的方式呈现给客户端程序。

举例：

家族谱的编写：

男性：可传宗接代，也有权利把一些人剔除族谱。

女性：记录到家谱中，但不能传宗接代。

理解：每一个小家庭中，爸爸妈妈和我，都是爸爸做主，可踢出我跟妈妈中的任何一个，也可增加任何一个。组件模式中的组件可以是单独一个对象组成，也可以是多个组件组成（一个家庭，甚至一个家庭的多级延续）；

类图：

族员共性代码：

//// <summary>
    /// //族人 抽象出来的族人共性
    /// </summary>
    public abstract class Father
    {
        //族人的姓名
        protected string name = string.Empty;
        public string Name
        {
            get
            {
                return name;
            }
        }

        //增加后代
        public abstract void Add(Father boy);
        //逐出家谱
        public abstract void Remove(Father boy);

        //定义所有族人，做个简介
        public abstract void Intro();
    }

家族成员代码

//男性后代
    public class Boy : Father
    {
        //构造函数
        public Boy() { }
        public Boy(string Name)
        {
            this.name = Name;
        }

        List<Father> myFamily = new List<Father>();

        //自我简介
        public override void Intro()
        {
            Console.WriteLine("我是:{0};", Name);
            foreach (Father f in myFamily)
            {
                f.Intro();
            }
        }

        //增加后代
        public override void Add(Father boy)
        {
            myFamily.Add(boy);
        }

        //逐出家谱
        public override void Remove(Father boy)
        {
            myFamily.Remove(boy);
        }
    }

    //女性后代 
    public class Gril : Father
    {
        //构造函数
        public Gril() { }
        public Gril(string Name)
        {
            this.name = Name;
        }
        //自我简介
        public override void Intro()
        {
            Console.WriteLine("我是:{0};", Name);
        }
        //不能添加
        public override void Add(Father store)
        {
            throw new NotImplementedException();
        }
        //不能删除
        public override void Remove(Father store)
        {
            throw new NotImplementedException();
        }
    }

客户端代码：

public static void Main()
        {
            //爷爷取老婆
            Boy yeye = new Boy("爷爷");
            Gril nainai = new Gril("奶奶");
            yeye.Add(nainai);

            //爷爷要孩子
            Boy baba = new Boy("爸爸");
            Gril gugu = new Gril("姑姑");            
            yeye.Add(gugu);
            yeye.Add(baba);

            //爸爸要我
            Boy me = new Boy("me");
            baba.Add(me);

            //我要孩子
            Boy son = new Boy("son");
            me.Add(son);

            //爷爷的大家庭，族谱做介绍
            yeye.Intro();

            Console.Read();
        }

总结：

有组合模式的案例可知：客户端代码，很容易组建层次结构，并且层次分明，同时又很容易遍历所有的组件集合。但要注意理解组合模式中的节点与页，节点可删可加，页则不能增删。

大家都好好理解，消化下这个模式，想想都在哪里，哪种情况下能使这个模式的特性发挥的淋漓尽职。

                   _ooOoo_
                  o8888888o
                  88" . "88
                  (| -_- |)
                  O\  =  /O
               ____/`---'\____
             .'  \\|     |//  `.
            /  \\|||  :  |||//  \
           /  _||||| -:- |||||-  \
           |   | \\\  -  /// |   |
           | \_|  ''\---/''  |   |
           \  .-\__  `-`  ___/-. /
         ___`. .'  /--.--\  `. . __
      ."" '<  `.___\_<|>_/___.'  >'"".
     | | :  `- \`.;`\ _ /`;.`/ - ` : | |
     \  \ `-.   \_ __\ /__ _/   .-` /  /
======`-.____`-.___\_____/___.-`____.-'======
                   `=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
           佛祖保佑       永无BUG