设计模式（5）——单一职责模式（1）——装饰模式

最新推荐文章于 2022-11-24 14:58:29 发布
最新推荐文章于 2022-11-24 14:58:29 发布
阅读量264 收藏
点赞数
分类专栏： Java设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34805255/article/details/96350539
版权

目录

0.单一职责模式

1.基本介绍

2.动机

3.类图

4.案例

案例1：IO流操作

普通实现：

装饰模式重构上述代码实现：

案例2：星巴克咖啡订单项目

方案1：

方案2：

方案3：使用装饰者模式进行重构

5.源码分析

6.总结

0.单一职责模式

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

典型：

  • 装饰模式（Decorator）
  • 桥接模式（Bridge）

1.基本介绍

定义：

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

装饰者模式体现了开放封闭原则（OCP原则）

2.动机

  • 在某些情况下我们可能会“过度地使用继承来扩展对象地功能”，由于继承为类型引入的静态特质（比如下述案例1中CryptoFIleStream类中读文件流、定位文件流、写文件流都是固定的代码，不会改变），使得这种扩展方式缺乏灵活性；并且随着子列的增多（扩展功能的增多），各种子类的组合（扩展功能的组合）会导致更多子类的膨胀
  • 如何使“对象功能的扩展”能够根据需要来动态地实现？同时避免“扩展功能的增多”带来的子类膨胀问题？从而使得任何“功能扩展变化”所导致的影响降为最低？

3.类图

原理：

装饰者模式总是包含主体和包装（即在主体上的扩展功能），用打包一个快递解释

  • 主体：比如我们要打包的衣服、陶瓷（被装饰者ConcreteComponent）
  • 包装：包装主体的方式，比如报纸填充，塑料泡沫、纸板（装饰者Decorator）

装饰者模式的核心：

  • 装饰者既继承了主体的接口，又组合了主体接口，
  • 这样他就能重写主体的方法（因为继承），并且在重写的方法上调用主体对应方法（因为组合），
  • 这样重写的同时在调用主体方法的前后都可以灵活地添加自己的代码

注意：

  • 在如图的Component与ConcreteComponent之间，如果ConcreteComponent类很多，还可以设计一个缓冲层，将共有的部分提取出来，抽象是一个类

4.案例

案例1：IO流操作

普通实现：

package cn.cqu.decorator;

public interface Stream {

    char read(int number);
    void seek(int position);
    void write(char data);
}

package cn.cqu.decorator;

public class FileStream implements Stream{

    @Override
    public char read(int number) {
        //读文件流
        return 0;
    }

    @Override
    public void seek(int position) {
        //定位文件流
    }

    @Override
    public void write(char data) {
        //写文件流
    }
}

package cn.cqu.decorator;

public class NetworkStream implements Stream{
    @Override
    public char read(int number) {
        //读网络流
        return 0;
    }

    @Override
    public void seek(int position) {
        //定位网络流
    }

    @Override
    public void write(char data) {
        //写网络流
    }
}

package cn.cqu.decorator;

public class CryptoFIleStream  extends FileStream{

    @Override
    public char read(int number) {

        //额外的加密操作

        super.read(number);//读文件流
        return 0;
    }

    @Override
    public void seek(int position) {
        //额外的加密操作

        super.seek(position);//定位文件流

        //额外的加密操作
    }

    @Override
    public void write(char data) {
        //额外的加密操作

        super.write(data);//写文件流

        //额外的加密操作
    }
}

package cn.cqu.decorator;

public class CryptoNetworkStream  extends NetworkStream{

    @Override
    public char read(int number) {

        //额外的加密操作

        super.read(number);//读网络流
        return 0;
    }

    @Override
    public void seek(int position) {
        //额外的加密操作

        super.seek(position);//定位网络流

        //额外的加密操作
    }

    @Override
    public void write(char data) {
        //额外的加密操作

        super.write(data);//写网络流

        //额外的加密操作
    }
}
package cn.cqu.decorator;

public class CryptoBufferedFIleStream  extends FileStream{

    @Override
    public char read(int number) {

        //额外的缓冲操作
        //额外的加密操作

        super.read(number);//读文件流
        return 0;
    }

    @Override
    public void seek(int position) {
        //额外的缓冲操作
        //额外的加密操作

        super.seek(position);

        //额外的加密操作
    }

    @Override
    public void write(char data) {
        //额外的缓冲操作
        //额外的加密操作

        super.write(data);

        //额外的加密操作
    }
}


