4.装饰者模式

Posted 2020-11-26 qmillet

1.基本介绍

　　装饰者模式：定态的将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性，装饰者模式也体现了OCP（开闭）原则。

2.实践

【案例】星巴克咖啡订单：三种咖啡，三种调料，要求在扩展新的咖啡种类时具有良好的扩展性，使用OO来计算不同种类咖啡的费用。

 

 

 　　这样设计当增加一个单品咖啡时，或者一个新调料，类的数量就会倍增，出现类爆炸。

　　【装饰者解决】

①角色组成

　　抽象构件(Component)角色：给出一个抽象接口，以规范准备接收附加责任的对象。
   　具体构件(ConcreteComponent)角色：定义一个将要接收附加责任的类
       装饰角色(Decorator)：持有一个构件(Component)对象的实例，并定义一个与抽象构件接口一致的接口
　　具体装饰角色(ConcreteDecorator)：负责给构件对象“贴上”附加的责任

②何时使用：

    1）需要扩展一个类的功能，或给一个类增加附加责任。

    2）需要动态的给一个对象增加功能，这些功能可以再动态地撤销。

    3）需要增加一些基本功能的排列组合而产生的非常大量的功能，从而使继承变得不现实。

 

 

 装饰者模式下订单：2*巧克力+1*牛奶+LongBlack

 

 

 Coffee和Decorator使用组合的关系联系在一起

public abstract class Drink {

    public String des; // 描述
    private float price = 0.0f;
    public String getDes() {
        return des;
    }
    public void setDes(String des) {
        this.des = des;
    }
    public float getPrice() {
        return price;
    }
    public void setPrice(float price) {
        this.price = price;
    }
    
    //计算费用的抽象方法
    //子类来实现
    public abstract float cost();
}

Drink

 

Coffee、Decorator继承Drink

1 public class Coffee  extends Drink {
2     @Override
3     public float cost() {
4         // TODO Auto-generated method stub
5         return super.getPrice();
6     }
7 }

Coffee

 

 1 public class Decorator extends Drink {
 2     private Drink obj;
 3     
 4     public Decorator(Drink obj) { //组合
 5         // TODO Auto-generated constructor stub
 6         this.obj = obj;
 7     }
 8     
 9     @Override
10     public float cost() {
11         // TODO Auto-generated method stub
12         // getPrice 自己价格
13         return super.getPrice() + obj.cost();
14     }
15     
16     @Override
17     public String getDes() {
18         // TODO Auto-generated method stub
19         // obj.getDes() 输出被装饰者的信息
20         return des + " " + getPrice() + " && " + obj.getDes();
21     }
22 }

Decorator

 

四种咖啡单品，继承Coffee

1 public class Espresso extends Coffee {
2     public Espresso() {
3         setDes(" 意大利咖啡 ");
4         setPrice(6.0f);
5     }
6 }

Espresso

 

1 public class LongBlack extends Coffee {
2 
3     public LongBlack() {
4         setDes(" longblack ");
5         setPrice(5.0f);
6     }
7 }

LongBlack

 

public class ShortBlack extends Coffee{
    
    public ShortBlack() {
        setDes(" shortblack ");
        setPrice(4.0f);
    }
}

ShortBlack

 

1 public class DeCaf extends Coffee {
2     public DeCaf() {
3         setDes(" 无因咖啡 ");
4         setPrice(1.0f);
5     }
6 }

DeCaf

 

三种调料，继承Decorator

public class Milk extends Decorator {
    public Milk(Drink obj) {
        super(obj);
        // TODO Auto-generated constructor stub
        setDes(" 牛奶 ");
        setPrice(2.0f); 
    }
}

Milk

 

1 public class Soy extends Decorator{
2     public Soy(Drink obj) {
3         super(obj);
4         // TODO Auto-generated constructor stub
5         setDes(" 豆浆  ");
6         setPrice(1.5f);
7     }
8 }

Soy

 

1 //具体的Decorator， 这里就是调味品
2 public class Chocolate extends Decorator {
3     public Chocolate(Drink obj) {
4         super(obj);
5         setDes(" 巧克力 ");
6         setPrice(3.0f); // 调味品 的价格
7     }
8 }

Chocolate

 

咖啡厅，完成订单任务

 1 public class CoffeeBar {
 2 
 3     public static void main(String[] args) {
 4         // TODO Auto-generated method stub
 5         // 装饰者模式下的订单：2份巧克力+一份牛奶的LongBlack
 6 
 7         // 1. 点一份 LongBlack
 8         Drink order = new LongBlack();
 9         System.out.println("费用1=" + order.cost());
10         System.out.println("描述=" + order.getDes());
11 
12         // 2. order 加入一份牛奶
13         order = new Milk(order);
14 
15         System.out.println("order 加入一份牛奶 费用 =" + order.cost());
16         System.out.println("order 加入一份牛奶 描述 = " + order.getDes());
17 
18         // 3. order 加入一份巧克力
19 
20         order = new Chocolate(order);
21 
22         System.out.println("order 加入一份牛奶 加入一份巧克力  费用 =" + order.cost());
23         System.out.println("order 加入一份牛奶 加入一份巧克力 描述 = " + order.getDes());
24 
25         // 3. order 加入一份巧克力
26 
27         order = new Chocolate(order);
28 
29         System.out.println("order 加入一份牛奶 加入2份巧克力   费用 =" + order.cost());
30         System.out.println("order 加入一份牛奶 加入2份巧克力 描述 = " + order.getDes());
31     
32         System.out.println("===========================");
33         
34         Drink order2 = new DeCaf();
35         
36         System.out.println("order2 无因咖啡  费用 =" + order2.cost());
37         System.out.println("order2 无因咖啡 描述 = " + order2.getDes());
38         
39         order2 = new Milk(order2);
40         
41         System.out.println("order2 无因咖啡 加入一份牛奶  费用 =" + order2.cost());
42         System.out.println("order2 无因咖啡 加入一份牛奶 描述 = " + order2.getDes());
43     }
44 }

View Code

 

 摘自https://blog.csdn.net/zhshulin/article/details/38665187

 ·装饰模式和适配器模式的关系
　　装饰模式和适配器模式都是“包装模式(Wrapper Pattern)”，它们都是通过封装其他对象达到设计的目的的，但是它们的形态有很大区别。
　　理想的装饰模式在对被装饰对象进行功能增强的同时，要求具体构件角色、装饰角色的接口与抽象构件角色的接口完全一致。而适配器模式则不然，一般而言，适配器模式并不要求对源对象的功能进行增强，但是会改变源对象的接口，以便和目标接口相符合。
　　装饰模式有透明和半透明两种，这两种的区别就在于装饰角色的接口与抽象构件角色的接口是否完全一致。透明的装饰模式也就是理想的装饰模式，要求具体构件角色、装饰角色的接口与抽象构件角色的接口完全一致。相反，如果装饰角色的接口与抽象构件角色接口不一致，也就是说装饰角色的接口比抽象构件角色的接口宽的话，装饰角色实际上已经成了一个适配器角色，这种装饰模式也是可以接受的，称为“半透明”的装饰模式，如下图所示。
　　在适配器模式里面，适配器类的接口通常会与目标类的接口重叠，但往往并不完全相同。换言之，适配器类的接口会比被装饰的目标类接口宽。
显然，半透明的装饰模式实际上就是处于适配器模式与装饰模式之间的灰色地带。如果将装饰模式与适配器模式合并成为一个“包装模式”的话，那么半透明的装饰模式倒可以成为这种合并后的“包装模式”的代表。