首页 > 其他分享 >设计模式 -- Decorator（装饰模式）

设计模式 -- Decorator（装饰模式）

时间：2022-09-20 19:00:28浏览次数：51  
标签：... 加密 -- void char int 设计模式 public Decorator

装饰模式(Decorator)

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

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

原先

在下面有一组伪代码，这组伪代码主要我i饿了描述一些流的操作，比如文件流、网络流、内存流

此时、当我需要通过继承扩展一些功能时、例如扩展加密和缓存操作时

// 一个流的基类
interface Stream {
    char Read(int number);

    void Seek(int position);

    void Write(char data);
};

// 文件流
class FileStream implements Stream {
    public char Read(int number){
        //读文件流
        char read = 0;
        // ...
        return read;
    }
    public void Seek(int position){
        //定位文件流
        // ...
    }
    public void Write(char data){
        //写文件流
        // ...
    }
};

// 网络流
class NetworkStream implements Stream {
    public char Read(int number){
        //读网络流
        char read = 0;
        // ...
        return read;
    }
    public void Seek(int position){
        //定位网络流
        // ...
    }
    public void Write(char data){
        //写网络流
        // ...
    }
};

class MemoryStream implements Stream {
    public char Read(int number){
        //读内存流
        char read = 0;
        // ...
        return read;
    }
    public void Seek(int position){
        //定位内存流
        // ...
    }
    public void Write(char data){
        //写内存流
        // ...
    }
};

// 扩展文件流加密类
class CryptoFileStream extends FileStream{
    public char Read(int number){
        //额外的加密操作...

        //读文件流
        return super.Read(number);
    }
    public void Seek(int position){
        //额外的加密操作...
        super.Seek(position); // 定位文件流
        //额外的加密操作...
    }
    public void Write(char data){
        //额外的加密操作...
        super.Write(data); // 写文件流
        //额外的加密操作...
    }
};

// 扩展网络流加密类
class CryptoNetworkStream extends NetworkStream {
    public char Read(int number){
        //额外的加密操作...
        return super.Read(number); //读网络流
    }

    public void Seek(int position){
        //额外的加密操作...
        super.Seek(position); //定位网络流
        //额外的加密操作...
    }

    public void Write(char data){
        //额外的加密操作...
        super.Write(data);//写网络流
        //额外的加密操作...
    }
};

// 扩展内存流加密类
class CryptoMemoryStream extends MemoryStream {
    public char Read(int number){
        //额外的加密操作...
        return super.Read(number); // 读内存流
    }

    public void Seek(int position){
        //额外的加密操作...
        super.Seek(position); //定位内存流
        //额外的加密操作...
    }

    public void Write(char data){
        //额外的加密操作...
        super.Write(data);//写内存流
        //额外的加密操作...
    }
};

// 扩展文件流缓存类
class BufferedFileStream extends FileStream{
    //...
};

// 扩展网络流缓存类
class BufferedNetworkStream extends NetworkStream{
    //...
};

// 扩展内存流缓存类
class BufferedMemoryStream extends MemoryStream{
    //...
}

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

此时我们可以看到、当我们需要通过继承扩展时、都需要重新实现一遍操作、其实、文件流、网络流、内存流都继承了Stream流、只需写一个扩展类操作Stream流这个接口即可、不通过继承的方式、而是通过对象组合的方式。

重构

// 一个流的基类
interface Stream {
    char Read(int number);

    void Seek(int position);

    void Write(char data);
};

// 文件流
class FileStream implements Stream {
    public char Read(int number){
        //读文件流
        char read = 0;
        // ...
        return read;
    }
    public void Seek(int position){
        //定位文件流
        // ...
    }
    public void Write(char data){
        //写文件流
        // ...
    }
};

// 网络流
class NetworkStream implements Stream {
    public char Read(int number){
        //读网络流
        char read = 0;
        // ...
        return read;
    }
    public void Seek(int position){
        //定位网络流
        // ...
    }
    public void Write(char data){
        //写网络流
        // ...
    }
};

class MemoryStream implements Stream {
    public char Read(int number){
        //读内存流
        char read = 0;
        // ...
        return read;
    }
    public void Seek(int position){
        //定位内存流
        // ...
    }
    public void Write(char data){
        //写内存流
        // ...
    }
};

// 扩展加密
class CryptoStream implements Stream {

    private Stream stream; //...

    CryptoStream(Stream stream) {
        this.stream = stream;
    }

    public char Read(int number){
        //额外的加密操作...
        return stream.Read(number);//读文件流
    }
    public void Seek(int position){
        //额外的加密操作...
        stream.Seek(position);//定位文件流
        //额外的加密操作...
    }
    public void Write(char data){
        //额外的加密操作...
        stream.Write(data);//写文件流
        //额外的加密操作...
    }
};

class BufferedStream implements Stream{

    private Stream stream;//...

    BufferedStream(Stream stream) {
        this.stream = stream;
    }

    public char Read(int number) {
        // 缓存操作 ...
        return stream.Read(number);
    }

    public void Seek(int position) {
        // 缓存操作 ...
        stream.Seek(position);
    }

    public void Write(char data) {
        // 缓存操作 ...
        stream.Write(data);
    }
};

重构后扩展只需要写一个类传入Stream接口多态操作即可、现在每个扩展类都需要写构造函数传入Stream、可以写一个父类继承如下：

// 一个流的基类
interface Stream {
    char Read(int number);

    void Seek(int position);

    void Write(char data);
};

// 文件流
class FileStream implements Stream {
    public char Read(int number){
        //读文件流
        char read = 0;
        // ...
        return read;
    }
    public void Seek(int position){
        //定位文件流
        // ...
    }
    public void Write(char data){
        //写文件流
        // ...
    }
};

