【Java设计模式】装饰者模式

✍ 装饰者模式的装饰 顾名思义类似于这种：

回到正题，一般有两种方式可以实现给一个类或对象增加行为：

• 继承机制，使用继承机制是给现有类添加功能的一种有效途径，通过继承一个现有类可以使得子类在拥有自身方法的同时还拥有父类的方法。但是这种方法是静态的，用户不能控制增加行为的方式和时机。
• 关联机制，即将一个类的对象嵌入另一个对象中，由另一个对象来决定是否调用嵌入对象的行为以便扩展自己的行为，我们称这个嵌入的对象为装饰器(Decorator)。

装饰模式以 对客户透明的方式动态地给一个对象附加上更多的责任， 换言之 ， 客户端并不会觉得对象在装饰前和装饰后有什么不同 。 装饰模式可以 在不需要创造更多子类的情况下 ， 将对象的功能加以扩展 。 这就是装饰模式的模式动机

装饰模式(Decorator Pattern) ： 动态地给一个对象增加一些额外的职责(Responsibility) ，就增加对象功能来说，装饰模式比生成子类实现更为灵活。其别名也可以称为 包装器(Wrapper)，与适配器模式的别名相同，但它们适用于不同的场合。根据翻译的不同，装饰模式也有人称之为“油漆工模式”，它是一种 对象结构型模式

装饰模式包含如下角色：

• Component: 抽象构件：定义一个抽象接口以规范准备接收附加责任的对象。
• ConcreteComponent: 具体构件：实现抽象构件，通过装饰角色为其添加一些职责。
• Decorator: 抽象装饰类：继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
• ConcreteDecorator: 具体装饰类：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

✍ 演示一下：

不满足装饰者模式的情况
以买煎饼为例

public class Battercake {
    protected String getDesc(){
        return "煎饼";
    }
    protected int cost(){
        return 5;
    }
}

煎饼 加一个鸡蛋

public class BattercakeWithEgg extends Battercake{
    @Override
    protected String getDesc() {
        return super.getDesc()+"加一个鸡蛋";
    }

    @Override
    protected int cost() {
        return super.cost()+ 1;
    }
}

煎饼加一个鸡蛋 加一个烤肠

public class BattercakeWithEggSausage extends BattercakeWithEgg{
    @Override
    protected String getDesc() {
        return super.getDesc()+"加一根香肠";
    }

    @Override
    public int cost() {
        return super.cost()+2;
    }
}

测试:

public class Test {
    public static void main(String[] args) {
        Battercake battercake = new Battercake();
        System.out.println(battercake.getDesc()+ " 销售价格为："+battercake.cost());

        BattercakeWithEgg battercakeWithEgg = new BattercakeWithEgg();
        System.out.println(battercakeWithEgg.getDesc()+ " 销售价格为："+battercakeWithEgg.cost());

        BattercakeWithEggSausage battercakeWithEggSausage = new BattercakeWithEggSausage();
        System.out.println(battercakeWithEgg.getDesc()+ " 销售价格为："+battercakeWithEgg.cost());
    }
}

我们看一下它的UML类图 很容易发现 单纯的继承关系

如果一个煎饼加两个鸡蛋 或者别的其他的呢 容易引起"类爆炸"

所以为了解决这个问题 引入装饰着模式,下面让我们看一下满足装饰者模式的写法

这里被装饰的是煎饼 装饰者是鸡蛋和香肠

创建煎饼的抽象类（Component: 抽象构件）

public abstract class ABattercake {
    protected abstract String getDesc();
    protected abstract int cost();
}

创建煎饼（ ConcreteComponent: 具体构件）

public class Battercake extends ABattercake{
    protected String getDesc(){
        return "煎饼";
    }
    protected int cost(){
        return 5;
    }
}

创建装饰者的抽象类（Decorator: 抽象装饰类）

public class AbstractDecorator extends ABattercake{
    private ABattercake aBattercake;

    public AbstractDecorator(ABattercake aBattercake) {  //注入煎饼
        this.aBattercake = aBattercake;
    }

