设计模式_装饰器模式_Decorator

已于 2024-01-23 10:28:01 修改
阅读量1k 收藏 19
点赞数 22
分类专栏： 设计模式 文章标签： 设计模式 装饰器模式
于 2024-01-22 15:28:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39977988/article/details/135749249
版权

生活案例

咖啡厅 咖啡定制案例

在咖啡厅中，有多种不同类型的咖啡，客户在预定了咖啡之后，还可以选择添加不同的调料来调整咖啡的口味，当客户点了咖啡添加了不同的调料，咖啡的价格需要做出相应的改变。

要求：程序实现具有良好的拓展性、改动方便、维护方便

【方案一】
在这里插入图片描述

写一个抽象类，然后将所有咖啡和调料组合形成多个类来继承抽象类，缺点：当增加一个单品咖啡，或者调味，类的数量就会大增，产生类爆炸问题

【方案二】

在这里插入图片描述

分析：

  • 可以控制类的数量，不至于造成很多的类
  • 增加或者删除调料种类时，代码的维护量很大
  • 如果同样一种调料可以点多份时，可以将 hasMilk 返回一个对应int类型的数据来表示调料的份数

装饰者模式介绍

介绍

  • 动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更好，装饰者模式也体现了开闭原则(ocp)
  • 假如有一块蛋糕，如果加上奶油，就变成了奶油蛋糕；再加上草莓，就变成了草莓奶油蛋糕。整个过程就是在不断装饰蛋糕的过程。根据装饰者模式编写的程序的对象与蛋糕十分相似。首先有一个相当于蛋糕的对象，然后像不断地装饰蛋糕一样地不断地对其增加功能，它就变成了使用目的更加明确的对象。

出场角色

  • Component（主体，被装饰对象）：增加功能时的核心角色，定义了接口（API）
  • ConcreteComponent（具体主体）：实现了Component角色所定义的接口
  • Decorator（装饰者）：该角色具有与Component角色相同的接口(API)，在它内部保存了Component角色
  • ConcreteDecorator( 具体的装饰者)

在这里插入图片描述

案例实现

案例一（咖啡厅问题）

类图

在这里插入图片描述

在这里插入图片描述

代码实现

【被装饰主体】

package com.test.decorator;

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

/**
* 计算费用的抽象方法，需要子类来实现
* @return
*/
public abstract float cost();

}

【缓冲类：整合所有咖啡的共同点，这个类不一定要写，要结合实际情况】

package com.test.decorator;

public class Coffee  extends Drink {

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

}

【单品咖啡：意大利咖啡】

package com.test.decorator;

public class Espresso extends Coffee {

public Espresso() {
setDes(" 意大利咖啡 ");
// 初始化意大利咖啡的价格
setPrice(6.0f);
}
}

【单品咖啡：美式咖啡】

package com.test.decorator;

