装饰器模式（通俗易懂）

最新推荐文章于 2023-11-11 21:15:00 发布
最新推荐文章于 2023-11-11 21:15:00 发布
阅读量805 收藏 2
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alu_em/article/details/110041657
版权

文章目录

反例都是为了和装饰器模式进行对比，突出其优点，若想直接查看装饰器模式的“真身”，可直接跳到装饰器模式目录

装饰器模式

简述：装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

业务场景：星巴克卖咖啡，一开始只有4种咖啡

Decaf：无咖啡因咖啡 Espresso：特浓咖啡 DarkRoast：焦炒咖啡 HouseBlend：混合咖啡
因所有咖啡都有共性，所有开发人员，把它们的共性上提到一个父类中：Beverage

反例 #1

abstract class Beverage {
    private String description;

    public Beverage(String description) {
        this.description = description;
    }

    public abstract double cost();

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

class Decaf extends Beverage {

    public Decaf() {
        super("无咖啡因咖啡");
    }

    @Override
    public double cost() {
        return 1;
    }
}


class Espresso extends Beverage {

    public Espresso() {
        super("特浓咖啡");
    }

    @Override
    public double cost() {
        return 1.5;
    }
}

class DarkRoast extends Beverage {

    public DarkRoast() {
        super("焦炒咖啡");
    }

    @Override
    public double cost() {
        return 2;
    }
}

class HouseBlend extends Beverage {

    public HouseBlend() {
        super("混合咖啡");
    }

    @Override
    public double cost() {
        return 3;
    }
}

//==============================================
public class AppTest {
    public static void main(String[] args) {
        Beverage b = new Decaf();
        Beverage b2 = new Espresso();
        Beverage b3 = new DarkRoast();
        Beverage b4 = new HouseBlend();

        System.out.println(b.getDescription() + ":" + b.cost());
        System.out.println(b.getDescription() + ":" + b2.cost());
        System.out.println(b.getDescription() + ":" + b3.cost());
        System.out.println(b.getDescription() + ":" + b4.cost());
    }
}

如此设计存在问题：

星巴克的老板为了提高自身的竞争力，想出了一个新的业务：调料。也就是可以给咖啡中放入调料：牛奶、豆浆、摩卡、泡沫

如何设计应对这种变化呢？

。。。。。。

反例 #2

为了满足上面需求中的变化：可以尝试这样解决问题：

//为加牛奶的Decaf咖啡创建一个类
class DecafWithMilk {
    
}
// 为加牛奶的Espresso咖啡创建一个类
class EspressoWithMilk {
    
}
// 为加牛奶且加豆浆的Decaf咖啡创建一个类
class DecafWithMilkAndSoy {
    
}
......

很明显，这样设计会导致类爆炸式增长，因此不能如此设计。

反例 #3

针对于反例2的问题，我们何必为每一种咖啡每加一种调料都创建一个类呢？这样太2了、太笨了！

我们可以直接在父类Beverage中，添加4个boolean属性，分别代表是否加了对应的4种调料！

abstract class Beverage {
    private String description;

    private boolean milk,soy,mocha,bubble;

    public Beverage(String description) {
        this.description = description;
    }

    public double cost() {
        double total = 0;
        if (milk) {
            total += 0.2;
        }
        if (soy) {
            total += 0.3;
        }
        if (mocha) {
            total += 0.4;
        }
        if (bubble) {
            total += 0.1;
        }
        return total;
    }

    public String getDescription() {
        if (milk) {
            description += " 牛奶";
        }
        if (soy) {
            description += " 豆浆";
        }
        if (mocha) {
            description += " 摩卡";
        }
        if (bubble) {
            description += " 气泡";
        }
        return description;
    }

    public void setDescription(String description) { this.description = description; }

    public boolean isMilk() { return milk; }

    public void setMilk(boolean milk) { this.milk = milk; }

    public boolean isSoy() { return soy; }

    public void setSoy(boolean soy) { this.soy = soy; }

    public boolean isMocha() { return mocha; }

    public void setMocha(boolean mocha) { this.mocha = mocha; }

    public boolean isBubble() { return bubble; }

