装饰器模式笔记

定义

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

功能

除了继承，装饰者模式可以更弹性的扩展功能。

优点

1. 1. 良好的设计原则， 类对扩展开放，对修改关闭。
   2. 装饰者类可动态的用于装饰组件。
   3. 可以用无数个装饰类包装一个组件。

缺点

1. 1. 会导致设计中出现很多小对象，使程序变得复杂。

例子

组件基类：

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

 

具体组件类：

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

	public double cost(){
		return 10.0;
	}

}

 

public class DarkRoast extends Beverage {
	
	public DarkRoast(){
		description = "Dark Roast";
	}
	@Override
	public double cost() {
		return 12.0;
	}

}

装饰器接口（或抽象类）：

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

 

装饰器类：

public class Milk extends CondimentDecorator {

	Beverage beverage;

	public Milk(Beverage beverage){
		this.beverage = beverage;
	}
	
	@Override
	public double cost() {
		return beverage.cost() + 1;
	}

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

}

 

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

}

执行类：

public class StarBuzzCoffee {

	public static void main(String args[]){
		Beverage beverage = new HouseBlend();
		System.out.println(beverage.getDescription());
		System.out.println(beverage.cost());
		
		Beverage beverage2 = new DarkRoast();
		beverage2 = new Milk(beverage2);
		beverage2 = new Mocha(beverage2);
		System.out.println(beverage2.getDescription());
		System.out.println(beverage2.cost());
	
	}
	
}

执行结果：

House blend
10.0
Dark Roast , Milk, Mocha
13.5

 

总结

• • 良好的设计原则：对扩展开放，对修改关闭。
  • 继承属于扩展形式之一，但不见得是弹性设计的最佳方式。
  • 组合和委托可用于在运行时动态地加上新的行为。
  • 你可以用无数个装饰者来包装一个组件。
  • 装饰着会导致设计中出现许多小对象，如果过度使用，会让程序变得很复杂。