在java IO 流中我们经常看到这样的写法：

ObjectOutputStream oos = new ObjectOutputStream(

				new BufferedOutputStream(new FileOutputStream("obj.ser")));

这其实就是IO流使用装饰设计模式，装饰设计模式通常包含：

1、抽象的组件（抽象类或接口）

2、具体的组件：需要装饰的对象

3、抽象的装饰：包含了对抽象组件的引用以及装饰着共同的方法

4、具体的装饰类：被装饰的对象

下面模拟咖啡用装饰模式，直接上完整代码：

package com.xzlf.io;

/**

 * 模拟咖啡

 * 1、抽象的组件（抽象类或接口）

 * 2、具体的组件：需要装饰的对象

 * 3、抽象的装饰：包含了对抽象组件的引用以及装饰着共同的方法

 * 4、具体的装饰类：被装饰的对象

 * @author xzlf

 *

 */

public class DecorateTest02 {

	public static void main(String[] args) {

		Drink coffe = new Coffe();

		Drink milk = new Milk(coffe);

		System.out.println(milk.info() + "-->" + milk.cost());

		Drink suger = new Suger(coffe);

		System.out.println(suger.info() + "-->" +suger.cost());

		suger = new Suger(milk);

		System.out.println(suger.info() + "-->" +suger.cost());

	}

}

/* 抽象组件 */

interface Drink{

	double cost();// 费用

	String info();// 说明

}

/* 具体组件 */

class Coffe implements Drink{

	private String name = "原味咖啡";

	@Override

	public double cost() {

		return 10;

	}

	@Override

	public String info() {

		return name;

	}

}

/* 抽象的装饰类 */

abstract class Decorate implements Drink{

	private Drink drink;

	public Decorate(Drink drink) {

		this.drink = drink;

	}

	@Override

	public double cost() {

		return drink.cost();

	}

	@Override

	public String info() {

		return drink.info();

	}

}

/* 具体的装饰类 */

class Milk extends Decorate{

	public Milk(Drink drink) {

		super(drink);

	}

	@Override

	public double cost() {

		return super.cost()*10;

	}

	@Override

	public String info() {

		return super.info() + "加入了牛奶";

	}

}

/* 具体的装饰类 */

class Suger extends Decorate{

	public Suger(Drink drink) {

		super(drink);

	}

	@Override

	public double cost() {

		return super.cost()*2;

	}

	@Override

	public String info() {

		return super.info() + "加入了蔗糖";

	}

}

运行测试：