装饰者模式

装饰者模式

咖啡案例引入

• 1.咖啡种类，有意大利咖啡(Espresso)，ShortBlack，美式咖啡(LongBlack)，无因咖啡(Decaf)。
  
• 2.调料，Milk，Soy(豆浆)，Chocolate(巧克力)。
  
• 3.要求再扩展新的咖啡种类时，具有良好的扩展性，改动方便，维护方便。
  
• 4.客户可以点单品咖啡，也可以点单品 + 调料组合。
  

方案1类图


方案1类图分析

• 1.Drink是抽象类，表示饮料。
  
• 2.description是对咖啡的描述，如咖啡的名字。
  
• 3.cost()是计算费用，Drink类中定义为抽象的。
  
• 4.Decaf等就是单品咖啡，继承Drink，重写cost()。
  
• 5.Espresso && Milk就是单品咖啡 + 调料，这个组合很多。
  
• 6.这样设计，会有很多类，当我们增加一个单品咖啡，或者一个新的调料，类的数量就会暴增，会出现类爆炸。
  

方案2类图


类图分析

方案1会出现，咖啡单品 + 调料组合会造成类的倍增，因此可以做改进，将调料内置在Drink中，这样就不会出现类爆炸，提高项目的可维护性。说明milk,soy,chocolate可以设计为Boolean，表示是否要添加相应的调料。

• 1.方案2可以控制类数量，避免类爆炸情况。
  
• 2.但在增加和删除调料时，代码的维护量还是很大。
  
• 3.用户点多份调料的情况，可以返回一个int值，代表份数。
  
• 4.可以考虑使用装饰者模式。
  

基本介绍

• 1.装饰者模式(Decorator Pattern)，动态的将新功能附加到对象上。在对象扩展方面，比继承更有弹性，装饰者模式也提醒了开闭原则(ocp)。
  
• 2.这里提到的动态附加新功能到对象上，和ocp，在案例中有体现。
  

装饰者原理举例

• 1.装饰者模式就像打包一个快递。主体是衣服，陶瓷等，包装，比如塑料，泡沫，木板等。这样构成一个完整的快递。
  
• 2.主体，就是Drink(被装饰者)，包装就是Decorator(装饰者)。
  

装饰者模式实现案例类图


说明，类图中的Decorator应该是继承Drink，然后在Decorator中组合一个 Drink drink属性;

