【设计模式——学习笔记】23种设计模式——装饰器模式Decorator(原理讲解+应用场景介绍+案例介绍+Java代码实现)

简介: 【设计模式——学习笔记】23种设计模式——装饰器模式Decorator(原理讲解+应用场景介绍+案例介绍+Java代码实现)

生活案例

咖啡厅 咖啡定制案例

在咖啡厅中,有多种不同类型的咖啡,客户在预定了咖啡之后,还可以选择添加不同的调料来调整咖啡的口味,当客户点了咖啡添加了不同的调料,咖啡的价格需要做出相应的改变。

要求:程序实现具有良好的拓展性、改动方便、维护方便

【方案一】

写一个抽象类Drink,然后将所有咖啡和调料组合形成多个类来继承抽象类,缺点:当增加一个单品咖啡,或者调味,类的数量就会大增,产生类爆炸问题

【方案二】

分析:

  • 可以控制类的数量,不至于造成很多的类
  • 增加或者删除调料种类时,代码的维护量很大
  • 如果同样一种调料可以点多份时,可以将 hasMilk 返回一个对应int类型的数据来表示调料的份数

装饰者模式介绍

介绍

  • 动态的将新功能附加到对象上。在对象功能扩展方面,它比继承更好,装饰者模式也体现了开闭原则(ocp)
  • 假如有一块蛋糕,如果加上奶油,就变成了奶油蛋糕;再加上草莓,就变成了草莓奶油蛋糕。整个过程就是在不断装饰蛋糕的过程。根据装饰者模式编写的程序的对象与蛋糕十分相似。首先有一个相当于蛋糕的对象,然后像不断地装饰蛋糕一样地不断地对其增加功能,它就变成了使用目的更加明确的对象。

出场角色

  • Component(主体,被装饰对象):增加功能时的核心角色,定义了接口(API)
  • ConcreteComponent(具体主体):实现了Component角色所定义的接口
  • Decorator(装饰者):该角色具有与Component角色相同的接口(API),在它内部保存了Component角色
  • ConcreteDecorator( 具体的装饰者)

案例实现

案例一(咖啡厅问题)

类图

代码实现

【被装饰主体】

package com.atguigu.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;
   }
   /**
    * 计算费用的抽象方法,需要子类来实现
    * @return
    */
   public abstract float cost();
}

【缓冲类:整合所有咖啡的共同点,这个类不一定要写,要结合实际情况】

package com.atguigu.decorator;
public class Coffee  extends Drink {
   @Override
   public float cost() {
      return super.getPrice();
   }
}

【单品咖啡:意大利咖啡】

package com.atguigu.decorator;
public class Espresso extends Coffee {
   public Espresso() {
      setDes(" 意大利咖啡 ");
      // 初始化意大利咖啡的价格
      setPrice(6.0f);
   }
}

【单品咖啡:美式咖啡】

package com.atguigu.decorator;
public class LongBlack extends Coffee {
   public LongBlack() {
      setDes(" longblack ");
      setPrice(5.0f);
   }
}

【单品咖啡:浓咖啡】

package com.atguigu.decorator;
public class ShortBlack extends Coffee{
   public ShortBlack() {
      setDes(" shortblack ");
      setPrice(4.0f);
   }
}

【装饰者】

package com.atguigu.decorator;
/**
 * 装饰物,继承了Drink,还聚合了Drink
 */
public class Decorator extends Drink {
   private Drink obj;
   /**
    * 聚合Drink
    * @param obj
    */
   public Decorator(Drink obj) {
      this.obj = obj;
   }
   @Override
   public float cost() {
      // getPrice 自己价格 + 咖啡的价格
      return super.getPrice() + obj.cost();
   }
   /**
    * 输出信息
    * @return
    */
   @Override
   public String getDes() {
      // obj.getDes() 输出被装饰者的信息
      return des + " " + getPrice() + " && " + obj.getDes();
   }
}

【具体装饰者:巧克力】

package com.atguigu.decorator;
/**
 * 具体的Decorator, 这里就是调味品
 */
public class Chocolate extends Decorator {
   public Chocolate(Drink obj) {
      super(obj);
      setDes(" 巧克力 ");
      // 调味品 的价格
      setPrice(3.0f); 
   }
}

【具体装饰者:牛奶】

package com.atguigu.decorator;
public class Milk extends Decorator {
   public Milk(Drink obj) {
      super(obj);
      setDes(" 牛奶 ");
      setPrice(2.0f);
   }
}

【具体装饰者:豆浆】

package com.atguigu.decorator;
public class Soy extends Decorator{
   public Soy(Drink obj) {
      super(obj);
      setDes(" 豆浆  ");
      setPrice(1.5f);
   }
}

【主类】

package com.atguigu.decorator;
public class CoffeeBar {
   public static void main(String[] args) {
      System.out.println("============== 订单1 =============");
      // 装饰者模式下的订单:2份巧克力+一份牛奶的LongBlack
      // 1. 点一份 LongBlack
      Drink order = new LongBlack();
      System.out.println("费用=" + order.cost());
      System.out.println("描述=" + order.getDes());
      System.out.println();
      // 2.加入一份牛奶
      order = new Milk(order);
      System.out.println("order 加入一份牛奶 费用 =" + order.cost());
      System.out.println("order 加入一份牛奶 描述 = " + order.getDes());
      System.out.println();
      // 3.加入一份巧克力
      order = new Chocolate(order);
      System.out.println("order 加入一份牛奶 加入一份巧克力 费用 =" + order.cost());
      System.out.println("order 加入一份牛奶 加入一份巧克力 描述 = " + order.getDes());
      System.out.println();
      // 4.加入一份巧克力
      order = new Chocolate(order);
      System.out.println("order 加入一份牛奶 加入2份巧克力 费用 =" + order.cost());
      System.out.println("order 加入一份牛奶 加入2份巧克力 描述 = " + order.getDes());
      System.out.println();
   }
}

【运行】

============== 订单1 =============
费用=5.0
描述= longblack 
order 加入一份牛奶 费用 =7.0
order 加入一份牛奶 描述 =  牛奶  2.0 &&  longblack 
order 加入一份牛奶 加入一份巧克力 费用 =10.0
order 加入一份牛奶 加入一份巧克力 描述 =  巧克力  3.0 &&  牛奶  2.0 &&  longblack 
order 加入一份牛奶 加入2份巧克力 费用 =13.0
order 加入一份牛奶 加入2份巧克力 描述 =  巧克力  3.0 &&  巧克力  3.0 &&  牛奶  2.0 &&  longblack 

咖啡样式拓展代码实现

只需要新增一个单品咖啡类,就可以购买了,拓展性非常强大

【新增单品咖啡:无因咖啡】

package com.atguigu.decorator;
public class DeCaf extends Coffee {
   public DeCaf() {
      setDes(" 无因咖啡 ");
      setPrice(1.0f);
   }
}

【主类】

package com.atguigu.decorator;
public class CoffeeBar {
   public static void main(String[] args) {
      System.out.println("============== 订单2 =============");
      Drink order2 = new DeCaf();
      System.out.println("order2 无因咖啡 费用 =" + order2.cost());
      System.out.println("order2 无因咖啡 描述 = " + order2.getDes());
      System.out.println();
      order2 = new Milk(order2);
      System.out.println("order2 无因咖啡 加入一份牛奶 费用 =" + order2.cost());
      System.out.println("order2 无因咖啡 加入一份牛奶 描述 = " + order2.getDes());
      System.out.println();
   }
}

【运行】

============== 订单2 =============
order2 无因咖啡 费用 =1.0
order2 无因咖啡 描述 =  无因咖啡 
order2 无因咖啡 加入一份牛奶 费用 =3.0
order2 无因咖啡 加入一份牛奶 描述 =  牛奶  2.0 &&  无因咖啡 
Process finished with exit code 0

