设计模式之装饰者模式代码

1. 装饰模式指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

2. 角色

• 抽象构件角色（Component）：具体构件类和抽象装饰者类的共同父类。

• 具体构件角色（ConcreteComponent）：抽象构件的子类，装饰者类可以给它增加额外的职责。

• 装饰角色（Decorator）：抽象构件的子类，具体装饰类的父类，用于给具体构件增加职责，但在子类中实现。

• 具体装饰角色（ConcreteDecorator）：具体装饰类，定义了一些新的行为，向构件类添加新的特性。

3. 代码实现

public abstract class Drink {
public String des;//描述
private float price = 0.0f;
public String getDes() {
   return des;
}
public void setDes(String des) {
   this.des = des;
}
public float getPrice() {
   return price;
}
public void setPrice(float price) {
   this.price = price;
}
@Override
public String toString() {
   return "Drink [des=" + des + ", price=" + price + "]";
}
public Drink(String des, float price) {
   super();
   this.des = des;
   this.price = price;
}
public Drink() {
   super();
}
//计算费用的抽象方法
//子类进行实现
public abstract float cost();
}

public class Decorator extends Drink{
private Drink obj;
public Decorator(Drink obj) {
   this.obj = obj;
}
@Override
public float cost() {
   // TODO Auto-generated method stub
   return super.getPrice() + obj.cost();
}
@Override
public String getDes() {
   // TODO Auto-generated method stub
   return des + " "+ getPrice() + "&&" + obj.getDes();
}
}

//调味品
public class Chocolate extends Decorator{

public Chocolate(Drink obj) {
   super(obj);
   setDes("巧克力");
   setPrice(3.0f);
}

}
public class Milk extends Decorator{

public Milk(Drink obj) {
   super(obj);
   setDes("牛奶");
   setPrice(2.0f);
}

}
public class Soy extends Decorator{

public Soy(Drink obj) {
   super(obj);
   setDes("豆浆");
   setPrice(2.f);
}

}

public class Coffee extends Drink{

@Override
public float cost() {
   // TODO Auto-generated method stub
   return super.getPrice();
}

}
public class DesCaf extends Coffee{
public DesCaf() {
   setDes("无因咖啡");
   setPrice(1.0f);
}
}
public class Espresso extends Coffee{
public Espresso(){
  setDes("意大利咖啡");
   setPrice(6.0f);
}
}
public class LongBlack extends Coffee{
public LongBlack() {
   setDes("longblack");
   setPrice(5.0f);
}
}

//客户端调用
public class CoffeeBar {
public static void main(String[] args) {
   //装饰着模式订单

   //点一份longblack
   Drink order = new LongBlack();
   System.out.println("描述1= "+order.getDes());
   System.out.println("费用1= "+order.cost());

   //加入一份牛奶
   order = new Milk(order);
   System.out.println("order 加入一份牛奶 描述2= "+order.getDes());
   System.out.println("order 加入一份牛奶 费用2= "+order.cost());

   order = new Chocolate(order);
   System.out.println("order 加入一份牛奶 加入一份巧克力 描述3= "+order.getDes());
   System.out.println("order 加入一份牛奶 加入一份巧克力 费用3= "+order.cost());

   Drink order1 = new DesCaf();
   System.out.println("描述1= "+order1.getDes());
   System.out.println("费用1= "+order1.cost());
}
}

4. 应用分析

通过装饰者模式实现咖啡价格计算的模型

Beverage 是抽象的饮料类，HousrBlend、DarkRoast、Espresso、Decaf 是具体的饮料类型，都继承了Beverage。CondimentDecorator 是抽象的配料类， Milk、Mocha、Soy、Whip是具体的配料，都继承了 CondimentDecorator 。CondimentDecorator 关联了一个 Beverage 类 ，可以对具体的饮料附加行为，从而达到新的目的。

CondimentDecorator 为什么要继承 Beverage 呢？

因为 CondimentDecorator 关联了需要加入配料的饮料，对饮料加入配料后，其本制上还是一种饮料，所以CondimentDecorator 需要继承 Beverage，也便于后续再次加入配料，保证其始终都是一种饮料。

为便于理解，可将 CondimentDecorator 理解为一种加入配料的饮料 。

• Beverage 抽象类：

package headfirst.designpatterns.Decorator;
​
public abstract class Beverage {
​
    // 每种饮料的描述：“名称，配料1，配料2...”
    String description = "Unknown Beverage";
​
    public String getDescription() {
        return description;
    }
​
    // 每种类型饮料的价格不同，故定义为抽象方法
    public abstract double cost();
}

• DarkRoast类：

package headfirst.designpatterns.Decorator;
​
​
public class DarkRoast extends Beverage {
​
    public DarkRoast() {
        description = "Dark Roast";
    }
​
    @Override
    public double cost() {
        return .99;
    }
}

• Decaf 类：

