初识设计模式(装饰者模式)

 前言:总结这两天学到的装饰者模式,并用java小小的实现一下。书中有写到:给爱用继承的人一个全新的设计眼界。(ps,本文最后有个小问题待解决)

什么是装饰者模式(Decorator Pattern)?

定义:动态地将责任附加到对象上。若要扩展功能,装饰者提供了比继承更有弹性的替代方案。

使用的设计原则:开放-关闭原则,类应该对扩展开放,对修改关闭。

代表:Java IO 流

类图:

初识设计模式(装饰者模式)_第1张图片

 

装饰者模式的优缺点?

  优点

  1. Decorator模式与继承关系的目的都是要扩展对象的功能,但是Decorator可以提供比继承更多的灵活性。
  2. 通过使用不同的具体装饰类以及这些装饰类的排列组合,设计师可以创造出很多不同行为的组合。

  缺点

  1. 装饰模式会导致设计中出现许多小类,如果过度使用,会使程序变得很复杂,也会给使用此API的程序员造成困扰。
  2. 这种比继承更加灵活机动的特性,也同时意味着更加多的复杂性。
  3. 装饰模式是针对抽象组件(Component)类型编程。但是,如果你要针对具体组件编程时,就应该重新思考你的应用架构,以及装饰者是否合适。当然也可以改变Component接口,增加新的公开的行为,实现“半透明”的装饰者模式。在实际项目中要做出最佳选择。
  4. 采用装饰者在实例化组件时,将增加代码的难度。一旦使用装饰者模式,不只需要实例化组件,还要把此组件包装进装饰者中。(这个问题可以使用工厂(Factory)模式和生成器(Builder)模式来解决)

什么情况下使用装饰者模式?

  1. 需要扩展一个类的功能,或给一个类添加附加职责。
  2. 需要动态的给一个对象添加功能,这些功能可以再动态的撤销。
  3. 需要增加由一些基本功能的排列组合而产生的非常大量的功能,从而使继承关系变的不现实。
  4. 当不能采用生成子类的方法进行扩充时。一种情况是,可能有大量独立的扩展,为支持每一种组合将产生大量的子类,使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏,或类定义不能用于生成子类。

举例说明

  场景:现在需要炒一盘菜,可以给这盘菜加多种作料,这盘菜也可以有不同作料的组合。

  实现:(如果只有一盘菜存在,不会再有第二盘菜的情况,也可以不创建抽象组件,直接创建具体组件,抽象的装饰类继承具体组件。)

  • 先创建抽象组件
     1 /**
     2  * 抽象组件 一盘菜
     3  */
     4 abstract class Dish{
     5     protected String name;
     6 
     7     public String getName(){
     8         return this.name;
     9     }
    10 }
  • 然后创建具体组件
    1 /**
    2  * 具体组件
    3  */
    4 class MeatDish extends Dish{
    5     public MeatDish(){
    6         super.name = "meatDish";
    7     }
    8 }
  • 然后创建抽象装饰类
    1 /**
    2  * 抽象装饰类 作料
    3  */
    4 abstract class Seasoning extends Dish{
    5     @Override
    6     public abstract String getName();
    7 }
  • 然后创建抽象具体装饰类
     1 /**
     2  * 具体装饰类 盐
     3  */
     4 class Salt extends Seasoning{
     5     private Dish dish;
     6     public Salt(Dish dish){
     7         this.dish = dish;
     8     }
     9     @Override
    10     public String getName() {
    11         return this.dish.getName() + " ,Salt";
    12     }
    13 }
    14 
    15 /**
    16  * 具体装饰类,鸡精
    17  */
    18 class ChickenPowder extends Seasoning{
    19     private Dish dish;
    20     public ChickenPowder(Dish dish){
    21         this.dish = dish;
    22     }
    23     @Override
    24     public String getName() {
    25         return this.dish.getName() + " ,ChickenPowder";
    26     }
    27 }
  • 然后测试
    1 public static void main(String[] args){
    2         Dish dish = new MeatDish();
    3         System.out.println(dish.getName());
    4 
    5         dish = new Salt(dish);
    6         dish = new ChickenPowder(dish);
    7         System.out.println(dish.getName());
    8     }
  • 最后输出结果

初识设计模式(装饰者模式)_第2张图片

总结:

  1. 装饰者和被装饰者拥有相同的超类
  2. 你可以用一个或多个装饰者包装一个对象
  3. 既然装饰者和被装饰者对象有相同的超类型,所以在任何需要原始对象(被包装的)的场合,可以用装饰过的对象代替它
  4. 装饰者可以在所委托被装饰者的行为之前与/或之后,加上自己的行为,以达到特定的目的
  5. 对象可以在任何时候被装饰,所有可以在运行时动态地、不限量地用你喜欢的装饰者来装饰对象

提问:

  问:不是说这个让爱用继承的人改变眼界吗?怎么类图还是使用的继承?

  答: 这么做的重点在于,装饰者和被装饰者必须是一样的类型,也就是有共同的超类,这是相当关键的地方。在这里,是利用继承达到“类型匹配”,而不是利用继承获得“行为”。

  问:那么行为从哪里来?

  答:当我们将装饰者与组件组合时,就是在加入新的行为。所得到的新行为,并不是继承自超类,而是由组合对象得来的。如果这里依赖继承,那么类的行为只能只能在编译时静态决定。换句话说,行为如果不是来自超类,就是子类覆盖后的版本。反之,利用组合,可以把装饰者混合着用,而且是在运行时。这样,就可以在任何时候实现新的装饰者增加新的行为,如果依赖继承,每当需要新行为时,还得修改现有的代码。

  问:为什么Componet要设计为一个抽象类,而不是一个接口?

  答:通常装饰者模式是采用抽象类。(有大神知道的吗?还请不吝赐教)

 

参考书籍:《Head First 设计模式》《大话设计模式》

转载于:https://www.cnblogs.com/yuxiaole/p/9220672.html

你可能感兴趣的:(设计模式,java)