装饰者模式（Decorator）

定义

装饰模式，动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更加灵活

Component：是定义一个对象接口，可以给这些对象动态的添加职责。

ConcreteComponent：是定义了一个具体的对象，也可以个这个对象添加一些职责。

Decorator:装饰抽象类，继承了Component，从外类来扩展Component类的功能，但对于Component来说，是无需知道Decorator的存在的。

ConcreteDecorator就是具体的装饰对象，起到给Component添加职责的功能

Component是定义一个对象接口，可以给这些对象动态地添加职责。ConcreteComponent是定义了一个具体的对象，也可以给这个对象添加一些职责。Decorator装饰抽象类，继承了Component，从外类来扩展Component类的功能，但对于Component来说，是无需知道Decorator的存在的。至于ConcreteDecorator就是具体的装饰对象，起到给Component添加职责的功能。

应用场景

咖啡店里咖啡中可以加不同的配料–摩卡、牛奶、糖、奶泡；不同的饮品加上不同的配料有不同的价钱

在开发中，对于一些业务逻辑的处理，通常的做法或许就是将一些可能动态变化的业务逻辑封装起来，由于动态可变化，所以对于后期的逻辑的变更以及业务的扩展性能就需要一种设计去管理它。

装饰者模式很好的解决了这个问题，装饰着模式的含义：动态的给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。

实例

Component类：

public interface Component {
    public abstract void Operation();
}

ConcreteComponent 类

public class ConcreteComponent implements Component {

    @Override
    public void Operation() {
        System.out.println("具体对象的操作；");
    }
}

Decorator类

public class Decorator implements Component {
    protected Component component;
    //设置Component
    public void setComponent(Component component){
        this.component=component;
    }
    //重写Operation方法，实际执行的是Component的Operation
    @Override
    public void Operation() {
        if(component!=null){
            component.Operation();
        }
    }
}

ConcreteDecoratorA 类

public class ConcreteDecoratorA extends Decorator {
    //本类独有的功能，以区别于ConcreteDecoratorB
    private String addState;


    //首先运行Component的Operation，再执行本类的功能，如addState，相当于对原Component进行了修饰。
    @Override
    public void Operation() {
        super.Operation();
        addState="添加装饰的属性";
        System.out.println("具体装饰对象A的操作");
    }

}

ConcreteDecoratorB 类

public class ConcreteDecoratorB extends Decorator {
    @Override
    public void Operation() {
        super.Operation();
        AddedBehavior();
        System.out.println("具体装饰对象B的操作");
    }
    //本类独有的方法，区别于ConcreteDecoratorA
    private void AddedBehavior() {
    }
}

客户端代码：

public class Main {
    public static void main(String[] args){
        ConcreteComponent c =new ConcreteComponent();
        ConcreteDecoratorA ca=new ConcreteDecoratorA();
        ConcreteDecoratorB cb = new ConcreteDecoratorB();
        /*
        * 装饰方法是：
        * 首先用ConcreteComponent实例化对象C
        * 然后用ConcreteDecoratorA的实例化对象ca来包装从C
        * 再用ConcreteDecoratorB的实例化对象cb来包装ca
        * 最终执行cb的Operation
        * */
        ca.setComponent(c);
        cb.setComponent(ca);
        cb.Operation();
    }
}

如果只有一个ConcreteComponent类而没有抽象的Component类，那么，Decorator类可以是ConcreteComponent的一个子类。同样道理，如果只有一个ConcreteDecorator类，那么就没有必要建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator的之人合并成一个类。

总结

装饰模式是为已有功能动态地添加更多功能的一种方式。

什么时候用它：当系统需要新功能的时候，是向旧的类中添加新的代码。这些新加的代码通常装饰了原有类的核心职责或主要行为。他们再在主类中加入了新的字段，新的方法和新的逻辑，从而添加了主类的复杂度，而这些新加入进去的东西仅仅是为了满足一些旨在某特定情况下才会执行的特殊行为的需要。而装饰模式却提供了一个非常好的解决方案，它把每个要装饰的功能放在独立的类中，并让这个类包装它所要装饰的对象，因此，当需要执行特殊行为时，客户代码就可以在运行时根据需要有选择地，按顺序地使用装饰功能包装对象

优点：
把类中的装饰功能从类中搬移去除，这样简化原有的类
有效地把类的核心职责和装饰功能区分开。而且可以去除相关类中重复的装饰逻辑。