设计模式（八）装饰模式

概念

装饰模式能够在不改变原类文件和继承的情况下，动态的宽展一个对象的功能，通过创建一个包装对象来包裹真实的对象。

模式结构

在这几类角色结构中，必须扩展Component的功能，但Component并不知道Docorator的存在，ConcreteDocorator才是具体的装饰对象，起了给Component添加职责的作用。

• 抽象构建角色（Component）：抽象接口，用来规范准备接口附加责任的对象；
• 具体构建角色（ConcreteComponent）：定义一个将要接口附加责任的类；
• 装饰角色（Docorator）：定义一个与抽象构建角色一致的接口，持有一个抽象构建角色的引用；
• 具体的装饰角色（ConcreteDocorator）：负责给构建角色添加附加责任。

示例说明

/**
 * 抽象构建角色
 */
public interface Icomponent {
    void showCoffee();
    double showPrice();
}

/**
 * 具体的构建角色
 */
class Coffee implements Icomponent{
    private String name;
    private double price;

    public Coffee(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public void showCoffee() {
        System.out.println(this.name+"咖啡");
    }

    @Override
    public double showPrice() {
        return this.price;
    }
    // 省略get,set方法
}

/**
 * 装饰角色
 */
abstract class Docorator implements Icomponent{
    private Icomponent component;

    public void setComponent(Icomponent component) {
        this.component = component;
    }

    @Override
    public void showCoffee() {
        component.showCoffee();
    }

    @Override
    public double showPrice() {
        return component.showPrice();
    }
}

/**
 * 具体的装饰角色1
 */
class Milk extends Docorator{
    @Override
    public void showCoffee() {
        System.out.print("加奶的");
        super.showCoffee();
    }

    @Override
    public double showPrice() {
        return 20.0 + super.showPrice();
    }
}

/**
 * 具体的装饰角色2
 */
class Sugar extends Docorator{
    @Override
    public void showCoffee() {
        System.out.print("加糖的");
        super.showCoffee();
    }

    @Override
    public double showPrice() {
        return 10.0 + super.showPrice();
    }
}

class DocoratorClient{
    public static void main(String[] args){
        Icomponent coffee = new Coffee("蓝山", 80.0);
        Docorator milk = new Milk();
        Docorator sugar = new Sugar();

        coffee.showCoffee();
        System.out.println(coffee.showPrice());
        System.out.println("======================================");

        milk.setComponent(coffee);
        milk.showCoffee();
        System.out.println(milk.showPrice());
        System.out.println("======================================");

        sugar.setComponent(milk);
        sugar.showCoffee();
        System.out.println(sugar.showPrice());
    }
}

运行结果：

蓝山咖啡
80.0
======================================
加奶的蓝山咖啡
100.0
======================================
加糖的加奶的蓝山咖啡
110.0

装饰模式的思考起点就是利用“多用组合，少用继承”的原则；Java中装饰模式典型的使用是I/0流；装饰模式和AOP在思想上有共同之处。

装饰模式优缺点

• 比继承更灵活：继承是静态的，一旦继承，多有子类都有同样的功能；而装饰则是把功能分散到每个装饰器中，然后通过对象组合的方式，动态的组合调用；
• 更容易复用功能：功能分散到每个装饰器中，每个装饰器的功能相对简单，有利于复用；
• 简化高层定义：通过组合个方式给对象增加更多的功能，不需要在定义顶层类的时候把所有的功能都定义出来；
• 会产生很多细粒度对象：由于功能细分到每个装饰器，这样装饰器类会越来越多。