设计模式学习笔记-装饰者模式-Decorator Patte

发表于

定义

装饰者模式：在不改变原类文件以及不使用继承的情况下，动态地将责任附加到对象上，从而实现动态拓展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

设计原则

要使用装饰者模式，需要满足以下设计原则：

  1. 多用组合，少用继承
  2. 开放-关闭原则：类应该对拓展开放，对修改关闭

UML类图

我们先来看看装饰者模式的类图，再来详细讲述：

由上自下：
1、Girl是基类。通常是一个抽象类或者一个接口，定义了属性或者方法，方法的实现可以由子类实现或者自己实现。通常不会直接使用该类，而是通过继承该类来实现特定的功能，它约束了整个继承树的行为。比如说，如果Girl代表人，即使通过装饰也不会使人变成别的动物。
2、AmericanGirl是Girl的子类，实现了相应的方法，它充当了“被装饰者”的角色。
3、GirlDecorator也是Girl的子类，它是装饰者共同实现的抽象类（也可以是接口）。比如说，GirlDecorator代表学习课程或兴趣这一类装饰者，那么它的子类应该是科学、艺术课这样的具体的装饰者。
4、Science是GirlDecorator的子类，是具体的装饰者，由于它同时也是Girl的子类，因此它能方便地拓展Girl的状态（比如添加新的方法）。每个装饰者都应该有一个实例变量用以保存某个Girl(Component也可以理解为抽象组件)的引用，这也是利用了组合的特性。在持有Girl的引用后，由于其自身也是Girl的子类，那么，相当于Science(ConcreteDecorator)具体的装饰者包裹了Girl(Component)抽象对象，不但有Girl的特性，同时自身也可以有别的特性，也就是所谓的装饰。

Java 实例

为了更加深刻地理解装饰者模式，我们来看一个简单的栗子。首先，我们假设现在有这样一个需求：你是一个教育培训机构，这边女孩有来自各个国家的，然后针对某个国家的女孩学习不同课程需要继续和描述。此时，某个国家的女孩就是被装饰着，某个课程就是装饰者。

Step 1、创建Component基类

因为总体对象是女孩，所以我们可以把人抽象为基类，新建Girl.java:

1
2
3
4
5
6
7
复制代码public abstract class Girl {
    String description = "no particular";
    public String getDescription(){
        return description;
    }
    public abstract int cost();
}

Step 2、创建被装饰者——ConcreteComponent

具体的客户有来自各个国家的，美国的，加拿大等。

1
2
3
4
5
6
7
8
9
10
复制代码public class AmericanGirl extends Girl {
    //一个实例，相当于被装饰者。
    public AmericanGirl(){
        description = description + "+American";
    }
    @Override
    public int cost() {
        return 0;
    }
}

Step 3、创建Decorator

创建装饰者类GirlDecorator.java

1
2
3
复制代码public abstract class GirlDecorator extends Girl{
    public abstract String getDescription();
}

Step 4、创建ConcreteDecorator

