装饰模式java咖啡_浅谈装饰者模式+JAVA I/O中的装饰者模式

最新推荐文章于 2022-10-27 15:40:36 发布

原创最新推荐文章于 2022-10-27 15:40:36 发布 · 244 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#装饰模式java咖啡

本文介绍装饰者模式在饮料店场景的应用，通过实例说明如何避免类爆炸，并展示Java I/O操作中装饰者模式的具体实现。

1. 装饰者模式

举个栗子，假如在一家饮料店中有两种饮料，分别是奶茶和咖啡，相对的有三种调料，蜂蜜、块糖和摩卡，这样消费者就有不同的消费组合，比如加糖摩卡咖啡、蜂蜜摩卡咖啡，加糖奶茶......如果饮料的种类或者调料的种类增多，那么消费组合就会相应的增多，反映到编程代码上就会出现“类爆炸”，而且再添加新的饮料或者调料时会不可避免的改变原有的类的代码，这就违反了设计原则中的开放-关闭原则，即类应该对扩展开放，对修改关闭。

1.1 类图

使用装饰者模式就能很好地解决这个问题，废话不多说，该例子的类图如下：

其中Beverage是抽象类，CondimentDecorator是继承自Beverage类的抽象类。

1.2 饮料的抽象类

Beverage.java代码：