package cn.cqu.decorator;

public class CryptoBufferedNetworkStream  extends FileStream{

    @Override
    public char read(int number) {

        //额外的缓冲操作
        //额外的加密操作

        super.read(number);//读网络流
        return 0;
    }

    @Override
    public void seek(int position) {
        //额外的缓冲操作
        //额外的加密操作

        super.seek(position);//定位网络流

        //额外的加密操作
    }

    @Override
    public void write(char data) {
        //额外的缓冲操作
        //额外的加密操作

        super.write(data);//写网络流

        //额外的加密操作
    }
}

上述代码大致继承体系：

n表示主体类的数量，m表示装饰者的数量

分析问题：

  • 1.因为部分扩展功能，整个继承体系变得异常庞大
  • 2.代码重复性很高，比如CryptoFIleStream中的加密操作都是相同的代码，CryptoBufferedFIleStream中的缓冲操作和加密操作在read、seek、write方法中都是相同的代码

装饰模式重构上述代码实现：

Stream.java

package cn.cqu.decorator;

public abstract class Stream {

    abstract char read(int number);
    abstract void seek(int position);
    abstract void write(char data);
}

主体类
FileStream.java

package cn.cqu.decorator;

public class FileStream extends Stream{

    @Override
    public char read(int number) {
        //读文件流
        return 0;
    }

    @Override
    public void seek(int position) {
        //定位文件流
    }

    @Override
    public void write(char data) {
        //写文件流
    }
}

NetworkStream.java

package cn.cqu.decorator;

public class NetworkStream extends Stream{
    @Override
    public char read(int number) {
        //读网络流
        return 0;
    }

    @Override
    public void seek(int position) {
        //定位网络流
    }

    @Override
    public void write(char data) {
        //写网络流
    }
}

装饰类

DecoratorStream.java

package cn.cqu.decorator;

public abstract class DecoratorStream extends Stream{
    protected Stream stream;

}

 CryptoStream.java

package cn.cqu.decorator;

public class CryptoStream extends DecoratorStream{

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

    @Override
    public char read(int number) {

        //额外的加密操作

        stream.read(number);//读文件流
        return 0;
    }

    @Override
    public void seek(int position) {
        //额外的加密操作

        stream.seek(position);

        //额外的加密操作
    }

    @Override
    public void write(char data) {
        //额外的加密操作

        stream.write(data);

        //额外的加密操作
    }
}

BufferedStream.java 

package cn.cqu.decorator;

public class BufferedStream  extends DecoratorStream{
    public BufferedStream(Stream stream){
        this.stream = stream;
    }

    @Override
    public char read(int number) {

        //额外的缓冲操作

        stream.read(number);//读文件流
        return 0;
    }

    @Override
    public void seek(int position) {
        //额外的缓冲操作

        stream.seek(position);

    }

    @Override
    public void write(char data) {
        //额外的缓冲操作

        stream.write(data);

    }
}

客户端：

package cn.cqu.decorator;

public class Client {

    public static void main(String[] args) {

        //定义一个文件流
        FileStream fileStream = new FileStream();
        //加密文件流（对于扩展操作即装饰，需要传入一个被装饰者即主体）
        CryptoStream cryptoStream = new CryptoStream(fileStream);
        //给加密后的文件流加入缓冲操作
        BufferedStream bufferedStream01 = new BufferedStream(fileStream);

        //加密缓冲文件流
        BufferedStream bufferedStream02 = new BufferedStream(cryptoStream);

    }
}

上述代码大致继承体系：

案例2：星巴克咖啡订单项目

  • 1.咖啡种类/单品咖啡：Espresso（意大利浓咖啡）、ShortBlack、LongBlack（美式咖啡）、Decat（无因咖啡）
  • 2.调料：Milk、Soya、Chocolate
  • 3.要求在扩展新的咖啡种类时，具有良好的扩展性、改动方便、维护方便
  • 4.使用OO的来计算不同种类咖啡的费用：客户可以点单品咖啡，也可以点单品咖啡+调料组合

方案1：

 

解释：

  • 1.Drink是一个抽象类，表示饮料
  • 2.des就是对咖啡的描述，比如咖啡的名字
  • 3.cost()方法就是计算费用，Drink类中做成一个抽象方法
  • 4.Decaf就是单品咖啡，继承Drink
  • 5.Espress&&Milk就是单品咖啡+调料，这个组合很多

问题分析：

  • 这样设计，会有很多类，当我们增加一个单品咖啡或者一个新的调料时，类的数量就会倍增，就会出现类爆炸

