装饰者模式（Decorator Pattern）

一、装饰者模式的内容

装饰（Decorator）模式又名包装（Wrapper）模式[GOF95]。装饰者模式动态地将责任附加到对象上。想要扩展功能，装饰者提供有别于继承的另一种选择。该模式以对客户端透明的方式扩展对象的功能。利用组合在运行时动态的合成自己想要的对象，这比继承更具弹性，是继承关系的一个替代方案。

二、装饰者模式的结构


 

涉及角色

(1)抽象构件角色：定义一个抽象接口，来规范准备附加功能的类。

(2)具体构件角色（即被装饰者）：将要被附加功能的类，实现抽象构件角色接口。

(3)抽象装饰者角色：持有对具体构件角色的引用并定义与抽象构件角色一致的接口。

(4)具体装饰角色：实现抽象装饰者角色，负责为具体构件添加额外功能。

    其中，被装饰者与抽象装饰者都继承与抽象构件角色，具体装饰角色继承与抽象装饰角色，之所以让装饰者和被装饰者继承于同一组件是想让装饰者和被装饰者具有统一的类型而非为了继承行为。

    装饰者模式的基本思想是用装饰者来包装组件使之成为一个同类型的新组件，所以在装饰者角色中，记录当前对象（一般是声明一个基类引用变量，构造器中传对象引用参数初始化此变量），利用多态技术，用基类对象引用最终被包裹后的对象（注意：每包裹一层就把之前的对象覆盖掉），就获得了组件和所有包裹过组件的行为。

三、要点

  • 继承属于扩展的形式之一，但不见得是达到弹性设计的最佳方式。（子类数量爆炸、设计死板、以及基类加入的新功能并不能适用与所有子类。）
  • 在我们的设计中，应该允许行为可以被扩展，而无须修改现有的代码。
  • 组合和委托可以再运行时动态地加上新的行为。
  • 除了继承，装饰者模式也可以让我们扩展行为。
  • 装饰者模式意味着一群装饰者类，这些类用来包装具体组件。
  • 装饰者类反应被装饰的组件的类型
  • 装饰者可以再被装饰者的行为前面与/或后面加上自己的行为，甚至将被装饰者的行为整个去掉，而达到特性行为的目的。
  • 你可以用无数个装饰者包装一个组件。
  • 装饰者一般对组件的客户是透明的，除非客户依赖于组件的具体类型。
  • 装饰者会导致设计中出现许多小对象，如果过度使用，会让程序变得很复杂。
  • 装饰者和被装饰对象有相同的超类型。

四、装饰者模式当中OO原则

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

五、装饰者模式示例代码

代码一、
[java] view plaincopy
  1. // the Window interface  
  2. interface Window {  
  3.     public void draw(); // draws the Window  
  4.     public String getDescription(); // returns a description of the Window  
  5. }  
  6.    
  7. // implementation of a simple Window without any scrollbars  
  8. class SimpleWindow implements Window {  
  9.     public void draw() {  
  10.         // draw window  
  11.     }  
  12.    
  13.     public String getDescription() {  
  14.         return "simple window";  
  15.     }  
  16. }  