/**

* @author yylin

public abstract class Beverage {

// 饮料的描述

protected String description;

public Beverage() {

description = "饮料的抽象类";

}

public String getDescription() {

return description;

}

public abstract double cost();

}

1.3 调味品的抽象类

CondimentDecorator.java代码：

/**

* @author yylin

// 调味品装饰者，继承自饮料的抽象类

public abstract class CondimentDecorator extends Beverage {

public CondimentDecorator() {

description = "调味品的抽象类";

}

@Override

public abstract String getDescription();//所有的调料品装饰者必须重写getDescription()方法

@Override

public abstract double cost();//所有的调料品装饰者必须重写cost()方法

}

1.4 饮料奶茶的实现类

TeaMilk.java的代码：

/**

* @author yylin

public class TeaMilk extends Beverage {

public TeaMilk(){

//饮料的描述

description="奶茶";

}

/* (non-Javadoc)

* @see Beverage#cost()

@Override

public double cost() {

//奶茶一杯三块钱

return 3.0;

}

1.5 饮料咖啡的实现类

Coffee.java的代码：

/**

* @author yylin

public class Coffee extends Beverage {

public Coffee() {

//饮料的描述

description="咖啡";

}

/* (non-Javadoc)

* @see Beverage#cost()

@Override

public double cost() {

//咖啡一杯四块钱

return 4.0;

}

1.6 调味品蜂蜜的实现类

Honey.java的代码：

/**

* @author yylin

// 蜂蜜，继承自调味品抽象类

public class Honey extends CondimentDecorator {

// 记录饮料的变量，是被装饰者

Beverage beverage;

// 让被装饰者记录到实例变量中

public Honey(Beverage beverage) {

this.beverage = beverage;

}

@Override

public String getDescription() {

// 描述调味品和饮料

return "蜂蜜" + beverage.getDescription();

}

* (non-Javadoc)

* @see CondimentDecorator#cost()

@Override

public double cost() {

// 加蜂蜜一块钱，计算加了蜂蜜的饮料的价钱

return 1.0 + beverage.cost();

}

1.7 调味品摩卡的实现类

Mocha.java的代码：

/**

* @author yylin

// 摩卡，继承自调味品装饰者

public class Mocha extends CondimentDecorator {

// 用一个变量记录饮料，也就是被装饰者

Beverage beverage;

// 把被装饰者记录到实例变量中

public Mocha(Beverage beverage) {

this.beverage = beverage;

}

@Override

public String getDescription() {

// 描述调味品和饮料

return "摩卡" + beverage.getDescription();

}

@Override

public double cost() {

// 加摩卡一块钱，计算加了摩卡的饮料的价钱

return 1.0 + beverage.cost();

}

1.8 调味品糖的实现类

Sugar.java的代码：

/**

* @author yylin

// 糖，继承自调味品抽象类

public class Sugar extends CondimentDecorator {

// 用一个变量记录饮料，也就是被装饰者

Beverage beverage;

// 把被装饰者记录到实例变量中

public Sugar(Beverage beverage) {

this.beverage = beverage;

}

@Override

public String getDescription() {

// 描述加糖的饮料

return "加糖" + beverage.getDescription();

}

@Override

public double cost() {

// 计算加了糖的饮料的价钱

return 1.0 + beverage.cost();

}

1.9 测试类

/**

* @author yylin

//测试类

public class TestMain {

public static void main(String[] args) {

// 点一杯蜂蜜摩卡咖啡

Beverage beverage1 = new Coffee();// 定义咖啡对象

beverage1 = new Mocha(beverage1);// 用摩卡装饰

beverage1 = new Honey(beverage1);// 用蜂蜜装饰

System.out.println("顾客点了(" + beverage1.getDescription() + ")\n价格是："

+ beverage1.cost() + "元");

// 点一杯加糖奶茶

Beverage beverage2 = new TeaMilk();// 定义奶茶对象

beverage2 = new Sugar(beverage2);// 用糖装饰

System.out.println("顾客点了(" + beverage2.getDescription() + ")\n价格是："

+ beverage2.cost() + "元");

}

运行结果

2. JAVA I/O中的装饰者模式

例题：

l先从文件test.txt中读Employee对象的数据存到HashMap，

l再把HashMap中的Employee对象的数据存到一个新的文件test2.txt。

代码：

2.1 Employee实体类Employee.java

package com.nwpu;

/**

* @author yylin

public class Employee {

private String id;

private String name;

private String department;

public Employee() {

}

public Employee(String id, String name, String department) {

this.id = id;

this.name = name;

this.department = department;

}

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getDepartment() {

return department;

}

public void setDepartment(String department) {

this.department = department;

}

@Override

public String toString() {

return id+","+name+","+department;

}

2.2 测试类TestFileIO.java

package com.nwpu;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.util.HashSet;

import java.util.Set;

/**

* @author yylin

* 读取文件时：

* 一行一行读取文件，解决读取中文字符时出现乱码。

* 流的关闭顺序：先打开的后关，后打开的先关，

* 否则有可能出现java.io.IOException: Stream closed异常。

* 写入文件时：

* 一行一行写入文件，解决写入中文字符时出现乱码。

* 流的关闭顺序：先打开的后关，后打开的先关，

* 否则有可能出现java.io.IOException: Stream closed异常。

public class TestFileIO {

public static void main(String[] args) {

/**

* read file

FileInputStream fis=null;//文件输入流

InputStreamReader isr=null;//读入输入流

BufferedReader br=null;//对读入的文件流缓存

Set set=new HashSet();

try {

String fileURL="E:/test/test.txt";

fis=new FileInputStream(fileURL);

//解决读入中文乱码的问题 + 用InputStreamReader类装饰FileInputStream类

isr=new InputStreamReader(fis,"UTF-8");

//用BufferedReader类装饰BufferedReader类

br=new BufferedReader(isr);

String line="";

String arrs[]=null;

//按行读入

while ((line=br.readLine())!=null) {

System.out.println(line);//输出读入的行

arrs=line.split(",");

//注入对象

set.add(new Employee(arrs[0],arrs[1],arrs[2]));

}

//流的关闭顺序：先打开的后关，后打开的先关

br.close();

isr.close();

fis.close();

} catch (Exception e) {

e.printStackTrace();

}

for (Employee e : set) {

System.out.println(e.toString());

}

/**

* write file

FileOutputStream fos=null;//文件输出流

OutputStreamWriter osw=null;//写出输出流

BufferedWriter bw=null;//缓存写出的输出流

try {

String fileURL="E:/test/test2.txt";

fos=new FileOutputStream(fileURL);

//解决中文乱码问题 + 用OutputStreamWriter类装饰FileOutputStream类

osw=new OutputStreamWriter(fos,"UTF-8");

//用BufferedWriter类装饰OutputStreamWriter类

bw=new BufferedWriter(osw);

for (Employee e : set) {

bw.write(e.toString()+"\r\n");

}

//注意关闭的先后顺序，先打开的后关闭，后打开的先关闭

bw.close();

osw.close();

fos.close();

} catch (Exception e) {

e.printStackTrace();

}

2.3 运行结果

程序运行前：

test.txt中：

程序运行后：

test.txt中：