`
AutomaticThoughts
  • 浏览: 162140 次
社区版块
存档分类
最新评论

设计模式读书笔记之装饰器模式(Decorator) .

 
阅读更多

Decorator装饰器模式就是创建一个新类为某一个类动态添加新功能或增强原有的功能.

特点:
装饰器持有一个被装饰的对象;
装饰器和被装饰的对象有相同的接口;
装饰器给被装饰的对象添加额外的功能或增强已有的功能.
即保持接口, 增强功能. 表现形式上最大的特点是装饰器使用并且实现一个父类.

 

示例代码：

 

[java] view plaincopyprint?
  1. //装饰器和被装饰的对象共同的接口   
  2. package designpattern.decorator;  
  3.   
  4. public interface Target {  
  5.     public void operation();  
  6. }  
  7.   
  8. //被装饰的类   
  9. package designpattern.decorator;  
  10.   
  11. public class ConcreteTarget implements Target{  
  12.       
  13.     public void operation() {  
  14.         System.out.println("Original operation.");  
  15.     }  
  16. }  
  17.   
  18. //装饰器1   
  19. package designpattern.decorator;  
  20.   
  21. public class Decorator1 implements Target{  
  22.       
  23.     private Target target;  
  24.       
  25.     public Decorator1(Target t){  
  26.         this.target = t;  
  27.     }  
  28.     public void operation() {  
  29.         System.out.println("Before decorator 1");  
  30.         target.operation();  
  31.         System.out.println("Atfer decorator 1");  
  32.     }  
  33. }  
  34.   
  35. //装饰器2   
  36. package designpattern.decorator;  
  37.   
  38. public class Decorator2 implements Target{  
  39.       
  40.     private Target target;  
  41.       
  42.     public Decorator2(Target t){  
  43.         this.target = t;  
  44.     }  
  45.     public void operation() {  
  46.         System.out.println("Before decorator 2");  
  47.         target.operation();  
  48.         System.out.println("Atfer decorator 2");  
  49.     }  
  50. }  
  51.   
  52. //装饰器3   
  53. package designpattern.decorator;  
  54.   
  55. public class Decorator3 implements Target{  
  56.       
  57.     private Target target;  
  58.       
  59.     public Decorator3(Target t){  
  60.         this.target = t;  
  61.     }  
  62.     public void operation() {  
  63.         System.out.println("Before decorator 3");  
  64.         target.operation();  
  65.         System.out.println("Atfer decorator 3");  
  66.     }  
  67. }  
  68.   
  69. //测试代码   
  70. package designpattern.decorator;  
  71.   
  72. public class Test {  
  73.     public static void main(String[] args){  
  74.         Target t = new ConcreteTarget();  
  75.         Target obj = new Decorator1(new Decorator2(new Decorator3(t)));  
  76.         obj.operation();  
  77.     }  
  78. }  

 

这个例子还是显得有些生硬，结合生活中的例子解剖一下装饰器。

一个士兵(Solider)可以行军(march)，开火(fire)。 可以用特种装备来装饰这个兵。如：可以用飞行器装配这个兵，使之可飞行， 可以用侦查装备装饰这个兵， 使之可侦查，夜视装备装饰他，使之可夜视。则FlySoldier, ScoutSoldier, NightVisionSoldier是Soldier的装饰器。 而且这些装饰器可以任意组合。

 

[java] view plaincopyprint?
  1. package designpattern.decorator;  
  2. //兵   
  3. public interface Soldier {  
  4.     public String getAbility();  
  5. }  
  6.   
  7. //中国兵   
  8. package designpattern.decorator;  
  9. public class ChineseSoldier implements Soldier{  
  10.     public String getAbility() {  
  11.         return "I am a soldier, I can ";  
  12.     }  
  13. }  
  14.   
  15. //会飞的兵   
  16. package designpattern.decorator;  
  17. public class FlySoldier implements Soldier{  
  18.     private Soldier soldier;  
  19.     public FlySoldier(Soldier s){  
  20.         this.soldier = s;  
  21.     }  
  22.     public String getAbility() {  
  23.         return soldier.getAbility() + "fly ";  
  24.     }  
  25. }  
  26.   
  27.   
  28. //会侦查的兵   
  29. package designpattern.decorator;  
  30. public class ScoutSoldier implements Soldier{  
  31.     private Soldier soldier;  
  32.     public ScoutSoldier(Soldier s){  
  33.         this.soldier = s;  
  34.     }  
  35.     public String getAbility() {  
  36.         return soldier.getAbility() + "scout ";  
  37.     }  
  38. }  
  39.   
  40. //能夜视的兵   
  41. package designpattern.decorator;  
  42. public class NightVisionSoldier implements Soldier{  
  43.     private Soldier soldier;  
  44.     public NightVisionSoldier(Soldier s){  
  45.         this.soldier = s;  
  46.     }  
  47.     public String getAbility() {  
  48.         return soldier.getAbility() + "night vision ";  
  49.     }  
  50. }  
  51.   
  52. //测试用例   
  53. package designpattern.decorator;  
  54. public class Test {  
  55.     public static void main(String[] args){  
  56.         Soldier s = new ChineseSoldier();  
  57.         //通过各种装饰器装备出一个特种兵   
  58.         Soldier sprcialSoldier = new NightVisionSoldier(new FlySoldier(new ScoutSoldier(s)));  
  59.         System.out.println(sprcialSoldier.getAbility());  
  60.     }  
  61. }  

 

通过这个例子进一步分析装饰器的特征：

1 兵不需要知道装备， 而装饰器持有兵，兵是一个简单的兵，而装饰器可以非常复杂， 这是第一个特征；

2 一个兵被装备之后他还是一个兵，即装饰器和被装饰的对象有相同的接口；

3 可以用不同的装备装饰一个兵，这些装备可以随便搭配。

 

再举一例: 很多老的单元楼的自来水龙头都放在外面, 为了怕别人偷水, 都给自家的龙头加一个盒子锁; 有的人会给龙头加长管子一直牵到自家厨房; 那么加锁, 搭管子就是对龙头进行装饰.并且满足3个特征: 1 装饰器(锁, 管子)都持有原来的水龙头,并增强了原来的水龙头的功能;2 加了锁,套了管子的水龙头还是水龙头; 3  这些装饰器可以方便的拆卸, 组合.

 

经典案例:

jdk中io使用Decorator对各种流进行封装.

如 BufferedInputStream bi = new BufferedInputStream(new FileInputStream("1.txt"));BufferedInputStream 对FileInputStream进行装饰;InputStream是他们共有的接口.

BufferedReader br = new BufferedReader(new FileReader("1.txt"));

BufferedReader对FileReader进行装饰, Reader是他们共同的接口.

还有更多...

 

优点:

在拓展类的功能上比继承拥有更大的灵活性

装饰器类可以方便自由的组合

 

缺点:

使用更少的类，但是构造复杂

分享到：
| 设计模式读书笔记之策略模式(Strategy) .
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics