[设计模式] 装饰者模式
[设计模式] 装饰者模式
手机用户请 横屏获取最佳阅读体验， REFERENCES中是本文参考的链接，如需要链接和更多资源，可以关注其他博客发布地址。
平台 | 地址 |
|---|---|
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》读书笔记
本文参与 腾讯云自媒体分享计划，分享自微信公众号。
原始发表：2019-08-12，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录