使用组合的设计模式——美颜相机中的装饰者模式

这是设计模式系列的第二篇，系列文章目录以下：

1. 一句话总结异曲同工的设计模式：工厂模式=？策略模式=？模版方法模式

2. 使用组合的设计模式 —— 美颜相机中的装饰者模式

3. 使用组合的设计模式 —— 找对象要用的远程代理模式

4. 用设计模式去掉不必的状态变量 —— 状态模式

几乎全部的设计模式都是经过增长一层抽象来解决问题。

上一篇中提到的三个设计模式经过相同的手段来达到相同的目的：它们经过接口和抽象方法来新增抽象层以应对变化。

这一系列的后续几篇中会提到的四个设计模式经过相同的手段来达到不一样的目的：它们经过新增一个类并持有原有类的方式实现对其扩展或限制。

这一篇先来看看装饰者模式。

装饰者模式就好像美颜相机，经过添加不一样的装饰品，它可让你变成另外一个你。（虽然可能面目全非，但本质上仍是你）

只复用类型

假设有四种饰品：耳环、钻石、黄金、羽毛。不一样装饰品有不一样价格，一般咱们会这样作抽象：

//抽象饰品
public abstract class Accessory {
    public abstract String name();//饰品名称
    public abstract int cost();//饰品价格
}

//耳环
public class Ring extends Accessory {
    @Override
    public String name() { return "Ring"; }
    @Override
    public int cost() { return 20; }
}

//钻石
public class Diamond extends Accessory {
    @Override
    public String name() { return "Diamond"; }
    @Override
    public int cost() { return 1000; }
}

//黄金
public class Gold extends Accessory {
    @Override
    public String name() { return "Gold"; }
    @Override
    public int cost() { return 300; }
}

//羽毛
public class Feather extends Accessory {
    @Override
    public String name() { return "Feather"; }
    @Override
    public int cost() { return 90; }
}
复制代码

现推出两款新饰品：黄金耳环，羽毛黄金耳环。一样的思路，使用继承能够解决问题：

public class GoldRing extends Accessory {
    @Override
    public String name() { return "GoldRing"; }
    @Override
    public int cost() { return 320; }
}

public class FeatherGoldRing extends Accessory {
    @Override
    public String name() {  "FeatherGoldRing"; }
    @Override
    public int cost() { return 1110; }
}
复制代码

• 若是继续推出更多的新品，好比羽毛耳环，钻石耳环，羽毛钻石耳环。。。每一个新产品都用一个新的类表示，这样就会遇到子类膨胀的问题。
• 除此以外，继承还有一个更致命的缺点：对单个类型的饰品没有统一的控制力。若是黄金涨价了，咱们须要分别修改GoldRing和FeatherGoldRing的价格，若是和黄金相关的饰品有好几十个，那简直是一场噩梦。
• 在计算GoldRing价格的时候，咱们并无复用现有代码，即没有复用Gold和Ring已经定义的cost()行为，而只是经过继承复用了类型（GoldRing是一个Accessory）。只复用类型而没有复用行为的后果是：当Gold涨价时，GoldRing无感知。

有没有一种比继承更好的方案在现有饰品基础上扩展新的饰品？

既复用类型又复用行为

采用组合的方式就能够实现既复用类型又复用行为：

public class Gold extends Accessory {
    private Accessory accessory;
    public Gold(Accessory accessory) { this.accessory = accessory; }
    
    @Override
    public String name() {
        return "Gold " + accessory.name();
    }
    @Override
    public int cost() {
        return 300 + accessory.cost();
    }
}

public class Feather extends Accessory {
    private Accessory accessory;
    public Feather(Accessory accessory) { this.accessory = accessory; }

    @Override
    public String name() {
        return "Feather " + accessory.name();
    }
    @Override
    public int cost() {
        return 90 + accessory.cost();
    }
}
复制代码

