常用设计模式——装饰器模式

简介

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其类的结构的一种结构型模式。这种模式创建了一个装饰类，用来包装原有的类，并在保证类的签名完整性的条件下，提供了额外功能。

实现

前几天星巴克的猫爪杯可谓是赚足眼球，一个小小的杯子被网友们热捧。价格更是被炒到600元一个，还有人通宵到星巴克排队购买的，表示搞不懂，哈哈哈。那么干脆就以星巴克咖啡为例来讲讲装饰器模式的实现吧。星巴克咖啡有拿铁、星冰乐两个系列，在该基础上又可以选择是否加糖或牛奶等搭配。

首先定义一个咖啡的接口：

/**
 * 咖啡接口
 *
 * @author hxy
 * @date 2019/3/7
 */
public interface Coffee {
    /**
     * 获取咖啡调料
     *
     * @return
     */
    String getSeasoning();

    /**
     * 获取咖啡价格
     *
     * @return
     */
    double getPrice();
}

然后编写原味的（不加调料的）拿铁跟冰星乐两个系列的咖啡实体：

/**
 * 拿铁咖啡实体
 *
 * @author hxy
 * @date 2019/3/7
 */
public class TeaLatte implements Coffee {

    @Override
    public String getSeasoning() {
        return "拿铁咖啡";
    }

    @Override
    public double getPrice() {
        return 25.00;
    }
}

/**
 * 星冰乐实体类
 *
 * @author hxy
 * @date 2019/3/7
 */
public class Frappuccino implements Coffee {
    @Override
    public String getSeasoning() {
        return "星冰乐";
    }

    @Override
    public double getPrice() {
        return 28.00;
    }
}

接着创建一个调料抽象装饰器：

/**
 * 调料抽象装饰器
 *
 * @author hxy
 * @date 2019/3/7
 */
public abstract class CondimentDecorator implements Coffee {

    public Coffee coffee;

    /**
     * 要加调料的是哪种咖啡
     *
     * @param coffee
     */
    public CondimentDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public abstract String getSeasoning();

    @Override
    public abstract double getPrice();
}

CondimentDecorator 是调料装饰类，实现了 Coffee 接口，并在内部维护了一个 Coffee 的实例，并可以通过构造函数初始化，表明要加调料的是哪种咖啡。而 CondimentDecorator 里的方法本身通常采用默认实现。他的子类才是有具体装饰的装饰实体。

然后创建调料的具体装饰，首先是糖的装饰器：

/**
 * 牛奶装饰
 *
 * @author hxy
 * @date 2019/3/7
 */
public class MilkDecorator extends CondimentDecorator {

    /**
     * 要加调料的是哪种咖啡
     *
     * @param coffee
     */
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }

    /**
     * 添加牛奶调料
     *
     * @return
     */
    @Override
    public String getSeasoning() {
        return coffee.getSeasoning().concat("+牛奶");
    }

    /**
     * 加一份牛奶，价格增加5.00元
     *
     * @return
     */
    @Override
    public double getPrice() {
        return coffee.getPrice() + 5.00;
    }
}

这里我们在 getSeasoning() 方法实现加牛奶的逻辑，在 getPrice() 方法增加牛奶调料的价格。可以看到，具体的加装饰逻辑是在装饰实体类里面实现的。

同理，创建糖的实体类：

/**
 * 糖的装饰器
 *
 * @author hxy
 * @date 2019/3/7
 */
public class SugarDecorator extends CondimentDecorator {

    /**
     * 要加调料的是哪种咖啡
     *
     * @param coffee
     */
    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }

    /**
     * 添加糖
     *
     * @return
     */
    @Override
    public String getSeasoning() {
        return coffee.getSeasoning().concat("+糖");
    }

    /**
     * 加一份糖，价格增加3.00元
     *
     * @return
     */
    @Override
    public double getPrice() {
        return coffee.getPrice() + 3.00;
    }
}

最后，让我们写个测试类来看看装饰器模式是怎么使用的吧：

/**
 * Main class
 *
 * @author hxy
 * @date 2019/3/7
 */
public class Main {
    public static void main(String[] args) {
        //普通的拿铁
        Coffee coffee = new TeaLatte();
        System.out.format("这是一份%s,价格是：%f%n", coffee.getSeasoning(), coffee.getPrice());
        //加一份牛奶
        coffee = new MilkDecorator(coffee);
        System.out.format("这是一份%s,价格是：%f%n", coffee.getSeasoning(), coffee.getPrice());
        //加一份糖
        coffee = new SugarDecorator(coffee);
        System.out.format("这是一份%s,价格是：%f", coffee.getSeasoning(), coffee.getPrice());
    }
}

为什么要使用装饰器模式

一般的，我们为了扩展一个类通常使用继承的方式，但是这种方式伴随着扩展功能的增多，子类就会很膨胀。装饰器模式就能很好的解决这种问题，装饰器模式可以将具体的功能职责划分，装饰类和被装饰类可以独立发展，不会互相耦合，可以动态的扩展一个类的功能。