【设计模式】单一职责模式（装饰模式/桥模式）

最新推荐文章于 2023-11-12 21:41:28 发布
最新推荐文章于 2023-11-12 21:41:28 发布
阅读量88 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 c++ 多态
原文链接：https://blog.csdn.net/qq_35484146/article/details/113002885
版权

单一职责模式

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

下面两种模式在责任划分方面尤为突出（其他的模式也是有职责划分问题的）

  • 装饰模式Decorator
  • 桥模式Bridge

1.装饰模式Decorator

动机： 在某些情况下过度的使用继承来扩展对象的功能，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性并且随着子类的增多（扩展功能的增多），各种子类的组合（扩展功能的组合）会导致更多的子类膨胀

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

//业务操作 流操作
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();

}

上述代码类关系图：

image-20210507120002556

类太多了！！代码重复太多！！代码冗余

//修改过程
//业务操作 流操作
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{
      //由继承改为组合
//     //FileStream* stream; //当一个变量的声明类型都是某个类型的子类时 直接声明称父类类型就可以了
//     Stream* stream;//=new FileStream();  把编译时的东向变成运行时的东西
// public:
//     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 CryptoNetworkStream{
//     Stream* stream;//=new NetWorkStream();
// public:
//     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 CryptoMemoryStream{
//     Stream* stream;//=new MemoryStream();
// public:
//     virtual char Read(int number){
        
//         //额外的加密操作...
//         stream->Read(number);//读内存流
//     }
//     virtual void Seek(int position){
//         //额外的加密操作...
//         stream->Seek(position);//定位内存流
//         //额外的加密操作...
//     }
//     virtual void Write(byte data){
//         //额外的加密操作...
//         stream->Write(data);//写内存流
//         //额外的加密操作...
//     }
// };
//上面的加密操作都是一样的了 不一样的是注释的new ***Stream
//运行时让他们不一样 编译时是一样的
//编译时让他们复用 是一样的 运行时利用多态让他们不一样
//上述三个类就可以合并为一个类

class CryptoStream : public Stream{
    Stream* stream;//=....
public:
    CryptoStream(Stream *stream): stream(stream){}
    //虚函数需要继承一个接口基类
    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 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();

    //更改后 运行时装配
    FileStream* s1 = new FileStream();
    CryptoStream* s2 = new CryptoStream(s1);//加密
    BufferedStream* s3 = new BufferedStream(s1);//缓存
    BufferedStream* s4 = new BufferedStream(s2);//加密 + 缓存


}

//修改后
//业务操作
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;//...

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);
    
    

}
//根据马丁弗勒经典重构
//如果某一个类它的多个子类有同样的字段 需要将字段往上提（提到基类或者中间类）
//stream提到基类Stream不合适 因为FileStream/NetworkStream等不需要stream这个字段 所以建立一个中间类比较合适

//业务操作
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);//加密+缓冲
    
    

}

上述代码类关系图：

image-20210507120017473

  • 继承->组合
  • 编译时确定->运行时确定
  • 当一个变量的声明类型都是某个类型的子类时 直接声明称父类类型就可以了
  • 如果某一个类它的多个子类有同样的字段 需要将字段往上提（提到基类或者中间类）

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

image-20210507121155739

要点总结：

  1. 通过采用组合而非继承的手法，Decorator模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的灵活性差和多子类衍生问题
  2. Decorator类在接口上表现为is-a component的继承关系，即Decorator类继承了component类所具有的接口。但在实现上又表现为has-a component的组合关系，即Decorator类又使用了另一个component类
  3. Decorator模式的目的并非解决多子类衍生的继承问题，Decorator模式应用的要点在于解决主体类在多个方向上的扩展功能——是为装饰的含义 filestream/networkstreaam等为主体的操作，而加密/缓冲等为扩展的操作

2.桥模式Bridge

动机： 由于某些类型的固有的实现逻辑，使得它们具有两个及以上变化的维度

