JAVA设计模式之装饰者模式

咖啡店需要做一个订单系统，以合乎饮料供应要求。

1.最初是这样设计的：

/**
 * 饮料抽象类
 *
 */
public abstract class Beverage {
    
    protected String description;
    
    public String getDescription() {
        return this.description;
    }
    
    /**
     * 子类需自定义自己的价格
     * @return
     */
    public abstract double cost();
    
}

每一种饮料都需要继承该抽象类，并覆写cost()方法。

2.但是购买咖啡时需要考虑到调料的部分，每种咖啡会加不同种的调料，比如蒸奶、豆浆、摩卡或者覆盖奶泡，那么订单系统需要考虑加入不同调料后的价格。因此需要实现不同的子类来定义添加不同调料后的价格。大家知道，一种咖啡跟多种调料有多种组合方式，那么多种咖啡和多种调料的组合后，几乎是类爆炸！

维护极其困难：

如果某种饮料价格调整；或是新增了某种饮料，怎么办？

后来经过改进后，把是否存在某种调料作为饮料的属性，并在饮料抽象类中实现cost方法，子类可以覆写cost方法并设置添加的调料最终确定添加不同调料后的价格：

/**
 * 饮料抽象类
 *
 */
public abstract class Beverage {
    
    private boolean milk;//牛奶
    private boolean soy;//豆浆
    private boolean mocha;//摩卡
    private boolean whip;//奶泡
    
    private double milkCost = 0.19;
    private double soyCost = 0.26;
    private double mochaCost = 0.29;
    private double whipCost = 0.17;
    
    protected String description;
    
    //setter getter method

    public String getDescription() {
        return this.description;
    }
    
    public double cost() {
        double condimentCost = 0.0;
        if (hasMilk()) {
            condimentCost += milkCost;
        }
        if (hasSoy()) {
            condimentCost += soyCost;
        }
        if (hasMocha()) {
            condimentCost += mochaCost;
        }
        if (hasWhip()) {
            condimentCost += whipCost;
        }
        return condimentCost;
    }
    
}

/**
 * 低糖咖啡
 *
 */
public class Decaf extends Beverage {
    
    @Override
    public String getDescription() {
        return "It is Decaf.";
    }

    @Override
    public double cost() {
        super.setMilk(true);//添加牛奶调料
        return 1.99 + super.cost();
    }
    
}

这样一来，如果有五种咖啡，那么只需要实现五个子类即可，不同的子类可以灵活设置添加不同的调料。

但是这样的设计存在一定的问题：

1）调料价格的改变会使我们改变现有代码；

2）出现新调料，就需要加上新的方法，并改变父类中的cost方法；

3）若出现新的饮料，如红茶，那么新的饮料继承该父类，父类中的调料属性并不合适，如奶泡等；

... ...

设计原则：类应该对扩展开放，对修改关闭。

装饰者模式思想：以饮料为主体，然后在运行时以调料来“装饰”饮料。

例如客户需要摩卡和奶泡深焙咖啡，那么要做的是：

拿一个深焙咖啡对象；

以摩卡对象装饰；

以奶泡对象装饰；

摩卡和奶泡属于调料，但是也是装饰者，它的类型反映了它装饰的对象，所谓反映，指的是两者类型一致。那么所有调料需要继承Beverage。

使用装饰者模式设计的代码：

/**
 * 饮料抽象类
 *
 */
public abstract class Beverage {
    
    protected String description;
    
    public String getDescription() {
        return this.description;
    }
    
    /**
     * 获取每种饮料的价格
     * @return
     */
    public abstract double cost();
}

/**
 * 调料抽象类
 *
 */
public abstract class Condiment extends Beverage {
    
    public abstract String getDescription();
    
}

这里调料继承饮料，仅仅是为了使两者具有相同的类型，并非为了复用父类的行为。

下面是饮料的子类：

/**
 * 深焙咖啡
 *
 */
public class DarkRoast extends Beverage {
    
    public DarkRoast() {
        description = "DarkRoast";
    }
    @Override
    public double cost() {
        return 0.19;
    }

}

/**
 * 浓缩咖啡
 *
 */
public class Espresso extends Beverage {
    
    public Espresso() {
        description = "Espresso";
    }
    
    @Override
    public double cost() {
        return 1.99;
    }

}

/**
 * 黑咖啡
 *
 */
public class HoseBlend extends Beverage {
    
    public HoseBlend() {
        description = "Hose Blend Coffee";
    }
    
    @Override
    public double cost() {
        return 0.99;
    }

}

调料(装饰者)子类：

/**
 * 摩卡
 *
 */
public class Mocha extends Condiment {

    private Beverage beverage;
    
    public Mocha(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Mocha";
    }

    @Override
    public double cost() {
        return 0.20 + beverage.cost();
    }

}

/**
 * 豆浆
 *
 */
public class Soy extends Condiment {
    
    private Beverage beverage;
    
    public Soy(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Soy";
    }

    @Override
    public double cost() {
        return 0.23 + beverage.cost();
    }

}

/**
 * 奶泡
 *
 */
public class Whip extends Condiment {
    
    private Beverage beverage;
    
    public Whip(Beverage beverage) {
        this.beverage = beverage;
    }
    
    @Override
    public String getDescription() {
        return beverage.getDescription() + ", Whip";
    }

    @Override
    public double cost() {
        return 0.69 + beverage.cost();
    }

}

测试代码：

public class ComponentTest {
    @Test
    public void test() {
        Beverage beverage = new Espresso();
        System.out.println(beverage.getDescription() + ", $" + beverage.cost());
        Beverage beverage2 = new HoseBlend();
        beverage2 = new Mocha(beverage2);
        beverage2 = new Mocha(beverage2);
        beverage2 = new Whip(beverage2);
        System.out.println(beverage2.getDescription() + ", $" + beverage2.cost());
        Beverage beverage3 = new DarkRoast();
        beverage3 = new Soy(beverage3);
        beverage3 = new Mocha(beverage3);
        beverage3 = new Whip(beverage3);
        System.out.println(beverage3.getDescription() + ", $" + beverage3.cost());
    }
}

运行结果：

Espresso, $1.99
Hose Blend Coffee, Mocha, Mocha, Whip, $2.08
DarkRoast, Soy, Mocha, Whip, $1.31

java/IO中有很多用到装饰者模式的设计，有兴趣的朋友可以了解下。