[java] view plaincopy
  1. // abstract decorator class - note that it implements Window  
  2. abstract class WindowDecorator implements Window {  
  3.     protected Window decoratedWindow; // the Window being decorated  
  4.    
  5.     public WindowDecorator (Window decoratedWindow) {  
  6.         this.decoratedWindow = decoratedWindow;  
  7.     }  
  8.     public void draw() {  
  9.         decoratedWindow.draw();  
  10.     }  
  11. }  
  12.    
  13. // the first concrete decorator which adds vertical scrollbar functionality  
  14. class VerticalScrollBarDecorator extends WindowDecorator {  
  15.     public VerticalScrollBarDecorator (Window decoratedWindow) {  
  16.         super(decoratedWindow);  
  17.     }  
  18.    
  19.     public void draw() {  
  20.         decoratedWindow.draw();  
  21.         drawVerticalScrollBar();  
  22.     }  
  23.    
  24.     private void drawVerticalScrollBar() {  
  25.         // draw the vertical scrollbar  
  26.     }  
  27.    
  28.     public String getDescription() {  
  29.         return decoratedWindow.getDescription() + ", including vertical scrollbars";  
  30.     }  
  31. }  
  32.    
  33. // the second concrete decorator which adds horizontal scrollbar functionality  
  34. class HorizontalScrollBarDecorator extends WindowDecorator {  
  35.     public HorizontalScrollBarDecorator (Window decoratedWindow) {  
  36.         super(decoratedWindow);  
  37.     }  
  38.    
  39.     public void draw() {  
  40.         decoratedWindow.draw();  
  41.         drawHorizontalScrollBar();  
  42.     }  
  43.    
  44.     private void drawHorizontalScrollBar() {  
  45.         // draw the horizontal scrollbar  
  46.     }  
  47.    
  48.     public String getDescription() {  
  49.         return decoratedWindow.getDescription() + ", including horizontal scrollbars";  
  50.     }  
  51. }  
[java] view plaincopy
  1. public class DecoratedWindowTest {  
  2.     public static void main(String[] args) {  
  3.         // create a decorated Window with horizontal and vertical scrollbars  
  4.         Window decoratedWindow = new HorizontalScrollBarDecorator (  
  5.                 new VerticalScrollBarDecorator(new SimpleWindow()));  
  6.    
  7.         // print the Window's description  
  8.         System.out.println(decoratedWindow.getDescription());  
  9.     }  
  10. }  
代码二、

[java] view plaincopy
  1. public abstract class Beverage {  
  2.     String description = "Unknown Beverage";  
  3.     
  4.     public String getDescription() {  
  5.         return description;  
  6.     }  
  7.    
  8.     public abstract double cost();  
  9. }  
[java] view plaincopy
  1. public abstract class CondimentDecorator extends Beverage {  
  2.     public abstract String getDescription();  
  3. }  

[java] view plaincopy
  1. public class DarkRoast extends Beverage {  
  2.     public DarkRoast() {  
  3.         description = "Dark Roast Coffee";  
  4.     }  
  5.    
  6.     public double cost() {  
  7.         return .99;  
  8.     }  
  9. }  

[java] view plaincopy
  1. public class Decaf extends Beverage {  
  2.     public Decaf() {  
  3.         description = "Decaf Coffee";  
  4.     }  
  5.    
  6.     public double cost() {  
  7.         return 1.05;  
  8.     }  
  9. }  

[java] view plaincopy
  1. public class Espresso extends Beverage {  
  2.     
  3.     public Espresso() {  
  4.         description = "Espresso";  
  5.     }  
  6.     
  7.     public double cost() {  
  8.         return 1.99;  
  9.     }  
  10. }  

[java] view plaincopy
  1. public class HouseBlend extends Beverage {  
  2.     public HouseBlend() {  
  3.         description = "House Blend Coffee";  
  4.     }  
  5.    
  6.     public double cost() {  
  7.         return .89;  
  8.     }  
  9. }  

[java] view plaincopy
  1. public class Milk extends CondimentDecorator {  
  2.     Beverage beverage;  
  3.   
  4.     public Milk(Beverage beverage) {  
  5.         this.beverage = beverage;  
  6.     }  
  7.   
  8.     public String getDescription() {  
  9.         return beverage.getDescription() + ", Milk";  
  10.     }  
  11.   
  12.     public double cost() {  
  13.         return .10 + beverage.cost();  
  14.     }  
  15. }  