    @Override
    protected String getDesc() {
        return this.aBattercake.getDesc();
    }

    @Override
    protected int cost() {
        return this.cost();
    }
}

鸡蛋的装饰者（ConcreteDecorator: 具体装饰类）

public class EggDecorator extends AbstractDecorator {
    public EggDecorator(ABattercake aBattercake) {
        super(aBattercake);
    }

    @Override
    protected String getDesc() {
        return super.getDesc()+"加一个鸡蛋";
    }

    @Override
    protected int cost() {
        return super.cost()+1;
    }
}

香肠的装饰者（ConcreteDecorator: 具体装饰类）

public class SausageDecorator extends AbstractDecorator{
    public SausageDecorator(ABattercake aBattercake) {
        super(aBattercake);
    }

    @Override
    protected String getDesc() {
        return super.getDesc()+"加一根香肠";
    }

    @Override
    protected int cost() {
        return super.cost()+1;
    }
}

类图:

测试:

public class Test {
    public static void main(String[] args) {
       ABattercake  aBattercake;
       aBattercake = new Battercake();
       aBattercake = new EggDecorator(aBattercake);
       aBattercake = new EggDecorator(aBattercake);
       aBattercake = new SausageDecorator(aBattercake);
       System.out.println(aBattercake.getDesc() + " 销售价格为:" +aBattercake.cost());
    }
}

结果:

类图:

分析一下：
与继承关系相比 ， 关联关系的主要优势在于 不会破坏类的封装性， 而且 继承是一种耦合度较大的静态关系 ， 无法在程序运行时动态扩展。 在软件开发阶段 ， 关联关系虽然不会比继承关系减少编码量 ， 但是到了软件维护阶段 ， 由于关联关系使系统有较好的松耦合性 ， 因此使得 系统更加容易维护。 当然 ， 关联关系的缺点是比继承关系要创建更多的对象 。 使用装饰模式实现扩展比继承更加灵活 ， 它以对客户透明的方式动态地给一个对象附加更多的责任。 装饰模式可以在不需要创造更多子类的情况下 ， 将对象的功能加以扩展

✍ 提一点别的应用加深印象

多重加密系统
某系统提供了一个数据加密功能，可以对字符串进行加密。最简单的加密算法通过对字母进行移位来实现，同时还提供了稍复杂的逆向输出加密，还提供了更为高级的求模加密。用户先使用最简单的加密算法对字符串进行加密，如果觉得还不够可以对加密之后的结果使用其他加密算法进行二次加密，当然也可以进行第三次加密。现使用装饰模式设计该多重加密系统。

✍ 说一下这个设计模式的优缺点：
装饰模式的优点

• 装饰模式与继承关系的目的都是要扩展对象的功能，但是装饰模式可以提供比继承更多的灵活性。
• 可以通过一种动态的方式来扩展一个对象的功能，通过配置文件可以在运行时选择不同的装饰器，从而实现不同的行为。
• 通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出很多不同行为的组合。可以使用多个具体装饰类来装饰同一对象，得到功能更为强大的对象。
• 具体构件类与具体装饰类可以独立变化，用户可以根据需要增加新的具体构件类和具体装饰类，在使用时再对其进行组合，原有代码无须改变，符合“开闭原则”。

装饰模式的缺点

• 使用装饰模式进行系统设计时将产生很多小对象，这些对象的区别在于它们之间相互连接的方式有所不同，而不是它们的类或者属性值有所不同，同时还将产生很多具体装饰类。这些装饰类和小对象的产生将增加系统的复杂度，加大学习与理解的难度。
• 这种比继承更加灵活机动的特性，也同时意味着装饰模式比继承更加易于出错，排错也很困难，对于多次装饰的对象，调试时寻找错误可能需要逐级排查，较为烦琐。

✍ 在以下情况下可以使用装饰模式：

• 在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
• 需要动态地给一个对象增加功能，这些功能也可以动态地被撤销。
• 当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。不能采用继承的情况主要有两类：第一类是系统中存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长；第二类是因为类定义不能继承（如final类）。