• 上述四种饰品其实分为两类，耳环属于基本饰品，而羽毛、黄金、钻石属于附加饰品，附加饰品能够装饰基本饰品。
• 附加饰品和基础饰品拥有相同的超类型Accessory，但附加饰品还经过组合的方式持有一个超类型实例，这样就能够经过注入超类型的方式将其和任意基础饰品组合到一块儿造成新的饰品。

用组合的方式实现羽毛黄金耳环：

Accessory ring = new Gold(new Feather(new Ring()));
复制代码

• 为了说明装饰与被装饰的关系，使用了带有俄罗斯套娃既视感的代码（虽然这样的代码可读性较差）。
• Ring做为基础饰品被Feather装饰成羽毛耳环，羽毛耳环接着被Gold装饰成换羽毛黄金耳环。
• 过程当中并无为羽毛黄金耳环新增一个叫FeatherGoldRing的子类，而是复用了现有的Feather和Gold的行为。这样就解决了子类泛滥和控制力的问题。若是黄金涨价，只须要修改Gold.cost()，全部被Gold装饰的饰品价格都会随之而涨。
• 这个方案还有一个更有用的好处：在运行时动态新增类型。经过继承新增的类型都是在编译时定死的，而经过组合的方式只要新增一行俄罗斯套娃式的代码，程序运行起来后就新增了一个类型，好比要新增“双倍黄金羽毛耳环”这个类型，只须要以下的代码：

Accessory ring = new Gold(new Gold(new Feather(new Ring())));
复制代码

抽象的装饰者？

新的需求来了：基础饰品镶嵌附加饰品收取 10% 的一次性加工费。咱们能够为全部附加饰品增长一层抽象：

public abstract class Decorator extends Accessory{
    private Accessory accessory;
    public Decorator(Accessory accessory) { this.accessory = accessory; }

    @Override
    public int cost() {
        return  1.1 * accessory.cost();
    }
}
复制代码

• Decorator经过组合持有超类型Accessory且规定了在构造时必须注入超类型，它还定义了镶嵌加工费的收费标准。
• 如今就能够像这样从新定义附加饰品：

public class Gold extends Decorator {
    public Gold(Accessory accessory){ super(accessory); }

    @Override
    public String name() {
        return "Gold " + accessory.name();
    }
    @Override
    public int cost() {
        return 300 + super.cost();
    }
}
复制代码

• 其实对于装饰者模式来讲，为装饰者定义一个抽象的父类不是必须的，只要知足继承超类型，以及持有超类型引用这两点就是装饰者模式。除非须要统一操做全部装饰者，好比在美颜相机这个场景中，须要经过遍历找出全部附加饰品。

题外话

使用装饰者模式后，Gold和Feather中有一些样板代码，若是使用Kotlin能够将代码简化以下：

class Feather(val accessory: Accessory) : Accessory by accessory {
    override fun name(): String = "Feather" + accessory.name()
    override fun cost(): Int = 90 + accessory.cost()
}

class Gold(val accessory: Accessory) : Accessory by accessory {
    override fun name(): String = "Gold" + accessory.name()
    override fun cost(): Int = 300 + accessory.cost()
}
复制代码

经过by关键词把类委托给一个具备超类型的成员变量accessory，若是不重写，类中的name()和cost()的默认实现都将转发给accessory。

总结

• 装饰者模式是一种复用原有类并对其进行扩展的方式，它是继承的替代方法。
• 装饰者模式经过继承原有类型实现复用类型。这一点很重要，由于全部使用原有类型的地方不须要修改代码就能够替换成装饰者。
• 装饰者模式经过组合持有原有类实例实现复用行为。
• 装饰者模式经过在调用原有类方法的先后插入新的逻辑实现功能扩展。
• 装饰者模式符合开闭原则，即在新增功能的时候没有修改原有代码。
• 装饰者模式特别适用于子类型之间能够有随机组合的场景，好比美颜相机的各类道具组合以后造成新的道具。

运用组合的设计模式不止装饰者一个，该系列的后续文章会继续分析“组合”在设计模式中的运用。

推荐阅读

• 应用设计模式和产品经理成为好朋友——策略模式实战