案例二

类图

代码实现

【抽象主体】

package com.atguigu.decorator.Sample;
public abstract class Display {
    /**
     * 获取横向字符数(抽象方法,需要子类去实现)
     * @return
     */
    public abstract int getColumns();
    /**
     * 获取纵向行数(抽象方法,需要子类去实现)
     * @return
     */
    public abstract int getRows();
    /**
     * 获取第row行的字符串(抽象方法,需要子类去实现)
     * @param row
     * @return
     */
    public abstract String getRowText(int row);
    /**
     * 显示所有行的字符串
     */
    public void show() {
        // 遍历行数
        for (int i = 0; i < getRows(); i++) {
            // 获取改行的字符串来打印出来
            System.out.println(getRowText(i));
        }
    }
}

【具体主体】

package com.atguigu.decorator.Sample;
/**
 * 该类用来显示单行字符串
 */
public class StringDisplay extends Display {
    /**
     * 要显示的字符串
     */
    private String string;
    /**
     * 构造方法
     *
     * @param string 要显示的字符串
     */
    public StringDisplay(String string) {
        this.string = string;
    }
    @Override
    public int getColumns() {
        // 字符数
        return string.getBytes().length;
    }
    @Override
    public int getRows() {
        // 行数是1
        return 1;
    }
    /**
     * 只有第0行可以获取到字符串,其他都是空
     * @param row
     * @return
     */
    @Override
    public String getRowText(int row) {
        // 仅当row为0时返回值
        if (row == 0) {
            return string;
        } else {
            return null;
        }
    }
}

【抽象装饰者】

package com.atguigu.decorator.Sample;
/**
 * 装饰者抽象类,注意要继承抽象主体,并聚合抽象主体
 */
public abstract class Border extends Display {
    /**
     * 表示被装饰物
     */
    protected Display display;
    protected Border(Display display) {
        // 在生成实例时通过参数指定被装饰物
        this.display = display;
    }
}

【具体修饰者1】

package com.atguigu.decorator.Sample;
/**
 * 在字符串的左右两侧添加边框
 */
public class SideBorder extends Border {
    /**
     * 表示装饰边框的字符
     */
    private char borderChar;
    /**
     * 通过构造函数指定Display和装饰边框字符
     * @param display
     * @param ch
     */
    public SideBorder(Display display, char ch) {
        super(display);
        this.borderChar = ch;
    }
    /**
     * 字符数为字符串字符数加上两侧边框字符数
     * @return
     */
    public int getColumns() {
        return 1 + display.getColumns() + 1;
    }
    /**
     * 行数即被装饰物的行数
     * @return
     */
    public int getRows() {
        // 在字符串的两侧添加字符并不会增加行数,所以直接返回主体的行数即可
        return display.getRows();
    }
    /**
     * 指定的那一行的字符串为被装饰物的字符串加上两侧的边框的字符
     * @param row
     * @return
     */
    public String getRowText(int row) {
        return borderChar + display.getRowText(row) + borderChar;
    }
}

【具体装饰者2】

package com.atguigu.decorator.Sample;
/**
 * 在字符串的上下左右都加上装饰框
 */
public class FullBorder extends Border {
    public FullBorder(Display display) {
        super(display);
    }
    public int getColumns() {
        // 字符数为被装饰物的字符数加上两侧边框字符数
        return 1 + display.getColumns() + 1;
    }
    public int getRows() {
        // 行数为被装饰物的行数加上上下边框的行数
        return 1 + display.getRows() + 1;
    }
    /**
     * 指定的那一行的字符串
     *
     * @param row
     * @return
     */
    public String getRowText(int row) {
        if (row == 0) {                                                 // 上边框
            return "+" + makeLine('-', display.getColumns()) + "+";
        } else if (row == display.getRows() + 1) {                      // 下边框
            return "+" + makeLine('-', display.getColumns()) + "+";
        } else {                                                        // 其他边框
            return "|" + display.getRowText(row - 1) + "|";
        }
    }
    /**
     * 生成一个重复count次字符ch的字符串
     *
     * @param ch
     * @param count
     * @return
     */
    private String makeLine(char ch, int count) {
        StringBuffer buf = new StringBuffer();
        for (int i = 0; i < count; i++) {
            buf.append(ch);
        }
        return buf.toString();
    }
}

