设计模式笔记—4_Decorator装饰者模式

最新推荐文章于 2024-10-06 22:28:35 发布
最新推荐文章于 2024-10-06 22:28:35 发布
阅读量160 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Felix_hyfy/article/details/104617358
版权

Decorator装饰者模式是一种“单一职责”模式

  • 在软件组件的设计中，如果责任划分得不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码。这时候的关键是划清责任

动机

  • 在某些情况下我们可能会“过度地使用继承来扩展对象的功能”。由于继承为类型引入的静态特质（通过继承实现，而动态特质可以通过组合实现），使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的增多），各种子类的组合（扩展功能的组合）会导致更多子类的急剧膨胀
  • 如何使"对象功能的扩展"能够根据需要来动态的实现？同时避免“扩展功能的增多”带来的子类膨胀问题？从而使得任何“功能扩展变化”所导致的影响将为最低？

定义

  • 动态（组合）地给一个对象增加一些额外的职责。就增加功能而言，Decorator模式比生成子类（继承）更为灵活（消除重复代码&减少子类个数）

结构

在这里插入图片描述

代码对比

decorator1.cpp

//业务操作接口
class Stream{
public：
    virtual char Read(int number)=0;
    virtual void Seek(int position)=0;
    virtual void Write(char data)=0;
    
    virtual ~Stream(){}
};

//主体类
class FileStream: public Stream{
public:
    virtual char Read(int number){
        //读文件流
    }
    virtual void Seek(int position){
        //定位文件流
    }
    virtual void Write(char data){
        //写文件流
    }

};

class NetworkStream :public Stream{
public:
    virtual char Read(int number){
        //读网络流
    }
    virtual void Seek(int position){
        //定位网络流
    }
    virtual void Write(char data){
        //写网络流
    }
    
};

class MemoryStream :public Stream{
public:
    virtual char Read(int number){
        //读内存流
    }
    virtual void Seek(int position){
        //定位内存流
    }
    virtual void Write(char data){
        //写内存流
    }
    
};

//扩展操作
class CryptoFileStream :public FileStream{
public:
    virtual char Read(int number){
       
        //额外的加密操作...
        FileStream::Read(number);//读文件流，静态特质，通过组合实现
        
    }
    virtual void Seek(int position){
        //额外的加密操作...
        FileStream::Seek(position);//定位文件流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        FileStream::Write(data);//写文件流
        //额外的加密操作...
    }
};

class CryptoNetworkStream : :public NetworkStream{
public:
    virtual char Read(int number){
        
        //额外的加密操作...
        NetworkStream::Read(number);//读网络流
    }
    virtual void Seek(int position){
        //额外的加密操作...
        NetworkStream::Seek(position);//定位网络流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        NetworkStream::Write(data);//写网络流
        //额外的加密操作...
    }
};

class CryptoMemoryStream : public MemoryStream{
public:
    virtual char Read(int number){
        
        //额外的加密操作...
        MemoryStream::Read(number);//读内存流
    }
    virtual void Seek(int position){
        //额外的加密操作...
        MemoryStream::Seek(position);//定位内存流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        MemoryStream::Write(data);//写内存流
        //额外的加密操作...
    }
};

class BufferedFileStream : public FileStream{
    //...
};

class BufferedNetworkStream : public NetworkStream{
    //...
};

class BufferedMemoryStream : public MemoryStream{
    //...
}




class CryptoBufferedFileStream :public FileStream{
public:
    virtual char Read(int number){
        
        //额外的加密操作...
        //额外的缓冲操作...
        FileStream::Read(number);//读文件流
    }
    virtual void Seek(int position){
        //额外的加密操作...
        //额外的缓冲操作...
        FileStream::Seek(position);//定位文件流
        //额外的加密操作...
        //额外的缓冲操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        //额外的缓冲操作...
        FileStream::Write(data);//写文件流
        //额外的加密操作...
        //额外的缓冲操作...
    }
};



void Process(){

        //编译时装配
    CryptoFileStream *fs1 = new CryptoFileStream();

    BufferedFileStream *fs2 = new BufferedFileStream();

    CryptoBufferedFileStream *fs3 =new CryptoBufferedFileStream();

}

decorator2.cpp

//业务操作
class Stream{

public：
    virtual char Read(int number)=0;
    virtual void Seek(int position)=0;
    virtual void Write(char data)=0;
    
    virtual ~Stream(){}
};

//主体类
class FileStream: public Stream{
public:
    virtual char Read(int number){
        //读文件流
    }
    virtual void Seek(int position){
        //定位文件流
    }
    virtual void Write(char data){
        //写文件流
    }

};