public class LongBlack extends Coffee {

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

【单品咖啡：浓咖啡】

package com.test.decorator;

public class ShortBlack extends Coffee{

public ShortBlack() {
setDes(" shortblack ");
setPrice(4.0f);
}
}

【装饰者】

package com.test.decorator;

/**
* 装饰物，继承了Drink，还聚合了Drink
*/
public class Decorator extends Drink {
private Drink obj;

/**
* 聚合Drink
* @param obj
*/
public Decorator(Drink obj) {
this.obj = obj;
}

@Override
public float cost() {
// getPrice 自己价格 + 咖啡的价格
return super.getPrice() + obj.cost();
}

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

}

【具体装饰者：巧克力】

package com.test.decorator;

/**
* 具体的Decorator， 这里就是调味品
*/
public class Chocolate extends Decorator {

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

}

【具体装饰者：牛奶】

package com.test.decorator;

public class Milk extends Decorator {

public Milk(Drink obj) {
super(obj);
setDes(" 牛奶 ");
setPrice(2.0f);
}

}

【具体装饰者：豆浆】

package com.test.decorator;

public class Soy extends Decorator{

public Soy(Drink obj) {
super(obj);
setDes(" 豆浆  ");
setPrice(1.5f);
}

}

【主类】

package com.test.decorator;

public class CoffeeBar {

public static void main(String[] args) {

System.out.println("============== 订单1 =============");
// 装饰者模式下的订单：2份巧克力+一份牛奶的LongBlack
// 1. 点一份 LongBlack
Drink order = new LongBlack();
System.out.println("费用=" + order.cost());
System.out.println("描述=" + order.getDes());
System.out.println();

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

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

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

}

}

【运行】

============== 订单1 =============
费用=5.0
描述= longblack 

order 加入一份牛奶 费用 =7.0
order 加入一份牛奶 描述 =  牛奶  2.0 &&  longblack 

order 加入一份牛奶 加入一份巧克力 费用 =10.0
order 加入一份牛奶 加入一份巧克力 描述 =  巧克力  3.0 &&  牛奶  2.0 &&  longblack 

order 加入一份牛奶 加入2份巧克力 费用 =13.0
order 加入一份牛奶 加入2份巧克力 描述 =  巧克力  3.0 &&  巧克力  3.0 &&  牛奶  2.0 &&  longblack
咖啡样式拓展代码实现

只需要新增一个单品咖啡类，就可以购买了，拓展性非常强大

【新增单品咖啡：无因咖啡】

package com.test.decorator;

public class DeCaf extends Coffee {

public DeCaf() {
setDes(" 无因咖啡 ");
setPrice(1.0f);
}
}

【主类】

package com.test.decorator;

public class CoffeeBar {

public static void main(String[] args) {

System.out.println("============== 订单2 =============");

Drink order2 = new DeCaf();
System.out.println("order2 无因咖啡 费用 =" + order2.cost());
System.out.println("order2 无因咖啡 描述 = " + order2.getDes());
System.out.println();

order2 = new Milk(order2);
System.out.println("order2 无因咖啡 加入一份牛奶 费用 =" + order2.cost());
System.out.println("order2 无因咖啡 加入一份牛奶 描述 = " + order2.getDes());
System.out.println();

}

}

【运行】

============== 订单2 =============
order2 无因咖啡 费用 =1.0
order2 无因咖啡 描述 =  无因咖啡 

order2 无因咖啡 加入一份牛奶 费用 =3.0
order2 无因咖啡 加入一份牛奶 描述 =  牛奶  2.0 &&  无因咖啡 


Process finished with exit code 0

案例二

类图

在这里插入图片描述

代码实现

【抽象主体】

package com.test.decorator.Sample;

public abstract class Display {
/**
* 获取横向字符数（抽象方法，需要子类去实现）
* @return
*/
public abstract int getColumns();

/**
* 获取纵向行数（抽象方法，需要子类去实现）
* @return
*/
public abstract int getRows();

/**
* 获取第row行的字符串（抽象方法，需要子类去实现）
* @param row
* @return
*/
public abstract String getRowText(int row);

/**
* 显示所有行的字符串
*/
public void show() {
// 遍历行数
for (int i = 0; i < getRows(); i++) {
// 获取改行的字符串来打印出来
System.out.println(getRowText(i));
}
}
}

【具体主体】

package com.test.decorator.Sample;

/**
* 该类用来显示单行字符串
*/
public class StringDisplay extends Display {
/**
* 要显示的字符串
*/
private String string;

/**
* 构造方法
*
* @param string 要显示的字符串
*/
public StringDisplay(String string) {
this.string = string;
}

@Override
public int getColumns() {
// 字符数
return string.getBytes().length;
}

@Override
public int getRows() {
// 行数是1
return 1;
}

/**
* 只有第0行可以获取到字符串，其他都是空
* @param row
* @return
*/
@Override
public String getRowText(int row) {
// 仅当row为0时返回值
if (row == 0) {
return string;
} else {
return null;
}
}
}

【抽象装饰者】

package com.test.decorator.Sample;

/**
* 装饰者抽象类，注意要继承抽象主体，并聚合抽象主体
*/
public abstract class Border extends Display {
/**
* 表示被装饰物
*/
protected Display display;

protected Border(Display display) {
// 在生成实例时通过参数指定被装饰物
this.display = display;
}
}

【具体修饰者1】

package com.test.decorator.Sample;

/**
* 在字符串的左右两侧添加边框
*/
public class SideBorder extends Border {
/**
* 表示装饰边框的字符
*/
private char borderChar;

/**
* 通过构造函数指定Display和装饰边框字符
* @param display
* @param ch
*/
public SideBorder(Display display, char ch) {
super(display);
this.borderChar = ch;
}

/**
* 字符数为字符串字符数加上两侧边框字符数
* @return
*/
public int getColumns() {
return 1 + display.getColumns() + 1;
}

/**
* 行数即被装饰物的行数
* @return
*/
public int getRows() {
// 在字符串的两侧添加字符并不会增加行数，所以直接返回主体的行数即可
return display.getRows();
}

/**
* 指定的那一行的字符串为被装饰物的字符串加上两侧的边框的字符
* @param row
* @return
*/
public String getRowText(int row) {
return borderChar + display.getRowText(row) + borderChar;
}
}

【具体装饰者2】

package com.test.decorator.Sample;

/**
* 在字符串的上下左右都加上装饰框
*/
public class FullBorder extends Border {
public FullBorder(Display display) {
super(display);
}

public int getColumns() {
// 字符数为被装饰物的字符数加上两侧边框字符数
return 1 + display.getColumns() + 1;
}

public int getRows() {
// 行数为被装饰物的行数加上上下边框的行数
return 1 + display.getRows() + 1;
}

/**
* 指定的那一行的字符串
*
* @param row
* @return
*/
public String getRowText(int row) {
if (row == 0) {                                                 // 上边框
return "+" + makeLine('-', display.getColumns()) + "+";
} else if (row == display.getRows() + 1) {                      // 下边框
return "+" + makeLine('-', display.getColumns()) + "+";
} else {                                                        // 其他边框
return "|" + display.getRowText(row - 1) + "|";
}
}

/**
* 生成一个重复count次字符ch的字符串
*
* @param ch
* @param count
* @return
*/
private String makeLine(char ch, int count) {
StringBuffer buf = new StringBuffer();
for (int i = 0; i < count; i++) {
buf.append(ch);
}
return buf.toString();
}
}

【主类】

package com.test.decorator.Sample;

public class Main {
public static void main(String[] args) {
Display b1 = new StringDisplay("Hello, world.");
Display b2 = new SideBorder(b1, '#');
Display b3 = new FullBorder(b2);
b1.show();
b2.show();
b3.show();
Display b4 =
new SideBorder(
        new FullBorder(
                new FullBorder(
                        new SideBorder(
                                new FullBorder(
                                        new StringDisplay("你好，世界。")
                                ),
                                '*'
                        )
                )
        ),
        '/'
);
b4.show();
}
}

【运行】

Hello, world.

#Hello, world.#

+---------------+
|#Hello, world.#|
+---------------+

/+------------------------+/
/|+----------------------+|/
/||*+------------------+*||/
/||*|你好，世界。|*||/
/||*+------------------+*||/
/|+----------------------+|/
/+------------------------+/

Process finished with exit code 0

装饰着模式在IO流源码的应用

在这里插入图片描述