    public void setBubble(boolean bubble) { this.bubble = bubble; }
}

class Decaf extends Beverage {

    public Decaf() {
        super("无咖啡因咖啡");
    }

    @Override
    public double cost() {
        // 咖啡本身价格 + 调料价格
        return 1 + super.cost();
    }
}


class Espresso extends Beverage {

    public Espresso() {
        super("特浓咖啡");
    }

    @Override
    public double cost() {
        return 1.5 + super.cost();
    }
}

class DarkRoast extends Beverage {

    public DarkRoast() {
        super("焦炒咖啡");
    }

    @Override
    public double cost() {
        return 2 + super.cost();
    }
}

class HouseBlend extends Beverage {

    public HouseBlend() {
        super("混合咖啡");
    }

    @Override
    public double cost() {
        return 3 + super.cost();
    }
}

//====================客户端==========================
public class AppTest {
    public static void main(String[] args) {
        Beverage b = new Decaf();

        b.setMilk(true);
        b.setSoy(true);

        System.out.println(b.getDescription() + ":" + b.cost());

    }
}

优点：

1. 类没有爆炸式增长

2. 若星巴克的老板又加入了一个新的饮料：茶，不会带来大大影响

//====================客户端==========================
// 新增饮料
class Tea extends Beverage {
    public Tea() {
        super("茶");
    }
    public double cost() {
        return 2;
    }
}

public class AppTest {
    public static void main(String[] args) {
        Beverage b2 = new Tea();
        System.out.println(b2.getDescription() + ":" + b2.cost());

    }
}

缺点：

  1. 星巴克的老板新加入一种调料：枸杞，就要重新改写父类Berverage的cost方法和getdisecription方法，从而将枸杞加进去，违反了开闭原则。

装饰器模式

package com.aluem.m_decorator.d;

/**
 * 业务场景：星巴克卖咖啡，一开始只有4种咖啡
 */
//----------------饮料父类----------------
abstract class Beverage {
    // description ==> 无咖啡因咖啡
    private String description;
    public Beverage(String description) {
        this.description = description;
    }
    public abstract double cost();

    public String getDescription() {
        return description;
    }
}
/**
 * 判断两个类之间能不能有继承关系，主要看这两个类之间有没有“is a”关系。并且要符合里氏替换原则。
 * 以上只是原则，不是语法强制的，也就是说在特定情况下，可以违反这个规则，在装饰器模式中就是这样。
 * 尽管调料不是饮料，但是为了制作出装饰器模式，我们也要让调料去继承饮料。
 */
//----------------调料父类----------------
abstract class Condiment extends Beverage {
    protected Beverage beverage;
    public Condiment(Beverage beverage) {
        super("调料");
        this.beverage = beverage;
    }
    // 关联Beverage类是为了在该处使用传入的子类方法
    public double cost() {
        return beverage.cost();
    }
}
//----------------饮料----------------
class Decaf extends Beverage {
    public Decaf() {
        super("无咖啡因咖啡");
    }
    @Override
    public double cost() {
        return 3;
    }
}
//----------------调料----------------
class Milk extends Condiment {
    public Milk(Beverage beverage) {
        super(beverage);
    }
    @Override
    public double cost() {
        return beverage.cost() + 1;
    }
    @Override
    public String getDescription() {
        return beverage.getDescription() + " 牛奶";
    }
}

class Soy extends Condiment {
    public Soy(Beverage beverage) {
        super(beverage);
    }
    @Override
    public double cost() {
        return beverage.cost() + 0.5;
    }
    @Override
    public String getDescription() {
        return beverage.getDescription() + " 豆浆";
    }
}
//===================客户端===========================
// 1.加入新的饮料
class Tea extends Beverage {

    public Tea() {
        super("茶");
    }

    @Override
    public double cost() {
        return 2;
    }
}
// 2.加入新的调料
class GouQi extends Condiment {

    public GouQi(Beverage beverage) {
        super(beverage);
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + " 枸杞";
    }