// 网络流
class NetworkStream implements Stream {
    public char Read(int number){
        //读网络流
        char read = 0;
        // ...
        return read;
    }
    public void Seek(int position){
        //定位网络流
        // ...
    }
    public void Write(char data){
        //写网络流
        // ...
    }
};

class MemoryStream implements Stream {
    public char Read(int number){
        //读内存流
        char read = 0;
        // ...
        return read;
    }
    public void Seek(int position){
        //定位内存流
        // ...
    }
    public void Write(char data){
        //写内存流
        // ...
    }
};

// 装饰模式
abstract class DecoratorStream implements Stream {
    protected Stream stream;

    DecoratorStream(Stream stream) {
        this.stream = stream;
    }
}

// 扩展加密
class CryptoStream extends DecoratorStream {
    CryptoStream(Stream stream) {
        super(stream);
    }

    public char Read(int number){
        //额外的加密操作...
        return stream.Read(number);//读文件流
    }
    public void Seek(int position){
        //额外的加密操作...
        stream.Seek(position);//定位文件流
        //额外的加密操作...
    }
    public void Write(char data){
        //额外的加密操作...
        stream.Write(data);//写文件流
        //额外的加密操作...
    }
};

// 扩展缓存
class BufferedStream extends DecoratorStream{
    BufferedStream(Stream stream) {
        super(stream);
    }

    public char Read(int number) {
        // 缓存操作 ...
        return stream.Read(number);
    }

    public void Seek(int position) {
        // 缓存操作 ...
        stream.Seek(position);
    }

    public void Write(char data) {
        // 缓存操作 ...
        stream.Write(data);
    }
};

// 使用
public class Main {
    @Test
    public void T1() {
        // 文件流
        FileStream fileStream = new FileStream();
        // 扩展加密流
        CryptoStream cryptoStream = new CryptoStream(fileStream);
        // 此时、缓存流又拥有了加密流的功能
        BufferedStream bufferedStream = new BufferedStream(cryptoStream);
    }
}

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

要点总结

  • 通过采用组合而非继承的手法，Decorator模式实现了在运动时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用集成带来的“灵活性差”和“多子类衍生的问题”
  • Decorator类在接口上变现为is-a Component的继承关系，即Decorator类集成了Component类所具有的接口。但在实现上又表现为has-a Component的组合关系，即Decorator类又使用了另外一个Component类。
  • Decorator模式的目的并非解决“多子类衍生的多继承”问题，Decorator模式应用的重要点在于解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义。
  • 当我们看到一个类的字段类型和父类相同时、那么大概率这个类是应用了装饰模式的

标签：...,加密,--,void,char,int,设计模式,public,Decorator
From： https://www.cnblogs.com/tie-dao/p/16712152.html

相关文章

  • 个人职业规划
    一、自我介绍我是软件工程11班的一名学生，我叫伍晓叶，来自湖南益阳，之前就读于湖南机电职业技术学院。通过大专三年的学习和一段时间的实习经历，让我知道到了自己对于Java专业......
  • 实验2：Open vSwitch虚拟交换机实践
    实验目的1.能够对OpenvSwitch进行基本操作；2.能够通过命令行终端使用OVS命令操作OpenvSwitch交换机，管理流表；3.能够通过Mininet的Python代码运行OVS命令，控制网络拓扑中......
  • Linux入门
    一、Linux介绍1、Linux的优点，优势一切都是一个文件，连配置文件都储存在文本中，方便增删改查系统中拥有小型，单一用途的程序当遇到复杂任务，通过不同功能用途的程序组合起......
  • 01 uniapp/微信小程序 项目day01
    一.起步1.1配置uni-app开发环境什么是uni-app，就是基于vue的一个开发框架，可以将我们写的一套代码，同时发布到ios、安卓、小程序等多个平台官方推荐使用Hbuilderx来写uni......
  • 华氏——摄氏温度转化表
    #include<stdio.h>intmain(void){intfahr,lower,upper;doublecelsius;printf("Enterlower:");scanf("%d",&lower);printf("Enterupper:");sc......
  • 报告分享|数据变现，车企利润新增长点
    报告链接：http://tecdat.cn/?p=28549梳理客户在系统内的行为数据，整合第三方数据（社交、电商、电信等），勾勒客户画像，产出用户洞察。由此设计各个客户群体在市场营销、销售、售......
  • dd测试读写实时查看带宽输出
    测试ssd带宽写盘操作:sudoddif=/dev/zeroof=./test1.datbs=8kcount=70000000conv=fdatasyncps查看对应线程ID,然后使用命令kill-10ID即可查看磁盘温度:su......
  • 容斥与反演技巧（一）
    二项式反演我们直接上式子好了一般有两种形式，第一种是\[f(n)=\sum_{i=0}^n\binom{n}{i}g(i)\iffg(n)=\sum_{i=0}^n(-1)^{n-i}\binom{n}{i}f(i)\]第二种是\[f(n)=\sum......
  • 报告分享|2022年中国零售数字化白皮书
    报告链接：http://tecdat.cn/?p=28557白皮书详细分析了中国零售业数字化转型现状，揭示了正在重塑中国零售市场的四大主要趋势，并从中提炼出对零售企业的关键启示。过去十年，中......
  • 2022中国消费者智能网联汽车数据安全和个人隐私意识与顾虑调查报告
    报告链接：http://tecdat.cn/?p=28552 该调查于2021年11月至12月通过《环球时报》和君迪微信公众号进行样本收集，重点研究了消费者对智能网联汽车数据安全的认知、信心和担......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99