Gof-装饰者模式

继续打卡设计模式

今天来聊一下装饰者设计模式

一、实际需求

先提出这样一个实际问题：

咖啡种类/单品咖啡：Espresso(意大利浓咖啡)、ShortBlack、LongBlack(美式咖啡)、Decaf(无因咖啡)

相对应与咖啡的种类。我们还可以添加不同的调料。例如milk，soy,chocolate

这个时候用户来点不同的咖啡可以选择性对的添加不同的调料来改善口味

我们首先想到的可能会是桥接模式那种感觉，把抽象和实现分开，继而创建不同的实例化对象。我们有没有相关因为现在的实现并不是说简单的创建对象。在于我们如何灵活的满足客户的需求。调料对于咖啡来讲是一个辅助性的。我们举一个生活实例，例如糖+水可以是糖水。那么理解上来讲 水和糖水都还是属于水。当时糖却不是属于水，这种概念就是说我们往一种事物中添加另外一种物质却没有改变该事物的本质。我们就把这种动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性。遵循开闭原则，这种模式为装饰者设计模式。

二、装饰者设计模式来解决该问题

首先我们要有一个基类。

/**
 * @author: 德鑫
 * Description:
 * @Date: 2021/01/14
 */

public abstract class Drink {
    //描述
    public String des;
    //价格
    private float price = 0.0f;

    public String getDes() {
        return des;
    }

    public Drink setDes(String des) {
        this.des = des;
        return this;
    }

    public float getPrice() {
        return price;
    }

    public Drink setPrice(float price) {
        this.price = price;
        return this;
    }
    //计算费用的抽象方法
    public abstract float cost();
}

/**
 * @author: 德鑫
 * Description: 这里简单理解就是咖啡是属于饮料
 * @Date: 2021/01/14
 */

public class Coffee extends Drink {
    @Override
    public float cost() {
        return super.getPrice();
    }
}

现在咖啡类来继承饮料类，重新里面的抽象方法

那么现在就依次来创建出我们需求中的类都继承coffee这个类

/**
 * @author: 德鑫
 * Description:
 * @Date: 2021/01/14
 */

public class DeCaf extends Coffee {
    public DeCaf() {
        setDes(" 无因咖啡 ");
        setPrice(1.0f);
    }
}

/**
 * @author: 德鑫
 * Description:
 * @Date: 2021/01/14
 */

public class Espresso extends Coffee {

    public Espresso() {
        setDes(" 意大利咖啡 ");
        setPrice(6.0f);
    }
}

/**
 * @author: 德鑫
 * Description:
 * @Date: 2021/01/14
 */

public class LongBlack extends Coffee {

    public LongBlack() {
        setDes(" longblack ");
        setPrice(5.0f);
    }
}

/**
 * @author: 德鑫
 * Description:
 * @Date: 2021/01/14
 */

public class ShortBlack extends Coffee {
    public ShortBlack() {
        setDes(" shortblack ");
        setPrice(4.0f);
    }
}

那这是我们说的四种咖啡，里面都通过构造方法来设置各个类的属性值

那么接着我们现在有调料

/**
 * @author: 德鑫
 * Description:
 * @Date: 2021/01/14
 */

public class Chocolate extends Decorator {
    public Chocolate(Drink obj) {
        super(obj);
        setDes(" 巧克力 ");
        setPrice(3.0f); // 调味品 的价格
    }
}

/**
 * @author: 德鑫
 * Description:
 * @Date: 2021/01/14
 */

public class Milk extends Decorator {

    public Milk(Drink drink) {
        super(drink);
        setDes(" 牛奶 ");
        setPrice(2.0f);
    }
}

/**
 * @author: 德鑫
 * Description:
 * @Date: 2021/01/14
 */

public class Soy extends Decorator{
    public Soy(Drink obj) {
        super(obj);
        setDes(" 豆浆 ");
        setPrice(1.5f);
    }
}

三种调料完毕

现在最关键的一部来了，我们的装饰者模式在这里起作用了

/**
 * @author: 德鑫
 * Description:
 * @Date: 2021/01/14
 */

public class Decorator extends Drink {

    private Drink drink;

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

    @Override
    public float cost() {
        return super.getPrice() + drink.cost();
    }

    @Override
    public String getDes() {
        return des +getPrice() + " && " + drink.getDes();
    }
}

这里理解装饰者模式在于结合了抽象与扩展改功能的一个结合

/**
 * @author: 德鑫
 * Description: 客户端测试
 *
 * 装饰者模式是动态的将功能附件到对象上。遵守的是开闭原则，在对象扩展方面。它比继承更有弹性
 * @Date: 2021/01/14
 */

public class Client {
    public static void main(String[] args) {
        // 1. 点一份 LongBlack
        Drink order = new LongBlack();
        System.out.println("费用1=" + order.cost());
        System.out.println("描述=" + order.getDes());

        // 2. order 加入一份牛奶
        order = new Milk(order);

        System.out.println("order 加入一份牛奶 费用 =" + order.cost());
        System.out.println("order 加入一份牛奶 描述 = " + order.getDes());

        // 3. order 加入一份巧克力

        order = new Chocolate(order);

        System.out.println("order 加入一份牛奶 加入一份巧克力  费用 =" + order.cost());
        System.out.println("order 加入一份牛奶 加入一份巧克力 描述 = " + order.getDes());

        // 3. order 加入再一份巧克力

        order = new Chocolate(order);

        System.out.println("order 加入一份牛奶 加入2份巧克力   费用 =" + order.cost());
        System.out.println("order 加入一份牛奶 加入2份巧克力 描述 = " + order.getDes());

        System.out.println("===========================");

        Drink order2 = new DeCaf();

        System.out.println("order2 无因咖啡  费用 =" + order2.cost());
        System.out.println("order2 无因咖啡 描述 = " + order2.getDes());

        order2 = new Milk(order2);

        System.out.println("order2 无因咖啡 加入一份牛奶  费用 =" + order2.cost());
        System.out.println("order2 无因咖啡 加入一份牛奶 描述 = " + order2.getDes());

    }
}

多提一句吧，向我们常用的IO结构，filterInputstream就是一个装饰者