Java与设计模式(3)--装饰模式

首先我们来看一个使用OutputStream的例子：

public class TestFileOutputStream {
	public static void main(String[] args) throws IOException {
		FileOutputStream outs = new FileOutputStream("test.txt");
		String str = "Test File Output Stream";
		outs.write(str.getBytes());
		outs.close();
	}
}

以上是简单的I/O例子，如果我们有很多数据需要写入，那么我们肯定不能每次都去写磁盘，所以我们需要缓存，Java中我们可以使用BufferedOutputStream：

public class TestBufferedOutputStream {
	public static void main(String[] args) throws IOException {
		BufferedOutputStream outs = new BufferedOutputStream(
				new FileOutputStream("test.txt"));
		for (int i = 0; i < 10000; i++) {
			String str = "Test File Output Stream" + i;
			outs.write(str.getBytes());
		}
		outs.close();
	}
}

我们回想一下，如果按照面向对象的三要素：封装、继承、多态来说，我们需要扩展FileOutputStream的时候我们应该用的是继承才对，应该从FileOutputStream继承出一个BufferedFileOutputStream子类，但实际上我们是通过包装一个FileOutputStream得到的一个带缓冲的文件写入对象，这里使用到的就是我们将要讲述的 装饰模式。

我们下面了解一下装饰模式的内容：

什么是装饰模式

装饰模式是JAVA的23种设计模式之一，英文叫Decorator Pattern，又叫装饰者/包装模式(Wrapper)模式。装饰模式是在不必改变原类文件和使用继承的情况下，动态的扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

装饰模式的特点

1. 装饰对象和真实对象有相同的接口。这样客户端对象就可以和真实对象相同的方式和装饰对象交互。
2. 装饰对象包含一个真实对象的引用（reference）
3. 装饰对象接受所有来自客户端的请求。它把这些请求转发给真实的对象。
4. 装饰对象可以在转发这些请求以前或以后增加一些附加功能。这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。在面向对象的设计中，通常是通过继承来实现对给定类的功能扩展。

装饰模式中的角色

1. Component：抽象出的主体对象。通常是一个接口或抽象类，例如OutputStream。
2. ConcreteComponent：是要动态扩展的对象，它继承自Component。这是一个具体的类，一般情况下都具有基本的功能，例如FileOutputStream。
3. Decorator：抽象的装饰类。一般情况下这个类实现了Component，且包含了一个Component的引用，例如BufferedOutputStream的父类FilterOutputStream。
4. ConcreteDecorator：实现Decorator的类，用来实现具体扩展Component的功能代码，例如我们的BufferedOutputStream。一般情况下ConcreteDecorator都有多个，分别用来扩展不同的功能。

实例

Component.java

public interface Component {
	public void output();
}

ConcreteComponent.java

public class ConcreteComponent implements Component {
	@Override
	public void output() {
		System.out.println("ConcreteComponent output.");
	}
}

Decorator.java

public class Decorator implements Component{
	public Component c;
	
	public Decorator(Component c) {
		super();
		this.c = c;
	}

	@Override
	public void output() {
		c.output();
	}
}

ConcreteDecoratorA.java

public class ConcreteDecoratorA extends Decorator {
	public ConcreteDecoratorA(Component c) {
		super(c);
	}

	@Override
	public void output() {
		super.output();
		
		System.out.println("ConcreteDecoratorA output.");
	}
}

ConcreteDecoratorB.java

public class ConcreteDecoratorB extends Decorator {
	public ConcreteDecoratorB(Component c) {
		super(c);
	}

	@Override
	public void output() {
		super.output();
		
		System.out.println("ConcreteDecoratorB output.");
	}
}

Client.java

public class Client {
	public static void main(String[] args) {
		Component c = new ConcreteComponent();
		Component a = new ConcreteDecoratorA(c);
		Component b = new ConcreteDecoratorB(a);
		
		b.output();
	}
}