Decorator 装饰器模式

作用：动态的给对象增加额外的功能。这比通过生成子类的方式更为灵活。因为：1）有的时候，我们希望给某个对象而不是一个类增加功能。2）虽然继承机制也是增加功能的一种有效途径。但这种方式是静态的，无法控制增加的方式和时机。

别名：也叫包装器(Wrapper)。

解释：装饰器，顾名思义就是在某个对象的外面添加一些装饰的东西。我们把被装饰的对象称为组件，将该组件嵌入到另一个对象中，由这个对象添加功能。我们称这个嵌入的对象为装饰。

结构图：

Component：定义了对象的接口，我们要给这些对象动态的添加功能。
ConcreteComponent：具体的对象类。
Decorators：装饰器的父类。如果你确定只有一个装饰器类，也可以不采用这种继承模式。该类需要维持一个Component对象。并且需要与Component接口一致。
Decorator1/Decorator2：具体的装饰器类。每个类中都有增加的功能。

代码实例：

Component类

public abstract class Component {
    public abstract void draw();
}

ConcreteComponent类

public class ConcreteComponent extends Component{
    public void draw(){
        System.out.println("This is a round");
    }
}

Decorators类

public class Decorators extends Component{
    private Component component;
    public Decorators(Component c){
        this.component=c;
    }
    public  void draw(){
        component.draw();
    }
}

Decorator1类-BorderDecorator

public class BorderDecorator extends Decorators{
    public BorderDecorator(Component c) {
        super(c);
    }
    public void  draw(){
        super.draw();
        System.out.println("Draw: the border of round will be red color");
    }
}

Decorator2类-InnerDecorator

public class InnerDecorator extends Decorators{
    public InnerDecorator(Component c) {
        super(c);
    }
    public void  draw(){
        super.draw();
        System.out.println("Draw: the inner of round will be bule color");
    }
}

测试类

public class Test {
    public static void main(String args[]){
        Component c1=new ConcreteComponent();
        System.out.print("1: ");
        c1.draw();
        Component c2=new ConcreteComponent();
        System.out.print("2: ");
        c2.draw();
        BorderDecorator d1=new BorderDecorator(c1);
        System.out.print("3: ");
        c1.draw();
        System.out.print("4: ");
        d1.draw();
        InnerDecorator d2=new InnerDecorator(c2);
        System.out.print("5: ");
        d2.draw();
        InnerDecorator d3=new InnerDecorator(d1);
        System.out.print("6: ");
        d3.draw();
        Component cbig=new ConcreteComponent();
        Component dbig=new InnerDecorator(new BorderDecorator(cbig));
        System.out.print("7: ");
        dbig.draw();    
    }
}
/*
Output:
1: This is a round
2: This is a round
3: This is a round
4: This is a round
Draw: the border of round will be red color
5: This is a round
Draw: the inner of round will be bule color
6: This is a round
Draw: the border of round will be red color
Draw: the inner of round will be bule color
7: This is a round
Draw: the border of round will be red color
Draw: the inner of round will be bule color
*/

说明：
1 比静态继承更为灵活。可以在运行的时候增加功能(也可以删除某些功能)。并且，可以为一个特定的Component类提供多个不同的Decorator类，可以对功能进行混合。
2 避免在层次结构高层的类有太多特征。装饰器模式提供了一种“即用即付”的方式来增加功能。它不试图创建一个拥有所有可预见的特征的复杂的类。而是可以创建一个简单的类，逐渐的增加功能。
3 有许多小对象。在装饰器的过程中，会创建许多装饰器对象。每个装饰器类也会有许多对象，但这并不是它们的类或者它们的属性值有所不同。

实现注意点:
1 接口一致性。装饰对象的结构必须与它所装饰的Component的接口一致。
2 保持Component类的简单性。该类应该集中于定义接口而不是存储数据。
3 改变的是对象的外壳。我们可以将装饰器看作是对象的外壳，最终的效果是可以改变对象的行为。改变对象的行为还可以通过改变对象内核的方式，但那不是装饰器模式。