JAVA设计模式之装饰者模式

最新推荐文章于 2024-03-15 10:11:34 发布
最新推荐文章于 2024-03-15 10:11:34 发布
阅读量241 收藏
点赞数 1
分类专栏： Java设计模式 文章标签： JAVA设计模式 JAVA装饰者模式 装饰者模式 双子座的独居
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22118991/article/details/84591144
版权

文章目录

一、装饰者模式简介

装饰（ Decorator ）模式又叫做包装模式。通过一种对客户端透明的方式来扩展对象的功能，是继承关系的一个替换方案，在功能扩展方面比继承更具有弹性。

二、装饰者模式的结构

在这里插入图片描述

三、装饰者模式的角色与职责

  1. 抽象组件角色： 一个抽象接口，是被装饰类和装饰类的父接口。
  2. 具体组件角色：为抽象组件的实现类。
  3. 抽象装饰角色：包含一个组件的引用，并定义了与抽象组件一致的接口。
  4. 具体装饰角色：为抽象装饰角色的实现类。负责具体的装饰。
-组件具体组件装饰组件具体装饰组件
类ComponentConrreteComponent extends ComponentDecorator extends ComponentConrreteDecorator extends Component
方法methodA()methodA()methodA()methodA()
方法methodB()methodB()methodB()methodB()

四、装饰者模式的具体实现

考虑如下的案例
咖啡馆订单项目：

  1. 咖啡种类：Espresso、ShortBlack、LongBlack、Decaf
  2. 调料：Milk、Soy、Chocolate
  3. 扩展性好、改动方便、维护方便

1、不使用装饰者模式方案一

方案设计
类DrinkDecaf extends DrinkShortblack extends DrinkLongblack extends DrinkShortblack&Soy extends DrinkDecaf&Milk extends Drink
字段desc
方法getDesc()getDesc()getDesc()getDesc()getDesc()getDesc()
方法cost()cost()cost()cost()cost()cost()
类设计

不使用装饰者时，我们首先定义一个抽象类，接着从抽象类中继承各种咖啡类,并重写Drink类的getDesc（）方法和cost（）方法。
Drink类：

// An highlighted block
package design.decorator.gys.nodeco1;
public abstract class Drink {
private String desc;
public Drink(String desc) {
 super();
 this.desc = desc;
}
public String getDesc() {
 return desc;
 }
abstract double cost();
}

继承Drink类的三个子类
Decaf类：

// An highlighted block
package design.decorator.gys.nodeco1;
public class Decaf extends Drink{
 public Decaf() {
  super("Decaf");
 }
 @Override
 public double cost() {
  return 5.0;
 }
}

Shortblack类：

// An highlighted block
package design.decorator.gys.nodeco1;
public class Shortblack extends Drink{
 public Shortblack() {
  super("Shortblack");
 }
 @Override
 public double cost() {
  return 6.0;
 }
}

Espresso类：

// An highlighted block
package design.decorator.gys.nodeco1;
public class Espresso extends Drink{
 public Espresso() {
  super("Espresso");
 }
 @Override
 public double cost() {
  return 7.0;
 }
}

测试程序如下：

// An highlighted block
package design.decorator.gys.nodeco1;
public class Test {
 public static void main(String[] args) {
 Drink d1=new Decaf();
  Drink d2=new Shortblack();
  Drink d3=new Espresso();
  System.out.println(d1.getDesc()+":  $"+d1.cost());
  System.out.println(d2.getDesc()+":  $"+d2.cost());
  System.out.println(d3.getDesc()+":  $"+d3.cost());
 }
}

测试输出如下：

// An highlighted block
Decaf:  $5.0
Shortblack:  $6.0
Espresso:  $7.0

此种方法在有大量子类时，会出现类爆炸现象，因此不适合本案例。

2、不适用装饰者模式方案二

方案设计
类Drink（抽象类）Decaf extends DrinkShortblack extends DrinkLongblack extends Drink
字段desc、milk、soy、chocolate
方法getDesc()
方法cost()cost()cost()cost()
方法hasMilk()、setMilk()
方法hasSoy()、setSoy()
方法hasChocolate()、setCholocate()

在此方案中，我们设置三个布尔变量milk、soy、chocolate来判断是否包含加入调料，并通过hasMilk()、setMilk()、hasSoy()、setSoy()、hasChocolate()、setCholocate()方法来判断和设置加入调料。

类设计

Drink类：

