装饰者模式

1.动态地将责任附加到对象上，扩展功能，比继承更有弹性。

2.代码

C++

//decorate c++
#include <iostream>
#include <string>
using namespace std;

//基类 饮料
class Beverage{
public:
    Beverage(string s): description(s){}
    virtual string getDescription(){                 //配料需覆盖，饮料不用
        return description;
    }
    virtual double cost() = 0;
private:
    string description;
};

//子类 饮料:浓咖啡
class Espresso : public Beverage{
public:
    Espresso() : Beverage("Espresso"){}               //不能在子类初始化列表初始化父类成员
    double cost(){
        return 1.99;
    }
};

//子类 饮料:混合
class HouseBlend : public Beverage{
public:
    HouseBlend() : Beverage("House Blend coffee"){}
    double cost(){
        return 0.89;
    }
};

//配料
class CondimentDecorator : public Beverage{
public:
    CondimentDecorator(string s): Beverage(s){}
};

//配料:摩卡
class Mocha : public CondimentDecorator{
public:
    Mocha(Beverage* beverage) : m_pbeverage(beverage),CondimentDecorator("Mocha"){}
    string getDescription(){
        return m_pbeverage->getDescription() + ",Mocha";
    }
    double cost(){
        return .20 + m_pbeverage->cost();
    }
private:
    Beverage* m_pbeverage;
};

//配料:鲜奶油
class Whip : public CondimentDecorator{
public:
    Whip(Beverage* beverage) : m_pbeverage(beverage),CondimentDecorator("Whip"){}
    string getDescription(){
        return m_pbeverage->getDescription() + ",Whip";
    }
    double cost(){
        return .30 + m_pbeverage->cost();
    }
private:
    Beverage* m_pbeverage;
};

//
int main(){
    //beverage*1
    Beverage* beverage_1 = new Espresso();
    cout<<beverage_1->getDescription()<<" $"<<beverage_1->cost()<<endl;
    
    //Mocha*2 Whip*1
    Beverage* beverage_2 = new Espresso();
    beverage_2 = new Mocha(beverage_2);    
    beverage_2 = new Mocha(beverage_2);
    beverage_2 = new Whip(beverage_2);
    cout<<beverage_2->getDescription()<<" $"<<beverage_2->cost()<<endl;

    return 0;
}

  Java

//decorate java
//base class
abstract class Beverage{
    String description = "Unknown Beverage";
    public String getDescription(){
        return description;
    }
    public abstract double cost();
}
abstract class CondimentDecorator extends Beverage{
    public abstract String getDescription();
}

//Espresso
class Espresso extends Beverage{
    public Espresso(){
        description = "Espresso";
    }
    public double cost(){
        return 1.99;
    }
}

//HouseBlend
class HouseBlend extends Beverage{
    public HouseBlend(){
        description = "House Blend coffee";
    }
    public double cost(){
        return 0.89;
    }
}
//Mocha
class Mocha extends CondimentDecorator{
    Beverage beverage;
    public Mocha(Beverage beverage){
        this.beverage = beverage;
    }
    public String getDescription(){
        return beverage.getDescription() + ",Mocha";
    }
    public double cost(){
        return .20 + beverage.cost();
    }
}

//Whip
class Whip extends CondimentDecorator{
    Beverage beverage;
    public Whip(Beverage beverage){
        this.beverage = beverage;
    }
    public String getDescription(){
        return beverage.getDescription() + ",Whip";
    }
    public double cost(){
        return .30 + beverage.cost();
    }
}
//main
public class StarbuzzCoffee{
    public static void main(String[] args){
        //a beverage
        Beverage beverage = new Espresso();
        System.out.println(beverage.getDescription() + " $" + beverage.cost());
        
        //Mocha*2 Whip*1
        Beverage beverage2 = new Espresso();
        beverage2 = new Mocha(beverage2);
        beverage2 = new Mocha(beverage2);
        beverage2 = new Whip(beverage2);
        System.out.println(beverage2.getDescription() + " $" + beverage2.cost());
    }
}

  3. 杂记：

（1）利用继承设计子类的行为是在编译时静态决定的

         利用组合扩展对象的行为，动态的

         组合维护，添加新功能，无须更改已存在代码，bug引入风险低

（2）类应该对扩展开放，对修改关闭

        每个部分都遵守：没必要，增加复杂度；通常集中在最有可能改变的地方

（3）应对继承滥用设计

（4）装饰和被装饰者 有相同基类，利用继承达到类型匹配，而不是利用继承获得 行为