设计模式四装饰模式(Decorator)

最新推荐文章于 2023-08-01 22:13:10 发布

我要精通C++

最新推荐文章于 2023-08-01 22:13:10 发布

阅读量154

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/Edidaughter/article/details/119062086

版权

装饰者模式单一职责动态扩展类爆炸继承 vs 组合

关键词由CSDN通过智能技术生成

设计模式专栏收录该内容

14 篇文章 0 订阅

订阅专栏

1.装饰者模式

1.1 装饰者模式是单一职责模式的一种

1.2 模式定义

1.3 UML

1.4 通过现象看本质

1.5 提纲

2.没有经过设计的场景下的类爆炸V1

3.更新了一个版本V2

4.更新了更好的版本V3

1.装饰者模式

1.1 装饰者模式是单一职责模式的一种

1.1.1 单一职责模式
在软件组织的设计中，如果责任划分的不清晰，是的继承得到的结果往往是随着需求的变化，
子类急剧膨胀，同时充斥着重复代码，这个时候的关键是划清职责.

1.1.2 典型的单一职责模式
Decorator
Bridge

1.1.3 单一职责模式的动机
某些情况下我们可能会过度地使用继承来扩展对象的功能,由于继承为类型引入的静态特质,是的这种扩展方式缺乏灵活性，并且随着子类的增多(扩展功能的增多),各种子类的组合(功能扩展的组合)会导致更多子类的膨胀.

如何是“对象功能的扩展”能够根据需要来动态地实现呢？同时避免“扩展功能的增多”带来的子类膨胀的问
题？从而使得任何“功能扩展变化”所导致的影响降为最低.

1.2 模式定义

动态(组合)地给一个对象增加一些额外的职责，就增加动能而言，Decorator模式比生成子类
(继承)更为灵活(消除重复代码&减少子类个数).--《设计模式》GoF

1.3 UML

1.4 通过现象看本质

一个类既继承基类，又组合基类.那么可以合理怀疑这个类采用了Decorator设计模式.

1.5 提纲

通过采用组合而非继承的手法，装饰迷失实现了在运行时动态扩展对象功能的能力，而且可以根据
需要拓展多个功能，避免了使用继承带来的灵活性查和多子类衍生问题.


装饰类在接口上表现为is-a Component的继承关系，即装饰类竟成了Component类所具有的接口，
但在实现上又表现为has-a Component的组合关系，即装饰类又使用了另外一个Component类.

装饰模式的目的并非解决“多子类衍生的多继承”问题，装饰模式应用的要点在于解决“主体类
在多个方向上的扩展功能”--是为“装饰”的含义.

2.没有经过设计的场景下的类爆炸V1

// 设计一些流操作，文件流，网络流，内存流，加密+缓存

// 业务操作
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 CryptoFileSystem:public FileStream{
public:
     virtual char Read(int number){
         // 额外的加密操作...
         FileStream::Read(number); // 读文件流
         // 额外的加密操作...
     }
    
    virtual void Seek(int position){
         // 额外的加密操作...
         FileStream::Seek(position); // 定位文件流
         // 额外的加密操作...
    }
    
    virtual void Write(char 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(char 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(char data){
         
         // 额外的加密操作...
         MemoryStream::Write(data); // 写内存流
         // 额外的加密操作...
    }
};



// 扩展操作--缓冲
class BufferedFileSystem:public FileStream{
   // ...
};

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

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


class CryptoBufferedFileSystem:public FileStream{
public:
     virtual char Read(int number){
         // 额外的加密操作...
         // 额外的缓冲操作...
         FileStream::Read(number); // 读文件流
     }

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

3.更新了一个版本V2

// 业务操作
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();new NetworkStream();new MemoryStream();
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(char 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);


}

4.更新了更好的版本V3

// 业务操作
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;//...prefer 组合 to 继承 ，灵魂手法
      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(char 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);
}

我要精通C++

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式四装饰模式(Decorator)

1.装饰者模式是单一职责模式的一种1.1 单一职责模式在软件组织的设计中，如果责任划分的不清晰，是的继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这个时候的关键是划清职责.1.2 典型的单一职责模式DecoratorBridge1.3 单一职责模式的动机某些情况下我们可能会过度地使用继承来扩展对象的功能,由于继承为类型引入的静态特质,是的这种扩展方式缺乏灵活性，并且随着子类的增多(扩展功能的增多),各种子类的组合(功能扩展的组合)会导致更多子类的膨胀.如何
复制链接

扫一扫