1. //饮品
2. public abstract class Drink {
4.     private String des;
5.     private float price;
7.     public String getDes() {
8.         return des;
9.     }
11.     public void setDes(String des) {
12.         this.des = des;
13.     }
15.     public float getPrice() {
16.         return price;
17.     }
19.     public void setPrice(float price) {
20.         this.price = price;
21.     }
23.     public abstract float cost();
24. }
25. //咖啡父类
26. public class Coffee extends Drink {
27.     @Override
28.     public float cost() {
29.         return super.getPrice();
30.     }
31. }
32. public class Decaf extends Coffee{
33.     public Decaf(){
34.         setDes(" 无因咖啡 ");
35.         setPrice(3.0f);
36.     }
37. }
38. public class Espresso extends Coffee{
39.     public Espresso(){
40.         setDes(" 意大利咖啡 ");
41.         setPrice(6.0f);
42.     }
43. }
44. public class LongBlack extends Coffee{
45.     public LongBlack(){
46.         setDes(" 美式咖啡 ");
47.         setPrice(5.0f);
48.     }
49. }
50. public class ShortBlack extends Coffee{
51.     public ShortBlack(){
52.         setDes(" 黑咖啡 ");
53.         setPrice(5.0f);
54.     }
55. }
56. /**
57. * @author 长名06
58. * @version 1.0
59. * 修饰者 是调料的父类
60. */
61. public class Decorator extends Drink{
63.     private Drink drink;//组合一个drink
65.     public Decorator(Drink drink){
66.         this.drink = drink;
67.     }
69.     @Override
70.     public float cost() {
71.         //super.getPrice()代表小料的价格 drink.cost()代表饮料的价格
72.         return super.getPrice() + drink.cost();
73.     }
75.     @Override
76.     public String getDes() {
77.         //重写描述方法
78.         return super.getDes() + getPrice() + " && " + drink.getDes();
79.     }
80. }
81. public class Milk extends Decorator{
82.     public Milk(Drink drink){
83.         super(drink);
84.         setDes(" 牛奶 ");
85.         setPrice(2.0f);
86.     }
87. }
88. public class Soy extends Decorator{
89.     public Soy(Drink drink){
90.         super(drink);
91.         setDes(" 豆浆 ");
92.         setPrice(3.0f);
93.     }
94. }
95. public class Chocolate extends Decorator{
96.     public Chocolate(Drink drink){
97.         super(drink);
98.         setDes(" 巧克力 ");
99.         setPrice(3.0f);
100.     }
101. }
102. //测试
103. public class Client {
104.     public static void main(String[] args) {
105.         //下订单，买2份巧克力 + 1份牛奶的LongBlack咖啡
106.         //1.买一份LongBlack咖啡
107.         //咖啡要用Drink接收，不能使用自己的咖啡类型
108.         //因为被小料修饰过的咖啡的类型是对应的小料类型
109.         //如果用自己的咖啡类型，就不能完成 修饰过的咖啡 赋给原有的咖啡了
110.         Drink longBlack = new LongBlack();
111.         System.out.println("LongBlack咖啡价格 " + longBlack.cost());
112.         System.out.println("LongBlack咖啡描述 " + longBlack.getDes());
114.         //2.给LongBlack咖啡，加一个牛奶小料
115.         longBlack = new Milk(longBlack);
116.         System.out.println("加一个牛奶小料的LongBlack咖啡价格 " + longBlack.cost());
117.         System.out.println("加一个牛奶小料的LongBlack咖啡描述 " + longBlack.getDes());
119.         //3.给LongBlack咖啡，加一个巧克力小料
120.         longBlack = new Chocolate(longBlack);
121.         System.out.println("加一个牛奶小料 加一个巧克力小料的LongBlack咖啡价格 " + longBlack.cost());
122.         System.out.println("加一个牛奶小料 加一个巧克力小料的LongBlack咖啡描述 " + longBlack.getDes());
124.         //4.给LongBlack咖啡，加两个巧克力小料
125.         longBlack = new Chocolate(longBlack);
126.         System.out.println("加一个牛奶小料 加两个巧克力小料的LongBlack咖啡价格 " + longBlack.cost());
127.         System.out.println("加一个牛奶小料 加两个巧克力小料的LongBlack咖啡描述 " + longBlack.getDes());
129.         System.out.println("==============");
131.         Drink decaf = new Decaf();
132.         System.out.println(decaf.cost());
133.         System.out.println(decaf.getDes());
135.         decaf = new Soy(decaf);
136.         System.out.println("加一个豆浆小料的LongBlack咖啡价格 " + decaf.cost());
137.         System.out.println("加一个豆浆小料的LongBlack咖啡描述 " + decaf.getDes());
138.     }
139. }

复制代码

装饰者模式在JDK应用分析

1. import java.io.DataInputStream;
2. import java.io.FileInputStream;
4. /**
5. * @author 长名06
6. * @version 1.0
7. */
8. public class AnalysisDecoratorIO {
9.     public static void main(String[] args) throws Exception{
10.         //JDK源码中就使用到了装饰者模式
11.         //1.InputStream是抽象类,类似我们前面讲的Drink
12.         //2.FileInputStream是InputStream子类，类似我们前面的 DeCaf, LongBlack
13.         //3. FilterInputStream是InputStream子类:类似我们前面的Decorator修饰者
14.         //4. DataInputStream是 FilterInputStream子类，具体的修饰者，类似前面的Milk, Soy 等
15.         // 5.FilterInputStream类有 protected volatile InputStream in属性 ;即含被装饰者
16.         //6.分析得出在jdk 的io体系中，就是使用的装饰者模式
17.         DataInputStream dis = new DataInputStream(new FileInputStream("d:\\abc.txt"));
18.     }
19. }

复制代码

只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！