【主类】

package com.atguigu.decorator.Sample;
public class Main {
    public static void main(String[] args) {
        Display b1 = new StringDisplay("Hello, world.");
        Display b2 = new SideBorder(b1, '#');
        Display b3 = new FullBorder(b2);
        b1.show();
        b2.show();
        b3.show();
        Display b4 =
                new SideBorder(
                        new FullBorder(
                                new FullBorder(
                                        new SideBorder(
                                                new FullBorder(
                                                        new StringDisplay("你好,世界。")
                                                ),
                                                '*'
                                        )
                                )
                        ),
                        '/'
                );
        b4.show();
    }
}

【运行】

Hello, world.
#Hello, world.#
+---------------+
|#Hello, world.#|
+---------------+
/+------------------------+/
/|+----------------------+|/
/||*+------------------+*||/
/||*|你好,世界。|*||/
/||*+------------------+*||/
/|+----------------------+|/
/+------------------------+/
Process finished with exit code 0

装饰着模式在IO流源码的应用

  • InputStream 是抽象类, 类似我们前面讲的 Drink
  • FileInputStream 是 InputStream 子类,类似我们前面的 DeCaf, LongBlack
  • FilterInputStream 是 InputStream 子类:类似我们前面 的 Decorator 修饰者

DataInputStream 是 FilterInputStream 子类,具体的修饰者,类似前面的 Milk, Soy 等

FilterInputStream 类 有 protected volatile InputStream in; 即聚合了被装饰者

总结

  • 在装饰者模式中,装饰者与被装饰者具有一致性。装饰者类是表示被装饰者的类的子类,这就体现了它们之间的一致性,它们具有相同的接口,这样,就算被装饰者被装饰了,接口还是向外暴露的(接口的透明性)
  • 可以在不改变被装饰者的前提下增加功能,如案例中在显示字符串之前对字符串进行修饰
  • 只需要一些装饰物即可添加许多功能:通过自由组合调料,可以让咖啡拥有各种不同的味道
  • 装饰者模式也有缺点:会导致程序中增加许多功能类似的很小的类

什么是父类和子类的一致性

可以将子类的实例保存到父类的变量中,也可以直接调用从父类中继承的方法

如何让自己和被委托对象有一致性

使用委托让接口具有透明性时,自己和被委托对象具有一致性

Rose和Violet都有相同的method方法。Rose将method方法的处理委托给了 Violet。这两个类虽然都有 method 方法,但是没有明确在代码中体现出“共通性”。

如果要明确地表示method方法是共通的,只需要像下面这样编写一个抽象类Flower,然后让Rose和Violet都继承并实现方法即可。

或者让Flower作为接口

文章说明

  • 本文章为本人学习尚硅谷的学习笔记,文章中大部分内容来源于尚硅谷视频(点击学习尚硅谷相关课程),也有部分内容来自于自己的思考,发布文章是想帮助其他学习的人更方便地整理自己的笔记或者直接通过文章学习相关知识,如有侵权请联系删除,最后对尚硅谷的优质课程表示感谢。
  • 本人还同步阅读《图解设计模式》书籍(图解设计模式/(日)结城浩著;杨文轩译–北京:人民邮电出版社,2017.1),进而综合两者的内容,让知识点更加全面
