装饰者模式

全文以例子来介绍，一步步明白什么是装饰者模式。

一.抛出需求

星巴兹咖啡厅有很多种类的咖啡，如混合咖啡（HouseBlend），焦炒咖啡（DarkRoast），脱因咖啡（Decaf），特浓咖啡（Espresso）。而且咖啡中又会加入很多的调味料：如蒸奶（Steamed Milk），豆浆（Soy），摩卡（Mocha），奶泡（whip）等。上述二者随意搭配，比如，Decaf配了豆浆两份，摩卡一份，还加了奶泡，现在要知道这份咖啡的价格和名称（什么咖啡以及加入了什么配料）

二.普通的的设计

缺点：
1.调料的价格改变，Beverage超类的代码就要改变
2.加入了新的调味料，超类中需要加入新的方法
3.如果不是咖啡，而是冰红茶之类的并不适合继承这个超类
4.has的方法是判断有没有（一份），如果顾客想加入两份怎么办
结论：
很明显，上述是失败的设计。

引出设计原则：类对扩展开放，对修改关闭
我们的目标：允许类容易扩展，在不修改现有代码的情况下，就可搭配新的行为。
这样的设计具有弹性可以应对改变，接受新的功能来应对改变的需求。

三.装饰者模式

基本思路：一杯浓缩咖啡，我们以摩卡装饰它，以奶泡装饰它，如下图所示

先记住上图的基本框架，就是这样一层一层包起来的，所以叫装饰者。类的继承关系如下图



根据上面的框图，实现代码如下：
饮料基类：

public abstract class Beverage {
	String description = "Unknown Beverage";
  
	public String getDescription() {
		return description;
	}
 
	public abstract double cost();
}

调味料抽象类:

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

四种咖啡，继承自饮料基类：

public class HouseBlend extends Beverage {
	public HouseBlend() {
		description = "House Blend Coffee";
	}
 
	public double cost() {
		return .89;
	}
}

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

public class DarkRoast extends Beverage {
	public DarkRoast() {
		description = "Dark Roast Coffee";
	}
 
	public double cost() {
		return .99;
	}
}

public class Decaf extends Beverage {
	public Decaf() {
		description = "Decaf Coffee";
	}
 
	public double cost() {
		return 1.05;
	}
}

四种调味料类，有一个Beverage的成员变量，在构造函数里初始化，这就是保证了可以包装的关键

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();
	}
}


public 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();
	}
}


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 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 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());
	}
}

装饰者模式的优缺点：
增加了设计的灵活性和可扩展性，但是增加了很多类，导致不容易理解（参考java I/O）
哦，对了，还是那句话，多用组合，少用继承


----------------------------------------------------------就----酱--------------------------------------------------------