结构型-装饰者模式

1、一个实例

在一家咖啡店有很多种咖啡，但都基于一种基本饮料开发出来的，每一种咖啡也可以加入很多不同的配料。
饮料有：HouseBlend(首选咖啡)，Espresso(浓缩咖啡)，DarkRoast(焦炒咖啡),Decaf(脱因咖啡)
调料有：Milk(牛奶)、摩卡（mocha）、豆浆（Soy）、奶泡（Whip）
这时候用户下单要打印票据显示配方和价格，该如何做呢？

//被装饰者父类
public abstract class Beverage {
    String description = "Unknown Beverage";

    public String getDescription() {
        return description;
    }

    public abstract double cost();
}
//创建几个实现类
public class HouseBlend extends Beverage {
    public HouseBlend() {
        description = "House Blend Coffee";
    }

    @Override
    public double cost() {
        return 0.89;
    }
}
public class DarkRoast extends Beverage {

    public Espresso() {
        description = "DarkRoast";
    }

    @Override
    public double cost() {
        return 1.99;
    }
}

• 装饰类（写法1）

//创建装饰者
public abstract class CondimentDecorator extends Beverage {
    public abstract String getDescription();
}
// 创建具体的装饰者
public class Mocha extends CondimentDecorator {
    Beverage beverage;

    public Mocha(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public double cost() {
        return 0.2 + beverage.cost();
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ",Mocha";
    }
}

public class Milk extends CondimentDecorator {
    Beverage beverage;

    public Milk(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public double cost() {
        return 0.1 + beverage.cost();
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ",Milk";
    }
}

• 装饰类（写法2）

//创建装饰者父类
public abstract class CondimentDecorator extends Beverage {
    protected Beverage beverage;

    public CondimentDecorator(Beverage beverage) {
        this.beverage = beverage;
    }

    public abstract String getDescription();

}
// 创建具体的装饰者
public class Mocha extends CondimentDecorator {
    public Milk(Beverage beverage) {
        super(beverage);
    }

    @Override
    public double cost() {
        return 0.2 + beverage.cost();
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ",Mocha";
    }
}

public class Milk extends CondimentDecorator {
    public Milk(Beverage beverage) {
        super(beverage);
    }

    @Override
    public double cost() {
        return 0.1 + beverage.cost();
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ",Milk";
    }
}

• main方法

public class StartbuzzCoffee {
    public static void main(String[] args) {
        Beverage beverage = new DarkRoast();
        //一杯不加调料的咖啡
        System.out.println(beverage.getDescription() + ",价格：" + beverage.cost());
        //用摩卡和牛奶装饰下
        Beverage beverage2 = new DarkRoast();
        beverage2=new Mocha(beverage2);
        beverage2=new Milk(beverage2);
        System.out.println(beverage2.getDescription() + ",价格：" + beverage2.cost());

        Beverage beverage3=new Milk(new Mocha(new DarkRoast()));
        System.out.println(beverage3.getDescription() + ",价格：" + beverage3.cost());
    }
}
输出
DarkRoast,价格：1.99
DarkRoast,Mocha,Milk,价格：2.29
DarkRoast,Mocha,Milk,价格：2.29

1652267688(1).png

2、什么是装饰者模式

2.1、定义装饰者模式

动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更具有弹性的替代方案。

2.2 特征

• 装饰者和被装饰者有相同的超类型。
• 可以用一个或多个装饰者包装一个对象。
• 对象可以在任何时候被装饰

怎么看出来是使用了装饰模式呢？
当你看到 new BufferedInputStream(new FileInputStream("test.txt"));这种写法就差不多了。

• 装饰者和被装饰者有相同的超类型
• 装饰者持有超类型的引用，这样装饰者就可以不断的修饰 被装饰者

3、 java中的实例

1652342401(1).png

上图是java中的inputStream。我们可以看出来FilterInputStream就是我们的装饰者。

//被装饰者父类
public abstract class InputStream{
    public abstract int read() ;
}
//实现类(具体被装饰者)
public class FileInputStream extends InputStream{
  public FileInputStream(File file){}
  public int read() throws IOException{}
}
public class StringBufferInputStream extends InputStream {
  public synchronized int read(){}
  public StringBufferInputStream(String s) { }
}
public class ByteArrayInputStream extends InputStream {
    public ByteArrayInputStream(byte buf[]) {}
    public synchronized int read(){}
}

• 装饰类

//创建装饰者
public class FilterInputStream extends InputStream {
  protected volatile InputStream in;
  protected FilterInputStream(InputStream in) {
        this.in = in;
    }
  public int read() throws IOException {
        return in.read();
    }
}
// 创建具体的装饰者
public class BufferedInputStream extends FilterInputStream {
  public synchronized int read(){}
}

• 具体使用

 public static void main(String[] args){
  InputStream in = new BufferedInputStream(new FileInputStream("test.txt"));
}