    @Override
    public double cost() {
        return beverage.cost() + 1;
    }
}

public class AppTest {
    public static void main(String[] args) {
        Beverage beverage = new Decaf();

        Beverage beverage2 = new Milk(beverage);
        Beverage beverage3 = new Soy(beverage2);

        System.out.println(beverage3.getDescription() + ":" + beverage3.cost());
    }
}

执行示意图

在这里插入图片描述

在这里插入图片描述

优点：

  1. 加入新的饮料，不会违反开闭原则
  2. 加入新的调料，也不会违反开闭原则
//===================客户端===========================
// 1.加入新的饮料
class Tea extends Beverage {
    public Tea() {
        super("茶");
    }
    @Override
    public double cost() {
        return 2;
    }
}
public class AppTest {
    public static void main(String[] args) {
        Beverage beverage;
        beverage = new Tea(); // 无咖啡因咖啡
        beverage = new Milk(beverage);
        beverage = new Milk(beverage);
        System.out.println(beverage.getDescription() + ": " + beverage.cost());
    }
}

//===================客户端===========================
// 2.加入新的调料
class GouQi extends Condiment {
    public GouQi(Beverage beverage) {
        super(beverage);
    }
    @Override
    public String getDescription() {
        return super.getDescription() + " 枸杞";
    }
    @Override
    public double cost() {
        return super.cost() + 2;
    }
}
public class AppTest {
    public static void main(String[] args) {
        Beverage beverage;
        beverage = new Tea(); // 无咖啡因咖啡
        beverage = new Milk(beverage);
        beverage = new GouQi(beverage);
        System.out.println(beverage.getDescription() + ": " + beverage.cost());
    }
}

UML类图

2020-11-22 23-30-06 的屏幕截图

缺点：

由于使用装饰模式，可以比使用继承关系需要较少数目的类。使用较少的类，当然使设计比较易于进行。但是，在另一方面，使用装饰模式会产生比使用继承关系更多的对象。更多的对象会使得查错变得困难，特别是这些对象看上去都很相像。

JDK源码中的装饰器模式展现

jdk中的流，就是使用装饰器模式

public class AppTest {
    public static void main(String[] args) throws IOException {
        //InputStream 抽象组件 ==> 饮料
        //FileInputStream 具体组件 ==> 无咖啡因咖啡
        InputStream in = new FileInputStream("/home/aluem/软件著作权任务安排.txt");
        //BufferedInputStream 装饰器 ==> 牛奶、豆浆
        BufferedInputStream bis = new BufferedInputStream(in);
        InputStreamReader isr = new InputStreamReader(bis);

        isr.close();
    }
}

从上面的代码可以大致看出装饰器的形式，Inputstream类的子类为具体组件（无咖啡因咖啡）与一个抽象装饰器

在这里插入图片描述

那么其抽象装饰器是什么呢？抽象装饰器是关联与继承抽象组件InputSream的，我们从类关系中找到FilterInputStream类：

在这里插入图片描述

在这里插入图片描述

从源码分析，FilterInputStream（抽象装饰器：调料）类确实关联且继承Inputsream（抽象组件：饮料）类

从而Filterinputstream的子类为（装饰器：牛奶，豆浆。。）
在这里插入图片描述

装饰java.io类UML类图

在这里插入图片描述

装饰器模式的简单实用

public class AppTest2 {
    public static void main(String[] args) throws Exception {
        Reader in = new FileReader("/home/aluem/1.txt");
         //关联Reader是为了使用Reader的功能，继承Reader是为了自己本身可以作为Reader传到别的装饰器中
        BufferedReader br = new BufferedReader(in);//BufferedReader可以读行，而读行需要使用FileReader的读取字符的功能，因此使用装饰器模式
		//BufferedReader br2 = new BufferedReader(br);
        String line = null;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }

        br.close();
    }
}

上面是JDK中的BufferedReader，我们通过装饰器模式自己创建一个新的BufferredReader模拟原来的。

public class MyBufferReader extends Reader {
    private Reader in;

    public MyBufferReader(Reader in){
        this.in = in;
    }

    public String readLine() throws IOException {
        StringBuilder sb = new StringBuilder();
        int read;

        while(true){
            read = in.read();
            if (read == '\r')
                continue;
            if (read == '\n' || read == -1){
                break;
            }
            sb.append((char)read);
        }
        if (sb.toString().length() == 0){
            if (read == '\n'){
                return "";
            }else {
                return null;
            }
        }else {
            return sb.toString();
        }
    }

