浅谈装饰者模式+JAVA I/O中的装饰者模式

1. 装饰者模式

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

1.1 类图

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

浅谈装饰者模式+JAVA I/O中的装饰者模式_第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中:

浅谈装饰者模式+JAVA I/O中的装饰者模式_第2张图片

程序运行后:

test.txt中:

浅谈装饰者模式+JAVA I/O中的装饰者模式_第3张图片

 

 

 

 

 

 

 

 

 

 

转载于:https://www.cnblogs.com/Yang-Yuanlin/p/10018324.html

你可能感兴趣的