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)模式。装饰模式是在不必改变原类文件和使用继承的情况下，动态的扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

装饰模式的特点

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

装饰模式中的角色

Component：抽象出的主体对象。通常是一个接口或抽象类，例如OutputStream。
ConcreteComponent：是要动态扩展的对象，它继承自Component。这是一个具体的类，一般情况下都具有基本的功能，例如FileOutputStream。
Decorator：抽象的装饰类。一般情况下这个类实现了Component，且包含了一个Component的引用，例如BufferedOutputStream的父类FilterOutputStream。
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();
}
}