六、装饰模式

装饰模式-（Decorator）：动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。装饰模式的过程不是稳定的，也就是说可以变化；而建造者模式要求建造过程必须稳定，顺序等不能发生变化。

• 1.首先定义一个接口对象或者抽象对象，来给这个对象动态添加职责（功能或方法）

package com.zcbl.client.zcblsdk.decoratormodel;

/**
 * Created by serenitynanian on 2018/2/8.
 * Component 定义一个抽象对象（或对象接口），可以给这个对象动态地添加职责
 */

public abstract class Component {

    public abstract void operate();
}

• 2.定义个具体的对象，也可以给这个对象动态添加一些职责（功能或方法），这个对象继承或实现Component

package com.zcbl.client.zcblsdk.decoratormodel;

/**
 * Created by serenitynanian on 2018/2/8.
 * ConcreteComponent 是定义了一个具体的对象，也可以给这个对象添加一些职责
 */

public class ConcreteComponent extends Component {
    @Override
    public void operate() {
        System.out.println("-----ConcreteComponent-------具体对象的操作");
    }
}

• 3.定义一个装饰的抽象类，继承自Component，从外类来扩展Component类的功能，但对于Component来说，是无需知道Decorator的存在的；

package com.zcbl.client.zcblsdk.decoratormodel;

/**
 * Created by serenitynanian on 2018/2/8.
 * Decorate 装饰抽象类，继承了Component,从外类来扩展Component类的功能，但对于Component来说，是无需知道Decorate的存在
 */

public abstract class Decorate extends Component {
    private Component component;

    /**
     * 设置component
     * @param component
     */
    public void setComponent(Component component) {
        this.component = component;
    }

    /**
     * 重写operate(),实际执行的是Component的operate()
     */
    @Override
    public void operate() {
        if (component != null) {
            component.operate();
        }
    }
}

• 4.创建具体的装饰对象，起到给Component添加职责的功能；

package com.zcbl.client.zcblsdk.decoratormodel;

/**
 * Created by serenitynanian on 2018/2/8.
 * 具体的装饰对象，起到给Component添加职责功能。
 */

public class ConcreteDecoratorA extends Decorate {

    private String addedState ;

    @Override
    public void operate() {
        //首先运行父类的Component的operate方法，在执行本类的功能，如addedState,相当于对Component进行了装饰；
        super.operate();
        addedState = "New Stated";
        System.out.println("具体的装饰对象A的操作");
    }
}

package com.zcbl.client.zcblsdk.decoratormodel;

/**
 * Created by serenitynanian on 2018/2/8.
 */

public class ConcreteDecoratorB extends Decorate {

    @Override
    public void operate() {
        //首先运行父类的Component的operate方法，在执行本类的功能，如addedBehavior(),相当于对Component进行了装饰；
        super.operate();
        addedBehavior();
    }

    /**
     * 本类独有的方法，以区别于ConcreteDecoratorA
     */
    private void addedBehavior() {

        System.out.println("----------addedBehavior--------");

    }
}

• 5.具体的条用如下：

package com.zcbl.client.zcblsdk.decoratormodel;

/**
 * Created by serenitynanian on 2018/2/8.
 */

public class DecoratorTest {

    public static void main(String[] args) {
        /**
         * 装饰的方法是：首先用ConcreteComponent实例化对象c，然后用ConcreteDecoratorA的实例化对象d1来包装c，
         * 再用ConcreteDecoratorB的实例化对象d2来包装d1，最终执行d2的operate()方法；
         */
        ConcreteComponent c = new ConcreteComponent();
        ConcreteDecoratorA d1 = new ConcreteDecoratorA();
        ConcreteDecoratorB d2 = new ConcreteDecoratorB();
        //装饰过程
        d1.setComponent(c);
        d2.setComponent(d1);

        d2.operate();
    }
}

• 6. 总结：
     1.装饰模式是利用setComponent来对对象进行包装的。这样每个装饰对象的实现就和如何使用这个对象分离开了，每个装饰对象只需要关心自己的功能，不需要关心如何被添加到对象链当中。
     2.学习模式要善于变通，如果只有一个ConcreteComponent类而没有抽象的Component类，那么Decorator类可以是ConcreteComponent的一个子类。同样道理，如果只有一个ConcreteDecorator类，那么就没有建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator的责任合并成一个类；

问题来了：装饰模式是为已有的功能动态地添加更多功能的一种方式，到底要在什么时候用它呢？

装饰模式是为了在已有功能上添加新的功能，那么如果新添加的功能仅仅是为了满足一些只在某种特定情况下才会执行的特殊功能时，是一个很好的解决方案；他把每个要装饰的功能放在单独的类中，并让这个类有选择的、按顺序地包装它所要装饰的对象；