设计模式随笔-装饰者模式

装饰者模式

当自己还是菜鸟的时候，曾经以为用继承处理一切。但是后来才运行时的强大之处，真的是让自己的眼界开阔了很多。
装饰者模式正是可以给喜欢用继承的人另外一个思想。

需求

初始设计

某咖啡店原设计是这样的……

但是这个设计，如果我要在HouseBlend（综合咖啡）的基础上+牛奶，那么我就必须在创建一个类：HouseBlendWithMilk，这样的话如果我每一种coffee都需要加一种配料就产生多少个子类，而且配料之间还能够重叠。这样要创建多少个类啊，啊大家可想而知。这种设计方法是不可取的。可能大家会想到可以继承原有的子类啊，例如：HouseBlend（综合咖啡）被HouseBlendWithMilk（牛奶综合咖啡）继承，可能这样可以让大家比较好的让他们分类，但是类还是没有减少哦。
很明显，如果牛奶涨价了，怎么办？某咖啡馆给自己制造了一个维护噩梦。

改进设计

于是乎，某咖啡店的程序员需要重构咖啡店的设计。
重构的设计图如下：

现在超类的cost()是一个具体的方法，在子类中需要覆盖和继承子类的cost()方法。这样达到的效果是不用创建那么多的子类了。比如，当我需要一杯mocha咖啡只需要在子类里面的一杯普通咖啡+setMocha(true),这样子类的cost()就可以计算出子类的咖啡价格+抽象类中设置mocha的值了。
这种方法也有一些缺陷：
1.调料价格的改变会让我们更改调料的价格
2.一旦出现新的调料，我们必须在超类中加上。
3.如果以后开发出一种饮料，是不需要牛奶的，这样继承超类的牛奶配料就不合适了，因为根本就用不到。
4.如果用户想要双倍的mocha咖啡怎么办呢？无法实现了。

这里设计到一个设计原则：类应该对扩展开放，对修改关闭。

程序员在一次重构代码

某咖啡店的成员员打算用一种设计模式：只针对扩展开发-修改关闭，他就是“装饰者模式”

认识装饰模式

拿咖啡为例子，饮料即为主体，然后让许多的配料来装饰它。
如下图所示：

1.首先是创建一个DarkRoast（焦糖咖啡），并有自己的价格
2.然后添加Mocha（摩卡）配料，处理被装饰的价格+摩卡的价格。
3.最后添加Whip（奶油），处理被装饰的价格+奶油的价格。

装饰者可以在所委托被装饰者的行为之前或之后，加上自己的行为，以达到特定的目的。

装饰者模式：动态地将责任附加到对象上。若要扩展功能，装饰者提供了更有弹性的方法。

装饰者构架，如下图所示：

好了，了解完这些概念之后，我们来从新设计咖啡馆吧。

咖啡馆装饰者模式

现在我们就用装饰者模式来从新设计咖啡馆的代码吧！

首先是component装饰者的父类（名称有所不同）：

public abstract class Beverage {    public String description = "Unknown Beverage";    public String getDescription(){        return description;    }    public abstract double cost();}

接下来我们实现的是装饰器的抽象类，也就是框架的Decoretor类（名称有所不同）：

public abstract class CondimentDecorator extends Beverage{    //必须要覆盖Beverage类的getDescription方法    public abstract String getDescription();}

然后是罗列一些饮料的代码（即ConcreteComponent，需要被装饰的基本类）：

//浓咖啡public class Espresso extends Beverage {    public Espresso() {        description = "Espresso";    }    @Override    public double cost() {        return 1.99;    }}//综合咖啡public class HouseBlend extends Beverage {    public HouseBlend() {        description = "House Blend Coffee";    }    @Override    public double cost() {        return 0.89;    }}

现在就以及实现了抽象组件(Beverage)、具体组件(Espresso、HouseBlend)、抽象装饰者(CondimentDecorator)
接下来是实现配料具体的装饰者了。

//摩卡配料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 .20 + beverage.cost();    }}//豆浆public class Soy extends CondimentDecorator {    Beverage beverage;    public Soy(Beverage beverage) {        this.beverage = beverage;    }    @Override    public String getDescription() {        return beverage.getDescription() + " ,soy";    }    @Override    public double cost() {        return beverage.cost() + .22;    }}//奶油public class Whip extends CondimentDecorator{    Beverage beverage;    public Whip(Beverage beverage) {        this.beverage = beverage;    }    @Override    public String getDescription() {        return beverage.getDescription() + ", Whip";    }    @Override    public double cost() {        return .11 + beverage.cost();    }}

所有类都实现之后就可以写测试类了：

public class CoffeeTest extends TestCase {    public void testCoffee(){        //单点一杯Espresso 不需要加调料，打印价格与描述        Beverage beverage = new Espresso();        System.out.println(beverage.getDescription() + " $" + beverage.cost());        Beverage beverage1 = new HouseBlend();  //先定一杯综合咖啡        beverage1 = new Soy(beverage1);  //加豆浆        beverage1 = new Whip(beverage1);  //加奶油        System.out.println(beverage1.getDescription() + " $" + beverage1.cost());    }}console:Espresso $1.99House Blend Coffee ,soy, Whip $1.22

Java中的装饰者类：Java I/O

和上面的某咖啡设计相比，Java I/O流设计其实都大同小异。
具体的类图查看，大家可以打开jdk文档来具体的了解一下，假设大家都看了上面的装饰者模式和了解了下i/o类。我们现在实现一个自己的i/o类。

public class LowerCaseInputStream extends FilterInputStream {    public LowerCaseInputStream(InputStream in) {        super(in);    }    @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 off, int len) throws IOException {        int c = super.read(b, off, len);        for (int i=off; i < off + c; i++){            b[i] = (byte) Character.toLowerCase((char)b[i]);        }        return c;    }}//测试方法：public void testIO(){        int c;        try {            InputStream in = new LowerCaseInputStream(                    new BufferedInputStream(                            new FileInputStream("D:"+ File.separator+"test.txt")));            while ((c = in.read()) >= 0){                System.out.print((char) c);            }            in.close();        } catch (FileNotFoundException e) {            e.printStackTrace();        } catch (IOException e) {            e.printStackTrace();        }    }//输出结果i love youProcess finished with exit code 0

test.txt 内容为：I LOVE YOU
输出结果为小写的:i love you

总结

装饰模式让我学习到了几个点：
1、为交互对象之间的松耦合而努力
2、对扩展开发，对修改关闭
3、装饰者模式-动态的将责任附加到对象上。想要扩展功能，装饰者提供有别于继承的另一种实现方式。