[结构型模式] head first 设计模式之装饰者模式(decorator)

柔情只为你懂 2022-04-17 02:25 135阅读 0赞

1 别名  
包装器wrapper  
  
2 介绍  
通过使用修饰模式，可以在运行时扩充一个类的功能。原理是：增加一个修饰类包裹原来的类，包裹的方式一般是通过在将原来的对象作为修饰类的构造函数的参数。装饰类实现新的功能，但是，在不需要用到新功能的地方，它可以直接调用原来的类中的方法。修饰类必须和原来的类有相同的接口。  
修饰模式是类继承的另外一种选择。类继承在编译时候增加行为，而装饰模式是在运行时增加行为。  
当有几个相互独立的功能需要扩充时，这个区别就变得很重要。在有些面向对象的编程语言中，类不能在运行时被创建，通常在设计的时候也不能预测到有哪几种功能组合。这就意味着要为每一种组合创建一个新类。相反，修饰模式是面向运行时候的对象实例的,这样就可以在运行时根据需要进行组合。一个修饰模式的示例是JAVA里的Java I/O Streams的实现。  
  
3 设计原则  
\[color=red\] 类应该对扩展开放，对修改关闭。\[/color\]  
  
4 条件  
\[color=red\] a) 装饰者和被装饰对象有相同的超类型；也就是有共同的超类，这是相当关键的地方；我们利用继承达到“类型匹配”，而不是利用继承的“行为”;  
b) 你可以用一个或则多个装饰者包装一个对象；\[/color\]  
  
5 定义  
\[color=red\] 动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。\[/color\]  
  
6 总结  
\[b\]装饰者模式的应用场景：\[/b\]  
\[color=red\]a、想透明并且动态地给对象增加新的职责的时候。  
b、给对象增加的职责，在未来存在增加或减少可能。  
c、用继承扩展功能不太现实的情况下，应该考虑用组合的方式。  
\[/color\]  
  
\[b\]装饰者模式的优点：\[/b\]  
\[color=red\]a、通过组合而非继承的方式，实现了动态扩展对象的功能的能力。  
b、有效避免了使用继承的方式扩展对象功能而带来的灵活性差，子类无限制扩张的问题。  
c、充分利用了继承和组合的长处和短处，在灵活性和扩展性之间找到完美的平衡点。  
d、装饰者和被装饰者之间虽然都是同一类型，但是它们彼此是完全独立并可以各自独立任意改变的。  
e、遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。\[/color\]  
  
\[b\]装饰者模式的缺点：\[/b\]  
\[color=red\] a、 装饰链不能过长，否则会影响效率。  
b、 因为所有对象都是继承于Component,所以如果Component内部结构发生改变，则不可避免地影响所有子类(装饰者和被装饰者)，也就是说，通过继承建立的关系总是脆弱地，如果基类改变，势必影响对象的内部，而通过组合(Decoator HAS A Component)建立的关系只会影响被装饰对象的外部特征。  
c、只在必要的时候使用装饰者模式，否则会提高程序的复杂性，增加系统维护难度。\[/color\]  
  
\[img\]http://t25-4.yunpan.360.cn/p/800-600.e86ff49b309968eeb8664969505395bb069af578.9841c6.jpg?t=a344bfb34b846467f2df389c48ad5ce8&d=20130821\[/img\]

#ifndef   DECORATOR_H
    #define   DECORATOR_H
    
    #include <iostream>
    #include <string>
    #include <cassert>
    using namespace std;
    
    //装饰者模式
    namespace Decorator
    {
       
    //const definitions
    //
    const double       ESPRESSO_PRICE       = 1.99;
    const double       HOUSEBLEND_PRICE     = 0.89;
    const double       MOCHA_PRICE          = 0.20;
    
    //
    class Beverage
    {
       
    public:
        Beverage()
        {
       
            m_Description = "Unknown Beverage";
        }
        virtual ~Beverage(){}
    
        virtual double cost() = 0 ;
        virtual string getDescription()
        {
       
            return m_Description;
        }
    
    protected:
        string m_Description;
    };
    
    //
    class Espresso : public Beverage
    {
       
    public:
        Espresso()
        {
       
            m_Description = "Espresso";
        }
        virtual double cost()
        {
       
            return ESPRESSO_PRICE;
        }
    };
    
    //
    class HouseBlend : public Beverage
    {
       
    public:
        HouseBlend()
        {
       
            m_Description =  "House Blend Coffee" ;
        }
        virtual double cost()
        {
       
            return HOUSEBLEND_PRICE;
        }
    };
    
    //
    class CondimentDecorator : public Beverage
    {
       
    public:
        virtual string getDescription() = 0;
    };
    
    class Mocha : public CondimentDecorator
    {
       
    public:
        Mocha(Beverage* beverage)
            : m_Beverage(NULL)
        {
       
            if (beverage != NULL)
            {
       
                //if (m_Beverage != NULL)
                //{
       
                //    delete m_Beverage;
                //    m_Beverage = NULL;
                //}
    
                this->m_Beverage = beverage;
            }
        }
        virtual ~Mocha()
        {
       
            //if (m_Beverage != NULL)
            //{
       
            //    delete m_Beverage;
            //    m_Beverage = NULL;
            //}
        }
    
        virtual string getDescription()
        {
       
            assert( m_Beverage != NULL);
            return m_Beverage->getDescription() + " , Mocha";
        }
    
        virtual double cost()
        {
       
            assert( m_Beverage != NULL);
            return MOCHA_PRICE + m_Beverage->cost();
        }
    
    private:
        Beverage* m_Beverage;
    };
    
    //
    class StarbuzzCoffee
    {
       
    public:
        void run()
        {
       
            Beverage* espresso = new Espresso();
            cout << espresso->getDescription().c_str() << " $" << espresso->cost() << endl;
            Beverage* mocha = new Mocha(espresso);
            cout << mocha->getDescription().c_str() << " $" << mocha->cost() << endl;
    
            Beverage* houseBlend = new HouseBlend();
            cout << houseBlend->getDescription().c_str() << " $" << houseBlend->cost() << endl;
            Beverage* mocha2 = new Mocha(houseBlend);
            cout << mocha2->getDescription().c_str() << " $" << mocha2->cost() << endl;
            Beverage* mocha3 = new Mocha(mocha);
            cout << mocha3->getDescription().c_str() << " $" << mocha3->cost() << endl;
    
            delete espresso;
            delete mocha;
            delete houseBlend;
            delete mocha2;
            delete mocha3;
        }
    };
    
    }//namespace Decorator
    
    #endif