  • InputStream 是抽象类, 类似我们前面讲的 Drink
  • FileInputStream 是 InputStream 子类，类似我们前面的 DeCaf, LongBlack
  • FilterInputStream 是 InputStream 子类：类似我们前面 的 Decorator 修饰者
  • DataInputStream 是 FilterInputStream 子类，具体的修饰者，类似前面的 Milk, Soy 等
  • FilterInputStream 类 有 protected volatile InputStream in; 即聚合了被装饰者

在这里插入图片描述

在这里插入图片描述

总结

  • 在装饰者模式中，装饰者与被装饰者具有一致性。装饰者类是表示被装饰者的类的子类，这就体现了它们之间的一致性，它们具有相同的接口，这样，就算被装饰者被装饰了，接口还是向外暴露的（接口的透明性）
  • 可以在不改变被装饰者的前提下增加功能，如案例中在显示字符串之前对字符串进行修饰
  • 只需要一些装饰物即可添加许多功能：通过自由组合调料，可以让咖啡拥有各种不同的味道
  • 装饰者模式也有缺点：会导致程序中增加许多功能类似的很小的类

什么是父类和子类的一致性

在这里插入图片描述

可以将子类的实例保存到父类的变量中，也可以直接调用从父类中继承的方法

如何让自己和被委托对象有一致性

使用委托让接口具有透明性时，自己和被委托对象具有一致性

在这里插入图片描述

Rose和Violet都有相同的method方法。Rose将method方法的处理委托给了 Violet。这两个类虽然都有 method 方法，但是没有明确在代码中体现出“共通性”。

如果要明确地表示method方法是共通的，只需要像下面这样编写一个抽象类Flower，然后让Rose和Violet都继承并实现方法即可。

在这里插入图片描述

或者让Flower作为接口

在这里插入图片描述

Roc Lau
关注
  • 22
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式_装饰器模式.zip
06-26
装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。 这种模式创建了一个装饰类，用来包装原有的类，并在...
java设计模式之装饰器模式（Decorator）
08-31
主要为大家详细介绍了java设计模式之装饰器模式Decorator，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
分析Python中设计模式之Decorator装饰器模式的要点
09-21
主要介绍了Python中设计模式之Decorator装饰器模式模式,文中详细地讲解了装饰对象的相关加锁问题,需要的朋友可以参考下
C#设计模式_设计模式_C#_
10-01
装饰模式(Decorator Pattern) 9. 组合模式(Composite Pattern) 10. 外观模式（Facade Pattern) 11. 享元模式(Flyweight Pattern) 12. 代理模式(Proxy Pattern) 行为型： 13. 模板方法(Template Method) 14. 命令...
Java设计模式之装饰模式（Decorator模式）介绍
09-03
主要介绍了Java设计模式之装饰模式（Decorator模式）介绍,本文讲解了为什么使用Decorator、如何使用装饰模式、Jive中的Decorator实现等内容,需要的朋友可以参考下
聊聊实际工作中设计模式的使用
hbnn111的专栏
04-23 808
其他的设计模式就不再过多介绍，像单例、建造者模式（如lombok的builder）、适配器、迭代器模式（yield）都是比较常见的模式。我希望读完这篇介绍之后你们也能够通过实际工作去真正掌握，纸上得来终觉浅嘛。如果实在不知道该如何动手去写，我推荐一个web框架，那是我见过的最好的web框架，即php界的laravel。我读过很多web框架的源码，像python的Django和Flask，java的Spring，golang的gin。
设计模式-行为型模式-观察者模式
weixin_45448080的博客
04-25 237
观察者模式用于定义对象间的一种一对多的依赖关系，使得当一个对象状态变化时，其所有依赖对象都会收到通知并自动更新。
Java中单例设计模式详解
qq_36720723的博客
04-26 499
在Java编程中，单例设计模式是一种创建对象的设计模式，它保证一个类仅有一个实例，并提供一个全局访问点来访问这个唯一实例。单例模式在很多场景下都非常有用，比如配置文件读取、线程池管理、缓存管理等。下面，我们将详细讲解Java中的单例设计模式，并通过代码示例帮助初学者理解。
每日一题：Spring 框架中都用到了哪些设计模式❓
lhcong_的博客
04-24 298
总之，Spring 框架中充分利用了许多设计模式，提供了良好的扩展性和灵活性，降低了代码的耦合度，提高了代码的可维护性。
Java设计模式中策略模式
Rsun2018的博客
04-24 307
在这个示例中，PaymentStrategy是策略接口，CreditCardPayment和PayPalPayment是具体策略。ShoppingCart是上下文，它持有一个对PaymentStrategy的引用，并在结账时调用支付方法。通过更改支付策略，我们可以在不修改ShoppingCart的情况下选择不同的支付方式。这种模式定义了一系列算法，并使这些算法可以相互替换，使得算法的变化独立于使用算法的客户。：负责维护一个对Strategy对象的引用，并且将客户请求委托给Strategy对象。
Javascript设计模式 -- 发布订阅模式
m0_73280507的博客
04-22 470
发布订阅模式是一种对象之间一对多的依赖关系(利用消息队列当，所有依赖它的对象都会得到状态改变的通知订阅者把自己想订阅的事件注册到调度中心发布者发布该事件到调度中心，当该事件触发的时候，会由调度的中心统一调度订阅者注册到调度中心的处理代码。
设计模式-00 设计模式简介之几大原则
jxusthusiwen的专栏
04-23 1016
设计模式相关的浅解，并运用modern cpp 来是实现，描述相关设计模式
设计模式-状态模式在Java中的使用示例-信用卡业务系统
BADAO_LIUMANG_QIZHI的博客
04-24 726
在软件系统中，有些对象也像水一样具有多种状态，这些状态在某些情况下能够相互转换，而且对象在不同的状态下也将具有不同的行为。为了更好地对这些具有多种状态的对象进行设计，我们可以使用一种被称之为状态模式的设计模式。状态模式用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题。当系统中某个对象存在多个状态，这些状态之间可以进行转换，而且对象在不同状态下行为不相同时可以使用状态模式。状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中，使得对象状态可以灵活变化，
设计模式学习笔记 - 项目实战一：设计实现一个支持各种算法的限流框架（分析）
最新发布
chenjian723122704的专栏
04-27 357
本章，我们主要对限流框架做了大的项目背景、需求背景介绍，以及更加具体的需求分析，明确了解要做什么，为下面两篇文章（设计和实现）做准备。本章的讲解中，基本的功能需求其实没有多少，但将非功能性需求考虑进去之后，明显就复杂多了。还是那句老话，写出能用的代码简单，写出好用的代码很难。对于限流框架来说，非功能性需求是设计与实现的难点。怎么做到易用、灵活、可扩展、低延迟、高容错，才是开发的重点。此外，本章还提到了一些需求分析的方法，比如画线框图、写用户用例、测试驱动开发等等。
Java23种设计模式-结构型模式之外观模式
csy08845的博客
04-24 541
ComputerFacade类作为外观类，它封装了对CPU、Memory和HardDrive类的操作，客户端只需要与ComputerFacade类交互，从而简化了客户端Demo的代码。（Facade Pattern）：为复杂的系统提供了一个简单的统一接口，使得系统更易于使用和理解（（Facade）：外观类提供了一个简化的接口，封装了系统的复杂性。：隐藏了系统的复杂细节，提供了一个简单的、高层的接口。：过于复杂的外观类可能会降低代码的可读性。：外观类的设计可能会限制系统的灵活性。：便于系统的维护和扩展。
【设计模式】使用 Builder 模式优化参数极多的函数
锋利的绵羊的博客
04-22 443
这样定义的问题是：需要将参数写在固定的位置，随着参数的增多，这种传参方式会变得难以维护。如果遇到某些定义在中间位置的参数为可选参数时，比如上面定义的idCard。
23种设计模式之抽象工厂
m0_63137850的博客
04-21 310
简单工厂和工厂方法 关注 产品等级 抽象工厂 关注 产品族 对于比较稳定的产品，抽象工厂更有效率（一个工厂生产很多产品族） 抽象工厂代码例子加深理解
工厂设计模式
qq_63748940的博客
04-23 435
一般情况下，工厂模式分为三种更加细分的类型：简单工厂、工厂方法和抽象工厂。
设计模式之组合模式
Rcain_R的博客
04-23 1060
组合模式（Composite Pattern）是一种结构型设计模式，它将对象结构（树形结构）中的对象（包括叶子节点和容器节点）都看作同一类型的对象，从而使得客户端可以一致地处理单个对象和对象组合。这种模式使得我们能够将单个对象和对象组合都看作树形结构的一部分，并且可以对整个树进行统一的操作，如遍历、添加、删除等。
设计模式的装饰器模式
10-20
装饰器模式是一种结构型设计模式，可以动态地为一个对象添加更多的功能，而不需要修改其原始类。通常，装饰器模式的实现方法是创建一个装饰器类来包装原始类，并在其中添加新的行为或功能。这个装饰器类具有与原始类...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值