如何应对这种多维度的变化？如何利用面向对象技术来使得类型可以轻松的沿着两个乃至多个方向变化而不引入额外的复杂度？

//通信工具在不同平台上的实现
class Messager{
public:
    virtual void Login(string username, string password)=0;
    virtual void SendMessage(string message)=0;
    virtual void SendPicture(Image image)=0;

    virtual void PlaySound()=0;
    virtual void DrawShape()=0;
    virtual void WriteText()=0;
    virtual void Connect()=0;
    
    virtual ~Messager(){}
};


//平台实现 pc和mobile n

class PCMessagerBase : public Messager{
public:
    
    virtual void PlaySound(){
        //**********
    }
    virtual void DrawShape(){
        //**********
    }
    virtual void WriteText(){
        //**********
    }
    virtual void Connect(){
        //**********
    }
};

class MobileMessagerBase : public Messager{
public:
    
    virtual void PlaySound(){
        //==========
    }
    virtual void DrawShape(){
        //==========
    }
    virtual void WriteText(){
        //==========
    }
    virtual void Connect(){
        //==========
    }
};



//业务抽象 精简版lite/完美版perfect  m
//类的数目 1 + n + n * m

class PCMessagerLite : public PCMessagerBase {
public:
    
    virtual void Login(string username, string password){
        
        PCMessagerBase::Connect();
        //........
    }
    virtual void SendMessage(string message){
        
        PCMessagerBase::WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        
        PCMessagerBase::DrawShape();
        //........
    }
};



class PCMessagerPerfect : public PCMessagerBase {
public:
    
    virtual void Login(string username, string password){
        
        PCMessagerBase::PlaySound();
        //********
        PCMessagerBase::Connect();
        //........
    }
    virtual void SendMessage(string message){
        
        PCMessagerBase::PlaySound();
        //********
        PCMessagerBase::WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        
        PCMessagerBase::PlaySound();
        //********
        PCMessagerBase::DrawShape();
        //........
    }
};


class MobileMessagerLite : public MobileMessagerBase {
public:
    
    virtual void Login(string username, string password){
        
        MobileMessagerBase::Connect();
        //........
    }
    virtual void SendMessage(string message){
        
        MobileMessagerBase::WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        
        MobileMessagerBase::DrawShape();
        //........
    }
};


class MobileMessagerPerfect : public MobileMessagerBase {
public:
    
    virtual void Login(string username, string password){
        
        MobileMessagerBase::PlaySound();
        //********
        MobileMessagerBase::Connect();
        //........
    }
    virtual void SendMessage(string message){
        
        MobileMessagerBase::PlaySound();
        //********
        MobileMessagerBase::WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        
        MobileMessagerBase::PlaySound();
        //********
        MobileMessagerBase::DrawShape();
        //........
    }
};


void Process(){
        //编译时装配
        Messager *m =
            new MobileMessagerPerfect();
}




//修改流程
//实现通信
class Messager{
public:
    //下面两波纯虚函数在其子类中只是部分override 将这两博东西放在一个类中不合适
    virtual void Login(string username, string password)=0;
    virtual void SendMessage(string message)=0;
    virtual void SendPicture(Image image)=0;

    // virtual void PlaySound()=0;
    // virtual void DrawShape()=0;
    // virtual void WriteText()=0;
    // virtual void Connect()=0;
    
    virtual ~Messager(){}
};

class MessagerImp{
public:

    virtual void PlaySound()=0;
    virtual void DrawShape()=0;
    virtual void WriteText()=0;
    virtual void Connect()=0;
    virtual ~MessagerImp(){}
};


//平台实现 pc和mobile

class PCMessagerBase : public MessagerImp{
public:
    
    virtual void PlaySound(){
        //**********
    }
    virtual void DrawShape(){
        //**********
    }
    virtual void WriteText(){
        //**********
    }
    virtual void Connect(){
        //**********
    }
};

class MobileMessagerBase : public MessagerImp{
public:
    
