设计模式——装饰者模式

参考书籍：设计模式之禅——秦小波著，机械工业出版社

1 定义

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

2 类图

图片来自百度百科

3 代码

（1）Component类

package com.amy.decoratordesign;

/**
 * 抽象构建
 * @author zhujinrong
 *
 */
public abstract class Component {

    /**
     * 抽象方法
     */
    public abstract void Operate();
}

 （2） ConcreteComponent类

package com.amy.decoratordesign;

/**
 * 具体构件
 * @author zhujinrong
 *
 */
public class ConcreteComponent extends Component{

    /**
     * 具体实现
     */
    @Override
    public void Operate() {
        // TODO Auto-generated method stub
        System.out.println("ConcreteComponent-Operate:do something");
    }
}

（3）Decorator类

package com.amy.decoratordesign;

/**
 * 抽闲装饰类
 * 
 * @author zhujinrong
 * 
 */
public abstract class Decorator extends Component {

    /**
     * 构件
     */
    private Component component = null;

    /**
     * 通过构造函数传递被修饰者
     * 
     * @param component
     *            构件
     */
    public Decorator(Component component) {
        this.component = component;
    }

    /**
     * 委托给被修饰者执行
     */
    @Override
    public void Operate() {
        this.component.Operate();
    }
}

（4）ConcreteDecoratorA 类

package com.amy.decoratordesign;

/**
 * 具体装饰类
 * @author zhujinrong
 *
 */
public class ConcreteDecoratorA extends Decorator {

    /**
     * 构造函数
     * @param component 构件
     */
    public ConcreteDecoratorA(Component component) {
        super(component);
        // TODO Auto-generated constructor stub
    }

    /**
     * 定义自己的修饰方法
     */
    private void method1() {
        System.out.println("ConcreteDecoratorA-method1:修饰");
    }
    
    /**
     * 重写父类的Operate方法
     */
    @Override
    public void Operate(){
        this.method1();
        super.Operate();
    }
}

（5）ConcreteDecoratorB类

package com.amy.decoratordesign;

/**
 * 具体装饰类B
 * 
 * @author zhujinrong
 * 
 */
public class ConcreteDecoratorB extends Decorator {

    /**
     * 构造函数
     * 
     * @param component
     *            构件
     */
    public ConcreteDecoratorB(Component component) {
        super(component);
        // TODO Auto-generated constructor stub
    }

    /**
     * 自定义装饰
     */
    private void method1() {
        System.out.println("ConcreteDecoratorB-method1:修饰。");
    }

    /**
     * 重写父类方法
     */
    @Override
    public void Operate() {
        this.method1();
        super.Operate();
    }
}

（6）Client类

package com.amy.decoratordesign;

/**
 * 场景类
 * @author zhujinrong
 *
 */
public class Client {
    /**
     * 程序入口
     * @param args
     */
    public static void main(String[] args) {
        Component component = new ConcreteComponent();

        // 第一次修饰
        component = new ConcreteDecoratorA(component);

        // 第二次修饰
        component = new ConcreteDecoratorB(component);

        // 修饰后运行
        component.Operate();
    }
}

4 执行结果

注意看看这个结果。

4 装饰模式的优缺点

（1）装饰类和被装饰类可以独立发展，而不会相互耦合。换句话说，Component类无须知道Decorator类，Decorator类是从外部来扩展Component类的功能，而Decorator也不用知道具体的构件。

（2）装饰模式是继承关系的一个替代方案。我们看装饰类Decorator，不管装饰多少层，返回的对象还是Component，实现的还是is-a的关系。

（3）装饰模式可以动态地扩展一个实现类的功能，这不需要多说，装饰模式的定义就是如此。

5 装饰模式的缺点

　　多层的装饰是比较复杂的。就想剥洋葱一样。

6 使用场景

（1）需要扩展一个类的功能，或给一个类增加附加功能

（2）需要动态地给一个对象增加功能，这些功能可以再动态地撤销

（3）需要为一批的兄弟类进行改装或加装功能，当然首选装饰模式

7 最佳实践

　　继承是静态地给类增加功能，而装饰模式则是动态地增加功能。

　　装饰模式是对继承的有力扩充。

　　装饰模式扩展性很好。