装饰者模式（十三）

一、定义

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

二、类图及各角色

1. Component 抽象组件（公共接口/抽象类）

    装饰者模式必须要有这样一个抽象的组件，被装饰者和装饰者都是这个抽象的具体实现。往往定义我们最核心、最原始、最基本的对象。

public abstract class Component {
    //抽象的方法
    public abstract void operate();
}

2. ConcreteComponent 具体组件（被修饰者）

     ConcreteComponent 是最核心、最原始、最基本的接口或抽象类的实现，即被修饰者。

public class ConcreteComponent extends Component {
    //具体实现
    @Override
    public void operate() {
        System.out.println("do Something");
    }
}

3. Decorator 修饰者

    一般我们会定义一个抽象类作为修饰者的共同父类（当然，如果这有一个修饰者的话，我们也是可以省略掉这个抽象的父类的），修饰者除了实现共同接口外，还会持有一个 Component 的实例。

public abstract class Decorator extends Component {
    private Component component;
    //通过构造函数传递被修饰者
    public Decorator(Component _component){
        this.component = _component;
    }
    //委托给被修饰者执行
    @Override
    public void operate() {
        this.component.operate();
    }
}

4. ConcreteDecorator 具体修饰者

    即 Decorator 抽象类的具体实现类

public class ConcreteDecorator1 extends Decorator {
    //定义被修饰者
    public ConcreteDecorator1(Component _component){
        super(_component);
    }
    //定义自己的修饰方法
    private void method1(){
        System.out.println("method1修饰");
    }
    //重写父类的Operation方法
    public void operate(){
        this.method1();
        super.operate();
    }
}

public class ConcreteDecorator2 extends Decorator {
    //定义被修饰者
    public ConcreteDecorator2(Component _component){
        super(_component);
    }
    //定义自己的修饰方法
    private void method2(){
        System.out.println("method2修饰");
    }
    //重写父类的Operation方法
    public void operate(){
        super.operate();
        this.method2();
    }
}

    最后我们可以模拟一个场景来调用，看看装饰者模式是如何运转的

public class Client {
    public static void main(String[] args) {
        Component component = new ConcreteComponent();
        //第一次修饰
        component = new ConcreteDecorator1(component);
        //第二次修饰
        component = new ConcreteDecorator2(component);
        //修饰后运行
        component.operate();
    }
}

三、优缺点

• 优点：

1. 动态的扩展一个类的功能，相比起继承，不管装饰多少层，它都不会产生深层继承的关系（继承层次很高后，代码是很难控制的）。
2. 装饰者和被装饰者可以独立发展，而不会互相耦合。即 Component 类无须知道 Decorator 类， Decorator 类是从外部来扩展 Component 类的功能， 而 Decorator 也不用知道具体的构件。

• 缺点：

1. 装饰太多后，会产生很多相似的对象，不易拍错。应当尽量减少装饰类的数量，降低系统复杂度。

四、使用场景

1. 需要扩展一个类的功能， 或给一个类增加附加功能。
2. 需要动态地给一个对象增加功能， 这些功能可以再动态地撤销。
3. 需要为一批的兄弟类进行改装或加装功能， 当然是首选装饰模式。

五、装饰者模式和代理模式

    也许大家还记得代理模式，的确，他们两者十分相似，装饰者其实就像一个特殊的代理。我的理解，装饰者侧重于扩展一个类或是对象的功能，代理者侧重于对原有方法进行改进。我们也不必追求他们两者之间的具体差别。

查看更多：设计模式分类以及六大设计原则

​