    virtual void PlaySound(){
        //==========
    }
    virtual void DrawShape(){
        //==========
    }
    virtual void WriteText(){
        //==========
    }
    virtual void Connect(){
        //==========
    }
};



//业务抽象 精简版lite/完美版perfect

//下面这个精简版可以代替两个平台上的Lite版本
//perfect版本同理
class MessagerLite : public Messager{
    MessagerImp* messagerimp;//=....运行时确定
    //Messager* Messager;//= new PCMessagerBase(); 这行代码不成立 PCMessagerBase()是纯虚基类 只实现了部分纯虚函数
public:
    
    virtual void Login(string username, string password){
        
        messagerimp->Connect();
        //........
    }
    virtual void SendMessage(string message){
        
        messagerimp->WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        
        messagerimp->DrawShape();
        //........
    }
};


class MessagerPerfect : public Messager{
    MessagerImp* messagerimp;//...
public:
    
    virtual void Login(string username, string password){
        
        messagerimp->PlaySound();
        //********
        messagerimp->Connect();
        //........
    }
    virtual void SendMessage(string message){
        
        messagerimp->PlaySound();
        //********
        messagerimp->WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        
        messagerimp->PlaySound();
        //********
        messagerimp->DrawShape();
        //........
    }
};

// class PCMessagerLite{
//     Messager* messager;//= new PCMessagerBase();运行时确定
// public:
    
//     virtual void Login(string username, string password){
        
//         messager->Connect();
//         //........
//     }
//     virtual void SendMessage(string message){
        
//         messager->WriteText();
//         //........
//     }
//     virtual void SendPicture(Image image){
        
//         messager->DrawShape();
//         //........
//     }
// };



// class PCMessagerPerfect : public PCMessagerBase {
// public:
    
//     virtual void Login(string username, string password){
        
//         PCMessagerBase::PlaySound();
//         //********
//         PCMessagerBase::Connect();
//         //........
//     }
//     virtual void SendMessage(string message){
        
//         PCMessagerBase::PlaySound();
//         //********
//         PCMessagerBase::WriteText();
//         //........
//     }
//     virtual void SendPicture(Image image){
        
//         PCMessagerBase::PlaySound();
//         //********
//         PCMessagerBase::DrawShape();
//         //........
//     }
// };


// class MobileMessagerLite{
//     MessagerBase* messager;//new mobileMessagerBase();
// public:
    
//     virtual void Login(string username, string password){
        
//         messager->Connect();
//         //........
//     }
//     virtual void SendMessage(string message){
        
//         messager->WriteText();
//         //........
//     }
//     virtual void SendPicture(Image image){
        
//         messager->DrawShape();
//         //........
//     }
// };


// class MobileMessagerPerfect : public MobileMessagerBase {
// public:
    
//     virtual void Login(string username, string password){
        
//         MobileMessagerBase::PlaySound();
//         //********
//         MobileMessagerBase::Connect();
//         //........
//     }
//     virtual void SendMessage(string message){
        
//         MobileMessagerBase::PlaySound();
//         //********
//         MobileMessagerBase::WriteText();
//         //........
//     }
//     virtual void SendPicture(Image image){
        
//         MobileMessagerBase::PlaySound();
//         //********
//         MobileMessagerBase::DrawShape();
//         //........
//     }
// };


void Process(){
        //编译时装配
        Messager *m =
            new MobileMessagerPerfect();
}

//继承自同一基类的派生类有相同的字段 将字段向上提


//修改后
//一个类中放了不同的函数 不同的变化方向 一个是平台实现 一个是业务变化方向 不应该放在一个类中 
class Messager{
protected:
     MessagerImp* messagerImp;//...
public:
    virtual void Login(string username, string password)=0;
    virtual void SendMessage(string message)=0;
    virtual void SendPicture(Image image)=0;
    
    virtual ~Messager(){}
};