package headfirst.designpatterns.Decorator;
​
public class Decaf extends Beverage {
​
    public Decaf() {
        description = "Decaf";
    }
​
    @Override
    public double cost() {
        return 1.05;
    }
​
}

• Espresso 类：

package headfirst.designpatterns.Decorator;
​
public class Espresso extends Beverage {
​
    public Espresso() {
        description = "Espresso";
    }
​
    @Override
    public double cost() {
        return 1.99;
    }
​
}

• HouseBlend 类：

package headfirst.designpatterns.Decorator;
​
public class HouseBlend extends Beverage {
​
    public HouseBlend() {
        description = "HouseBlend ";
    }
​
    @Override
    public double cost() {
        return 0.89;
    }
​
}

• CondimentDecorator 抽象类：

package headfirst.designpatterns.Decorator;
​
public abstract class CondimentDecorator extends Beverage {
​
    // 因为每种配料对饮料的描述进行了附加的说明，所以每种饮料添加配料后，都需要重写 getDescription方法。
    @Override
    public abstract String getDescription();
​
}

• Milk 类：

package headfirst.designpatterns.Decorator;
​
public class Milk extends CondimentDecorator {
​
    // 关联了一种饮料，以便对附加新的行为
    Beverage beverage;
​
    public Milk(Beverage beverage) {
        this.beverage = beverage;
    }
​
    // 附加新的行为,描述
    @Override
    public String getDescription() {
        return beverage.getDescription() + ",Milk";
    }
    // 附加新的行为,价格
    @Override
    public double cost() {
        return beverage.cost() + .10;
    }
}
​

• Mocha 类：

package headfirst.designpatterns.Decorator;
​
public class Mocha extends CondimentDecorator {
​
    Beverage beverage;
​
    public Mocha(Beverage beverage) {
        this.beverage = beverage;
    }
​
    @Override
    public String getDescription() {
        return beverage.getDescription() + ",Mocha";
    }
​
    @Override
    public double cost() {
        return beverage.cost() + .20;
    }
}

• Soy类：

package headfirst.designpatterns.Decorator;
​
public class Soy extends CondimentDecorator {
​
    Beverage beverage;
​
    public Soy(Beverage beverage) {
        this.beverage = beverage;
    }
​
    @Override
    public String getDescription() {
        return beverage.getDescription() + ",Soy";
    }
​
    @Override
    public double cost() {
        return beverage.cost() + .15;
    }
}

• Whip 类：

package headfirst.designpatterns.Decorator;
​
public class Whip extends CondimentDecorator {
​
    Beverage beverage;
​
    public Whip(Beverage beverage) {
        this.beverage = beverage;
    }
​
    @Override
    public String getDescription() {
        return beverage.getDescription() + ",Whip";
    }
​
    @Override
    public double cost() {
        return beverage.cost() + .10;
    }
}
​

• Test 类：

package headfirst.designpatterns.Decorator;
​
public class Test {
    public static void main(String[] args) {
​
        // 创建 Beverage 饮料，不加配料。
        Beverage espresso = new Espresso();
        System.out.println(espresso.getDescription() +" " + espresso.cost());
​
        // 创建 DarkRoast 饮料，加配料 Mocha、Mocha、Whip。
        Beverage darkRoast = new DarkRoast();
        darkRoast = new Mocha(darkRoast);
        darkRoast = new Mocha(darkRoast);
        darkRoast = new Whip(darkRoast);
        System.out.println(darkRoast.getDescription()+ " " + darkRoast.cost());
​
        // 创建 HouseBlend 饮料，加配料 Soy、Mocha、Whip。
        Beverage houseBlend = new HouseBlend();
        houseBlend = new Soy(houseBlend);
        houseBlend = new Mocha(houseBlend);
        houseBlend = new Whip(houseBlend);
        System.out.println(houseBlend.getDescription()+ " "+houseBlend.cost());
    }
}
​

• 输出结果

Espresso 1.99
Dark Roast,Mocha,Mocha,Whip 1.49
HouseBlend ,Soy,Mocha,Whip 1.34

5. 优点

• 通过组合而非继承的方式，动态地扩展一个对象的功能，在运行时可以选择不同的装饰器从而实现不同的功能。

• 有效的避免了使用继承的方式扩展对象功能而带来的灵活性差、子类无限制扩张的问题。

• 具体组件类与具体装饰类可以独立变化，用户可以根据需要新增具体组件类跟装饰类，在使用时在对其进行组合，原有代码无须改变，符合"开闭原则"。

6. 缺点

• 这种比继承更加灵活机动的特性，也同时意味着更加多的复杂性。

• 装饰模式会导致设计中出现许多小类 (I/O 类中就是这样)，如果过度使用，会使程序变得很复杂。

• 装饰模式是针对抽象组件（Component）类型编程。但是，如果你要针对具体组件编程时，就应该重新思考你的应用架构，以及装饰者是否合适。