[设计模式] 装饰者模式

@TOC

手机用户请横屏获取最佳阅读体验，REFERENCES中是本文参考的链接，如需要链接和更多资源，可以关注其他博客发布地址。

装饰者模式 动态地将责任附加到对象上，若要扩展功能，装饰者提供了比继承更有弹性的替代方案。

首先我们来分析下装饰者模式中有哪些角色：

• 装饰器：用于扩展被装饰者行为和特征
• 被装饰者：设计主体，一切的行为包装都为了丰富被装饰者的行为或是能力。

场景分析

朋友开了家畅饮吧，可以喝到不同种类的饮料。现在需要设计一种模型，能够满足多种饮料和辅料的添加，尽可能的优雅。

比如说：买一杯咖啡，价格是3元，但是要加奶的话，需要加价0.3元，还要根据不同的容量加价，如果是小杯的话1元，中杯2元，大杯3元。

实践

类图

在这里插入图片描述

抽象：定义被装饰者和装饰器

在这里插入图片描述

• IBeverage 接口定义所有饮料公共的行为，如计算价格。

public interface IBeverage {

    /**
     * 计算价格
     * @return
     */
    double cost();
}

• AbstractBeverage 定义抽象饮料对象，用来定义饮料的公共属性和一些常量定义。所有的被装饰者（饮料）都继承该对象。

public abstract class AbstractBeverage implements IBeverage {

    /**
     * 子类具体饮料
     */
    protected String description;
    /**
     * 定义容量，可以由外部传入
     */
    public Capacity capacity;

    /**
     * 定义饮料的描述方法【饮料A:+调料1、+调料2、+选择不同的杯容量】
     * @return
     */
    public abstract String getDescription();

    /**
     * 定义杯容量
     * @return
     */
    public abstract Capacity getCapacity();

    /**
     * 容量枚举定义
     */
    @AllArgsConstructor
    @Getter
    public enum Capacity{

        /**
         * 大杯
         */
        SMALL("small"),
        /**
         * 中杯
         */
        MIDDLE("middle"),
        /**
         * 小杯
         */
        BIG("big");

        private String name;
    }

    /**
     * 设置容量
     * @param capacity
     */
    public void setCapacity(Capacity capacity) {
        this.capacity = capacity;
    }
}

• BeverageDecorator 装饰器实例，用于描述饮料的一些特征和行为。如咖啡的加奶，不同容量等。装饰器根据传入的被装饰者，充当中间代理，对外提供被装饰者的信息。

public abstract class BeverageDecorator extends AbstractBeverage{

    protected AbstractBeverage beverage;

    /**
     * 定义杯容量
     *
     * @return
     */
    @Override
    public Capacity getCapacity() {
        return beverage.getCapacity();
    }



    /**
     * 计算价格
     *
     * @return
     */
    @Override
    public double cost() {
        return beverage.cost();
    }
}

装饰器实现

• 加奶

public class Milk extends BeverageDecorator {

    public Milk(AbstractBeverage beverage) {
        this.beverage = beverage;
    }

    /**
     * 定义饮料的描述方法【饮料A:+调料1、+调料2、+选择不同的杯容量】
     *
     * @return
     */
    @Override
    public String getDescription() {
        return beverage.getDescription()+",milk";
    }

    /**
     * 计算价格
     *
     * @return
     */
    @Override
    public double cost() {
        return 0.3 + super.cost();
    }
}

• 容量

public class Capacity extends BeverageDecorator {

    public Capacity(AbstractBeverage beverage) {
        this.beverage = beverage;
    }

    /**
     * 定义饮料的描述方法【饮料A:+调料1、+调料2、+选择不同的杯容量】
     *
     * @return
     */
    @Override
    public String getDescription() {
        return beverage.getDescription() + "," + getCapacity().getName();
    }

    @Override
    public double cost() {
        double capacityCost = 0;
        switch (getCapacity()) {
            case SMALL:
                capacityCost = 1;
                break;
            case MIDDLE:
                capacityCost = 2;
                break;
            case BIG:
                capacityCost = 3;
                break;
            default:
                break;
        }
        return super.cost() + capacityCost;
    }
}

