设计模式——单一职责模式之装饰模式

已于 2023-05-12 18:24:24 修改
阅读量643 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 c++ 装饰器模式
于 2023-05-12 18:22:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41839588/article/details/130642133
版权

文章目录

前言

一、“单一职责” 模式

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

二、Decorator 装饰模式

1、动机

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

2、模式定义

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

3、伪代码示例

有这样一种设计场景，需要设计一个 IO 库流操作，针对流操作我们有很多的需求，比如说文件流、网络流以及内存流，我们也有需要对流进行加密，对流进行缓存等等各种各样的操作。

①、第一种写法

decorator1.cpp

//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);//读文件流  静态特质，确定了只能调FileStream 
    }
    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);//读网络流 静态特质，确定了只能调NetworkStream
    }
    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();
}

涉及到的结构：
在这里插入图片描述
类的规模为：1 + n + n × m ! / 2
这份代码存在冗余，加密操作都是相同的，代码大量的重复。

②、第二种写法

重构

decorator2.cpp

//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){
        //写内存流
    }
};
 
//扩展操作，继承自Stream，是为了符合虚函数的接口规范
class CryptoStream: public Stream {
    
    Stream* stream;//...new FileStream() / new NetworkStream() /...
 
public:
    CryptoStream(Stream* stm) : stream(stm){
    
    }
    
    virtual char Read(int number){
       
        //额外的加密操作...
        stream->Read(number);//读文件流   动态特质，在运行时确定stream的具体类型
    }
    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);
}

修改后的优点：将“继承”改成“对象组合"，使用多态，在运行时确定具体类型，“编译时装配"变成了"运行时装配”。

③、第三种写法

进一步优化：将相同字段提到一个新的基类 DecoratorStream 中：

//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){
        //写内存流
    }
};
 
//扩展操作
class 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{
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); // 加密缓冲操作
}

此时类关系：
在这里插入图片描述
类的规模：1 + n + 1 + m

4、结构

在这里插入图片描述

【注】：

  • Component -> Stream (稳定)
  • Decorator -> DecoratorStream （稳定）
  • ConcreteComponent -> FileStream/NetworkStream/… （变化）
  • ConcreteDecoratorX-> CryptoStream / BufferedStream (变化)

总结

  • 通过采用组合而非继承的手法，Decorator 模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的“灵活性差”和“多子类衍生问题”。
  • Decorator 类在接口上表现为 is-a Component 的继承关系，即 Decorator 类继承了 Component 类所具有的接口。但在实现上又表现为 has-a Component 的组合关系，即 Decorator 类又使用了另外一个 Component 类。【注：DecoratorStream 类继承自 Stream，同时又有一个 Stream 类型的字段，一般这种既继承又组合的方式通常都是装饰模式。例子中的继承是为了完善接口的规范，组合是为了支持实现具体的类】
  • Decorator 模式的目的并非解决“多子类衍生的多继承”问题，Decorator 模式应用的要点在于解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义。

我的qq：2442391036，欢迎交流！

