zoukankan      html  css  js  c++  java
  • 装饰模式

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

    典型模式
    .Decorator
    .Bridge

    1.Decorator模式

    代码1:

    //业务操作
    class Stream{
        virtual char Read(int number) = 0;
        virtual char Seek(int position) = 0;
        virtual char Write(int data) = 0;
    
        virtual ~Stream(){}
    };
    
    //主类体
    class FileStream :public Stream{
    public:
        virtual char Read(int number){
            //读文件流
        }
        virtual char Seek(int position){
            //定位文件流
        }
        virtual char Write(int data){
            //写文件流
        }
    };
    
    class NetworkStream :public Stream{
    public:
        virtual char Read(int number){
            //读文件流
        }
        virtual char Seek(int position){
            //定位网络流
        }
        virtual char Write(int data){
            //写文件流
        }
    };
    
    class MemoryStream :public Stream{
    public:
        virtual char Read(int number){
            //读文件流
        }
        virtual char Seek(int position){
            //定位内存流
        }
        virtual char Write(int data){
            //写文件流
        }
    };
    
    //扩展操作
    class CryptoFileStream :public FileStream{
    public:
        virtual char Read(int number){
    
            //额外的加密操作....
            FileStream::Read(number);//读文件流
        }
        virtual char Seek(int position){ 
    
            //额外的加密操作....
            FileStream::Seek(position);//定位文件流
            //额外的加密操作....
        }
        virtual char Write(int data){
            
            //额外的加密操作....
            FileStream::Write(data);//写文件流
            //额外的加密操作....
        }
    };
    
    class BufferedFileSyream :public FileStream{
        //...
    };
    
    class BufferedNetWorkStream :public NetworkStream{
    
    };
    
    class BufferedMemoryStream : public MemoryStream{
    
    };
    
    class CryptoBuffedFileStream :public FileStream{
    public:
        virtual char Read(int number){
            //额外的加密操作
            //额外的缓冲操作
            FileStream::Read(number);//读文件流
        }
        virtual char Seek(int position){ 
            //额外的加密操作
            //额外的缓冲操作
            FileStream::Seek(position);//定位内存流
        }
        virtual char Write(int data){ 
            //额外的加密操作
            //额外的缓冲操作
            FileStream::Write(data);//写文件流
        }
    };
    
    void Process()
    {
        //编译时装配
        CryptoFileStream* fs1 = new CryptoFileStream;
        BufferedFileSyream *fs2 = new BufferedFileSyream;
        CryptoBuffedFileStream* fs3 = new CryptoBuffedFileStream;
    
    }

    该代码有什么问题?

    冗余度太高!

    示意图:

     

    该类的规模有多少?

    1+n+n*m!/2

    很明显,规模太大,在之后的维护中会占很大的时间

    因此,为了消除冗余,使用装饰模型来修改上面的代码

    代码2:

    //业务操作
    class Stream{
        virtual char Read(int number) = 0;
        virtual char Seek(int position) = 0;
        virtual char Write(int data) = 0;
    
        virtual ~Stream(){}
    };
    
    //主类体
    class FileStream :public Stream{
    public:
        virtual char Read(int number){
            //读文件流
        }
        virtual char Seek(int position){
            //定位文件流
        }
        virtual char Write(int data){
            //写文件流
        }
    };
    
    class NetworkStream :public Stream{
    public:
        virtual char Read(int number){
            //读文件流
        }
        virtual char Seek(int position){
            //定位网络流
        }
        virtual char Write(int data){
            //写文件流
        }
    };
    
    class MemoryStream :public Stream{
    public:
        virtual char Read(int number){
            //读文件流
        }
        virtual char Seek(int position){
            //定位内存流
        }
        virtual char Write(int data){
            //写文件流
        }
    };
    
    //扩展操作
    //当一个变量的声明类型都是某个类型的子类时候,那么把他声明为某个类型就可以了
    class DecoratorStream:public Stream{
    protected:
        Stream* stream;
        DecoratorStream(Stream stm) :stream(stm){    //构造器
    
        }
    }
    
    class CryptoStream :public DecoratorStream{
    public:
        CryptoStream(Stream stm) :stream(stm){    //构造器
    
        }
    
    
        virtual char Read(int number){
    
            //额外的加密操作....
            stream->Read(number);//读文件流
        }
        virtual char Seek(int position){
    
            //额外的加密操作....
            stream->Seek(position);//定位文件流
            //额外的加密操作....
        }
        virtual char Write(int data){
    
            //额外的加密操作....
            stream->Write(data);//写文件流
            //额外的加密操作....
        }
    };
    
    class BufferedSyream :public DecoratorStream{
    
        //...
    public:
        BufferedSyream(Stream stm) :stream(stm){    //构造器
    
        }
    };
    
    
    class CryptoBuffedFileStream :public FileStream{
    public:
        virtual char Read(int number){
            //额外的加密操作
            //额外的缓冲操作
            FileStream::Read(number);//读文件流
        }
        virtual char Seek(int position){
            //额外的加密操作
            //额外的缓冲操作
            FileStream::Seek(position);//定位内存流
        }
        virtual char Write(int data){
            //额外的加密操作
            //额外的缓冲操作
            FileStream::Write(data);//写文件流
        }
    };
    
    void Process()
    {
        //编译时装配
        FileStream* s1 = new FileStream();
        CryptoStream* s2 = new CryptoStream(s1);
        BufferedSyream* s3 = new BufferedSyream(s1);
        BufferedSyream* s4 = new BufferedSyream(s2);
    }

    示意图:

    代码的规模为:1+n+1+m

    已经达到了要求!

     

  • 相关阅读:
    WPF Caliburn 学习笔记(五)HelloCaliburn
    MSDN 教程短片 WPF 20(绑定3ObjectDataProvider)
    MSDN 教程短片 WPF 23(3D动画)
    比赛总结一
    HDU3686 Traffic Real Time Query System
    HDU3954 Level up
    EOJ382 Match Maker
    UESTC1565 Smart Typist
    HDU3578 Greedy Tino
    ZOJ1975 The Sierpinski Fractal
  • 原文地址:https://www.cnblogs.com/zhuifeng-mayi/p/11059454.html
Copyright © 2011-2022 走看看