方案2：

  • 方案1中因为咖啡单品+调料组合会造成类的倍增，因此可以做改进，将调料内置到Drink类，这样就不会造成类数量过多，从而提高项目的维护性

可以将milk、soy、chocolate设计成int，代表要加几份对应的调料

分析问题：

虽然使类的数量降低，但是还是存在问题

  • 在子类中添加或删除种类时，每个都需要去写是否需要添加每种调料的代码，代码的维护量很大（每个子类都需要维护，我们又“闻到了重复代码的味道”）
  • 增加新的调料种类时，既要修改父类，又要修改子类，违背了开放封闭原则

方案3：使用装饰者模式进行重构

代码实现：

Drink.java

package cn.cqu.decorator2;

public abstract class Drink {

    public String des;//描述
    private float price = 0.0f;

    public String getDes() {
        return des;
    }

    public void setDes(String des) {
        this.des = des;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    /**
     * 计算费用的抽象方法
     * 子类来实现
     */
    public abstract float cost();
}

coffee包下：

Coffee.java

package cn.cqu.decorator2.coffee;

import cn.cqu.decorator2.Drink;

public class Coffee extends Drink {

    @Override
    public float cost() {

        return super.getPrice();
    }
}

Espresso.java

package cn.cqu.decorator2.coffee;


public class Espresso extends Coffee {

    public Espresso(){
        setDes("意大利咖啡");
        setPrice(16.0f);
    }
}

LongBlack.java

package cn.cqu.decorator2.coffee;


public class LongBlack extends Coffee {

    public LongBlack(){
        setDes(" longblack ");
        setPrice(15.0f);
    }
}

ShortBlack.java

package cn.cqu.decorator2.coffee;


public class ShortBlack extends Coffee {
    public ShortBlack() {
        setDes(" shortblack ");
        setPrice(14.0f);
    }
}

decorator包下：

Decorator.java

package cn.cqu.decorator2.decorator;

import cn.cqu.decorator2.Drink;

public class Decorator extends Drink {
    private Drink drink;

    public Decorator(Drink drink){
        this.drink = drink;
    }

    @Override
    public float cost() {
        return super.getPrice()+drink.cost();
    }

    //输出被装饰者的描述信息
    @Override
    public String getDes(){
        return super.des + " " + super.getPrice() + "&&" +drink.getDes();
    }
}

Chocolate.java

package cn.cqu.decorator2.decorator;

import cn.cqu.decorator2.Drink;

public class Chocolate extends Decorator {
    public Chocolate(Drink drink) {
        super(drink);
        setDes("巧克力");
        setPrice(3.0f);//调味品的价格
    }
}

Milk.java

package cn.cqu.decorator2.decorator;

import cn.cqu.decorator2.Drink;

public class Milk extends Decorator {
    public Milk(Drink drink) {
        super(drink);
        setDes("牛奶");
        setPrice(2.0f);
    }
}

Soy.java

package cn.cqu.decorator2.decorator;

import cn.cqu.decorator2.Drink;

public class Soy extends Decorator {
    public Soy(Drink drink) {
        super(drink);
        setDes("豆浆");
        setPrice(1.5f);
    }
}

客户端：

CoffeeBar.java

package cn.cqu.decorator2;

import cn.cqu.decorator2.coffee.LongBlack;
import cn.cqu.decorator2.decorator.Chocolate;
import cn.cqu.decorator2.decorator.Milk;

public class CoffeeBar {

    public static void main(String[] args) {
        System.out.println("========================");
        //1.点一份longback
        Drink order = new LongBlack();
        System.out.println("点一份longback费用："+order.cost());
        System.out.println("点一份longback描述="+order.getDes());

        System.out.println("========================");
        //2.加入一份牛奶
        order = new Milk(order);
        System.out.println("加入一份牛奶费用："+order.cost());
        System.out.println("加入一份牛奶描述="+order.getDes());

        System.out.println("========================");
        //3.加入一份巧克力
        order = new Chocolate(order);
        System.out.println("加入一份巧克力费用："+order.cost());
        System.out.println("加入一份巧克力描述="+order.getDes());

        System.out.println("========================");
        //4.加入第二份巧克力
        order = new Chocolate(order);
        System.out.println("加入第二份巧克力费用："+order.cost());
        System.out.println("加入第二份巧克力描述="+order.getDes());

        System.out.println("========================");

    }
}

这种实现方式，不管我们是要新增coffee（主体）还是配料（装饰者）都只需要添加类，其他代码根本不需要去修改，符合开放封闭原则

5.源码分析