[java] view plaincopy
  1. public class Mocha extends CondimentDecorator {  
  2.     Beverage beverage;  
  3.    
  4.     public Mocha(Beverage beverage) {  
  5.         this.beverage = beverage;  
  6.     }  
  7.    
  8.     public String getDescription() {  
  9.         return beverage.getDescription() + ", Mocha";  
  10.     }  
  11.    
  12.     public double cost() {  
  13.         return .20 + beverage.cost();  
  14.     }  
  15. }  

[java] view plaincopy
  1. public class Soy extends CondimentDecorator {  
  2.     Beverage beverage;  
  3.   
  4.     public Soy(Beverage beverage) {  
  5.         this.beverage = beverage;  
  6.     }  
  7.   
  8.     public String getDescription() {  
  9.         return beverage.getDescription() + ", Soy";  
  10.     }  
  11.   
  12.     public double cost() {  
  13.         return .15 + beverage.cost();  
  14.     }  
  15. }  

[java] view plaincopy
  1. public class Whip extends CondimentDecorator {  
  2.     Beverage beverage;  
  3.    
  4.     public Whip(Beverage beverage) {  
  5.         this.beverage = beverage;  
  6.     }  
  7.    
  8.     public String getDescription() {  
  9.         return beverage.getDescription() + ", Whip";  
  10.     }  
  11.    
  12.     public double cost() {  
  13.         return .10 + beverage.cost();  
  14.     }  
  15. }  
[java] view plaincopy
  1. public class StarbuzzCoffee {  
  2.    
  3.     public static void main(String args[]) {  
  4.         Beverage beverage = new Espresso();  
  5.         System.out.println(beverage.getDescription()   
  6.                 + " $" + beverage.cost());  
  7.    
  8.         Beverage beverage2 = new DarkRoast();  
  9.         beverage2 = new Mocha(beverage2);  
  10.         beverage2 = new Mocha(beverage2);  
  11.         beverage2 = new Whip(beverage2);  
  12.         System.out.println(beverage2.getDescription()   
  13.                 + " $" + beverage2.cost());  
  14.    
  15.         Beverage beverage3 = new HouseBlend();  
  16.         beverage3 = new Soy(beverage3);  
  17.         beverage3 = new Mocha(beverage3);  
  18.         beverage3 = new Whip(beverage3);  
  19.         System.out.println(beverage3.getDescription()   
  20.                 + " $" + beverage3.cost());  
  21.     }  
  22. }  

六、 使用装饰模式的优点和缺点

使用装饰模式主要有以下的优点：

  1. 装饰模式与继承关系的目的都是要扩展对象的功能，但是装饰模式可以提供比继承更多的灵活性。
  2. 通过使用不同的具体装饰类以及这些装饰类的排列组合，设计师可以创造出很多不同行为的组合。
  3. 这种比继承更加灵活机动的特性，也同时意味着装饰模式比继承更加易于出错。

使用装饰模式主要有以下的缺点：

由于使用装饰模式，可以比使用继承关系需要较少数目的类。使用较少的类，当然使设计比较易于进行。但是，在另一方面，使用装饰模式会产生比使用继承关系更多的对象。更多的对象会使得查错变得困难，特别是这些对象看上去都很相像。


七、 模式实现的讨论

大多数情况下，装饰模式的实现都比上面定义中给出的示意性实现要简单。对模式进行简化时需要注意以下的情况：

（1）一个装饰类的接口必须与被装饰类的接口相容。

（2）尽量保持Component作为一个"轻"类，不要把太多的逻辑和状态放在Component类里。

（3）如果只有一个ConcreteComponent类而没有抽象的Component类（接口），那么Decorator类经常可以是ConcreteComponent的一个子类。如下图所示：

（4）如果只有一个ConcreteDecorator类，那么就没有必要建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator的责任合并成一个类。
 

八、装饰者模式在JDK当中应用

Decorator (recognizeable by creational methods taking an instance of same abstract/interface type which adds additional behaviour)

九、参考文献

 
posted @ 2014-05-15 16:04  jhhu  阅读(268)  评论(0)  编辑  收藏  举报