// An highlighted block
package design.decorator.gys.nodeco2;
public abstract class Drink {
 private String desc;
 private boolean milk; 
 private boolean soy; 
 private boolean chocolate; 
 public Drink(String desc) {
  super();
  this.desc = desc;
 }
 public String getDesc() {
  StringBuilder sb=new StringBuilder(desc);
  sb=hasMilk()?sb.append("+Milk"):sb;
  sb=hasSoy()?sb.append("+Soy"):sb;
  sb=hasChocolate()?sb.append("+Chocolate"):sb;
  return sb.toString(); 
   }
 public boolean hasMilk() {
  return milk;
 }
 public void setMilk() {
  milk=true;
 }
 public boolean hasSoy() {
  return soy;
 }
 public void setSoy() {
  soy=true;
 }
 public boolean hasChocolate() {
  return chocolate;
 }
 public void setChocolate() {
  chocolate=true;
 }
 abstract double cost();
}

定义子类：

// An highlighted block
package design.decorator.gys.nodeco2;
public class Decaf extends Drink{
 public Decaf() {
  super("Decaf");
  // TODO Auto-generated constructor stub
 }
 @Override
 double cost() {
  // TODO Auto-generated method stub
  double money=5;
  money=hasMilk()?money+2:money;
  money=hasSoy()?money+3:money;
  money=hasChocolate()?money+3.5:money;
  return money;
 }
}

// An highlighted block
package design.decorator.gys.nodeco2;
public class Espresso extends Drink{
 public Espresso() {
  super("Espresso");
  // TODO Auto-generated constructor stub
 }
 @Override
 double cost() {
  // TODO Auto-generated method stub
  double money=7;
  money=hasMilk()?money+2:money;
  money=hasSoy()?money+3:money;
  money=hasChocolate()?money+3.5:money;
  return money;
 }
}

测试程序如下：

// An highlighted block
package design.decorator.gys.nodeco2;
public class Test {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Drink d1=new Decaf();
  Drink d2=new Espresso();
  d1.setMilk();
  d1.setSoy();
  d2.setChocolate();
  System.out.println(d1.getDesc()+": $"+d1.cost());
  System.out.println(d2.getDesc()+": $"+d2.cost());
  System.out.println("------------------");
  d1.setMilk();
  System.out.println(d1.getDesc()+": $"+d1.cost());
  }
 }

测试结果如下：

// An highlighted block
Decaf+Milk+Soy: $10.0
Espresso+Chocolate: $10.5
------------------
Decaf+Milk+Soy: $10.0

有一个顾客很喜欢牛奶，又加了一份，但此时显示出的价格和原来一样，那么这个顾客岂不是吃的霸王餐。
该方案中，若是增删调料种类或者添加多份调料时，对代码的修改仍需要大量的工作。接着我们使用装饰者模式来设计。

3、使用装饰者模式

方案设计
-抽象类具体组件具体组件具体组件装饰组件具体装饰组件具体装饰组件
-DrinkDecaf extends DrinkShortblack extends DrinkEspresso extends DrinkDecorator extends DrinkChocolate extends DecoratorMilk extends Decorator
字段desc、price---Drink obj--
方法getDesc()---getDesc()--
方法cost()---cost()--

首先设计一个抽象Drink类，在类中实现Drink所需的大部分方法，除了cost()方法，因为在装饰者中，我们还需要加上调料的价格，在getDesc()方法中，不仅返回所点单品与调料名称，还返回总价和单品调料价格：

类设计

Drink类：

// An highlighted block
package design.decorator.gys.component;
public abstract class Drink {
 private String desc;
 private double price;
 public Drink() { 
 }
 public double getPrice() {
  return price;
 }
 public void setPrice(double price) {
  this.price = price;
 }
 public abstract double cost();
 public String getDesc() {
  return desc + ": $"+this.getPrice();
 }
 public void setDesc(String desc) {
  this.desc = desc;
 }
}

接下来定义两个分支，咖啡分支即组件和调料分支即装饰者。
咖啡组件分支：

// An highlighted block
package design.decorator.gys.concretecomponent;
import design.decorator.gys.component.Drink;
public class Coffee extends Drink{
 @Override
 public double cost() {
  // TODO Auto-generated method stub
  return this.getPrice();
 }
}

调料装饰者分支：

