HeadFirst设计模式3-装饰者模式

1. 为何需要装饰者模式（why)

  在我们的工作中，往往会这样的需求，就是动态地将责任附加到对象上，来达到拓展对象功能的目的。例如，对于做饼这件事来说，往往在做好一个饼之后，会有加糖，加盐，加鸡蛋这样类似的客户需求，不同的需求价格当然不同。我们通常的做法创建基类（Cake），然后让其他的子类继承它，试想下，如果如果有很多的类，岂不是会造成类爆炸，新出一款新的饼，就会构造一个类，计算不同的价格。而装饰者模式应用在这上面就非常的好。你想加糖，那我在外面包装一层，把额外的价格加上去。以后如果有几种配料的叠加，不用创造新的类，由原来的子类通过装饰者模式包装起来就行。

2. 如何实现装饰者模式how)

1. 定义一个饼的基类，其他的饼的种类继承它。

public abstract class Cake {
    public String message="CAKE";
    public float cost;
    public String getMessage(){
        return message;
    }
    //每个实现类自己实现
    public abstract float getCost();

}

油饼，和糖饼分别实现饼

public class BatterCake extends Cake {
    public BatterCake() {
        message="batterCake";
    }

    @Override
    public float getCost() {
        this.cost=1.2f;
        return cost;
    }
}

public class OilCake extends Cake{ //饼的实现类，油饼

    public OilCake() {
        message="oilCake";
    }
    @Override
    public float getCost() {
        this.cost=1.5f;
        return cost;
    }
}

2. 可以分别加糖或者加盐，因此先来个装饰器接口

public abstract class CakeDecorator extends Cake {
  
}

3.   分别实现通过装饰器加糖和加盐

/**
 * Created by maskwang on 2017/10/15 0015.
 * 饼加盐
 */
public class SaltDecorator extends CakeDecorator{
    Cake cake;

    public SaltDecorator(Cake cake) {
        this.cake = cake;
    }

    @Override
    public String getMessage() {
        return cake.getMessage()+"  with salt   ";
    }

    @Override
    public float getCost() {
        return cake.getCost()+0.3f;
    }
}

public class SugerDecorator extends CakeDecorator {
    Cake cake;

    public SugerDecorator(Cake cake) {
        this.cake = cake;
    }

    @Override
    public String getMessage() {
        return cake.getMessage()+"  with suger  ";
    }

    @Override
    public float getCost() {
        return cake.getCost()+0.2f;   //饼的钱+糖的钱
    }
}

4. 测试一下通过装饰器既加糖又加盐

public class Test {
    public static void main(String[] args) {
        Cake cake = new OilCake();
        cake = new SaltDecorator(cake);
        cake=new SugerDecorator(cake);
        System.out.println(cake.getMessage());
        System.out.println(cake.getCost());
    }
}

结果如下：

image.png

  这里解释一下，最后的2.0如何出来，构造出OilCake，cost就是1.5，
cake = new SaltDecorator(cake)，那么cost就是1.8。cake=new SugerDecorator(cake)，那么就是2.0。

5. 我们常见到的IO包下，就运用到装饰者模式，例如BufferedInputStream,DataInputStream等。也可以实现一个装饰器，把字母转化成小写。如下：

package com.designpattern.decoratorpattern;

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * Created by maskwang on 2017/10/15 0015.
 */
public class UperCaseInputStream extends FilterInputStream {

    public UperCaseInputStream(InputStream in) {
        super(in);
    }

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

    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        int result=super.read(b,off,len);
        for(int i=off;i

测试IO装饰类

 public static void main(String[] args) throws IOException {
//        Cake cake = new OilCake();
//        cake = new SaltDecorator(cake);
//        cake=new SugerDecorator(cake);
//        System.out.println(cake.getMessage());
//        System.out.println(cake.getCost());
        int c;
        try {
            InputStream in=new UperCaseInputStream(new BufferedInputStream(new FileInputStream("E:\\test.txt")));
            while ((c=in.read())>0)
                System.out.println((char)(c));
        }catch (IOException e){
            e.printStackTrace();
        }
    }

![Uploading image_647020.png . . .]

image.png

3. 总结（conclution)

•   从上述我们可以看出来 ，装饰者模式用于已经存在的类添加额外的功能，但是它也有缺点，就是它要在设计中加入大量的小类，会造成额外的空间占用。其核心思想还是如下：

  多用组合，少用继承。针对接口编程，不针对实现编程。对拓展开放，对修改关闭。
github地址：github.com/maskwang520