Java设计模式之装饰者模式

一、概念

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

       关系图：

说明：

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

二、应用实例

1.咖啡店订单系统

       顾客点饮料和调料之后，计算价格，打印描述等。

关系图：

实现代码：

Beverage类

package com.hanxin.decorator;

/**
 * 抽象基类，相当于Component
 * Created by hanxin on 2017/11/12.
 */
public abstract class Beverage {
    String description = "Unknown Berverage";
    public String getDescription(){
        return description;
    }
    //抽象方法，必须在子类中实现
    public abstract double cost();
}

CondimentDecorator类

package com.hanxin.decorator;

/**
 * 调味料父类，扩展自Beverage
 * Created by hanxin on 2017/11/12.
 */
public abstract class CondimentDecorator extends Beverage {
    //调味料要重新实现该方法
    public abstract String getDescription();
}

DarkRoast类

package com.hanxin.decorator;

/**
 * Created by hanxin on 2017/11/12.
 */
public class DarkRoast extends Beverage {
    public  DarkRoast(){
        this.description = "DarkRoast";
    }
    @Override
    public double cost() {
        return 1.05;
    }
}

Decaf类

package com.hanxin.decorator;

/**
 * Created by hanxin on 2017/11/12.
 */
public class Decaf extends Beverage {
    public Decaf(){
        this.description = "Decaf";
    }
    @Override
    public double cost() {
        return 0.99;
    }
}

Espresso类

package com.hanxin.decorator;

/**
 * Created by hanxin on 2017/11/12.
 */
public class Espresso extends Beverage {

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

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

HourseBlend类

package com.hanxin.decorator;

/**
 * Created by hanxin on 2017/11/12.
 */
public class HouseBlend extends Beverage {
    public HouseBlend(){
        this.description = "HouseBlend";
    }
    @Override
    public double cost() {
        return 0.89;
    }
}

Mocha类

package com.hanxin.decorator;

/**
 * Created by hanxin on 2017/11/12.
 */
public class Mocha extends CondimentDecorator {
    //用一个引用记录饮料（就是被装饰者）
    private Beverage beverage;
    //初始化，并将被装饰者引用传进来
    public Mocha(Beverage beverage){
        this.beverage = beverage;
    }
    @Override
    public String getDescription() {
        return beverage.getDescription()+",Mocha";
    }
    /*
        计算价格，调用被装饰者方法计算后，再加上调料价格
     */
    @Override
    public double cost() {
        return beverage.cost()+0.2;
    }
}

Milk类

package com.hanxin.decorator;

/**
 * Created by hanxin on 2017/11/12.
 */
public class Milk extends CondimentDecorator {
    private Beverage beverage;
    public Milk(Beverage beverage){
        this.beverage = beverage;
    }
    @Override
    public String getDescription() {
        return beverage.getDescription()+",Milk";
    }

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

Soy类

package com.hanxin.decorator;

/**
 * Created by hanxin on 2017/11/12.
 */
public class Soy extends CondimentDecorator {
    private Beverage beverage;
    public Soy(Beverage beverage){
        this.beverage = beverage;
    }
    @Override
    public String getDescription() {
        return beverage.getDescription()+",Soy";
    }

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

Whip类

package com.hanxin.decorator;

/**
 * Created by hanxin on 2017/11/12.
 */
public class Whip extends CondimentDecorator {
    private Beverage beverage;
    public Whip(Beverage beverage){
        this.beverage = beverage;
    }
    @Override
    public String getDescription() {
        return beverage.getDescription()+",Whip";
    }

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

测试类

package com.hanxin.decorator;

/**
 * Created by hanxin on 2017/11/12.
 */
public class Test {
    public static void main(String[] args) {
        Beverage beverage = new Espresso();
        System.out.println(beverage.getDescription()+" $"+beverage.cost());

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

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

    }
}

2.自定义IO类

实现代码：

LowerCaeInputStream类

package com.hanxin.decorator.javaAPI;

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

/**
 * Java IO 包中的流采用的是装饰者模式，以下是自定义大小写转换流
 * Created by hanxin on 2017/11/12.
 */
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(c));
    }

    @Override
    public int read(byte[] b,int offset,int len) throws IOException {
        int result = super.read(b,offset,len);
        for(int i=offset;i<offset+len;i++){
            b[i] = (byte)Character.toLowerCase((char)b[i]);
        }
        return result;
    }
}

测试类

package com.hanxin.decorator.javaAPI;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStream;

/**
 * Created by hanxin on 2017/11/12.
 */
public class Test {
    public static void main(String[] args) {
        int c;
        try{
            InputStream in = new LowerCaseInputStream(new BufferedInputStream(new FileInputStream("D:/test.txt")));
            while((c=in.read())>0){
                System.out.println((char)c);
            }
            in.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

三、装饰者模式优缺点

优点：

• 装饰者模式可以提供比继承跟多的灵活性
• 可以通过一种动态的方式来扩展一个对象的功能，在运行时选择不同的装饰器，实现不同的功能
• 通过使用不同的具体装饰类以及这些装饰类的排列组合，可以创造出不同的行为组合，可装用多个装饰器类来装饰对象， 得到功能强大的对象
• 具体构建类与具体装饰类可以独立化，用户可以根据需要增加新的具体构件类和具体装饰类，在使用时在对其进行组合，原有代码无需改变（开闭原则）

缺点：

• 会产生很多的小对象，增加了系统的复杂性
• 比继承更加易于出错，排错也很困难