创建Science.java和Art.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
复制代码public class Science extends GirlDecorator {
    private Girl girl;
    public Science(Girl girl){
        this.girl = girl;
    }
    @Override
    public String getDescription() {
        //其中this.girl.getDescription()可能是原始被装饰者
        //或者已经装饰过的girl了
        return this.girl.getDescription() + "+Like Science";
    }
    //装饰者附加上的功能
    public void caltulateStuff() {
        System.out.println("scientific calculation!");
    }
    @Override
    public int cost() {
        //装饰者，去装饰girl对象，然后加上装饰的新属性和任务
        return girl.cost() + 100;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
复制代码public class Art extends GirlDecorator {
    private Girl girl;
    public Art(Girl girl) {
        this.girl = girl;
    }
    @Override
    public String getDescription() {
        return this.girl.getDescription() + "+Like Art";
    }
    @Override
    public int cost() {
        return girl.cost() + 200;
    }
}

最后我们在测试类内测试我们的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
复制代码public class Main {
    public static void main(String[] args) {
        //普通美国女孩
        Girl g1 = new AmericanGirl();
        System.out.println(g1.getDescription());
        //喜欢科学的
        Science g2 = new Science(g1);
        System.out.println(g2.getDescription());
        //喜欢艺术的
        Art g3 = new Art(g2);
        System.out.println(g3.getDescription());
        //喜欢体育
        Sports g4 = new Sports(g3);
        System.out.println(g4.getDescription());
        System.out.println("g1,g2,g3,g4包装后的费用:"+g4.cost());
    }
}

最终的结果

1
2
3
4
5
复制代码no particular+American
no particular+American+Like Science
no particular+American+Like Science+Like Art
no particular+American+Like Science+Like Art; also learn Sports
g1,g2,g3,g4包装后的费用:600

特点

以上就是装饰者模式的一个小栗子，讲述了装饰者的基本用法。通过上述的例子，我们可以总结一下装饰者模式的特点。
（1）装饰者和被装饰者有相同的接口（或有相同的父类）。
（2）装饰者保存了一个被装饰者的引用。
（3）装饰者接受所有客户端的请求，并且这些请求最终都会返回给被装饰者。
（4）在运行时动态地为对象添加属性，不必改变对象的结构。

使用装饰者模式的最大好处就是其拓展性十分良好，通过使用不同的装饰类来使得对象具有多种多样的属性，灵活性比直接继承好。然而它也有缺点，那就是会出现很多小类，即装饰类，使程序变得复杂。

应用

学习了装饰者模式用法、特点以及优缺点后，我们再来看看装饰者模式在实际开发过程的应用。装饰者模式在Java中经常出现的地方就是JavaIO。提到JavaIO，脑海中就冒出了大量的类：InputStream、FileInputStream、BufferedInputStream……等，真是头都大了，其实，这里面大部分都是装饰类，只要弄清楚这一点就容易理解了。我们来看看JavaIO是怎样使用装饰者模式的。
从字符流来分析，我们知道，有两个基类，分别是InputStream和OutputStream，它们也就是我们上面所述的Component基类。接着，它有如下子类：FileInputStream、StringBufferInputStream等，它们就代表了上面所述的ConcreteComponent，即装饰对象。此外，InputStream还有FilterInputStream这个子类，它就是一个抽象装饰者，即Decorator，那么它的子类：BufferedInputStream、DataInputStream等就是具体的装饰者了。那么，从装饰者模式的角度来看JavaIO，是不是更加容易理解了呢？

下面，我们来自己实现自己的JavaIO的装饰者。要实现的功能是：把一段话里面的每个单词的首字母大写。我们先新建一个类：UpperFirstWordInputStream.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
复制代码public class UpperFirstWordInputStream extends FilterInputStream {
    private int cBefore = 32;
    public UpperFirstWordInputStream(InputStream in){
        //由于FilterInputStream已经保存了装饰对象的引用，这里直接调用super即可
        super(in);
    }
    public int read() throws IOException {
        //根据前一个字符是否是空格来判断是否要大写
        int c = super.read();
        if(cBefore == 32)
        {
            cBefore = c;
            return (c == -1 ? c: Character.toUpperCase((char) c));
        }else{
            cBefore = c;
            return c;
        }
    }
}

接着编写一个测试类：InputTest.java 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
复制代码public class InputTest {
    public static void main(String[] args) throws IOException {
        int c;
        StringBuffer sb = new StringBuffer();
        try {
            //这里用了两个装饰者，分别是BufferedInputStream和我们的UpperFirstWordInputStream
            InputStream in = new UpperFirstWordInputStream(new BufferedInputStream(new FileInputStream("/Users/nezha/Desktop/test.txt")));
            while((c = in.read()) >= 0)
            {
                sb.append((char) c);
            }
            System.out.println(sb);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

参考文献：

学习、探究Java设计模式——装饰者模式

  • 交流或更多内容请关注我的公众号：nezha_blog
  • 我的技术博客：nezha.github.io

微信公众号

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%