首页 > 其他分享> > [设计模式] 装饰者模式

[设计模式] 装饰者模式

2021-06-09 17:01:55 作者：互联网

[设计模式] 装饰者模式

平台	地址
CSDN	https://blog.csdn.net/sinat_28690417
简书	https://www.jianshu.com/u/3032cc862300
个人博客	https://yiyuery.github.io/NoteBooks/

场景分析

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

比如说：买一杯咖啡，价格是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》读书笔记

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

在这里插入图片描述

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

在这里插入图片描述

标签：coffee,return,模式,public,cost,Capacity,设计模式,装饰
来源： https://blog.51cto.com/u_15263565/2886098

[设计模式] 装饰者模式

目录

场景分析

实践

总结

REFERENCES

更多