装饰设计模式

关于装饰设计模式

      设计模式就是解决一类问题而行之有效的方法,装饰设计模式就是解决,对 已有对象进行功能增强,而又不去改变对象本身的问题。

简单小例子:

  1. class Person  
  2. {  
  3.     void chifan()  
  4.     {  
  5.         System.out.println("chifan");  
  6.     }  
  7. }  
  8.   
  9. /* 
  10. 为了不随便改变原有的代码。 
  11. 还要增强chifan功能。 
  12. 那么就定义一个类,对原有对象进行装饰。 
  13. */  
  14. class NewPerson  
  15. {  
  16.     private Person p;  
  17.     NewPerson(Person p)  
  18.     {  
  19.         this.p = p;  
  20.     }  
  21.     public void newChifan()  
  22.     {     
  23.         System.out.println("来一杯");  
  24.         p.chifan();  
  25.         System.out.println("来一根");  
  26.     }  
  27. }  
  28.   
  29. class  PersonDemo  
  30. {  
  31.     public static void main(String[] args)   
  32.     {  
  33.         Person p = new Person();  
  34.           
  35.         //NewPerson np = new NewPerson(p);  
  36.         //np.newChifan();  
  37.   
  38.         p.chifan();  
  39.     }  
  40. }  

在这个例子中,就是通过定义了一个NewPerson类来和Person类关联,只需通过传参让Person类和装饰类关联扩展Person对象的功能。

使用继承带来的局限性:

  1. /* 
  2. 房子:平房,楼房。 
  3.  
  4. House 
  5.     |--PingFang 
  6.     |--LouFang 
  7.  
  8.  
  9. 准备对房子进行装修。 
  10.  
  11.     1,对平房进行田园风光式的打造。 
  12.     2,对楼房进行欧式风格的打造。 
  13. 可以用继承的方式来完成。 
  14. House 
  15.     |--PingFang 
  16.         |--TianYuanPingFang 
  17.     |--LouFang 
  18.         |--OuShiLouFang 
  19.  
  20.      
  21. 该体系就有点臃肿,因为当平房想要改成欧式时,还要建立子类。 
  22. */  
  23. abstract class House  
  24. {  
  25.     abstract void show();  
  26. }  
  27.   
  28. class PingFang extends House  
  29. {  
  30.     public void show()  
  31.     {  
  32.         System.out.println("平房");  
  33.     }  
  34. }  
  35.   
  36. class TianYuanPingFang extends PingFang  
  37. {  
  38.     public void showTianYuan()  
  39.     {  
  40.         super.show();  
  41.         System.out.println("田园风格");  
  42.     }     
  43. }  
  44.   
  45. class LouFang extends House  
  46. {  
  47.     public void show()  
  48.     {  
  49.         System.out.println("楼房");  
  50.     }  
  51. }  
  52. class OuShiLouFang extends LouFang  
  53. {  
  54.     public void showOuShi()  
  55.     {  
  56.         super.show();  
  57.         System.out.println("欧式风格");  
  58.     }  
  59. }  
  60.   
  61.   
  62.   
  63. class  HouseDemo  
  64. {  
  65.     public static void main(String[] args)   
  66.     {  
  67.         PingFang p = new PingFang();  
  68.         ///p.show();  
  69.   
  70.         TianYuanPingFang t = new TianYuanPingFang();  
  71.         t.showTianYuan();  
  72.   
  73.   
  74.         LouFang l = new LouFang();  
  75.         //l.show();  
  76.         OuShiLouFang o = new OuShiLouFang();  
  77.         o.showOuShi();  
  78.     }  
  79. }  


使用装饰设计模式进行装饰:

    1. /* 
    2.  
    3. 原体系: 
    4. House 
    5.     |--PingFang 
    6.     |--LouFang 
    7. 无论将平房打造成田园还是欧式,都是对平房一种装修。 
    8. 而该装修也可以用楼房。 
    9.  
    10. 将现将该装修定义好,需要把什么房子进行改装修,传入即可。 
    11. House 
    12.     |--PingFang 
    13.     |--LouFang 
    14.     |--TianYuan 
    15.     |--OuShi 
    16.  
    17. */  
    18. abstract class House  
    19. {  
    20.     abstract void show();  
    21. }  
    22.   
    23. class PingFang extends House  
    24. {  
    25.     public void show()  
    26.     {  
    27.         System.out.println("平房");  
    28.     }  
    29. }  
    30.   
    31.   
    32. class LouFang extends House  
    33. {  
    34.     public void show()  
    35.     {  
    36.         System.out.println("楼房");  
    37.     }  
    38. }  
    39.   
    40.   
    41. class TianYuan extends House  
    42. {  
    43.   
    44.     private House h;  
    45.     TianYuan(House h)  
    46.     {  
    47.         this.h = h;  
    48.     }  
    49.     public void show()  
    50.     {  
    51.         System.out.println("田园风格");  
    52.     }  
    53.   
    54.     public void showTianYuan()  
    55.     {  
    56.         h.show();  
    57.         this.show();  
    58.     }  
    59.   
    60. }  
    61.   
    62.   
    63. class OuShi extends House  
    64. {  
    65.     private House h;  
    66.     OuShi(House h)  
    67.     {  
    68.         this.h = h;  
    69.     }  
    70.     public void show()  
    71.     {  
    72.         System.out.println("欧式风格");  
    73.     }  
    74.   
    75.     public void showOuShi()  
    76.     {  
    77.         h.show();  
    78.         this.show();  
    79.     }  
    80.   
    81. }  
    82.   
    83. class  HouseDemo2  
    84. {  
    85.     public static void main(String[] args)   
    86.     {  
    87.         PingFang p = new PingFang();  
    88.         LouFang l = new LouFang();  
    89.   
    90.         OuShi o = new OuShi(new TianYuan(p));  
    91.         o.showOuShi();  
    92.   
    93.         //TianYuan t = new TianYuan(l);  
    94.         //t.showTianYuan();  
    95.   
    96.         //OuShi o = new OuShi(l);  
    97.         //o.showOuShi();  
    98.     }  
    99. }
    100. Writer
      |--FileWriter
      |--BufferedFileWriter。
      |--DataWriter
      |--BufferedDataWriter。
      |--MediaWriter
      |--BufferedMediaWriter.

      优化:
      可以将缓冲技术单独抽取进行封装。
      要缓冲区谁将谁和缓冲相关联即可。
      这样的设计的相对体系会变的简单。
posted @ 2014-06-22 09:57  Questions张  阅读(361)  评论(0编辑  收藏  举报