服务器之家

服务器之家 > 正文

Java基于装饰者模式实现的染色馒头案例详解

时间:2021-04-29 11:10     来源/作者:chengqiuming

本文实例讲述了java基于装饰者模式实现的染色馒头案例。分享给大家供大家参考,具体如下:

一、模式定义

装饰者模式,是在不改变原类文件和使用继承的情况下,动态扩展一个对象功能,它是通过创建一个包装对象,也就是装饰来包装真实的对象。

装饰对象和真实对象有相同接口,这样客户端对象就可以和真实对象相同方式和装饰对象交互。

装饰对象包含一个真实对象的引用。

二、模式举例

1. 模式分析

我们借用黑心商贩制做染色馒头案例说明这一模式。

 Java基于装饰者模式实现的染色馒头案例详解

2. 装饰者模式静态类图

 Java基于装饰者模式实现的染色馒头案例详解

3. 代码示例

3.1 创建馒头接口——ibread

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.demo.abs;
/**
 * 馒头加工接口
 *
 * @author
 *
 */
public interface ibread {
  // 准备材料
  public void prepair();
  // 和面
  public void kneadflour();
  // 蒸馒头
  public void steamed();
  /**
   * 加工馒头方法
   */
  public void process();
}

3.2 正常馒头实现——normalbread

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package com.demo.abs;
/**
 * 正常馒头的实现
 *
 * @author
 *
 */
public class normalbread implements ibread {
  // 准备材料
  public void prepair() {
    system.out.println("准备面粉、水以及发酵粉...");
  }
  // 和面
  public void kneadflour() {
    system.out.println("和面...");
  }
  // 蒸馒头
  public void steamed() {
    system.out.println("蒸馒头...香喷喷的馒头出炉了!");
  }
  /**
   * 加工馒头方法
   */
  public void process() {
    // 准备材料
    prepair();
    // 和面
    kneadflour();
    // 蒸馒头
    steamed();
  }
}

3.3 创建抽象装饰者——abstractbread

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.demo.decorator;
import com.demo.abs.ibread;
/**
 * 抽象装饰者
 *
 * @author
 *
 */
public abstract class abstractbread implements ibread {
  // 存储传入的ibread对象
  private final ibread bread;
  public abstractbread(ibread bread) {
    this.bread = bread;
  }
  // 准备材料
  public void prepair() {
    this.bread.prepair();
  }
  // 和面
  public void kneadflour() {
    this.bread.kneadflour();
  }
  // 蒸馒头
  public void steamed() {
    this.bread.steamed();
  }
  // 加工馒头方法
  public void process() {
    prepair();
    kneadflour();
    steamed();
  }
}

3.4 创建染色剂装饰者——corndecorator

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.demo.decorator;
import com.demo.abs.ibread;
/**
 * 染色的玉米馒头
 *
 * @author
 *
 */
public class corndecorator extends abstractbread {
  // 构造方法
  public corndecorator(ibread bread) {
    super(bread);
  }
  // 黑心商贩 开始染色了
  public void paint() {
    system.out.println("添加柠檬黄的着色剂...");
  }
  // 重载父类的和面方法
  @override
  public void kneadflour() {
    // 在面粉中加入 染色剂 之后才开始和面
    this.paint();
    // 和面
    super.kneadflour();
  }
}

3.5 创建甜蜜素装饰者——sweetdecorator

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.demo.decorator;
import com.demo.abs.ibread;
/**
 * 甜蜜素馒头
 *
 * @author
 *
 */
public class sweetdecorator extends abstractbread {
  // 构造方法
  public sweetdecorator(ibread bread) {
    super(bread);
  }
  // 黑心商贩 开始添加甜蜜素
  public void paint() {
    system.out.println("添加甜蜜素...");
  }
  // 重载父类的和面方法
  @override
  public void kneadflour() {
    // 在面粉中加入 甜蜜素 之后才开始和面
    this.paint();
    // 和面
    super.kneadflour();
  }
}

3.6 生产甜玉米馒头——client

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.demo;
import com.demo.abs.ibread;
import com.demo.abs.normalbread;
import com.demo.decorator.corndecorator;
import com.demo.decorator.sweetdecorator;
/**
 * 客户端应用程序
 *
 * @author
 *
 */
public class client {
  /**
   * @param args
   */
  public static void main(string[] args) {
    // 生产装饰馒头
    system.out.println("\n====开始装饰馒头!!!");
    // 创建普通的正常馒头实例
    // 这是我们需要包装(装饰)的对象实例
    ibread normalbread = new normalbread();
    // 下面就开始 对正常馒头进行装饰了!!!
    // 使用甜蜜素装饰馒头
    normalbread = new sweetdecorator(normalbread);
    // 使用柠檬黄的着色剂装饰馒头
    normalbread = new corndecorator(normalbread);
    // 生产馒头信息
    normalbread.process();
    system.out.println("====装饰馒头结束!!!");
  }
}

4. 运行结果

====开始装饰馒头!!!
准备面粉、水以及发酵粉...
添加柠檬黄的着色剂...
添加甜蜜素...
和面...
蒸馒头...香喷喷的馒头出炉了!
====装饰馒头结束!!!

三、该模式设计原则

1 封闭变化部分
2 “开一闭"原则
3 面向抽象编程
4 优先使用组合,而非继承

四、使用场合

1. 当我们需要为某个现有对象动态增加一个新功能或职责时,可以考虑使用装饰者模式。

2. 当某个对象的职责经常发生变化或经常需要动态增加职责,避免为了适应这样的变化而增加继承子类扩展的方式,因为这种方式会造成子类膨胀速度过快,难以控制,此时可以使用装饰者模式。

五、装饰者模式静态类图

 Java基于装饰者模式实现的染色馒头案例详解

希望本文所述对大家java程序设计有所帮助。

原文链接:https://blog.csdn.net/chengqiuming/article/details/70139340

标签:

相关文章

热门资讯

2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全 2019-12-26
yue是什么意思 网络流行语yue了是什么梗
yue是什么意思 网络流行语yue了是什么梗 2020-10-11
背刺什么意思 网络词语背刺是什么梗
背刺什么意思 网络词语背刺是什么梗 2020-05-22
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总 2020-11-13
Intellij idea2020永久破解,亲测可用!!!
Intellij idea2020永久破解,亲测可用!!! 2020-07-29
返回顶部