DecoratorPattern装饰者模式

装饰者模式

1,定义

动态的给一个对象添加一些额外的职责。

装饰者模式通常有4个角色，就增加功能来说，装饰者模式比生成子类更加的灵活。

Component：抽象构件。通常是一个接口或者抽象类，定义最核心最原始的对象。

public interface AbstractComponent {

    /**
     * 抽象方法
     */
    void operate();
}

ConcreteComponent：具体构件。抽象构件的实现，即被装饰的对象。

public class Component implements AbstractComponent {

    @Override
    public void operate() {
        System.out.println("do something!");
    }
}

Decorator：抽象装饰者角色。通常是一个抽象类，可设置一个被装饰对象。

public abstract class Decorator implements AbstractComponent {

    /** 定义一个装饰构件 **/
    private AbstractComponent abstractComponent;

    /**
     * 通过构造函数设置被装饰者
     * @param abstractComponent
     */
    public Decorator(AbstractComponent abstractComponent) {
        this.abstractComponent = abstractComponent;
    }

    /**
     * 委托被装饰着执行
     */
    @Override
    public void operate() {
        this.abstractComponent.operate();
    }
}

ConcreteDecorator：具体装饰者角色。实现对构件的功能职责的扩展。

public class DecoratorOne extends Decorator {

    /**
     * 通过构造函数设置被装饰者
     *
     * @param abstractComponent
     */
    public DecoratorOne(AbstractComponent abstractComponent) {
        super(abstractComponent);
    }

    /**
     * 定义自己的装饰方法
     */
    private void methodOne() {
        System.out.println("DecoratorOne.methodOne 装饰");
    }

    /**
     * 重写被装饰对象的方法
     */
    @Override
    public void operate() {
        this.methodOne();
        super.operate();
    }
}

public class DecoratorTwo extends Decorator {

    /**
     * 通过构造函数设置被装饰者
     *
     * @param abstractComponent
     */
    public DecoratorTwo(AbstractComponent abstractComponent) {
        super(abstractComponent);
    }

    /**
     * 定义自己的装饰方法
     */
    private void methodTwo() {
        System.out.println("DecoratorTwo.methodTwo 装饰");
    }

    /**
     * 重写被装饰对象的方法
     */
    @Override
    public void operate() {
        super.operate();
        this.methodTwo();
    }
}

场景类

public class Client {

    public static void main(String[] args) {
        /** 定义被装饰着 **/
        AbstractComponent component = new Component();

        /** 第一次装饰 **/
        component = new DecoratorOne(component);

        /** 第二次装饰 **/
        component = new DecoratorTwo(component);

        component.operate();
    }
}

2.应用

2.1 优点

• 装饰者及被装饰者相互独立，两者解耦，提高系统的灵活性。
• 装饰者模式是继承关系的替代方案，且不论被装饰多少层，返回的对象仍然是该被装饰者。
• 装饰者模式可以动态的扩展一个实现类的功能。

2.2 缺点

• 多层装饰会增加实现类的复杂度，减少装饰类的数量可以降低系统的复杂度。

2.3 使用场景

• 动态的为一个对象增加功能，且可以动态的撤销。
• 为一批实现类改装或加装功能。