目录
相关文章
|
13天前
|
设计模式 缓存 应用服务中间件
「全网最细 + 实战源码案例」设计模式——外观模式
外观模式(Facade Pattern)是一种结构型设计模式,旨在为复杂的子系统提供一个统一且简化的接口。通过封装多个子系统的复杂性,外观模式使外部调用更加简单、易用。例如,在智能家居系统中,外观类可以同时控制空调、灯光和电视的开关,而用户只需发出一个指令即可。
123 69
|
26天前
|
存储 设计模式 算法
【23种设计模式·全精解析 | 行为型模式篇】11种行为型模式的结构概述、案例实现、优缺点、扩展对比、使用场景、源码解析
行为型模式用于描述程序在运行时复杂的流程控制,即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务,它涉及算法与对象间职责的分配。行为型模式分为类行为模式和对象行为模式,前者采用继承机制来在类间分派行为,后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低,满足“合成复用原则”,所以对象行为模式比类行为模式具有更大的灵活性。 行为型模式分为: • 模板方法模式 • 策略模式 • 命令模式 • 职责链模式 • 状态模式 • 观察者模式 • 中介者模式 • 迭代器模式 • 访问者模式 • 备忘录模式 • 解释器模式
【23种设计模式·全精解析 | 行为型模式篇】11种行为型模式的结构概述、案例实现、优缺点、扩展对比、使用场景、源码解析
|
1月前
|
设计模式 前端开发 JavaScript
前端必须掌握的设计模式——装饰器模式
装饰器模式是一种结构型设计模式,通过创建新类来包装原始对象,实现在不修改原有结构的前提下扩展新行为。其核心在于“组合”思想,使新功能可“即插即拔”。该模式具有解耦性、灵活性和动态性等特点,广泛应用于类的面向对象编程语言中,如JavaScript的注解和TypeScript的写法。示例中,通过装饰器模式为游戏角色动态添加装备,展示了其强大的扩展性和灵活性。
|
2月前
|
设计模式 消息中间件 搜索推荐
Java 设计模式——观察者模式:从优衣库不使用新疆棉事件看系统的动态响应
【11月更文挑战第17天】观察者模式是一种行为设计模式,定义了一对多的依赖关系,使多个观察者对象能直接监听并响应某一主题对象的状态变化。本文介绍了观察者模式的基本概念、商业系统中的应用实例,如优衣库事件中各相关方的动态响应,以及模式的优势和实际系统设计中的应用建议,包括事件驱动架构和消息队列的使用。
|
2月前
|
设计模式 Java 数据库连接
Java编程中的设计模式:单例模式的深度剖析
【10月更文挑战第41天】本文深入探讨了Java中广泛使用的单例设计模式,旨在通过简明扼要的语言和实际示例,帮助读者理解其核心原理和应用。文章将介绍单例模式的重要性、实现方式以及在实际应用中如何优雅地处理多线程问题。
48 4
|
2月前
|
设计模式 JavaScript Java
Java设计模式:建造者模式详解
建造者模式是一种创建型设计模式,通过将复杂对象的构建过程与表示分离,使得相同的构建过程可以创建不同的表示。本文详细介绍了建造者模式的原理、背景、应用场景及实际Demo,帮助读者更好地理解和应用这一模式。
|
8月前
|
Java
使用Java代码打印log日志
使用Java代码打印log日志
331 1
|
Java BI API
在Java代码中打日志需要注意什么?
日志是什么?日志是你在代码运行时打印出来的一些数据和记录,是快速排查问题的好帮手,是撕逼和甩锅的利器!
721 0
|
缓存 Java 网络架构
别在 Java 代码里乱打日志了,这才是正确的打日志姿势!
别在 Java 代码里乱打日志了,这才是正确的打日志姿势!
173 0
|
Java BI Apache
在Java代码中打日志需要注意什么?
云栖号资讯:【点击查看更多行业资讯】在这里您可以找到不同行业的第一手的上云资讯,还在等什么,快来! 为什么要打日志? 日志是什么?日志是你在代码运行时打印出来的一些数据和记录,是快速排查问题的好帮手! 做一件事情之前,先思考为什么。
在Java代码中打日志需要注意什么?