class NetworkStream :public Stream{
public:
    virtual char Read(int number){
        //读网络流
    }
    virtual void Seek(int position){
        //定位网络流
    }
    virtual void Write(char data){
        //写网络流
    }
    
};

class MemoryStream :public Stream{
public:
    virtual char Read(int number){
        //读内存流
    }
    virtual void Seek(int position){
        //定位内存流
    }
    virtual void Write(char data){
        //写内存流
    }
    
};

//扩展操作


class CryptoStream: public Stream {
    
    Stream* stream;//...new filestream();

public:
    CryptoStream(Stream* stm):stream(stm){
    
    }
    
    
    virtual char Read(int number){
       
        //额外的加密操作...
        stream->Read(number);//读文件流，动态特质，通过组合实现
    }
    virtual void Seek(int position){
        //额外的加密操作...
        stream::Seek(position);//定位文件流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        stream::Write(data);//写文件流
        //额外的加密操作...
    }
};



class BufferedStream : public Stream{
    
    Stream* stream;//...
    
public:
    BufferedStream(Stream* stm):stream(stm){
        
    }
    //...
};





void Process(){

    //运行时装配
    //编译时不进行加密、缓存……
    FileStream* s1=new FileStream();			//生产一个文件流对象
    CryptoStream* s2=new CryptoStream(s1);		//文件流对象加密
    
    BufferedStream* s3=new BufferedStream(s1);	//缓存
    
    BufferedStream* s4=new BufferedStream(s2);	//既加密又缓存
   
}

decorator3.cpp

//业务操作
class Stream{

public：
    virtual char Read(int number)=0;
    virtual void Seek(int position)=0;
    virtual void Write(char data)=0;
    
    virtual ~Stream(){}
};

//主体类
class FileStream: public Stream{
public:
    virtual char Read(int number){
        //读文件流
    }
    virtual void Seek(int position){
        //定位文件流
    }
    virtual void Write(char data){
        //写文件流
    }

};

class NetworkStream :public Stream{
public:
    virtual char Read(int number){
        //读网络流
    }
    virtual void Seek(int position){
        //定位网络流
    }
    virtual void Write(char data){
        //写网络流
    }
    
};

class MemoryStream :public Stream{
public:
    virtual char Read(int number){
        //读内存流
    }
    virtual void Seek(int position){
        //定位内存流
    }
    virtual void Write(char data){
        //写内存流
    }
    
};

//扩展操作

DecoratorStream: public Stream{
protected:
    Stream* stream;//...
    
    DecoratorStream(Stream * stm):stream(stm){
    
    }
    
};

class CryptoStream: public DecoratorStream {
 

public:
    CryptoStream(Stream* stm):DecoratorStream(stm){
    
    }
    
    
    virtual char Read(int number){
       
        //额外的加密操作...
        stream->Read(number);//读文件流
    }
    virtual void Seek(int position){
        //额外的加密操作...
        stream::Seek(position);//定位文件流
        //额外的加密操作...
    }
    virtual void Write(byte data){
        //额外的加密操作...
        stream::Write(data);//写文件流
        //额外的加密操作...
    }
};



class BufferedStream : public DecoratorStream{
    
    Stream* stream;//...
    
public:
    BufferedStream(Stream* stm):DecoratorStream(stm){
        
    }
    //...
};




void Process(){

    //运行时装配
    FileStream* s1=new FileStream();
    
    CryptoStream* s2=new CryptoStream(s1);
    
    BufferedStream* s3=new BufferedStream(s1);
    
    BufferedStream* s4=new BufferedStream(s2);
}

对比

  • 没使用Decorator模式时整个程序的框架为

在这里插入图片描述

  • decorator1.cpp过度地使用了继承来扩展对象的功能，且出现了严重的代码冗余（每个类中进行的重复的加密操作……）
  • decorator2.cppCryptoStream使用组合的方式（定义一个stream指针），利用在运行时令streamnew一个不同类型的对象（基类指针初始化派生类对象），来实现指向不同的类。这样做实现了程序在编译时不绑定，而是在运行时通过组合的方式将他们装配起来（编译时复用，运行时变化）。但是CryptoStream还是要继承Stream类，继承它的相关接口，遵循操作接口规范。同理BufferedStream也是类似的操作
  • decorator3.cpp将CryptoStream和BufferedStream中共同拥有的stream指针上提到了中间类DecoratorStream中。不提到Stream类中的原因是继承Stream类的FileStream类并不需要使用stream指针，所以应该设计中间类DecoratorStream
    • 中间类DecoratorStream可以定义各种操作，成为一个操作接口
    • 装饰Decorator操作本质上是扩展操作，必须需要在基类的对象上进行扩展才能实现，不能独立出现
  • 使用Decorator模式后整个程序的框架：

