设计模式（三）装饰者模式

参考：

1. 《headfirst设计模式》
2. 应用：https://www.jianshu.com/p/c8deb7f50d70

1. 概念解析

装饰者模式：在不改变原类文件和继承的情况下，动态的拓展一个对象的功能，通过创建一个包装对象，也就是装饰来包裹真实的对象。
特点：

1. 装饰对象和真实对象有相同的接口，这样客户端对象就能用同样的方式和装饰对象交互（与真实对象交互也一样的方式）。
2. 装饰对象包含一个真实对象的引用，这个引用就是为了下面的这一点，调用真实对象的方法。
3. 装饰对象接受所有来自客户端的请求，把这些请求转发给真实对象。
4. 装饰对象可以再转发请求时，添加一些自己的附加功能，所以在运行时，可以不修改原真实对象，达到拓展功能的意图。通常通过继承来实现对指定类的功能拓展。
   截个图放在这里，反正你也看不懂，先跳过往下看。
   
   headfirst这本书举了这么个例子，星巴克的咖啡订单系统设计。当然不是整体，就拿饮料这块来设计一下。
   
   嗯，不同的饮料继承实现超类的方法，得到各自的计算价格的方式。所以你得到了这样一个结果
   
   想想星巴克在那么多国家，那么多地区开了多少家店了，会有多少种风格各异的饮料。估计是要奔溃了。
   这就要考虑使用另外一种设计模式。
   重新设计一下咖啡
   
   注意到这里的CondimentDecorator拓展自Beverage类，用到了继承，目的其实是利用继承达到“类型匹配”，而不是利用继承获得“行为”。因为装饰者模式，其中一点是，装饰者必须能取代被装饰者。
   那么所说的“行为”是从哪里来的呢，这就是将装饰者与组件组合时，加入的新行为，所得到的新行为不是继承自超类，而是组合对象得到的。

2. 应用场景

1. 需要拓展一个类的功能，或者给一个类添加附加职责
2. 需要动态的给一个对象添加功能，并且可以动态的撤销这些功能。
3. 需要增加由一些基本的功能排列组合而产生的大量的功能。
4. 不能采用生成子类的方法进行扩充功能时，或者是类的定义被隐藏，或者不能用于生成子类。
   java.io这个包就是典型的装饰者模式设计的。
   
   再详细一点的解释：
   
   BufferedInputStream及LineNumberInputStream都扩展自 FilterInputStream，而FilterInputStream是一个抽象的装饰类。

不过装饰者模式也有个缺点，就是会创建很多的小类，那么在使用这些包装类的时候可能会造成一定的困扰。

3. 模式组成

装饰者由4个元素组成

1. 抽象组件（Component），beverage，一般是一个抽象类或者接口，用来规范准备接受附加责任的对象
2. 具体组件（ConcreteComponent），houseblend，实现了抽象组件的类，定义一个将要接收附加责任的类。
3. 抽象装饰者（Decorator），condimentdecorator，持有一个组件对象的实例，并实现一个与抽象组件一致的接口
4. 具体装饰者，mocha。添加附加责任。

4. 代码实现

来杯2杯咖啡，一个原味，一个加摩卡。。

1. 基础的饮料抽象组件：

public abstract class Beverage {
    public String description = "xxx";
    //打印一些文字信息
    public String getDescription() {
        return description;
    }
    public abstract double cost();
}

2. 具体的实现，在计算中直接返回咖啡的价格。

public class Espresso extends Beverage {
    public Espresso(){
        description = ".Espresso.";
    }
    @Override
    public double cost() {
        return 1.99;
    }
}

3. 为了实现有摩卡的咖啡，我们不能修改咖啡的部分，而是把摩卡当成组件插入。那么就来一个装饰者。

public abstract class CondimentDecorator extends Beverage{
    @Override
    public abstract String getDescription();
}

4. 实现这个装饰者，并加上一些额外的功能。

public class Mocha extends CondimentDecorator {
    Beverage beverage;
    public Mocha(Beverage beverage){
        this.beverage = beverage;
    }
    @Override
    public String getDescription() {
        return beverage.getDescription() + "...mocha";
    }
    @Override
    public double cost() {
        return 1.89 + beverage.cost();
    }
}

5. 测试

    @Test
    public void test(){
        Beverage b = new Espresso();
        System.out.println(b.getDescription() + " " + b.cost());
        Beverage b2 = new Espresso();
        b2 = new Mocha(b2);
        System.out.println(b2.getDescription() + " " + b2.cost());
    }
打印：
.Espresso. 1.99
.Espresso....mocha 3.88

看到加了mocha装饰者，并没有修改原咖啡类。

另外一个例子，新建一个自己的java io装饰类，把读取的文件中所有的大写字母变成小写的。

public class LcInputStream extends FileInputStream {
    public LcInputStream(String name) throws FileNotFoundException {
        super(name);
    }

    @Override
    public int read() throws IOException {
        int c = super.read();
        return (c == -1 ? c : Character.toLowerCase((char) c));
    }

    @Override
    public int read(byte[] b, int offset, int len) throws IOException {
        int result = super.read(b, offset, len);
        for (int i = offset; i < offset + result; i++) {
            b[i] = (byte) Character.toLowerCase((char) b[i]);
        }
        return result;
    }
}

测试代码：

try {
    int c;
    // 读取文件的地址
    InputStream in = new LcInputStream("/Users/xx/Downloads/fee.html");
    in.read();
    while ((c = in.read()) >= 0) {
        System.out.print((char) c);
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}
打印：读取的是html文件，有大小写的，得到的结果都是小写

5. 优缺点

优点，灵活，通过组合实现很多不同的行为。
缺点，太灵活，增加了复杂性，会产生很多小类。

6. 总结

有一点模糊，不是很理解。需要继续学习。

7. headfirst读书分享

1. 类应该对拓展开放，对修改关闭（开放-关闭原则）