前言
java中对象的增强手段大致有三种，继承、装饰者模式、动态代理。先来看看三者的特点：
继承
被增强的对象是固定的
增强的内容也是固定的
装饰者
被增强的对象是可以切换的
增强的内容是固定的
动态代理
被增强的对象是可以切换的
增强的内容也是可以切换的
定义
Decorator模式（别名Wrapper）：动态将职责附加到对象上，若要扩展功能，装饰者提供了比继承更具弹性的代替方案。
类图
2017-11-25_163302.png
通过类图，我们大致可以看到，装饰者模式有四个角色，被装饰者父接口、被装饰者、装饰者父类，具体装饰者
这里需要注意的是，上类图只是一个完整的装饰者结构，但其实装饰者还是可以有很多改变的地方的，
1、Component接口可以是接口也可以是抽象类，甚至是一个普通的父类
2、装饰器的抽象父类Decorator并不是必须的。
一个demo实例
一个被装饰者接口
/**
* 被一个装饰接口
*/
public interface Component {
void fun();
}
一个被装饰者实现类
/**
* 被装饰对象
*/
public class ConcreteComponent implements Component {
public void fun() {
System.out.println("原来的方法！");
}
}
一个装饰者父类（这里注意，此类要实现与被装饰类相同的接口）
/**
* 装饰者
* ClassName: Decorator
*/
//是你
public class Decorator implements Component {
//还有你
protected Component component;
public Decorator(Component component) {
super();
this.component = component;
}
@Override
public void fun() {
//component子类对象
component.fun();// 一切拜托你
}
}
若干个装饰者
//A装饰类
public class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
/**
* 扩展的一个方法
*/
public void method(){
System.out.println("扩展的方法！A");
}
/**
* 对之前方法进行加强
*/
public void fun(){
System.out.println("原方法功能的加强前：包装开始 A");
super.fun();
System.out.println("原方法功能的加强后：包装结束 A");
}
}
//B装饰类
public class ConcreteDecoratorB extends Decorator {
public ConcreteDecoratorB(Component component) {
super(component);
}
/**
* 扩展的一个方法
*/
public void method(){
System.out.println("扩展的方法！B");
}
/**
* 对之前方法进行加强
*/
public void fun(){
System.out.println("原方法功能的加强前：包装开始 B");
super.fun();
System.out.println("原方法功能的加强后：包装结束 B");
}
}
测试类
public class App{
public static void main(String[] args) {
//原来的对象
Component component = new ConcreteComponent();
System.out.println("---------------------");
component.fun();//调用原来的方法
//装饰A（装饰原对象）
ConcreteDecoratorA concreteDecoratorA = new ConcreteDecoratorA(component);//装饰A，对原来compent对象进行装饰
System.out.println("----------------------");
concreteDecoratorA.fun();
concreteDecoratorA.method();
//装饰B（装饰原对象）
ConcreteDecoratorB concreteDecoratorB = new ConcreteDecoratorB(component);//装饰B，对原来compent对象进行装饰
System.out.println("----------------------");
concreteDecoratorB.fun();
concreteDecoratorB.method();
//装饰B（装饰A对象）
concreteDecoratorB = new ConcreteDecoratorB(concreteDecoratorA);//装饰B，对A对象进行装饰
System.out.println("----------------------");
concreteDecoratorB.fun();
concreteDecoratorB.method();
}
}
2017-11-25_164633.png
以上就是一个简单的装饰者，另外装饰的父类不是必须的，可以不要装饰父类直接进行装饰。写到这里，不知道大家有没有想到我们使用的IO缓冲流和Collections去创建同步的集合容器。
这里引用一张左盟主的图
2017-11-25_165308.png
BufferedReader br = new BufferedReader(new FileReader(""));
BufferedWriter bw = new BufferedWriter(new FileWriter(""));
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(""));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(""));
我们可以看到，对普通流装饰后得到高效的缓冲流。
