装饰模式（Decorator）

定义

动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式比生成子类更加灵活、可作为继承的替代。又称装饰者模式（Wrapper）。

类图

• Component:定义一个对象接口，可以给这些对象动态地添加职责；
• ConcreteComponent:定义一个具体的Component，继承自ConcreateComponent，重写了Component类的虚函数；
• Decorator:维持一个指向Component对象的指针，该指针指向需要被装饰的对象；并定义一个
• Component接口一致的接口；

ConcreteDecorator:向组件添加职责。

实现

优点

可以动态为对象添加功能，相比于继承实现，组合的方式更加灵活而且代码量小很多

缺点

多层装饰会有无限剥离的问题，影响效率，性能，工作量大

使用场景

1. 在不影响其他对象的情况下，以动态的，透明的方式给单个对象添加职责；
2. 处理那些可以撤销的职责；
3. 当不能采用生成子类的方法进行扩充时。一种情况是，可能存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。

注意事项

1. 接口的一致性；装饰对象的接口必须与它所装饰的Component的接口是一致的，因此，所有的ConcreteDecorator类必须有一个公共的父类；这样对于用户来说，就是统一的接口；
2. 省略抽象的Decorator类；当仅需要添加一个职责时，没有必要定义抽象Decorator类。因为我们常常要处理，现存的类层次结构而不是设计一个新系统，这时可以把Decorator向Component转发请求的职责合并到ConcreteDecorator中；、
3. 保持Component类的简单性；为了保证接口的一致性，组件和装饰必须要有一个公共的Component类，所以保持这个Component类的简单性是非常重要的，所以，这个Component类应该集中于定义接口而不是存储数据。对数据表示的定义应延迟到子类中，否则Component类会变得过于复杂和臃肿，因而难以大量使用。赋予Component类太多的功能，也使得具体的子类有一些它们它们不需要的功能大大增大；

与桥接模式的区别

二者都是为了防止过度的继承，从而造成子类泛滥的情况。

1. 桥接模式中所说的分离，其实是指将结构与实现分离（当结构和实现有可能发生变化时）或属性与基于属性的行为进行分离；而装饰者只是对基于属性的行为进行封闭成独立的类，从而达到对其进行装饰，也就是扩展。比如：异常类和异常处理类之间就可以使用桥接模式来实现完成，而不能使用装饰模式来进行设计；如果对于异常的处理需要进行扩展时，我们又可以对异常处理类添加Decorator，从而添加处理的装饰，达到异常处理的扩展，这就是一个桥接模式与装饰模式的搭配；
2. 桥接中的行为是横向的行为，行为彼此之间无关联，注意这里的行为之间是没有关联的，就比如异常和异常处理之间是没有行为关联的一样；而装饰者模式中的行为具有可叠加性，其表现出来的结果是一个整体，一个各个行为组合后的一个结果。

示例1

游戏中的人物和时装。人物可以选择穿上帽子或穿上鞋子，或者都穿上，通过方法展示穿搭结果。
比较容易想到的实现方法就是单纯通过继承，一个人物基类，继承出一个穿帽子的人物类，一个穿鞋子的人物类，再一个穿帽子+鞋子的人物类。在只有两种选择时，需要产生3个子类，这种实现方式每增加一种选择就要增加一倍+1数量的子类，非常不可取。
实现方式：
第一步，抽象出一个装饰基类，类中添加一个人物类指针，在构造时传入人物类指针。
第二步，增加需要修饰的同名方法，在方法中通过指针调用原方法，再添加新修饰内容。
第三步，将装饰基类继承自人物基类，为了使传入装饰类A进行装饰的指针能够传入装饰类B进行其他装饰，并且使传入装饰类A的指针可以指向该装饰类对象。
最后一步，实现装饰基类，实现装饰内容。

#ifndef DECORATOR_HPP
#define DECORATOR_HPP
#include <iostream>
using namespace std;
//人物基类
class Man
{
public:
    virtual ~Man(){}
    virtual void Show()//用于展示
    {
        cout << "A man." <<endl;
    }
};

