装饰者模式

在不改变原有对象的基础之上，把功能附加到对象上，提供了比继承更有弹性的替代方案（扩展原有对象的功能）。

属于结构型

适用场景

扩展一个类的功能或给一个类添加附加职责
动态的给一个对象添加功能，这些功能可以再动态的撤销

案例

比如说我们购买煎饼，有时候需要加鸡蛋，有时候需要鸡蛋和火腿

原有设计

原有设计是这样的

基础煎饼类

public class Battercake {
    protected String getMsg() {
        return "煎饼";
    }

    public int getPrice() {
        return 5;
    }
}

煎饼加鸡蛋

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

    @Override
    public int getPrice() {
        return super.getPrice() + 1;
    }
}

煎饼加鸡蛋和香肠

public class BattercakeWithEggAndSausage extends BattercakeWithEgg {
    @Override
    protected String getMsg() {
        return super.getMsg() + "+1根香肠";
    }

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

测试类

public class App {
    public static void main(String[] args) {
        Battercake battercake = new Battercake();
        System.out.println(battercake.getMsg() + ",总价格" + battercake.getPrice());

        Battercake battercakeWithEgg = new BattercakeWithEgg();
        System.out.println(battercakeWithEgg.getMsg() + ",总价格" + battercakeWithEgg.getPrice());
    }

}

这种方式我们每次需要新购买一个产品都需要新增一个类

改良

使用装饰着模式

定义抽象类

public abstract class Battercake {
    protected abstract String getMsg();

    protected abstract int getPrice();

}

提供默认煎饼类

public class BaseBattercake extends Battercake {


    @Override
    protected String getMsg() {
        return "煎饼";
    }

    @Override
    protected int getPrice() {
        return 5;
    }
}

提供煎饼包装类

public class BattercakeDecorator extends Battercake {
    private Battercake battercake;

    public BattercakeDecorator(Battercake battercake) {
        this.battercake = battercake;
    }

    @Override
    protected String getMsg() {
        return battercake.getMsg();
    }

    @Override
    protected int getPrice() {
        return battercake.getPrice();
    }

}

鸡蛋包装类

public class EggDecorator extends BattercakeDecorator {

    public EggDecorator(Battercake battercake) {
        super(battercake);
    }

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

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

火腿包装类

public class SausageDecorator extends BattercakeDecorator {

    public SausageDecorator(Battercake battercake) {
        super(battercake);
    }
    @Override
    protected String getMsg() {
        return super.getMsg() + "加一个火腿";
    }

    @Override
    protected int getPrice() {
        return super.getPrice() + 5;
    }
}

测试

public class App {
    public static void main(String[] args) {
        Battercake battercake;
        battercake = new BaseBattercake();

        battercake = new EggDecorator(battercake);
        System.out.println(battercake.getMsg());
        System.out.println(battercake.getPrice());

        battercake = new EggDecorator(battercake);
        System.out.println(battercake.getMsg());
        System.out.println(battercake.getPrice());

        battercake = new SausageDecorator(battercake);
        System.out.println(battercake.getMsg());
        System.out.println(battercake.getPrice());
    }

}

这种方式每次新增都不需要新创类

类图

最初的类图

现在的类图

装饰器包装一定要满足is-a的关系

优点

是继承的有利补充，比继承灵活，不改变原有对象的情况下动态的给一个对象扩展功能，即插即用
通过不同装饰类以及这些装饰类的排列组合，可以实现不同的效果。
装饰者完全遵循开闭原则

缺点

会出现更多的代码，增加程序的复杂性
动态装饰时，多层装饰会更复杂

对比

	装饰者模式	适配器模式
形式	是一种非常特别的适配器模式	没有层级关系，装饰器模式有层级关系
定义	装饰者和被装饰者都实现同一个接口，主要目的是为了扩展之后依旧保留 OOP 关系	适配器和被适配者没有必然的联系，通常是采用继承或代理的形式进行包装
关系	满足 is-a 的关系	满足 has-a 的关系
功能	注重覆盖、扩展	注重兼容、转换
设计	前置考虑	后置考虑

源码中的应用

其在源码中应用的非常多，JDk中最明显的类就是IO中的BufferedReader,InputStream,OutputStream，看一下常用的InputStream结构图

代码地址：https://gitee.com/zzy0_0/learning/tree/master/design/src/main/java/com/zzjson/design/decorator

23种设计模式-装饰者模式