class MessagerImp{
public:
    virtual void PlaySound()=0;
    virtual void DrawShape()=0;
    virtual void WriteText()=0;
    virtual void Connect()=0;
    
    virtual MessagerImp(){}
};


//平台实现 n
class PCMessagerImp : public MessagerImp{
public:
    
    virtual void PlaySound(){
        //**********
    }
    virtual void DrawShape(){
        //**********
    }
    virtual void WriteText(){
        //**********
    }
    virtual void Connect(){
        //**********
    }
};

class MobileMessagerImp : public MessagerImp{
public:
    
    virtual void PlaySound(){
        //==========
    }
    virtual void DrawShape(){
        //==========
    }
    virtual void WriteText(){
        //==========
    }
    virtual void Connect(){
        //==========
    }
};



//业务抽象 m

//类的数目：1+n+m

class MessagerLite :public Messager {

    
public:
    
    virtual void Login(string username, string password){
        
        messagerImp->Connect();
        //........
    }
    virtual void SendMessage(string message){
        
        messagerImp->WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        
        messagerImp->DrawShape();
        //........
    }
};



class MessagerPerfect  :public Messager {
    
   
public:
    
    virtual void Login(string username, string password){
        
        messagerImp->PlaySound();
        //********
        messagerImp->Connect();
        //........
    }
    virtual void SendMessage(string message){
        
        messagerImp->PlaySound();
        //********
        messagerImp->WriteText();
        //........
    }
    virtual void SendPicture(Image image){
        
        messagerImp->PlaySound();
        //********
        messagerImp->DrawShape();
        //........
    }
};




void Process(){
    //运行时装配
    MessagerImp* mImp=new PCMessagerImp();
    Messager *m =new Messager(mImp);
}

模式定义： 将抽象部分（业务功能）与实现部分（平台实现）分离，使他们都可以独立变化

image-20210507144157498

  • Abstraction——>Messager(里面有一个imp指针指向Implementor) 业务抽象
  • Implementor——>MessagerImp 平台实现
  • RefinedAbstraction——>Lite/Perfect
  • ConcreteImplementor——>PC/Mobile

要点总结：

  1. Bridge模式使用对象间的组合关系解耦了抽象与实现之间的固有绑定关系， 使得抽象和实现可以沿着各自的维度变化。所谓抽象和实现沿着各自维度的变化，即子类化它们
  2. Bridge模式有时候类似于多继承方案 但多继承方案往往违背单一职责原则，复用性差。Bridge模式是比多继承方案更好的解决方法
  3. Bridge模式的应用一般在两个非常强的变化维度，有时一个类也有多于两个的变化维度，这时可以使用Bridge的扩展模式 将不同的变化维度打包成不同的基类