    @Override
    public int read(char[] cbuf, int off, int len) throws IOException {
        return 0;
    }

    @Override
    public void close() throws IOException {
        in.close();
    }

    /*===================客户端===========================*/
    public static void main(String[] args) throws IOException {
        Reader in = new FileReader("E:\\1.txt");
        MyBufferReader myBufferReader = new MyBufferReader(in);
      //  BufferedReader br = new BufferedReader(myBufferReader);   可以层层进行套娃包装

        String line;
        while(( line = myBufferReader.readLine() ) != null){
            System.out.println(line);
        }
    }
}

参考资料：Java设计模式-Mr.high、《设计模式就该这样学》

Aluem
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
23种设计模式 -设计模式图解.7z
09-11
23种设计模式的特点定义、优缺点、使用场景，源码中如何使用，资料思维导图。总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
设计模式之装饰器模式详解
weixin_45538589的博客
11-19 1万+
设计模式之装饰器模式详解 文章目录设计模式之装饰器模式详解一、什么是装饰者模式二、门面模式的角色组成四、门面模式示例五、门面模式优缺点 一、什么是装饰者模式 装饰器模式（Decorator Pattern） 也称为包装模式(Wrapper Pattern) 是指在不改变原有对象的基础之上，将功能附加到对象上，提供了比继承更有弹性的替代方案(扩展原有对象的功能)，属于结构型模式。装饰器模式的核心是功能扩展，使用装饰器模式可以透明且动态地扩展类的功能。 二、门面模式的角色组成 外观角色（Facade）：
设计模式之装饰器模式
weixin_64366370的博客
05-04 2415
装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。
设计模式~~~装饰者模式
PeakGao
10-13 1631
学习难度：※※※ 使用频率：※※※ 上班族大多都有睡懒觉的习惯，每天早上上班时间都很紧张，于是很多人为了多睡一会，就会用方便的方式解决早餐问题。有些人早餐可能会吃煎饼，煎饼中可以加鸡蛋，也可以加香肠，但是不管怎么“加码”，都还是一个煎饼。在现实生活中，常常需要对现有产品增加新的功能或美化其外观，如房子装修、相片加相框等，都是装饰器模式。 在软件开发过程中，有时想用一些现存的组件。这些组件可能只是完成了一些核心功能。但在不改变其结构的情况下，可以动态地扩展其功能。所有这些都可以釆用装饰模式来实现。 一
C++ 设计模式-装饰模式
wangdamingll的博客
11-28 502
介绍装饰模式和使用
通俗易懂了解Python装饰器原理
09-17
主要介绍了通俗易懂了解Python装饰器原理,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
白话设计模式通俗易懂
10-10
非常好的设计模式介绍资料，通俗易懂，适用于编程人员参考。采用了大量图片介绍系统的展示了编程当中常用的各种模式设计
观察者模式 通俗易懂讲解
05-18
文档加代码，如果看完pdf，观察者模式还没学会，感觉你没必要学设计模式了，文档非常通俗易通，适合新手上手。
通俗易懂的随机森林模型讲解
02-20
大家好，我是你们的好朋友小木。对于随机森林的模型，网上已经有灰常灰常多的讲解，大家讲的也非常的不错。但绝大多数大神讲解都是注重于理论，把算数的地方都给忽略了，我这次要以举例子的方法来讲解，这样可以让...
装饰器模式
weixin_43594279的博客
03-26 1678
装饰器模式一、装饰器模式二、装饰器模式实例之界面显示构件库1.实例说明2.实例类图3.实例代码参考文献 一、装饰器模式 装饰器模式（Decorator Pattern）别名为包装器（Wrapper），是一种对象结构型模式。 定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，就扩展功能而言它比生成子类的方式更为灵活 使用频率：3星 模式结构： 装饰器模式主要包含以下角色： 1、抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加责任的对象。 2、具体
设计模式---装饰器(Decorator)模式
honor_zhang的博客
09-07 1639
1 定义 装饰器（Decorator）模式，也称为包装（Wrapper）模式，是继承关系的一种替代方案。指在不改变对象结构的情况下，动态的给对象添加一些功能。 2 优缺点 2.1 优点 装饰器是继承的有力补充，比继承灵活，在不改变原有对象的情况下，动态的给一个对象扩展功能，即插即用 通过使用不用装饰类及这些装饰类的排列组合，可以实现不同效果 装饰器模式完全遵守开闭原则 2.2 缺点 装饰器模式会增加许多子类，过度使用会增加程序得复杂性。 3 装饰器模式的结构与实现 装饰器模式的类图如下所示：
《设计模式》之装饰器模式
向上的"狼"的博客
08-10 1044
《设计模式》之装饰器模式
Java设计模式（六）装饰器模式-与代理模式的区别-项目实战应用
孔明的博客
07-13 2489
装饰器模式（Decorator Pattern）: 在不改变对象自身的基础上，在程序运行期间给对象动态的添加职责；感觉有点儿类似于继承，不改变父类，子类可拓展功能； 和代理模式（代理设计模式） 真是太像了，简直一摸一样场景： 项目一期开发的时候，并没有给鉴权部分设置缓存；二期开发考虑到性能问题，想要给鉴权部分加上缓存，这里就选择了使用装饰器模式处理...
23种设计模式之装饰器模式（Decorator Pattern）
热门推荐
小威的博客
05-18 2万+
本篇文章将23种设计模式中的装饰器模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。
详解设计模式：装饰器模式
栗筝i的博客
11-29 2110
装饰器模式（Decorator Pattern）也称为包装模式（Wrapper Pattern），是 GoF 的 23 种设计模式中的一种结构型设计模式。装饰器模式 是指在不改变原有对象的基础之上，将功能附加到对象上，提供了比继承更有弹性的替代方案（扩展原有对象的功能）。 装饰器模式 的核心是功能扩展，使用装饰器模式可以透明且动态地扩展类的功能 本篇内容包括：关于装饰器模式、装饰器实现 Demo
【设计模式——学习笔记】23种设计模式——装饰器模式Decorator（原理讲解+应用场景介绍+案例介绍+Java代码实现）
记录一名在读研究生的学习笔记、感悟、开发产物
07-27 1240
讲解装饰器模式的思想，介绍其常见的应用场景，举例说明其实现方式
设计模式详解（十）——装饰器模式
最新发布
qq_44307209的博客
11-11 577
装饰器模式也称为包装模式是指在不改变现有对象结构的情况下，动态地给该对象增加一些职责，即增加其额外功能，提供了比继承更有弹性的替代方案(扩展原有对象的功能)，属于结构型模式。从代码层面而言，是对类的一个扩展或者是修饰，从传统方法而言，我们可以使用继承来对某一个类进行扩展，但是往往会导致会出现非常多的子类，如果我们要想避免这种情况，那么我们就可以使用设计模式中的——装饰器模式。比如平时我们都肯定喝过奶茶，奶茶肯定有很多种，而且点的奶茶，还可以加料，比如加珍珠，加椰果之类的。这就可以用装饰器模式处理了。
python内置的装饰器最通俗的讲解_如何最简单、通俗地理解Python的装饰器？
weixin_39924573的博客
12-06 85
目录：一、笔记二、我的自学路线三、笔记目录一、笔记1) 装饰器的定义① 装饰器就是给已有函数增加额外功能的函数，它本质上就是一个闭包函数。② 装饰器的功能特点：1. 不修改已有函数的源代码2. 不修改已有函数的调用方式3. 给已有函数增加额外的功能③ 闭包和装饰器的区分：如果闭包函数的参数有且只有一个，并且是函数，那么这个闭包函数称之为装饰器。④ 写代码要遵循开放封闭原则，它规定已经实现的功能代码...
解释器模式 代码解释加注释 通俗易懂
04-28
解释器模式是一种设计模式，它允许我们定义一种语言，并且可以使用该语言来解释和执行特定的任务。该模式适用于需要实现复杂语言处理的场景，例如编译器、解析器、计算器等。 实现解释器模式需要以下几个元素： - ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值