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

一、基本概念

装饰者模式是结构型设计模式。

装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。

允许向一个现有的对象添加新的功能。同时又不改变其结构，它是作为现有的类的一个包装。

主要解决的问题: 一般我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。

二、结构

结构：

• 装饰者（decorator）和具体组件（concretecomponent）都继承自组件（component）；
• 所谓装饰，就是把这个装饰者套在被装饰者之上，从而动态扩展被装饰者的功能；
• 装饰者的方法有一部分是自己的，这属于它的功能(半透明的装饰者模式)。然后调用被装饰者的方法实现，从而也保留了被装饰者的功能；

 

 

三、案例

1、装饰者模式案例

模拟在餐馆点饮料，我们可以点咖啡，而咖啡有decaf咖啡和espresso咖啡，而这两种咖啡都可以加牛奶和巧克力进去。

具体的代码组织结构图:

 

 

具体代码:

先看最高的component包下的drink类:

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

下面看两个具体的component:

/** 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();
    }
}

下面看decorator下的三个类:

第一个是装饰者的超类，继承自drink类:

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

2、javaio中使用装饰者模式

由于java i/o库需要很多性能的各种组合，如果这些性能都是用继承的方法实现的，那么每一种组合都需要一个类，这样就会造成大量性能重复的类出现，所以java io使用的是装饰者设计模式。

 

 

所以我们可以定义自己的装饰者。

这里我们定义一个流，这个流将读入的小写字母转换成大写字母。

uppercaseinputstream代码如下:

/**
 * 自己定义的输入流　　
 * 扩展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();
    }
}

输出结果演示:

 

 

四、总结

优缺点:

• 优点 : 装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。
• 缺点 : 多层装饰比较复杂。

实际应用: 　大多数情况下，装饰模式的实现都要比上面给出的示意性例子要简单。

• 如果只有一个concretecomponent类，那么可以考虑去掉抽象的component类（接口），把decorator作为一个concretecomponent子类；
• 　如果只有一个concretedecorator类，那么就没有必要建立一个单独的decorator类，而可以把decorator和concretedecorator的责任合并成一个类。

免费java高级资料需要自己领取，涵盖了java、redis、mongodb、mysql、zookeeper、spring cloud、dubbo高并发分布式等教程，一共30g。
传送门：https://mp.weixin.qq.com/s/jzddfh-7ynudmkjt0irl8q