// An highlighted block
package design.decorator.gys.decoretor;
import design.decorator.gys.component.Drink;
public class Decorator extends Drink{
 private Drink obj;
 public Decorator(Drink obj) {
  this.obj = obj;
 }
 @Override
 public double cost() {
  // TODO Auto-generated method stub
  return super.getPrice()+obj.cost();
 }
 public String getDesc() {
  return super.getDesc()+"\n"+obj.getDesc();
 }
}

接下来定义三个具体的组件，在这里，我们只需要提供咖啡单品的名称和价格即可：

// An highlighted block
package design.decorator.gys.concretecomponent;
public class Decaf extends Coffee{
 public Decaf() {
  this.setDesc("Decaf");
  this.setPrice(8);
  // TODO Auto-generated constructor stub
 }
}

// An highlighted block
package design.decorator.gys.concretecomponent;
public class Espresso extends Coffee{
 public Espresso() {
  this.setDesc("Espresso");
  this.setPrice(7.5);
  // TODO Auto-generated constructor stub
 }
}

// An highlighted block
package design.decorator.gys.concretecomponent;
public class Shortblack extends Coffee{
 public Shortblack() {
  this.setDesc("Shortblack");
  this.setPrice(5.0);
  // TODO Auto-generated constructor stub
 }
}

下面定义具体装饰者，由于在Decorator类中已经定义了全部的公共方法，所以在此处，我们同样只需要提供调料的名称和价格：

// An highlighted block
package design.decorator.gys.decoretor;
import design.decorator.gys.component.Drink;
public class Milk extends Decorator{
 public Milk(Drink obj) {
  super(obj);
  this.setPrice(3.0);
  this.setDesc("Milk");
  // TODO Auto-generated constructor stub
 }
}

// An highlighted block
package design.decorator.gys.decoretor;
import design.decorator.gys.component.Drink;
public class Soy extends Decorator{
 public Soy(Drink obj) {
  super(obj);
  this.setPrice(3.5);
  this.setDesc("Soy");
  // TODO Auto-generated constructor stub
 }
}

// An highlighted block
package design.decorator.gys.decoretor;
import design.decorator.gys.component.Drink;
public class Chocolate extends Decorator{
 public Chocolate(Drink obj) {
  super(obj);
  this.setPrice(4.0);
  this.setDesc("Chocolate");
  // TODO Auto-generated constructor stub
 }
}

这是咖啡馆来了三个客人，一个人点了单品Shortblack，而另一个人喜欢喝加了牛奶的咖啡，剩下的人特别喜欢巧克力，所以又加了两大份巧克力。

// An highlighted block
package design.decorator.gys.component;
import design.decorator.gys.concretecomponent.Shortblack;
import design.decorator.gys.decoretor.Chocolate;
import design.decorator.gys.decoretor.Milk;
public class Test {
 public static void print(Drink d) {
  System.out.println("总价：$"+d.cost()+"\n"+"详单："+"\n"+d.getDesc());
 }
 public static void main(String[] args) {
  // TODO Auto-generated method stub
   Drink shortblack=new Shortblack();
   Drink drink=new Milk(shortblack);
   print(shortblack);
   System.out.println("----------");
   print(drink);
   System.out.println("----------");
   drink=new Chocolate(drink);
   drink=new Chocolate(drink);
   print(drink);
 }
}

看一下点单系统的计算价格：

// An highlighted block
总价：$5.0
详单：
Shortblack: $5.0
----------
总价：$8.0
详单：
Milk: $3.0
Shortblack: $5.0
----------
总价：$16.0
详单：
Chocolate: $4.0
Chocolate: $4.0
Milk: $3.0
Shortblack: $5.0

现在，我们可是使用各种调料来包装单品咖啡，并且可以实现添加多份调料。再添加单品咖啡只需要继承Drink类，添加调料则继承Decorator类即可，不需要改变已有类的代码。
在此提出开放——关闭原则：

  • 开放：提供新功能的添加
  • 关闭：禁止修改已经存在的功能

五、JAVA内置装饰者

JAVA的IO结构

名称类
组件InputStream
具体组件FileInputStream、StringBufferInputSrteam、ByteArrayInputStream
装饰组件FilterInputStream
具体装饰组件BufferInputStream、DataInputStream、LineNumberInputStream
类设计

自定义一个输入流UpperInputStream类，该类位装饰类，用来装饰InputStream，该类将读到的字符转为大写字符，下面是代码示例：