  • InputStream是抽象类，相当于我们上述案例2中的Drink
  • FileStream继承了InputStream，是主体对象（被装饰者）
  • FilterInputStream既继承了InputStream，也组合了InputStream，是装饰者，类似于案例2中的Decorator
  • DataInputStream是FilterInputStream的子类，具体的修饰者，类似于案例中的Milk、Soy等

6.总结

  • 1.通过采用组合而非继承的手法，Decorator模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能，避免了使用继承带来的“灵活性差”和“多子类衍生问题”
  • 2.Decorator类在接口上表现为is-a Component的继承关系，即Decorator继承了Component类的所有接口，但在实现上有表现为has-a Component的组合关系，即Decorator类又使用了另一个Component类
  • 3.Decorator模式的目的并非解决“多子类衍生的多继承问题”，Decorator模式应用的要点在于解决“主体类在多个方向上的扩展功能”——即为“装饰”的含义
喵的波波鱼
关注
专栏目录
47 | Java连接 Mysql
微信号：RunsenLiu
06-06 975
首先，确保你已经安装了Maven。修改上述程序，将数据库连接信息（URL、用户名、密码）存储在配置文件中，并使用。使用Maven构建Java项目是一种常见的方式，而且非常便于管理依赖项。修改上述程序，向数据库插入一条新记录，并查询该记录以验证插入是否成功。目录下创建Java类，用于连接MySQL数据库和执行查询操作。这会告诉Maven在构建项目时下载MySQL JDBC驱动。文件中，添加MySQL JDBC依赖项。类，连接到MySQL数据库并执行查询。这将编译你的项目并运行。
JAVA 设计模式—————— 命令模式和职责链模式
weixin_46410481的博客
11-22 972
学习 Netty 前的准备工作！！ 这里，还是先来复习一下 OOP （面向对象）的七大原则： 开闭原则：对扩展开放，对修改关闭 里氏替换原则：继承必须确保超类所拥有的性质在子类中仍然成立。 依赖倒置原则：要面向接口编程，不要面向实现编程 单一职责原则：要控制类的粒度大小，将对象解耦，提高其内聚性 接口隔离原则：要为各个类创建它们需要的专用接口 迪米特法则：尽量先使用合并或者聚合等关联关系来实现，其次才考虑使用继承关系来实现 命令模式（详解版） 在软件开发系统中，方法的请求者 与 方法的实现者之间经常存在
单一职责模式——装饰模式
dongdong7_77的博客
11-13 83
单一职责模式 在软件组件设计中，如果责任划分的不清晰，使用继承得到的结果往往是随需求的变化，子类极具膨胀，同时充斥着重复代码，这时候关键是划清责任 装饰模式 桥模式 动机 在某些情况下我们可能会“过度地使用继承l来扩展对象的功能”，由于继承为类型引入静态特性，使得这种扩展方式缺乏灵活性，并且伴随着子类的增多（扩展功能的增多），各种子类组合（扩展功能组合）会导致更多子类的膨胀 问题代码 //业务操作 class Stream{ public： virtual char Read(int numbe
Java IO 装饰者模式
weixin_33750452的博客
02-12 124
Java IO 装饰者模式 装饰模式（Decorator） 　　装饰模式又名包装（Wrapper）模式。 　　装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。 　　装饰模式通过创建一个包装对象，也就是装饰，来包裹真实的对象。 　　装饰模式以对客户端透明的方式动态地给一个对象附加上更多的责任。换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同。 　　装饰模式可以...
装饰者模式 java io_关于 Java IO（一）：装饰模式
weixin_39895486的博客
02-12 221
Java 的 IO 系统采用了装饰器设计模式。其 IO 分为面向字节和面向字符两种，面向字节以字节为输入输出单位，面向字符以字符为输入输出单位。此外，在每部分中，又分为输入和输出两部分，相互对应，如InputStream类型和OutputStream类型。再往下分，又分为数据源类型和装饰器类型。数据源类型表示的是数据的来源和去处，而装饰器类型可以给输入输出赋予额外的功能。Java IO的结构在使用...
Decorator 装饰模式
xzpblog
06-08 112
“单一职责”模式: 在软件组件的设计中，如果责任划分的不清晰，使用继承得到的 结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码， 这时候的关键是划清责任。 典型模式 • Decorator • Bridge 动机（Motivation） 在某些情况下我们可能会“过度地使用继承来扩展对象的功能” ， 由于继承为类型引入的静态特质，使得这...
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
5. **设计原则**：结合SOLID原则（单一职责、开闭原则、里氏替换、接口隔离和依赖倒置），分析如何通过设计模式实现这些原则。 通过解答课后习题和模拟试题，学生不仅能深入理解设计模式的精髓，还能提升分析问题和...
设计模式——组合模式
01-07
由于不同地区存在着上下级关系，且会拥有多平级组合，如果采用每个组合主一个类，这样需要创建的类特别多，此时可使用组合模式，如下图： 上图左边可转为右边的递归关系，其原理是把一组相似的对象当作一个单一的...
【心得分享】 2. 设计模式——单一职责原则
muzi木子
01-30 854
2. 设计模式——单一职责原则 2.1 什么是单一职责 单一职责原则（全称：Single Responsibility Princile，简称SRP），它表示一个类只具有某种职能，比如人又生理需求（吃、喝、睡）、生活需求（工作、锻炼），生理需求和生活需求分别当做两个类，他们里边任意方法的改变都不会影响另一个类的正常运行，如果一个类里边具有多种职能，那么意味着一种职能的变化可能会影响另一种职能，那么这个时候就应当将它们才分成两个负责不同职能的类。 又比如，我们常用的DAO模式，就是采用的单例模式，比如Use
设计模式——策略模式的学习与理解
12-20
1. **单一职责原则**：每个类应只有一个职责，策略模式将算法的实现与使用算法的环境分离，使得每部分都有明确的职责。 2. **开放封闭原则**：系统应该对扩展开放，对修改关闭。策略模式允许添加新的算法而不影响...
java io -- FilterInputStream 与 装饰者模式
xjk201的博客
07-26 627
本文将介绍一个特殊的输入字节流：FilterInputStream，以及与之相随的一个经典的设计模式，装饰者模式。 在之前的文章中提到，InputStream的读取是以byte为单位的，但是我们日常中经常会读写其他类型的数据，当然，我们可以把读取出来的字节进行转码，转成我们需要的数据，那么能不能直接读取字符，int等数据呢？能，只需要利用DataInputStream这个类。  1 Filte...
java io 装饰者_Java IO 装饰者模式
weixin_30324103的博客
02-12 267
装饰模式(Decorator)装饰模式又名包装(Wrapper)模式。装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。装饰模式通过创建一个包装对象，也就是装饰，来包裹真实的对象。装饰模式以对客户端透明的方式动态地给一个对象附加上更多的责任。换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同。装饰模式可以在不创造更多子类的情况下，将对象的功能加以扩展。装饰模式把客户端的调用...
java io 装饰者_Java IO - 设计模式(装饰者模式)
weixin_33581743的博客
02-12 101
¶ Java IO - 设计模式(装饰者模式) Java I/O 使用了装饰者模式来实现。@pdai¶ 装饰者模式装饰者(Decorator)和具体组件(ConcreteComponent)都继承自组件(Component)，具体组件的方法实现不需要依赖于其它对象，而装饰者组合了一个组件，这样它可以装饰其它装饰者或者具体组件。所谓装饰，就是把这个装饰者套在被装饰者之上，从而动态扩展被装饰者的功能。...
java io 装饰者_Java IO 体系(一)： 装饰者模式
weixin_42310670的博客
03-04 236
前言. IO中常见的使用方式DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(new File(file))));提问：嵌套的原理是什么？答：写入文件时，使用了装饰者模式从里往外分析：new File(file) --> 将文件路径转换为真正的系统文件new Fi...
Java IO流之装饰器模式
最新发布
m0_60591654的博客
11-24 725
设计模式 之 装饰器模式 IO流
装饰模式
weixin_34021089的博客
06-20 117
“单一职责”模式:在软件组件的设计中,如果责任划分的不清晰,使用继承得到的结果往往是随着需求的变化,子类急剧膨胀,同时充斥着重复代码，这时候的关键是划清责任。 典型模式.Decorator.Bridge 1.Decorator模式 代码1： //业务操作 class Stream{ virtual char Read(int number) = 0; virt...
《看小说学设计模式》——Java设计模式解析
"看小说学设计模式pdf版" 是一本以轻松的小故事方式解释Java设计模式的书籍，适合不同层次的开发者，从初级到高级，甚至系统分析师都能从中获益。书中涵盖了25种常见的设计模式，包括策略模式、代理模式、单例模式等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值