须尽欢~~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java设计模式中单一职责原则详解.rar
07-10
Java设计模式中单一职责原则详解.rar
学习设计模式——职责链模式
01-20
职责链模式 // 定义一个公共类 let Leader = function () { this.nextLeader = null; }; Leader.prototype.setNext = function (next) { this.nextLeader = next; return next; // 这样可以链式子调用 } //...
设计模式之美——单一职责原则和开闭原则
iblade的博客
11-23 1262
看懂”和“会用”是两回事，而“用好”更是难上加难。SOLID 原则：SRP单一职责原则（the single responsibility principle ）OCP开闭原则（the open closed principle）LSP里氏替换原则（the liskov substitution principle）ISP接口独立原则（the interface segregation principle）
设计模式——单一职责类及经典案例
weixin_42034081的博客
04-01 289
单一职责类设计模式 再软件设计过程中，如果责任划分不清晰，使得继承得到的结果往往是随着需求变化， 子类急剧膨胀，同时充斥着重复的代码，这个时候的关键是划清责任； 典型模式： Decorator Bridge Decorator 动机： 在某些情况下，会过度的使用继承来拓展对象功能，由于继承为类型引入静态特质，这种拓展方式缺乏灵活性，并且随着子类的增多，各种子类的组合会导致更多的子类膨胀 //业务操作 class mystream { public: virtual char* Read(const int
设计模式——单一职责模式之桥模式
明天你好的博客
05-12 833
在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。典型模式DecoratorBridge将抽象部分业务功能)与实现部分平台实现)分离，使它们都可以独立地变化。Bridge 模式使用“对象间的组合关系解耦了抽象和实现之间固有的绑定关系，使得抽象和实现可以沿着各自的维度来变化。所谓抽象和实现沿着各自纬度的变化，即“子类化”它们。Bridge 模式有时候类似于多继承方案。
单一职责模式——装饰模式
dongdong7_77的博客
11-13 73
单一职责模式 在软件组件设计中，如果责任划分的不清晰，使用继承得到的结果往往是随需求的变化，子类极具膨胀，同时充斥着重复代码，这时候关键是划清责任 装饰模式 桥模式 动机 在某些情况下我们可能会“过度地使用继承l来扩展对象的功能”，由于继承为类型引入静态特性，使得这种扩展方式缺乏灵活性，并且伴随着子类的增多（扩展功能的增多），各种子类组合（扩展功能组合）会导致更多子类的膨胀 问题代码 //业务操作 class Stream{ public： virtual char Read(int numbe
Java 设计模式——装饰者模式
代码星辰的博客
07-16 812
本文介绍了装饰者模式的相关知识。
设计模式七大原则--单一职责原则
jiyanghao19的博客
12-29 369
单一原则
设计模式——装饰器模式
m0_60697583的博客
04-18 244
装饰器模式是一种结构型设计模式，它允许在不修改现有对象结构的情况下，动态地向对象添加新功能。这种模式通过将对象包装在装饰器对象中来实现，从而允许向对象添加新的行为。装饰器模式允许你通过将对象放入包含有特殊行为的装饰器对象中，来动态地为对象添加新的功能。装饰器模式实际上是对继承的一种替代方案，它通过组合而不是继承来实现功能的扩展。
设计模式——职责链模式
程序猿进阶
03-24 1878
在现实生活中，常常会出现这样的事例：一个请求有多个对象可以处理，但每个对象的处理条件或权限不同。例如，公司员工差旅费的报销，可审批的领导有部门负责人、副总经理、总经理等，但每个领导能批准的金额不同，员工必须根据自己要批准的金额去找不同的领导签名，也就是说员工必须记住每个领导的姓名、电话和地址等信息，这增加了难度。 在计算机软硬件中也有相关例子，例如异常处理中，处理程序根据异常的类型决定自己是否处理该异常；还有 Struts2 的拦截器、JSP 和 Servlet 的 Filter 等，所有这些，如果用责任链
设计模式结构型——装饰器模式
tszc95的博客
07-19 424
装饰器模式（Decorator Pattern），又称为包装模式(Wrapper Pattern)是指在不改变原有对象的基础之上，将功能附加到对象上，提供了比继承更有弹性的替代方案(扩展原有对象的功能)，即允许向一个现有的对象添加新的功能，属于结构型模式。装饰器模式的核心是功能扩展，使用装饰器模式可以透明且动态地扩展类的功能。装饰器模式通过将对象包装在装饰器类中，以便动态地修改其行为。其创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。
设计模式——开发常用的设计模式梳理
02-24
本文来自51cto，文章主要介绍了策略模式、观察者模式、装饰模式、单例模式以及饿汉模式等的相关内容。泛化=实现>组合>聚合>关联>依赖一个人(Person)可以买车(car)和房子(House)，那么就可以称：Person类依赖于Car类...
.NET中的设计模式——一步步发现装饰模式
02-27
前言过去我的一个朋友常说，学习...装饰器模式允许我们动态为对象添加行为。下面我们先介绍一个场景，然后寻找替代方法。这会帮助我们认清该模式的真实用途，尤其在灵活性这方面。思考过程今天我们参考的不是一个实际的
设计模式-享元模式
楠姐的博客
05-29 812
享元模式（Flyweight Pattern）是一种用于效率和内存优化的结构型设计模式。这种模式通过共享尽可能多的相似对象来减少内存使用，特别适合于处理大量对象时，每个对象都消耗大量内存的场景。总的来说，享元模式在处理大量相似对象时提供了一种有效的内存优化策略。然而，它的使用应当谨慎，需要正确评估和设计内部状态和外部状态，以确保不会对应用程序的逻辑造成负面影响。在 JavaScript 等动态语言中，享元模式可以帮助管理内存消耗，尤其是在客户端浏览器环境中，这对提升用户体验和应用性能都是非常有益的。
设计模式深度解析：分布式与中心化，IT界两大巨头“华山论剑”
制定明确可量化的目标，坚持默默的做事。
05-26 2645
分布式模式与中心化模式各有其独特的优势和局限性。分布式模式因其高容错性和适应大规模复杂系统的能力，在处理大数据和高并发场景中具有显著优势，然而，其节点间数据传输的安全性要求高，且开发调试难度较大，这是其面临的挑战。相比之下，中心化模式在安全控制和开发维护方面更具优势，适用于对安全性和稳定性要求较高的场景。在选择时，需综合考虑业务需求和技术要求，权衡利弊。未来，随着云计算、边缘计算等技术的发展，两种模式将迎来新的机遇与挑战，需灵活调整策略，确保系统高效稳定运行。
Java设计模式 _行为型模式_访问者模式
最新发布
weisian的博客
05-30 345
访问者模式，主要包含访问者和被访问者两种角色的实体，两者之间相互关联，被访问者依附于访问者，访问者可以访问被访问者的方法。学海无涯苦作舟！！！
23种设计模式之一— — — —装饰模式详细介绍与讲解
2201_75851346的博客
05-29 2781
装饰模式（别名：包装器）装饰模式（Decorator Pattern）是结构型的设计模式，它允许在运行时动态地向对象添加新的职责或功能，同时保持对象的原始类不变。通过使用装饰器模式，可以在不修改现有代码的基础上扩展对象的功能，
【设计模式】JAVA Design Patterns——Curiously Recurring Template Pattern（奇异递归模板模式）
CSBIGDOG的博客
05-27 492
奇异递归模板模式（curiously recurring template pattern，CRTP）是C++模板编程时的一种惯用法：其中类X派生自使用X本身作为模板参数的类模板实例化。对于正在策划赛事的综合格斗推广活动来说，确保在相同重量级的运动员之间组织比赛至关重要。这样可以防止体型明显不同的拳手之间的不匹配，例如重量级拳手与雏量级拳手的对决。效果： 允许拳手与相同重量级的对手交手，如果对手是不同重量级，则会出现错误。使类型中的某些方法接受特定于其子类型的参数。定义MmaFighter 的一些子类型。
C#设计模式——原型模式(Prototype Pattern)
06-01
原型模式是一种创建型设计模式，它允许通过复制已有对象来创建新对象，而不是通过实例化类并设置其属性来创建新对象。这样可以避免重复创建相同的对象，从而提高了创建对象的效率。 在原型模式中，原型对象是被复制...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

须尽欢~~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值