// An highlighted block
package design.decoretor.gys.inner;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
public class UpperInputStream extends FilterInputStream{
 protected UpperInputStream(InputStream in) {
  super(in);
  // TODO Auto-generated constructor stub
 }
 public int read() throws IOException {
  int c=super.read();
  return c==-1?c:Character.toUpperCase(c);
 } 
 public int read(byte[] b,int off,int len) throws IOException{
  int result=super.read(b, off, len);
  for(int i=0;i<result;i++)
   b[i]=(byte)Character.toUpperCase((char)(b[i]));
  return result;
 }
}

使用txt文本作文输入，：

测试程序如下：

// An highlighted block
package design.decoretor.gys.inner;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Testinner {
 public static void main(String[] args)  {
  // TODO Auto-generated method stub
  int ch;
  try {
  InputStream in=new UpperInputStream(new BufferedInputStream(new FileInputStream("F:\\5.txt")));
  
   while((ch=in.read())!=-1)
    System.out.print((char)ch);
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
}

测试输出如下：

// An highlighted block
THIS IS A TEST FILE.

通常情况下，我们会扩展两个分支，一个组件分支，另一个装饰者分支进行功能扩展。

要抱抱才会开心呀~~~~~~~~~~~~

在这里插入图片描述

双子座的独居
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java设计模式之装饰者模式
m0_47944994的博客
11-17 2194
java设计模式之装饰者模式
Java设计模式——装饰者模式
雪月清的博客
06-21 1912
装饰者模式是Java程序设计中常用的设计模式之一，当系统设计由于继承造成子类过多不利用维护和功能扩展时，使用装饰者模式是一个非常不错的选择，本文将以模拟sso单点登录的案例进行装饰者模式的详细介绍。
Java 设计模式之装饰者模式
来自上海的这位朋友
04-14 370
本文介绍了 Java 设计模式之一的装饰者模式。装饰者模式是一种结构性设计模式，它允许我们动态地将行为添加到对象中，而无需通过继承来实现。文章首先讲解了装饰者模式的基本原理，通过将对象包装在装饰器对象中来实现。然后，通过一个简单的案例来演示如何使用装饰者模式为咖啡添加额外的调料，动态地改变咖啡的行为，从而提高了代码的可维护性和可扩展性。最后，总结了装饰者模式的优点，通过将行为添加到对象中，而无需通过继承来实现，提高了代码的可维护性和可扩展性。
【设计模式】Java 设计模式之装饰者模式（Decorator）
最新发布
新手村长的专栏
03-15 1456
装饰者模式是一种动态地给一个对象添加一些额外的职责的设计模式，常用于扩展对象的功能而无需修改其结构。在软件架构中，装饰者模式具有广泛的应用，如构建服务链或中间件、实现插件式架构以及创建代理与拦截器等。通过装饰者模式，可以灵活地组合和扩展对象的功能，增强软件的可维护性和可扩展性。在服务导向架构中，装饰者模式能够用于构建包含日志记录、权限检查等功能的服务链。在插件式架构中，装饰者模式使得开发者能够通过编写插件来扩展应用程序的功能。然而，使用装饰者模式时也需要注意避免过度使用，以免导致代码复杂度增加。总之，装饰者
java设计模式之：装饰器模式
初念初恋的博客
06-12 1351
装饰模式可以在不改变一个对象本身功能的基础上给对象增加额外的新行为，在现实生活中，这种情况也到处存在，例如一张照片，我们可以不改变照片本身，给它增加一个相框，使得它具有防潮的功能，而且用户可以根据需要给它增加不同类型的相框，甚至可以在一个小相框的外面再套一个大相框。装饰模式是一种用于替代继承的技术，它通过一种无须定义子类的方式来给对象动态增加职责，使用对象之间的关联关系取代类之间的继承关系。在装饰模式中引入了装饰类，在装饰类中既可以调用待装饰的原有类的方法，还可以增加新的方法，以扩充原有类的功能。
Java设计模式之装饰者模式
01-20
要实现装饰者模式，注意一下几点内容: 　1.装饰者类要实现真实类同样的接口 　2.装饰者类内有一个真实对象的引用(可以通过装饰者类的构造器传入) 　3.装饰类对象在主类中接受请求，将请求发送给真实的对象(相当于...
Java设计模式之装饰者模式详解和代码实例
09-04
装饰者模式是一种设计模式，它允许我们向一个对象添加新的行为或职责，而无需修改该对象的源代码。这种模式是面向对象设计中的一种非常重要的模式，因为它提供了比继承更灵活的扩展方式。在Java中，装饰者模式尤其...
java设计模式系列之装饰者模式
09-02
装饰者模式(Decorator Pattern)是一种在不改变原有对象的前提下，通过包装对象来扩展其功能的设计模式。它属于结构型模式，适用于需要灵活扩展对象功能但又不想通过子类化来实现的情况。 在Java中，装饰者模式的...
java设计模式之装饰者模式代码
05-13
装饰者模式是面向对象设计模式的一种，主要用于动态地给一个对象添加一些额外的职责，而不会改变该对象的类。这种模式允许我们独立于对象的类来扩展对象的功能，为对象提供新的行为，同时保持了代码的可读性和可维护...
Java设计模式-装饰者模式
12-21
装饰者模式（Decorator Pattern）是一种结构型设计模式，它允许在运行时给对象增加新的行为或责任，而无需修改其源代码。这种模式通过创建一个与原对象具有相同接口的新对象（装饰者），并把原对象作为其内部成员，...
装饰者模式源代码java
01-18
这是代码，介绍请查看以下博客地址： http://www.cnblogs.com/homg/p/3525539.html 代码乱码请使用utf-8编码。
Java设计模式——装饰模式
TY_JUST的博客
10-20 308
设计模式——装饰模式 一、什么是装饰模式 ​ 装饰模式（Decorator），动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更灵活。UML结构图如 下： ​ Component是抽象构件，定义一个对象接口，可以给这些对象动态地添加职责； ​ ConcreteComponent定义一个具体对象，也可以给这个对象添加一些职责； ​ Decorator是装饰抽象类，实现接口或抽象方法； ​ Concret
JAVA设计模式--装饰者模式详解
qq_36944952的博客
06-03 1137
JAVA装饰者模式详解--代码案例、使用方式
Java设计模式（装饰设计模式）
0xc
07-08 556
作用：改写已存在的类的某个方法或某些方法，装饰设计模式（包装模式）场景：DataSource数据源连接池，获取Connection后的close不能关闭，而是放入连接池中，就需要使用装饰者设计模式口诀：1、编写一个类，实现与被包装类相同的接口。（具备相同的行为）2、定义一个被包装类类型的变量。3、定义构造方法，把被包装类的对象注入，给被包装类变量赋值。4、对于不需要改写的方法，调用原有的方法。5、...
JAVA设计模式初探之装饰者模式
热门推荐
一个本科小生的奋斗史
04-01 11万+
这个模式花费了挺长时间，开始有点难理解，其实就是 定义：动态给一个对象添加一些额外的职责,就象在墙上刷油漆.使用Decorator模式相比用生成子类方式达到功能的扩充显得更为灵活。 设计初衷:通常可以使用继承来实现功能的拓展,如果这些需要拓展的功能的种类很繁多,那么势必生成很多子类,增加系统的复杂性,同时,使用继承实现功能拓展,我们必须可预见这些拓展功能,这些功能是编译时就确定了,是静态的。 ...
JAVA设计模式-装饰模式
yanzhelee
08-09 778
装饰模式就是添加一些额外的功能（装饰作用）。装饰使得我们可以动态的为对象添加一些功能，而无需事先在类中定义。 装饰模式结构图如下：1 概述1.设计意图： 动态的为对象添加一些额外的功能。就增加功能来说，Decorator模式相比生成子类更为灵活。该模式以对客户端透明的方式扩展对象的功能。 2.适用环境 在不影响其它对象的情况下，以动态、透明的方式给单个对象添加职责。 处理那些可
1.Java装饰者模式
每天进步一点点
01-13 225
package lesson04; import java.util.Arrays; import java.util.List; /** * Created by Administrator on 2018/1/4. */ public class Test4 { public static void main(String[] args) { String[
Java设计模式的常见应用场景
想作会飞的鱼的博客
08-10 5万+
一、Java I/O中的设计模式1、适配器模式适配器模式就是把一个类的接口变换成客户端所能接受的另一种接口，从而使两个接口不匹配而无法在一起工作的两个类能够在一起工作。通常被用在一个项目需要引用一些开源框架来一起工作时，这些框架的内部都有一些关于环境信息的接口，需要从外部引入，但是外部的接口不一定能匹配，在这种情况下，就需要适配器模式来转换接口。 Java的I/O类库中有许多这样的需求，如将字

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值