装饰者模式--《Head First DesignPattern》

装饰者模式动态地将责任附加到对象杭，若要拓展功能，装设置提供了比继承更有弹性的替代方案。

星巴兹有多种咖啡，它们具有不同的价格。在购买咖啡时，也可以要求在其中加入各种调料，例如豆浆、摩卡、奶泡等等。需要根据所加入的调料收取不同的费用。

这里运用”装饰者模式“，以饮料为主体，然后在运行时以调料来“装饰”饮料，比如说顾客想要摩卡和奶泡深焙咖啡，那么

1. 哪一个深焙咖啡（DarkRoast）对象
2. 以摩卡对象装饰它
3. 以奶泡对象装饰它
4. 调用cost()方法，并依赖委托（delegate）将调料的价格加上去。

看一下装饰者模式的类图是如何实现的：

1. ConcreteComponent是我们要动态地加上新行为的对象
2. 每个Component都可以单独地使用，或者被装饰者包起来用
3. 每个装饰者都包装一个组件，也就是说，装饰者有一个实例变量以保存某个Component的应用。
4. Decorator是装饰者共同实现的接口。
5. ConcreteDecorator有一个实例变量，可以记录所装饰的食物。

所以实现的类图就变成：

代码如下:

Beverage，是基类，实现了getDescription()，同时cost是抽象方法。由子类去实现。

 package headfirst.decorator.starbuzz;

 public abstract class Beverage {
     String description = "Unknown Beverage";

     public String getDescription() {
         return description;
     }

     public abstract double cost();
 }

四种咖啡：

HouseBlend，DarkRoast，Espresso，Decaf

 package headfirst.decorator.starbuzz;

 public class HouseBlend extends Beverage {
     public HouseBlend() {
         description = "House Blend Coffee";
     }

     public double cost() {
         return .89;
     }
 }

 public class DarkRoast extends Beverage {
     public DarkRoast() {
         description = "Dark Roast Coffee";
     }

     public double cost() {
         return .99;
     }
 }

 public class Espresso extends Beverage {

     public Espresso() {
         description = "Espresso";
     }

     public double cost() {
         return 1.99;
     }
 }

 public class Decaf extends Beverage {
     public Decaf() {
         description = "Decaf Coffee";
     }

     public double cost() {
         return 1.05;
     }
 }

接下来是调料接口，或者是抽象类。它必须继承我们的Beverage。并且声明了getDescription()方法。

 package headfirst.decorator.starbuzz;

 public abstract class CondimentDecorator extends Beverage {
     public abstract String getDescription();
 }

接下来是四种调料:

 package headfirst.decorator.starbuzz;

 public class Mocha extends CondimentDecorator {
     Beverage beverage;

     //保存了一个Berverage对象
     public Mocha(Beverage beverage) {
         this.beverage = beverage;
     }

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

     public double cost() {
         //注意这里委托了beverage.cost()
         return .20 + beverage.cost();
     }
 }

 public class Whip extends CondimentDecorator {
     Beverage beverage;

     public Whip(Beverage beverage) {
         this.beverage = beverage;
     }

     public String getDescription() {
         return beverage.getDescription() + ", Whip";
     }

     public double cost() {
         return .10 + beverage.cost();
     }
 }

 public class Soy extends CondimentDecorator {
     Beverage beverage;

     public Soy(Beverage beverage) {
         this.beverage = beverage;
     }

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

     public double cost() {
         return .15 + beverage.cost();
     }
 }

 public class Milk extends CondimentDecorator {
     Beverage beverage;

     public Milk(Beverage beverage) {
         this.beverage = beverage;
     }

     public String getDescription() {
         return beverage.getDescription() + ", Milk";
     }

     public double cost() {
         return .10 + beverage.cost();
     }
 }

最后是测试代码：

 package headfirst.decorator.starbuzz;

 public class StarbuzzCoffee {

     public static void main(String args[]) {
         Beverage beverage = new Espresso();
         System.out.println(beverage.getDescription()
                 + " $" + beverage.cost());

         Beverage beverage2 = new DarkRoast();
         beverage2 = new Mocha(beverage2);
         beverage2 = new Mocha(beverage2);
         beverage2 = new Whip(beverage2);
         System.out.println(beverage2.getDescription()
                 + " $" + beverage2.cost());

         Beverage beverage3 = new HouseBlend();
         beverage3 = new Soy(beverage3);
         beverage3 = new Mocha(beverage3);
         beverage3 = new Whip(beverage3);
         System.out.println(beverage3.getDescription()
                 + " $" + beverage3.cost());
     }
 }

那如果我们这时产生了新的需求，要求在菜单上加上咖啡的容量的大小，供顾客选择大杯，小杯，中杯，那该怎么办？要注意，大杯的饮料比较贵，同时它加的调料也要比较多，所以调料的价格也不一样。

这时我们应该在Beverage中定义size和getSize()的函数，并且在四种饮料中要根据size的大小，cost()函数要返回不同的价格。

在调料中，我们也需要获取被装饰者的size，然后cost函数加上对应调料的价格。

 package headfirst.decorator.starbuzz;

 public class Soy extends CondimentDecorator {
     Beverage beverage;

     public Soy(Beverage beverage) {
         this.beverage = beverage;
     }

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

     public int getSize(){
         return beverage.getSize();
     }

     public double cost() {
         double cost = beverage.cost();
         if (getSize() == Beverage.TALL){
             cost += .10;
         }else if (getSize() == Beverage.GRANDE){
             cost += .15;
         }else if (getSize() == Beverage.VENTI){
             COST += .20;
         }
         return cost;
     }
 }

最后要说的就是java.io包中，定义了很多类，就是装饰者模式的实现。我们可以看看InputStream的实现。

OutputStream和Reader，Writer的设计大致差不多。