装饰者(Decorator)模式

装饰者模式的说明

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

装饰者模式的特点

• 装饰者和被装饰对象有相同的超类型；
• 可以用一个或多个装饰者包装一个对象；
• 在任何需要原始对象(被包装对象)的场合，可以用装饰过的对象代替它；
• 装饰者可以在所委托被装饰者的行为之前与之后，加上自己的行为，以达到特定的目的；
• 对象可以在任何时候被装饰，所以可以在运行时动态地、不限量地用你喜欢的装饰者来装饰对象。

举例说明

假设有一个抽象类Beverage，它提供一个cost()方法，表示一种饮料需要的钱。这时候有多种咖啡继承它，每种咖啡又可以分为加糖的、加奶泡的等等，这样子类就会很多，难以维护。这种情况下，可以把配料单独取出来，每种配料都实现了cost()方法，这时候，咖啡只需要按照自己的类型例如浓缩咖啡、混合咖啡分类。在计算cost的时候，可以把配料作为一个装饰者包装咖啡，这样，不管有多少种配料，都可以方便地计算价格了。

具体实现

一个”饮料”抽象类：

public abstract class Beverage {
    String description = "Unknown Beverage";

    public String getDescription() {
        return description;
    }

    public abstract double cost();
}

一个”调料”抽象类：

public abstract class CondimentDecorator extends Beverage {
        public abstract String getDescriotion();
}

几个咖啡类：

public class Espresso extends Beverage{

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

    public double cost(){
        return 1.99;
    }
}

public class HouseBlend extends Beverage{
    public HouseBlend(){
        description = "House Blend Coffee";
        }

        public double cost(){
        return .89;
        }
}

几个调料装饰者：

public class Mocha extends CondimentDecorator{
    Beverage beverage;

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

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

    public double cost(){
        return .20+beverage.cost();
    }
}

public class Whip extends CondimentDecorator {
    Beverage beverage;

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

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

    public double cost(){
        return .10+beverage.cost();
    }
}

public class Soy extends CondimentDecorator {
    Beverage beverage;

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

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

    public double cost(){
        return .15 + beverage.cost();
    }
}

装饰的过程：

Beverage beverage1 = new HouseBlend();
        beverage1 = new Soy(beverage1);
        beverage1 = new Mocha(beverage1);
        beverage1 = new Whip(beverage1);
        System.out.println(beverage1.getDescription()+"$"+beverage1.cost());

整个结构很简洁。

Java中的装饰者：I/O

Java I/O中，FilterInputStream和FilterOutputStream是抽象装饰者，可以装饰其它继承了输入/输出流的组件。

实现一个I/O装饰者，将大写转化为小写：

public class LowCaseInputStream extends FilterInputStream {
    public LowCaseInputStream(InputStream in){
        super(in);
    }

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

    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;
    }
}

两个read()方法，一个针对字节，一个针对字节数组。

装饰过程：

    try {
            InputStream in = new LowCaseInputStream(new BufferedInputStream((new FileInputStream("D:\\ss.txt"))));

            while ((c = in.read()) >= 0){
                System.out.print((char) c);
            }

            in.close();
        }catch (IOException e){
            e.printStackTrace();
        }

代码链接