Io流里面的过滤流和节点流用的就是装饰者模式。整个的IO体系就是装饰模式。
这个写法就是装饰者模式。对上面的三个已经存在的类（DataOutputStream,BufferedOutputStream,FileOutputStream）进行组合，具有三种功能。
对于DataOutputStream dos=new DataOutStream(new BufferedOutputStream(new FileOutputStream("data.txt")));
这行代码来说。
OutPutStream是抽象构建角色。因为这三个类都是继承于OuputStream抽象类的。
FileOutputStream是具体构建角色（真实角色）（节点流）。
FilterOutPutStream和FilterInputStream是装饰角色。因为在Io体系中，BufferedOutputStream，DataOutStream都是继承自FilterOutPutStream抽象类的。
BufferedOutputStream，DataOutStream是具体装饰角色。
装饰模式的特点：
1.装饰对象和真实对象有相同的接口。这句话是说，不管是BufferedOutputStream（装饰角色）还是FileOutputStream(真实角色)都是继续自OutPutStream.
2.装饰角色包含一个真实对象的引用。
3.装饰对象接收所有来自客户端的请求，再把请求交给真实对象。
4.装饰对象可以在转发这些请求以前或以后增加一些附加的功能。这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。
实现自己的装饰模式：
案例结构如下：
上图中：Client是测试端。
Component是抽象构建角色，相当于OutputStream.
ConcreteComponent是具体构建角色（真实角色），也就是IO流中的节点流，相当于FileOutputStream.
Decorator是抽象构建角色，相当于过滤流的父类，也就是相当于IO流中的FilterOutputStream.
ConcreteDecorator1相当于IO流中的过滤流，也就是这篇文章中的BufferedOutputStream.
ConcreteDecorator2相当于IO流中的过滤流，也就是这篇文章中的DataOutputStream.
具体代码如下：
Component
package com.guigu.shen.ConcreteComponent;
//抽象构建角色
public interface Component {
public void dosome();
}
ConcreteComponent:
package com.guigu.shen.ConcreteComponent;
//具体构建角色(就是真实角色，要被修饰的角色)
public class ConcreteComponent implements Component {
public void dosome() {
System.out.println("功能A");
}
}
Decorator:
package com.guigu.shen.ConcreteComponent;
/*
* 装饰角色
* 1.要实现抽象构建角色
* 2.要含有抽象构建角色的引用。
*
*/
public class Decorator implements Component {
private Component component;
public Decorator(Component component) {
this.component=component;
}
@Override
public void dosome() {
this.component.dosome();
}
}
ConcreteDecorator1:
package com.guigu.shen.ConcreteComponent;
//具体装饰角色1
public class ConcreteDecoraror1 extends Decorator {
public ConcreteDecoraror1(Component component) {
super(component);
}
@Override
public void dosome() {
// TODO Auto-generated method stub
super.dosome();
doAnotherThing();
}
public void doAnotherThing()
{
System.out.println("功能B");
}
}
ConcreteDecorator2:
package com.guigu.shen.ConcreteComponent;
//具体装饰角色2
public class ConcreteDecorator2 extends Decorator {
public ConcreteDecorator2( Component component) {
super(component);
}
@Override
public void dosome() {
super.dosome();
this.doAnotherThing();
}
public void doAnotherThing()
{
System.out.println("功能C");
}
}
Client:
package com.guigu.shen.ConcreteComponent;
public class Client {
public static void main(String[] args) {
//1.先建立具体构建角色也就是真实角色（相当于节点流）
Component component=new ConcreteComponent();
//2.构建第一个装饰角色
Component component2=new ConcreteDecoraror1(component);
//3.构建第二个装饰角色
Component component3=new ConcreteDecorator2(component2);
component3.dosome();
}
}
结果：
功能A
功能B
功能C
你看。我们的本来功能是功能A，但是我们给他又加了两个功能，功能B和功能C。
对于上面程序的执行流程解释如下：
当我们执行component3.dosome时——>
执行：ConcreteDecorator2中的dosome()方法。
dosome()方法是：
@Override
public void dosome() {
super.dosome();
this.doAnotherThing();
}
很明显要执行ConcreteDecoator2的父类Decorator的dosome方法。
我们看一下Decorator的dosome方法的方法。
public Decorator(Component component) {
this.component=component;
}
@Override
public void dosome() {
this.component.dosome();
}
很明显先要执行this.component=component里面的dosome方法。也就是公共A。
然后就是就是B
最后是C
这个过程好好看看。