//装饰器抽象类
class ManWithCloth:public Man//继承自Man，为了使被装饰的对象可以传入其他装饰器进行组合装饰
{
public:
    ManWithCloth(Man* pMan)
        :m_pMan(pMan){}
    virtual ~ManWithCloth()
    {
        if(NULL != m_pMan)
        {
            delete m_pMan;
            m_pMan = NULL;
        }
    }

    virtual void Show()//上述实现方式中的第二步
    {
        m_pMan->Show();//通过指针调用原指针所指对象的方法，然后添加方法进行修饰
        DressUp();//对原方法增加修饰
    }
    virtual void DressUp() = 0;//修饰方法在实现类中实现

private:
    Man* m_pMan;
};

//装饰器实现类
class ManWearAHat:public ManWithCloth
{
public:
    ManWearAHat(Man* pMan)
        :ManWithCloth(pMan){}
    virtual void DressUp()
    {
        cout << "Wear a Hat." << endl;
    }
};

class ManWearShoes:public ManWithCloth
{
public:
    ManWearShoes(Man* pMan)
        :ManWithCloth(pMan){}
    virtual void DressUp()
    {
        cout << "Wear shoes." << endl;
    }
};

#endif // DECORATOR_HPP

#include <iostream>
#include "decorator.hpp"
using namespace std;

int main()
{
    Man* pMan = new Man();
    pMan->Show();

    cout << "=====Wear Hat=====" << endl;
    pMan = new ManWearAHat(pMan);
    pMan->Show();

    cout << "====Wear Shoes====" << endl;
    pMan = new ManWearShoes(pMan);
    pMan->Show();

    delete pMan;
    pMan = NULL;

    return 0;
}

运行结果：

A man.
=====Wear Hat=====
A man.
Wear a Hat.
====Wear Shoes====
A man.
Wear a Hat.
Wear Shoes.

示例2

#include <iostream>

//抽象组件角色:给出一个抽象接口,以规范准备接收附加责任的对象
class Component{
public:
    virtual ~Component(){}
    
    virtual void Configuration() = 0;
};

//具体组件类
class Car: public Component {
public:
    void Configuration() override {
        std::cout << "------Car-------" << std::endl;
    }
};

//装饰角色:持有一个组件对象的实例,并实现一个与抽象组件接口一致的接口
class DecorateCar : public Component {
public:
    DecorateCar(Component* car) : car_(car) {}
    void Configuration() override {
        car_->Configuration();
    }

private:
    Component* car_;
};


//具体装饰角色:负责给组件对象添加额外的责任
class DecorateLED: public DecorateCar {
public:
    DecorateLED(Component* car) : DecorateCar(car){}
    
    void Configuration() override {
        DecorateCar::Configuration();
        AddLED();
    }

private:
    void AddLED() {
        std::cout << "--------AddLED" << std::endl;
    }
};

//具体装饰角色:负责给组件对象添加额外的责任
class DecoratePC : public DecorateCar {
public:
    DecoratePC(Component* car) : DecorateCar(car) {}
    
    void Configuration() override {
        DecorateCar::Configuration();
        AddPC();
    }

private:
    void AddPC() {
        std::cout << "-----------AddPC-----------" << std::endl;
    }
};

int main() {
    Car car;
    DecorateLED ledCar(&car);
    DecoratePC pcCar(&car);
    
    ledCar.Configuration();
    pcCar.Configuration();
    
    return 0;
}

示例3-python

#coding=utf-8
import os


class Person:
    def __init__(self, name):
        self.name = name

    def show(self):
        print('打扮的' + self.name)


class Finery(Person):
    def __init__(self):
        self.component = None

    def decorate(self, component):
        self.component = component

    def show(self):
        if self.component is not None:
            self.component.show()


class TShirt(Finery):
    def show(self):
        print '大T恤',
        self.component.show()


class BigTrouser(Finery):
    def show(self):
        print '垮裤',
        self.component.show()


class Sneaker(Finery):
    def show(self):
        print '运动鞋',
        self.component.show()


if __name__ == '__main__':
    p = Person('大熊')
    upClothes = TShirt()
    downClothes = BigTrouser()
    shoes = Sneaker()
    upClothes.decorate(p)
    downClothes.decorate(upClothes)
    shoes.decorate(downClothes)
    shoes.show()

运行结果：
运动鞋 垮裤 大T恤 打扮的大熊