装饰者模式

最新推荐文章于 2024-03-14 10:21:49 发布

MariaOzawa

最新推荐文章于 2024-03-14 10:21:49 发布

阅读量333

点赞数

分类专栏：设计模式文章标签：设计模式 java

本文链接：https://blog.csdn.net/MariaOzawa/article/details/105016211

版权

设计模式专栏收录该内容

14 篇文章 0 订阅

订阅专栏

定义

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

类型

结构型

适用场景

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

从名字来简单解释下装饰器。既然说是装饰，那么往往就是添加小功能这种，而且，我们要满足可以添加多个小功能。最简单的，代理模式就可以实现功能的增强，但是代理不容易实现多个功能的增强，当然你可以说用代理包装代理的多层包装方式，但是那样的话代码就复杂了。

优点

继承有力补充，比继承灵活，不改变原有对象的情况下给一个对象扩展功能
通过使用不同装饰类以及这些装饰类的排列组合，可以实现不同效果
符合开闭原则

缺点

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

Coding

举个简单的例子，我们大家都吃过煎饼，有时候会加一个蛋，加一根肠这样：

// 煎饼类
public class BatterCake {
    public String getDesc(){
        return "煎饼";
    }
    // 价格
    public int cost(){
        return 5;
    }
}

下面在来一个加蛋的煎饼，直接让它继承煎饼类就行：

public class BatterCakeWithEgg extends BatterCake {
    @Override
    public String getDesc() {
        return super.getDesc() + " 加一个鸡蛋";
    }
    @Override
    public int cost() {
        return super.cost() + 1;
    }
}

然后我还想在加蛋的基础上再加一根香肠：

public class BatterCakeWithEggSausage extends BatterCakeWithEgg {

    @Override
    public 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(batterCakeWithEggSausage.getDesc() + " 花费价格: " + batterCakeWithEggSausage.cost());
    }
}
// console
// 煎饼 花费价格: 5
// 煎饼 加一个鸡蛋 花费价格: 6
// 煎饼 加一个鸡蛋 加一根香肠 花费价格: 8

如果这时候有客户想要加两个鸡蛋呢，想加5个肠呢，是不是很变态？所有的可能都排列出来那要写多少个类？

接下里就是装饰者模式的show time：

装饰者模式要有一个抽象的实体类，还要有确定的实体类，要抽象的装饰者，和确定的装饰者。

在这场景中，被装饰的实体是煎饼，装饰者是鸡蛋和香肠。

// 抽象煎饼类
public abstract class AbsBatterCake {
    protected abstract String getDesc();
    protected abstract int cost();
}
// 一个实现类,煎饼
public class BatterCake extends AbsBatterCake {
    @Override
    protected String getDesc() {
        return "煎饼";
    }
    @Override
    protected int cost() {
        return 5;
    }
}

定义要加的小吃抽象装饰者基类，此类必须继承 AbsBatterCake:

// 小吃
public abstract class AbsSnack extends AbsBatterCake {}

定义具体能加的小吃，自然要继承 AbsSnack：

public class EggSnack extends AbsSnack {
    private AbsBatterCake batterCake;

    // 这里很关键，需要传入具体的煎饼
    // 当然也可以传入已经装饰好的煎饼
    public EggSnack(AbsBatterCake batterCake) {
        this.batterCake = batterCake;
    }

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

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

public class SausageSnack extends AbsSnack {
    private AbsBatterCake batterCake;

    public SausageSnack(AbsBatterCake batterCake) {
        this.batterCake = batterCake;
    }

    @Override
    protected String getDesc() {
        return this.batterCake.getDesc() + " 加一个香肠";
    }

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

客户端调用:

public class Test {
    public static void main(String[] args) {
        AbsBatterCake batterCake = new BatterCake();
        // 开始装饰
        // 加一个鸡蛋
        batterCake = new EggSnack(batterCake);
        // 再加一个鸡蛋
        batterCake = new EggSnack(batterCake);
        // 加一个肠
        batterCake = new SausageSnack(batterCake);
        System.out.println(batterCake.getDesc() + " 售出价格: " + batterCake.cost());

    }
}
// console
// 煎饼 加一个鸡蛋 加一个鸡蛋 加一个香肠 售出价格: 9

下面，我们再来说说 java IO 中的装饰模式。看下图 InputStream 派生出来的部分类：
在这里插入图片描述

我们知道 InputStream 代表了输入流，具体的输入来源可以是文件（FileInputStream）、管道（PipedInputStream）、数组（ByteArrayInputStream）等，这些就像前面奶茶的例子中的红茶、绿茶，属于基础输入流。

FilterInputStream 承接了装饰模式的关键节点，它的实现类是一系列装饰器，比如 BufferedInputStream 代表用缓冲来装饰，也就使得输入流具有了缓冲的功能，LineNumberInputStream 代表用行号来装饰，在操作的时候就可以取得行号了，DataInputStream 的装饰，使得我们可以从输入流转换为 java 中的基本类型值。

当然，在 java IO 中，如果我们使用装饰器的话，就不太适合面向接口编程了，如：

InputStream inputStream = new LineNumberInputStream(new BufferedInputStream(new FileInputStream("")));

这样的结果是，InputStream 还是不具有读取行号的功能，因为读取行号的方法定义在 LineNumberInputStream 类中。

我们应该像下面这样使用：

DataInputStream is = new DataInputStream(
                              new BufferedInputStream(
                                  new FileInputStream("")));