沙diao网友
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
6.装饰模式（Decorator）
qq_35484146的博客
01-23 133
本文讲述了单一职责模式中的装饰模式，介绍了装饰模式的动机、定义、结构、代码实例，最后进行了总结。 再次感谢GeekBand的李建忠老师、GOF等前辈 1. “单一职责”模式: 在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。 典型模式 Decorator 装饰模式 Bridge 2. 动机（Motivation） 在某些情况下我们可能会“过度地使用继承来扩展对象的功能”，由于继承为类型引入了静态特质[.
6、7 单一职责模式（装饰模式、桥模式)
sdsc1314的博客
12-25 118
1.装饰模式（Decorator) ①通过采用组合而非继承的方法，Decorator模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的灵活性差和多子类衍生问题 ②Decorator类在接口上表现为is-a Component的继承关系，即Decorator类继承了Component类所具有的接口。但在实现上又表示为has-a Component的组合关系，即Decorator类又使用另外一个Component类 2.桥模式（Bridge） ...
c++ 设计原则 - 单一职责原则
weixin_45053845的博客
11-12 272
然后，在需要的地方调用 FileCompressor 的方法进行压缩和解压操作，这样就实现了功能的扩展，并且不会影响到原有的文件读取和写入类。通过以上的两个场景，我们可以看到，根据单一职责原则的设计，当需求发生变化时，我们可以独立地扩展或修改相应的类，而不会对其他部分的代码造成影响。设计遵循单一职责原则：每个类只负责一项工作，当需求发生变化时，只需要修改对应的类，而无需影响其他类。当需求发生变化时，根据单一职责原则的设计，我们可以针对不同的需求独立地扩展或修改相应的类，而不会影响其他部分的代码。
【8】c++设计模式——＞单一职责原则
weixin_42097108的博客
10-04 442
如果一个类承担的职责过多，就等于把这些职责耦合到了一起，一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。指的就是将单一事物抽象出来组合成一个类，所以我们在设计类的时候每个类中处理的是单一事物而不是某些事物的集合。让类的功能单一，不让类与具体的事物耦合。软件设计真正要做的事情就是，发现根据需求发现职责，并把这些职责进行分离，添加新的类，给当前类减负，越是这样项目才越容易维护。设计模式中所谓的单一职责原则，就是对一个类而言，应该仅有一个引起它变化的原因，其实就是将这个类所承担的职责单一化。
单一职责原则（C++)
先锋小牛
08-31 1262
概念     就一个类而言，应该仅有一个引起它变化的原因。每个类实现一个功能。 简述     单一职责原则可以看作是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。职责过多，可能引起它变化的原因就越多，这将导致职责依赖，相互之间就产生影响，从而极大的损伤其内聚性和耦合度。单一职责，通常意味着单一的功能，因此不要为类实现过多的功能点，以保证实
C# 设计模式系列教程-装饰模式
09-02
每个装饰对象只关心自己的功能，不需要关心如何被添加到对象链当中。它是由Decorator的SetComponent方法来实现的，因而它们的职责是单一的。
24种设计模式与6大设计原则
最新发布
04-19
策略模式[STRATEGY PATTERN] 代理模式[PROXY PATTERN] 单例模式[SINGLETON PATTERN] 多例模式[MULTITION PATTERN] ...六大设计原则：单一职责原则，里氏替换原则，依赖倒置原则，接口隔离原则，迪米特法则，开闭原则。
尚硅谷设计模式源码笔记课件.zip
08-04
1) 内容包括: 设计模式七大原则(单一职责、接口隔离、依赖倒转、里氏替换、开闭原则、迪米特法则、合成复用)、UML类图(类的依赖、泛化和实现、类的关联、聚合和组合) 23种设计模式包括：创建型模式：单例模式(8种...
设计模式PPT.rar
08-27
01第一讲简单工厂模式 02第二讲工厂方法模式 03第三讲抽象工厂模式 04第四讲工厂模式在开发中的运用 05第五讲单例模式 06第六讲原型模式 07第七讲建造者模式 08第八讲装饰模式 09第九讲策略模式 10第十讲观察者模式 ...
java设计模式
05-08
第1章 单一职责原则 1.1 我是“牛”类，我可以担任多职吗 1.2 绝杀技，打破你的传统思维 1.3 我单纯，所以我快乐 1.4 最佳实践 第2章 里氏替换原则 2.1 爱恨纠葛的父子关系 2.2 纠纷不断，规则压制 2.3 最佳实践 第3...
c++ 面向对象设计五大原则
12-17
面向对象设计（OOD）是面向对象编程（OOP）必不可少的一个环节，只有好的设计，才能保障程序的质量。面向对象设计的主要任务就是类的设计，不少面向对象（OO）的先驱和前辈已经提出了很多关于类的设计原则，用于指导OOP，其中就包括类设计的五项基本原则。 1.单一职责原则（Single Resposibility Principle，SRP） 专注是一个人的优良品质，同样，单一职责也是一个类的优良设计。单一职责的核心思想：一个类只做好一件事情。 单一职责原则可以看作是高内聚、低耦合在面向对象原则上的引申。类的职责过多，容易导致类间职责依赖，提高耦合度，降低内聚性。通常意义下的单一职责，指的是类只有一
单一职责原则
Andrew's Blog
08-17 154
设计模式学习之单一职责原则
设计模式（一）：单一职责原则
工作学习记录
06-19 768
Single Responsibility Principle(SRP): There should never be more than one reason for a class to change. 单一职责原则的定义：应该有且只有一个原因导致类的变更。 按照字面意思理解，一个类应该只有一个功能才符合单一职责原则。 单一职责原则的好处： 1.因为只有一个职责，类的复
【学习笔记】C++下的单一职责原则（程杰-大话设计模式）
野生C++程序员
06-13 251
《大话设计模式》单一职责原则学习笔记
桥接模式和装饰者模式的区别及理解
夏虫的博客
12-01 3526
一、桥接模式 桥接模式必须由一方使用抽象类，持有使用接口的一方。 二、装饰者模式 从外观上看装饰者模式和桥接模式的类图只有一个地方不一样，就是最上边的接口和抽象类间的关系，装饰者模式是实现接口，桥接是以组合的方式持有接口。 三、两种模式的区别 桥接模式之所以能够解决类爆炸问题，就是因为相互直接接触的是接口和抽象类，其实每一个接口或者抽象类后背都可以看成是无数数目的不同类别的对象。于是各自拿出/删除对象就可以解决问题，如下图，就是想要哪两个货物结合，比如要A1、B1，那就直接通过商人交换就OK了，重点在于
常用设计者模式---装饰模式和桥接模式
静下心来吧，让自己变强大点！
02-15 2372
装饰模式 定义：动态给一个对象添加一些额外的职责,就象在墙上刷油漆.使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活。 要点：装饰者与被装饰者拥有共同的超类，继承的目的是继承类型，而不是行为 下面这个例子也有助于理解 装饰的流程和作用 现在需要一个汉堡，主体是鸡腿堡，可以选择添加生菜、酱、辣椒等等许多其他的配料，这种情况下就可以使用装饰者模式。 http:/
以C/C++语法浅谈六大设计原则（三）——单一职责原则（Single Responsibility Principle）
尘海折柳的博客
01-15 1115
单一职责原则(Single Responsibility Principle, SRP)：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。 简述：单一职责原则(Single Responsibility Principle, SRP)可以看作是低耦合、高内聚在面向对象原则上的引申与扩展，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因...
《大话设计模式》读书笔记之C++实现--chapter3单一职责原则
WingC的博客
03-30 458
单一职责的原则准确解释为：“就一个类来说，应该仅有一个引起它变化的原因”。如果一个类承担的职责过多，就相当于把这些职责耦合在一起，一个职责的变化可能会抑制或削弱这个类完成其他职责的能力。当变化发生时，设计会受到意想不到的破坏。 举一个例子来说，俄罗斯方块的游戏逻辑和界面应该分开，当移植到不同平台上时，游戏逻辑代码本身不会发生改动，仅需要对界面部分作出修改。如果你能想到多余一个的动机去改变类，那么
3.4 设计模式 ————————单一职责原则——面向对象设计原则
ice
08-17 153
单一职责原则也是面向对象设计原则中的一条，下面我们就来详细地对其进行介绍。 单一职责原则的定义 单一职责原则（Single Responsibility Principle，SRP）又称单一功能原则，由罗伯特·C.马丁（Robert C. Martin）于《敏捷软件开发：原则、模式和实践》一书中提出的。这里的职责是指类变化的原因，单一职责原则规定一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分（There should never be more than one reason for a cl
23种设计模式中符合单一职责原则的设计模式有哪些
06-08
在23种设计模式中，符合单一职责原则的设计模式有以下几种： 1. 简单工厂模式 2. 工厂方法模式 3. 抽象工厂模式 4. 单例模式 5. 原型模式 6. 适配器模式 7. 装饰器模式 8. 代理模式 9. 桥接模式 10. 组合模式 11. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值