演示

@Test
public void testX1(){
    AbstractBeverage coffee = new Coffee();
    System.out.println(coffee.getDescription());
    System.out.println(coffee.cost());
    //计算加奶价格
    BeverageDecorator addMilk = new Milk(coffee);
    System.out.println(addMilk.getDescription());
    System.out.println(addMilk.cost());
    //计算容量价格
    BeverageDecorator middleCapacity = new Capacity(addMilk);
    System.out.println(middleCapacity.getDescription());
    System.out.println(middleCapacity.cost());
    //改变容量，计算小杯价格
    coffee.setCapacity(AbstractBeverage.Capacity.SMALL);
    System.out.println(smallCapacity.getDescription());
    System.out.println(smallCapacity.cost());
}

看下输出：

Coffee
3.0
Coffee,milk
3.3
Coffee,milk,middle
5.3
Coffee,milk,small
4.3

总结

装饰模式特点

• 被装饰对象总是被层层装饰器包裹。每个被包裹的装饰器对象都继承自抽象定义的装饰器BeverageDecorator。
• 装饰器修饰的是被装饰者，装饰后，本身主体还是被装饰者，所以每个装饰器都会把被装饰者传入。
• 每次装饰，定义的抽象装饰器中的公共属性和方法都会被装饰器覆盖，但是覆盖会时会调用父类方法，

/**
 * 计算价格
 *
 * @return
 */
@Override
public double cost() {
    return 0.3 + super.cost();
}

加入我们先加奶，然后中杯换小杯，两次装饰的结果依次为

BeverageDecorator addMilk = new Milk(coffee);

BeverageDecorator middleCapacity = new Capacity(addMilk);
coffee.setCapacity(AbstractBeverage.Capacity.SMALL);

比较下两次装饰的代码，我们可以发现装饰模式是装饰器层层嵌套的一种设计模式，设计的主体就是被装饰者。

每次计算价格的时候先计算传入的被装饰对象的价格，然后加上自己的价格。

• 被装饰者和装饰器必须是统一类型，即拥有公共的基类，我们利用装饰器继承基类实现类型匹配，通过组合扩展行为和能力。

为了更形象的理解，我们还可以这样写：

BeverageDecorator coffee = new Coffee();
coffee.setCapacity(AbstractBeverage.Capacity.SMALL);
coffee = new Milk(coffee);
coffee = new Capacity(coffee);

设计基础

• 抽象
• 封装
• 多型
• 继承

面向对象设计原则

• 封装变化
• 多用组合，少用继承
• 针对接口编程，不针对实现编程
• 为交互对象之间的松耦合设计而努力
• 堆扩展开放，对修改关闭

优点

• 普通的继承而来的行为都是在编译时静态决定的，如果不是来自基类，就是子类覆盖后的版本。反之，利用组合，可以多个装饰器复合使用，运行时可以直接扩展基类的行为。
• 装饰者模式，动态地将责任附加到对象上，想要扩展功能，装饰者提供有别于继承的另一种选择
• 这种循环嵌套包装类的方式也可以理解为委托的方式，通过组合和委托，可以在运行时动态的添加新的行为
• 装饰者模式意味着有一群装饰器，来包装具体的组件
• 装饰器反映出被装饰的组件的类型，事实上，它们具有相同的类型，都是通过接口和继承实现的
• 装饰器可以在被装饰者（组件）的行为的前面或后面加上自己的行为，甚至将被装饰者的行为取代掉，而达到特定的目的
• 你可以用无数的装饰器包装一个组件
• 装饰者一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型
• 装饰者会导致设计中出现很多小对象（一般用来扩展装饰能力的），如果过度使用，会让程序变得复杂。

REFERENCES

《Head First》读书笔记

更多

扫码关注架构探险之道，回复文章标题，获取本文相关源码和资源链接

在这里插入图片描述

知识星球(扫码加入获取历史源码和文章资源链接)

在这里插入图片描述