（四）装饰模式

1 概述

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

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

• 示例代码

Component类

public abstract class Component {
    public abstract void operation();
}

ConcreteComponent类

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

Decorator类

public abstract class Decorator extends 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 abstract class Decorator extends 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();
        }
    }
}

ConcreteDecoratorB类

public class ConcreteDecoratorB extends Decorator {
    // 首先运行原Component的operation()，
    // 再执行本类的功能，如addedBehavior()，
    // 相当于对原Component进行了装饰
    @Override
    public void operation() {
        super.operation();
        addedBehavior();
        System.out.println("具体装饰对象B的操作");
    }

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

    }
}

客户端代码

public class Client {
    public static void main(String[] args) {
        ConcreteComponent c = new ConcreteComponent();
        ConcreteDecoratorA d1 = new ConcreteDecoratorA();
        ConcreteDecoratorB d2 = new ConcreteDecoratorB();
        d1.setComponent(c);
        d2.setComponent(d1);
        d2.operation();
    }

输出入下

具体对象的操作
具体装饰对象A的操作
具体装饰对象B的操作

Process finished with exit code 0

可以一层一层地包装修饰，动态添加功能。如上例中，d1包装了c，d2包装了d1。

• 装饰模式是利用SetComponent 来对对象进行包装的。这样每个装饰对象的实现就和如何使用这个对象分离开了，每个装饰对象只关心自己的功能，不需要关心如何被添加到对象链当中。

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

2 示例

• 目标：设计一个人物服饰系统
• 思路：采用装饰模式。但不使用Component，直接使用ConcreteComponent即Person。服饰类Finery继承Person类。

Person类

public class Person {
    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public void show() {
        System.out.print("装扮的" + name + "：");
    }
}

Finery类

public class Finery extends Person {
    protected Person component;

    public void decorate(Person component) {
        this.component = component;
    }

    @Override
    public void show() {
        if (component != null) {
            component.show();
        }
    }
}

TShirts类

public class TShirts extends Finery {
    @Override
    public void show() {
        super.show();
        System.out.print("T恤 ");
    }
}

BigTrouser类

public class BigTrouser extends Finery {
    @Override
    public void show() {
        super.show();
        System.out.print("垮裤 ");
    }
}

Sneakers类

public class Sneakers extends Finery {
    @Override
    public void show() {
        super.show();
        System.out.print("运动鞋 ");
    }
}

输出入下

第一种装扮
装扮的小明：T恤 垮裤 
第二种装扮
装扮的小明：T恤 运动鞋 

注：Finery类一定要调用component的show方法，之前写错成调用super.show()方法了，这样就不会调用中间各修饰类的show()方法了。具体的服装类才调用super.show()方法。

3 总结

• 装饰模式是为已有功能动态地添加更多功能的一种方式。
• 装饰模式把每个要装饰的功能放在单独的类中，并让这个类包装它所要装饰的对象，因此，当需要执行特殊行为时，客户代码就可以在运行时根据需要有选择地、按顺序地使用装饰功能包装对象了。
• 优点： 把类中的装饰功能从类中搬移去除，这样可以简化原有的类；有效地把类的核心职责和装饰功能区分开了。而且可以去除相关类中重复的装饰逻辑。

参考书籍
《大话设计模式》