在这里插入图片描述

要点总结

  • 通过采用组合而非继承的手法，Decorator模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承而带来的“灵活性差”和“多子类衍生问题”
  • Decorator类在接口上表现为is-a Component的继承关系，即Decorator类继承了Component类所具有的接口。但在实现上表现为has-a Component的组合关系，即Decorator类又使用了另外的一个Component类（既继承又组合）
  • Decorator模式的目的并非解决“多子类衍生的多继承”问题，Decorator模式应用的要点在于解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义
Felix_hyfy
关注
专栏目录
【c++设计模式12】结构型4：装饰模式（Decorator Pattern）
junxuezheng的博客
04-22 607
装饰模式（Decorator Pattern）是一种结构型设计模式，它允许你在不改变现有对象结构的情况下，动态地将责任（功能）附加到对象上。装饰模式通过以透明的方式扩展对象的功能，比继承更灵活。
Decorator 装饰模式
xzpblog
06-08 119
“单一职责”模式: 在软件组件的设计中，如果责任划分的不清晰，使用继承得到的 结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码， 这时候的关键是划清责任。 典型模式 • Decorator • Bridge 动机（Motivation） 在某些情况下我们可能会“过度地使用继承来扩展对象的功能” ， 由于继承为类型引入的静态特质，使得这...
装饰模式
weixin_34021089的博客
06-20 126
“单一职责”模式:在软件组件的设计中,如果责任划分的不清晰,使用继承得到的结果往往是随着需求的变化,子类急剧膨胀,同时充斥着重复代码，这时候的关键是划清责任。 典型模式.Decorator.Bridge 1.Decorator模式 代码1： //业务操作 class Stream{ virtual char Read(int number) = 0; virt...
设计模式---单一职责模式之装饰模式（Decorator）
weixin_30342827的博客
08-25 102
前提："单一职责"模式 在软件组件的设计中，如果责任划分的不清晰，使用继承，得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任 典型模式（表现最为突出） 装饰模式Decorator 桥接模式Bridge 一：装饰模式 （一）概念 装饰模式又叫做包装模式。通过一种对客户端透明的方式来扩展对象的功能，是继承关系的一个替换方案。 ...
设计模式（5）——单一职责模式（1）——装饰模式
波波鱼的博客
07-18 275
目录 0.单一职责模式 1.基本介绍 2.动机 3.类图 4.案例 案例1：IO流操作 普通实现： 装饰模式重构上述代码实现： 案例2：星巴克咖啡订单项目 方案1： 方案2： 方案3：使用装饰者模式进行重构 5.源码分析 6.总结 0.单一职责模式 在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这...
【GeekBand】C++设计模式笔记6_Decorator_装饰模式
最新发布
qq_38154295的博客
10-06 557
【GeekBand】C++设计模式笔记6_Decorator_装饰模式
设计模式学习笔记——Decorator装饰模式
左直拳的马桶_日用桶
02-04 748
装饰模式的作用或动机就是，尽量避免继承，而使用关联。原因是层层继承下来，内容会越来越多，有失控的危险。就扩展性而言，用关联比用继承好。所谓的关联，A使用了B，就叫A关联了B。Component 抽象构件ConcreteComponent 具体构件Decorator 抽象装饰类从图可知，Decorator聚合（强关联）了Component，Component与Decorator有相同的方法operat
Java设计模式之装饰模式（Decorator Pattern）
2401_84557521的博客
04-25 749
始的对象，如上面的成绩单。注意：在装饰模式中，必然有一个最基本、最核心、最原始的接口或抽象类充当Component 抽象构件。● ConcreteComponent 具体构件ConcreteComponent 是最核心、最原始、最基本的接口或抽象类的实现，你要装饰的就是它。● Decorator 装饰角色一般是一个抽象类，做什么用呢？实现接口或者抽象方法，它里面可不一定有抽象的方法呀，在它的属性里必然有一个 private 变量指向 Component 抽象构件。● 具体装饰角色。
设计模式笔记_08_装饰模式
七点十七
04-23 75
package com.maom.design.D_08_Decorator; /** * @Title: D_08_Decorator * @Description: 08_装饰模式 * @Author maohb * @Version 1.0 */ public class D_08_Decorator { public static void main(String[]...
图解java设计模式_学习笔记_java开发
03-09
这份"图解java设计模式_学习笔记"是针对Java开发者深入理解和应用设计模式的重要资源。在这里，我们将深入探讨Java设计模式的核心概念、分类以及它们在实际开发中的应用。 设计模式分为三大类：创建型、结构型和...
java设计模式笔记之装饰模式
08-26
在Java设计模式中，装饰模式（Decorator Pattern）是一种结构型设计模式，它的主要目的是在不改变原有对象结构的前提下，动态地为对象添加新的行为或责任。装饰模式通过将额外的功能包装在原始对象的外壳中来实现这...
设计模式笔记设计模式笔记
10-11
设计模式笔记是对这些模式的深入理解和应用记录，可以帮助开发者在面对复杂系统设计时，快速找到合适的结构和策略。以下是关于设计模式的一些核心知识点： 1. **设计模式的分类**： - 创建型模式：如单例...
设计模式之美—学习笔记
12-07
在这个“设计模式之美”的学习笔记中，我们将探讨一些主要的设计模式，以及它们在实际开发中的应用。 首先，我们从创建型模式开始。这类模式主要用于对象的创建，如单例模式（Singleton）、工厂模式（Factory ...
设计模式笔记—0_设计模式简介+面向对象设计原则
Felix_hyfy的博客
03-02 543
文章目录深入理解面向对象机制向下：深入理解三大面向对象机制向上：深刻把握面向对象机制所带来的抽象意义，理解如何使用这些机制来表达显示世界，掌握什么时“好的面向对象设计”软件设计复杂的根本原因：变化如何解决复杂性分解抽象软件设计的目标：复用重新认识面向对象理解隔离变化各司其职对象是什么？面向对象设计原则依赖倒置原则（DIP）开放封闭原则（OCP）单一职责原则（SRP）Liskov替换原则（LSP）接...
设计模式笔记—18_Composite组合模式
Felix_hyfy的博客
03-04 386
Composite组合模式是一种“数据结构”模式 常常有一些组件在内部具有特定的数据结构。如果让客户程序依赖这些特定的数据结构，将极大地破坏组件的复用。这时候，将这些特定数据结构封装在内部，在外部提供统一的接口，来实现与特定数据结构无关的访问，是一种行之有效的解决方案 动机 软件在某些情况下， 客户代码过多地依赖于对象容器复杂地内部实现结构。对象容器内部实现结构（而非抽象接口）的变化将引起客...
设计模式笔记—23_Interpreter解析器模式
Felix_hyfy的博客
03-04 356
文章目录Interpreter解析器模式是一种“领域规则”模式动机定义结构代码对比main.cpp说明要点总结 Interpreter解析器模式是一种“领域规则”模式 在特定领域中，某些变化虽然频繁，但可以抽象为某种规则。这时候，结合特定领域，将问题抽象为语法规则，从而给出在该领域下的一般性解决方案 动机 在软件构建过程中，如果某一特定领域的问题比较复杂，类似的结构在不断重复出现，如果使用普...
设计模式笔记—9_Builder构造器模式
Felix_hyfy的博客
03-03 338
文章目录Builder构建器是一种“对象创建”模式动机定义结构代码对比builder.cpp对比要点 Builder构建器是一种“对象创建”模式 通过“对象创建”模式绕开new，来避免对象创建（new）的过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作 动机 在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成...
设计模式笔记—11_Flyweight享元模式
Felix_hyfy的博客
03-03 255
文章目录Flyweight享元模式是一种“对象性能”模式动机定义结构代码对比flyweight.cpp对比要点总结 Flyweight享元模式是一种“对象性能”模式 面向对象很好地解决了“抽象”的问题，但是必不可免地要付出一定的代价。对于通常情况来说，面向对象的成本大都可以忽略不计。但是某些情况，面向对象所带来的成本必须谨慎处理 动机 在软件系统采用纯粹对象方案的问题在于大量细粒度的对象会很...
设计模式笔记—22_Visitor访问器模式
Felix_hyfy的博客
03-04 250
文章目录Visitor访问器模式是一种“行为变化”模式动机定义结构代码对比visitor1.cppvisitor2.cpp对比要点总结 Visitor访问器模式是一种“行为变化”模式 在组件的构建过程中，组件行为的变化经常导致组件本身剧烈的变化。“行为变化”模式将组件的行为和组件本身进行解耦，从而支持组件行为的变化，实现两者之间的松耦合 动机 在软件构建过程中，由于需求的改变，某些类层次结构...
设计模式笔记：装饰模式详解与应用
"这篇文档是作者学习设计模式的个人笔记，包含了多种常用设计模式的整理，如装饰模式、代理模式、责任链模式等，并提供了C#语言的源码示例。文档强调了通过实例理解设计模式的重要性，指出深入理解需要在实际编程中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值