the Decorator Pattern 装饰模式

 Decorating Objects  装饰对象 给爱用继承的人一个全新的设计眼界

 

 

动态地将责任附加到对象上。想要扩展功能，妆饰者提供有别于继承的另一种选择

 

星巴克更新订单系统

有多种咖啡和配料，

每种饮料价格不同，还有各种配料，每种咖啡搭配配料都会有不同的价格

 

超类：Beverage

Beverage
-description
-milk(boolean)
-soy(boolean)
..

--getDescription()
--cost()
--hasMilk()
--setMilk()
...

 

子类：HouseBlend,DarkRoast,Decaf,Espresso

超类cost()计算所有配料的钱，子类计算出饮料的钱

 

 

哪些需求或因素改变时会影响这个设计：

1. 配料价格的改变
2. 出现新的调料，我们需要加上新的方法，并改变超类中的cost方法
3. 出现新的饮料，某些配料可能并不适合
4. 顾客需要双倍咖啡
5. 顾客需要双倍配料

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

 

 
--------------------------------

如果顾客想摩卡和奶泡深焙咖啡
1.拿一个深焙咖啡(DarkRoast)对象
2.以摩卡(Mocha)对象装饰它
3.以奶泡(Whip)对象装饰它
4.调用cost方法，并依赖委托(delegate)将调料的价格加上去

---
以装饰者构造饮料订单
1.以DarkRoast对象开始
2.顾客想要摩卡(Mocha),所以建立一个Mocha对象，并用它将DarkRoast对象包(wrap)起来
3.顾客想要奶泡(Whip)，所以需要建立一个Whip装饰者，并用它将Mocha对象包起来。
4.计算价格。通过调用最外圈装饰者(whip)的cost方法就可以办到。whip的cost方法会先委托它装饰的对象（也就是mocha）计算出价格，然后再加上奶泡的价格。

 

装饰者和被装饰者有相同的超类型
可以用一个或者多个妆饰者包装一个对象
既然妆饰者和被装饰对象有相同的超类型，所以在任何需要原始对象（被包装的）的场合，可以用装试过的对象代替它
妆饰者可以在所委托被装饰者的行为之前与/或之后，加上自己的行为，以达到特定的目的
对象可以在任何时候被装饰，所以可以在运行时动态地、不限量地用你喜欢的妆饰者来装饰对象

 

 

抽象组件Beverage
具体组件HouseBlend
抽象装饰者CondimentDecorator
具体装饰者Mocha

/**
 * 抽象组件Beverage
 */
public abstract class Beverage {

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

//-----------------------------
/**
 * 让Condiment Decorator能够取代Beverage，
 * 所以将Condiment Decorator扩展自Beverage类
 * @author liang
 *  抽象装饰者CondimentDecorator
 */
public abstract class Condiment extends Beverage{
	public abstract String getDescription();
}

//------------------------

/**
 * 具体组件Espresso 
 */
public class Espresso extends Beverage {

	public Espresso(){
		description = "Espresso";
	}
	
	@Override
	public double cost() {
		return 1.99;
	}

}
//-----------------
/**
 * 具体装饰者
 */

public class Mocha extends Condiment {

	//用一个实例变量记录饮料，也就是被妆饰者
	Beverage beverage;
	
	public Mocha(Beverage beverage){
		this.beverage = beverage;
	}
	
	@Override
	public String getDescription() {
		return beverage.getDescription()+",Mocha";
	}

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

}
//----------------------
/**
 * 测试
 */

public class StarbuzzCoffee {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Beverage beverage = new Espresso();
		System.out.println(beverage.getDescription()+" $"+beverage.cost());
		
		Beverage beverage2 = new Espresso();
		beverage2 = new Mocha(beverage2);
		beverage2 = new Mocha(beverage2);
		beverage2 = new Whip(beverage2);
		System.out.println(beverage2.getDescription()+" $"+beverage2.cost());
	}

}

 
真实世界的妆饰者：java I/O

 

 

OO原则：
封装变化
多用组合，少用继承
针对接口变成，不针对实现编程
为交互对象之间的松耦合设计而努力
对扩展开发，对修改关闭