结合案例深入解析装饰者模式

/**
 * Component的超类
 * 单品和装饰者都要继承自这个类
 */
public abstract class Drink {

    private String description = ""; //一开始没有描述
    private double price = 0; //一开始价格为0

    /**
     * 抽象方法
     *  1、如果是单品的话就直接是自己的价格
     *  2、如果是装饰者的话就还要加上装饰品自己的价格
     */
    public abstract double cost();


    // setter getter

    public String getDescription() {
        return description;
    }
    public double getPrice() {
        return price;
    }
    public void setDescription(String description) { //描述的时候顺便把价格描述一下
        this.description = description;
    }
    public void setPrice(double price) {
        this.price = price;
    }
}

/** ConcreteComponent 1*/
public class Decaf extends Drink {

    public Decaf() {
        super.setDescription("Decaf");
        super.setPrice(3); //3块钱
    }

    @Override
    public double cost() {
        return getPrice();//super.getPrice()//这个就是父类的价格(自己什么也没加 (没有被装饰))
    }

    // 重写getter 后面加上自己的花费
    @Override
    public String getDescription() {
        return super.getDescription() + "-" + cost();
    }
}
/** ConcreteComponent 2
 *  也可以在ConcreteComponent和Drink类有一个过渡的类)  (比如Coffee类)
 */
public class Espresso extends Drink {

    public Espresso(){
        super.setDescription("Espresso");
        super.setPrice(4);
    }

    @Override
    public double cost() {
        return getPrice();//super.getPrice()//这个就是父类的价格(自己什么也没加)
    }

    @Override
    public String getDescription() {
        return super.getDescription() + "-" + cost();
    }
}

public class Decorator extends Drink{
    /**
     * 这个引用很重要，可以是单品，也可以是被包装过的类型，所以使用的是超类的对象
     * 这个就是要被包装的单品(被装饰的对象)
     */
    private Drink drink; //这里要拿到父类的引用，因为要控制另一个分支(具体的组件)

    public Decorator(Drink drink) {
        this.drink = drink;
    }

    /**
     * 如果drink是已经被装包过的，那么就会产生递归调用　　最终到单品
     */
    @Override
    public double cost() {
        return super.getPrice() + drink.cost(); // 自己的价格和被包装单品的价格
    }

    @Override
    public String getDescription() {
        return super.getDescription() + "-" + super.getPrice()
                + " && " + drink.getDescription();
    }
}

/**
 * 这个是具体的装饰者() --> 继承自中间的装饰着Decorator
 */
public class Chocolate extends Decorator{

    public Chocolate(Drink drink) { //如果父类搞了一个　带参数的构造函数，子类必须显示的使用super调用
        super(drink);
        super.setDescription("Chocolate");
        super.setPrice(1);
    }
}
public class Milk extends Decorator{

    public Milk(Drink drink) {
        super(drink); //调用父类的构造函数
        super.setDescription("Milk");
        super.setPrice(3);
    }
}

public class MyTest {
    public static void main(String[] args) {
        //只点一个单品 (Decaf 咖啡)
        Drink order = new Decaf();
        System.out.println("order description : " + order.getDescription());
        System.out.println("order price : " + order.cost());

        System.out.println("---------------加了调料的----------------");

        order = new Milk(order);// 加了牛奶
        order = new Chocolate(order);
        order = new Chocolate(order); // 加了两个巧克力
        System.out.println("order description : " + order.getDescription());
        System.out.println("order price : " + order.cost());
    }
}

order description : Decaf-3.0
order price : 3.0
---------------加了调料的----------------
order description : Chocolate-1.0 && Chocolate-1.0 && Milk-3.0 && Decaf-3.0
order price : 8.0

/**
 * 自己定义的输入流　　
 * 扩展FilterInputStream(这个类就是我们的Decorator) 中间装饰者　　
 * 所以我们只要继承这个就可以扩展自己的输入流装饰者　
 */
public class UpperCaseInputStream extends FilterInputStream{

    protected UpperCaseInputStream(InputStream in) {  //这个InputStream就是我们的Drink 类(超类)
        super(in);
    }

    // 实现两个read()方法，将大写转化成小写的读入

    //重写　相当于cost和description
    @Override
    public int read() throws IOException {
        int index = super.read(); //读取一个字节
        return index == -1 ? index : Character.toUpperCase((char)(index));  //小写转换成大写
    }

    //字节数组
    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        int index = super.read(b, off, len);
        for(int i = 0; i < index; i++)
            b[i] = (byte)Character.toUpperCase((char)(b[i]));
        return index;
    }
}

public class MyTest {

    public static void main(String[] args) throws IOException {
        InputStream in = new UpperCaseInputStream(new BufferedInputStream(new FileInputStream("/home/zxzxin/Java_Maven/DesignPatterns/src/main/java/decorator/java/in.txt")));// 将这个in.txt文件读入的内容转换成大写
        int len;
        while((len = in.read()) >= 0)
            System.out.print((char)(len));
        in.close();
    }
}