设计模式-装饰器模式（6）

最新推荐文章于 2024-06-20 18:41:36 发布
最新推荐文章于 2024-06-20 18:41:36 发布
阅读量107 收藏
点赞数
分类专栏： Play With 设计模式 文章标签： 设计模式 装饰器模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43891234/article/details/118699254
版权

装饰器模式

1. 实例

  • 业务场景：星巴克卖咖啡，一开始，只有四种咖啡：Decaf，Espresso，DrakRoast，HouseBlend。因为所有咖啡都有共性，所以可以继承自一个父类，Beverage。
// 0. 业务
// 星巴克卖咖啡，一开始，只有四种咖啡：Decaf，Espresso，DrakRoast，HouseBlend。
// 因为所有咖啡都有共性，所以可以继承自一个父类，Beverage(饮料)。

// 1. 咖啡父类
abstract class Beverage{
    private String description;

    // 父类有有参构造器了，所以没有默认的无参构造器，所以子类需要重写有参构造器，如果不重写
    // 则子类默认调用自己的无参构造器，从而调用父类的无参构造器（super()），但是父类没有无参（被有参代替），所以子类报错。
    public Beverage(String description) {
        this.description = description;
    }

    public abstract double cost();

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

// 2. 咖啡子类
// 2.1 无咖啡因咖啡
class Decaf extends Beverage{
    public Decaf() {
        super("无咖啡因咖啡");
    }

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


// 2.2 浓缩咖啡
class Espresso extends Beverage{
    public Espresso() {
        super("浓缩咖啡");
    }

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


// 2.3 深度烘焙咖啡
class DrakRoast extends Beverage{
    public DrakRoast() {
        super("深度烘焙咖啡");
    }

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


// 2.4 混合咖啡
class HouseBlend extends Beverage{
    public HouseBlend() {
        super("混合咖啡");
    }

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


// ========================客户端=====================
public class Test02 {
    public static void main(String[] args) {
        Beverage b1 = new Decaf();
        Beverage b2 = new Espresso();
        Beverage b3 = new DrakRoast();
        Beverage b4 = new HouseBlend();

        System.out.println(b1.getDescription() + ": " + b1.cost());
        System.out.println(b2.getDescription() + ": " + b2.cost());
        System.out.println(b3.getDescription() + ": " + b3.cost());
        System.out.println(b4.getDescription() + ": " + b4.cost());
    }
}

上面代码，目前没有问题。
但是变化来了：
星巴克老板为了提升竞争力，想到一个新业务，给咖啡中加调料：牛奶，豆浆，摩卡，泡沫。
那么如何应对这种变化呢？

针对上面的问题，有下面解决方案：

为加牛奶的Decaf创建一个类 DecafWithMilk，为加牛奶的Expresso创建一个ExpressoWithMilk…
但是这会引起类的爆炸增长，因为每个类不止加牛奶，豆浆，可以任意组合！

上面方案不可以！

针对上面问题，我们可以在父类Beverage中，添加4个boolean属性，分别代表4种调料，然后修改父类cost方法，要加上调料的价格；描述也要修改，要加上调料描述

private boolean milk,soy,mocha,bubble;
public boolean isMilk() {
return milk;
}
public void setMilk(boolean milk) {
this.milk = milk;
}

// 客户端
Beverage b1 = new Decaf();
b1.setMilk(true);
b1.setSoy(true);

// 0. 业务
// 星巴克卖咖啡，一开始，只有四种咖啡：Decaf，Espresso，DrakRoast，HouseBlend。
// 因为所有咖啡都有共性，所以可以继承自一个父类，Beverage(饮料)。

// 1. 咖啡父类
abstract class Beverage{
    private String description;
    private boolean milk,soy,mocha,bubble;

    // 父类有有参构造器了，所以没有默认的无参构造器，所以子类需要重写有参构造器，如果不重写
    // 则子类默认调用自己的无参构造器，从而调用父类的无参构造器（super()），但是父类没有无参（被有参代替），所以子类报错。
    public Beverage(String description) {
        this.description = description;
    }

    public double cost(){
        double total = 0;
        if(milk){
            total += 0.2;
        }
        if(soy){
            total += 0.3;
        }
        if(mocha){
            total += 0.4;
        }
        if(bubble){
            total += 0.1;
        }
        return total;
    }

    public String getDescription() {
        String str = description;
        if(milk)    str = str + " + milk";
        if(soy)    str = str + " + soy";
        if(mocha)    str = str + " + mocha";
        if(bubble)    str = str + " + bubble";
        return str;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public boolean isMilk() {
        return milk;
    }

    public void setMilk(boolean milk) {
        this.milk = milk;
    }

    public boolean isSoy() {
        return soy;
    }

    public void setSoy(boolean soy) {
        this.soy = soy;
    }

    public boolean isMocha() {
        return mocha;
    }

    public void setMocha(boolean mocha) {
        this.mocha = mocha;
    }

    public boolean isBubble() {
        return bubble;
    }

    public void setBubble(boolean bubble) {
        this.bubble = bubble;
    }
}

// 2. 咖啡子类
// 2.1 无咖啡因咖啡
class Decaf extends Beverage{
    public Decaf() {
        super("无咖啡因咖啡");
    }

    @Override
    public double cost() {
        // 无咖啡因咖啡价格 + 调料价格
        return 1 + super.cost();
    }
}


// 2.2 浓缩咖啡
class Espresso extends Beverage{
    public Espresso() {
        super("浓缩咖啡");
    }

    @Override
    public double cost() {
        return 2+ super.cost();
    }
}


// 2.3 深度烘焙咖啡
class DrakRoast extends Beverage{
    public DrakRoast() {
        super("深度烘焙咖啡");
    }

    @Override
    public double cost() {
        return 3 + super.cost();
    }
}


// 2.4 混合咖啡
class HouseBlend extends Beverage{
    public HouseBlend() {
        super("混合咖啡");
    }

    @Override
    public double cost() {
        return 4 + super.cost();
    }
}


// ========================客户端=====================
// 扩展饮料
class Tea extends Beverage{
	public Tea(){
		super("茶");
	}
	public double cost(){
		return 2 + super.cost();
	}
}

public class Test02 {
    public static void main(String[] args) {
        Beverage b1 = new Decaf();
        b1.setMilk(true);
        Beverage b2 = new Espresso();
        Beverage b3 = new DrakRoast();
        Beverage b4 = new HouseBlend();

        System.out.println(b1.getDescription() + ": " + b1.cost());
        System.out.println(b2.getDescription() + ": " + b2.cost());
        System.out.println(b3.getDescription() + ": " + b3.cost());
        System.out.println(b4.getDescription() + ": " + b4.cost());
    }
}

上述优点：

  1. 类没有爆炸
  2. 可以扩展饮料类型，如Tea，符合开闭原则

缺点

  1. 添加调料的时候需要修改源代码，违反开闭原则

修改成下面，下面代码则是装饰器模式

// 0. 业务
// 星巴克卖咖啡，一开始，只有四种咖啡：Decaf，Espresso，DrakRoast，HouseBlend。
// 因为所有咖啡都有共性，所以可以继承自一个父类，Beverage(饮料)。

// 1. 咖啡父类
abstract class Beverage{
    private String description;
    // 父类有有参构造器了，所以没有默认的无参构造器，所以子类需要重写有参构造器，如果不重写
    // 则子类默认调用自己的无参构造器，从而调用父类的无参构造器（super()），但是父类没有无参（被有参代替），所以子类报错。
    public Beverage(String description) {
        this.description = description;
    }
    public abstract double cost();

    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }

}

// 2. 咖啡子类
// 2.1 无咖啡因咖啡
class Decaf extends Beverage{
    public Decaf() {
        super("无咖啡因咖啡");
    }
    @Override
    public double cost() {
        // 无咖啡因咖啡价格 + 调料价格
        return 1;
    }
}

// 2.2 浓缩咖啡
class Espresso extends Beverage{
    public Espresso() {
        super("浓缩咖啡");
    }
    @Override
    public double cost() {
        return 2;
    }
}


// 2.3 深度烘焙咖啡
class DrakRoast extends Beverage{
    public DrakRoast() {
        super("深度烘焙咖啡");
    }
    @Override
    public double cost() {
        return 3;
    }
}


// 2.4 混合咖啡
class HouseBlend extends Beverage{
    public HouseBlend() {
        super("混合咖啡");
    }
    @Override
    public double cost() {
        return 4;
    }
}

// 3. 调料父类
// 判断2个类能不能继承，看is a，还要满足里氏替换原则。此处调料不是饮料，但是为了实现装饰器模式，我们只能这样
// 继承满足条件is a和里氏替换原则，只是原则，不是规定，特定条件下可以违反。
abstract class Condiment extends Beverage{
    protected Beverage beverage;
    public Condiment(Beverage beverage) {
        super("调料");
        // 第一次的时候是饮料，后面传入的都是调料
        // Beverage b1 = new Decaf();
        // Beverage b2 = new Milk(b1);  此时b1是Decaf饮料
        // Beverage b3 = new Soy(b2);   此时b2是Milk，并且此时Soy中继承自Condiment的字段beverage ==> Milk
        // Beverage b4 = new Mocha(b3);
        // Beverage b5 = new Bubble(b4);
        this.beverage = beverage;
    }
}

// 3.2 调料子类
class Milk extends Condiment{
    // 父类有 protected Beverage beverage;
    public Milk(Beverage beverage) {
        super(beverage);
    }
    @Override
    public double cost() {
        // 饮料的价格+牛奶（调料）价格
        return beverage.cost()+0.2;
    }
    @Override
    public String getDescription() {
        // 调用的传入饮料的描述
        return beverage.getDescription()+" + 牛奶";
    }
}

class Soy extends Condiment{
    public Soy(Beverage beverage) {
        super(beverage);
    }
    @Override
    public double cost() {
        // 饮料的价格+牛奶（调料）价格
        return beverage.cost()+0.3;
    }
    @Override
    public String getDescription() {
        return beverage.getDescription()+" + 豆浆";
    }
}


class Mocha extends Condiment{
    public Mocha(Beverage beverage) {
        super(beverage);
    }
    @Override
    public double cost() {
        // 饮料的价格+牛奶（调料）价格
        return beverage.cost()+0.4;
    }
    @Override
    public String getDescription() {
        return beverage.getDescription()+" + 摩卡";
    }
}


class Bubble extends Condiment{
    public Bubble(Beverage beverage) {
        super(beverage);
    }
    @Override
    public double cost() {
        // 饮料的价格+牛奶（调料）价格
        return beverage.cost()+0.5;
    }
    @Override
    public String getDescription() {
        return beverage.getDescription()+" + 泡沫";
    }
}


// ========================客户端=====================
// 扩展饮料和调料
class Tea extends Beverage{
    public Tea(){
        super("茶");
    }
    @Override
    public double cost() {
        return 2;
    }
}
// 调料枸杞
class GouQi extends Condiment{
    public GouQi(Beverage beverage) {
        super(beverage);
    }
    @Override
    public double cost() {
        return beverage.cost()+1;
    }
    @Override
    public String getDescription() {
        return beverage.getDescription()+" + 枸杞";
    }
}

public class Test02 {
    public static void main(String[] args) {
        Beverage b = new Decaf();
        // 不要理解成调料里面加饮料，理解成混合在一起
        Milk milk = new Milk(b);
        Soy soy = new Soy(milk);
        Mocha mocha = new Mocha(soy);
        Bubble bubble = new Bubble(mocha);
        System.out.println(bubble.getDescription()+" = "+bubble.cost());

        // 这种写法方便理解，milk等调料继承自饮料
        Beverage b1 = new Decaf();
        Beverage b2 = new Milk(b1);
        Beverage b3 = new Soy(b2);
        Beverage b4 = new Mocha(b3);
        Beverage b5 = new Bubble(b4);
        // 还可以加2份泡沫
        Beverage b6 = new Bubble(b5);
        System.out.println(b5.getDescription()+" = "+b5.cost());
        System.out.println(b6.getDescription()+" = "+b6.cost());

        // 扩展的饮料和调料
        Beverage b11 = new Tea();
        Beverage b22 = new GouQi(b11);
        Beverage b33 = new Milk(b22);
        System.out.println(b33.getDescription()+ " = " + b33.cost());
    }
}

无咖啡因咖啡 + 牛奶 + 豆浆 + 摩卡 + 泡沫 = 2.4
无咖啡因咖啡 + 牛奶 + 豆浆 + 摩卡 + 泡沫 = 2.4
无咖啡因咖啡 + 牛奶 + 豆浆 + 摩卡 + 泡沫 + 泡沫 = 2.9
茶 + 枸杞 + 牛奶 = 3.2

一直套娃罢了！！！！
在这里插入图片描述

装饰器模式核心：继承（每个调料类内部都有父类Condiment中的字段protected Beverage beverage，但是却会根据情况指向不同对象，但他们都是Beverage）+关联（Condiment中的字段protected Beverage beverage）
在这里插入图片描述
以上部分便是装饰器模式，其实jdk中的流就用了装饰器模式

2. 缺点

是杏花微雨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图解设计模式（6） 装饰模式
简易开头 快速迭代
08-31 224
一、 适用场景 动态地为一个对象增加新的功能。 装饰模式是一种用于代替继承的技术，无需通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系，更加灵活，同时避免了产生过多类型。 比如一个汽车，具有行驶的功能。后来业务扩展需要又需要它有飞行、潜水、自动驾驶的功能，如果这些功能都通过继承去实现的话，它们两两组合要写好多的类。 这个时候我们就...
设计模式--6.装饰模式
Happy_wu的专栏
02-07 394
装饰模式：动态的给一个对象添加一些额外的职责，就增加功能来说，装饰者模式比生成子类更为灵活。 结构图： 代码实现： 抽象类： package unit1to6.test6; package unit1to6.test6; public abstract class Component { public abstract void Operation(); }
利用装饰器模式封装核心业务单元
微软新技术
02-13 456
有的时候，希望实现一个基本的核心代码快，由外围代码实现专用性能的包装，最简单的方法，是使用超类，但是超类使用了继承而提升了耦合性。在这样的情况下，也可以使用装饰器模式，这是用组合取代继承的一个很好的方式。1、意图事实上，上面所要解决的意图可以归结为“在不改变对象的前提下，动态增加它的功能”，也就是说，我们不希望改变原有的类，或者采用创建子类的方式来增加功能，在这种情况下，可以采用装饰模式。2、结构
实战java设计模式（九）装饰器模式
你佳哥
11-13 219
装饰器模式是我本人觉得非常巧妙的一种设计模式，值得细细品味。 目录1 介绍2 例子2.1 饮料抽象类2.2 咖啡实体2.3 加佐料的饮料抽象类（核心）2.4 实现加佐料的饮料2.5 测试主类3 例子升华4 总结4.1 核心角色4.2 核心代码结构 1 介绍 允许向一个现有的对象添加新的功能，同时又不改变其结构。 2 例子 假设一个饮品店卖饮料，各个饮料口味不同（多糖、少糖、加奶、不加奶）价格也不一样。 2.1 饮料抽象类 //饮料的抽象类 interface Drink { int cost();
设计模式-装饰器模式
Hughes-T的博客
09-24 61
比继承更弹性的替代方案,透明动态地扩展功能
设计模式：装饰器模式（C++实现）
zsiming的博客
09-04 366
首先先上结论：装饰器模式的设计场景是为已有的类增加新的功能。有人可能会觉得有些奇怪：增加新的功能可以通过继承的方式进行实现。例如，我通过public继承把父类的东西全部继承过来，接口也全部继承过来，然后在子类的基础上增加新的接口不就行了？其实理论上确实是可以的，但是这种方式通过继承+增加功能（接口）的方式在某些情况下可能会存在冗余，而装饰器的设计模式可以减少这种冗余。例如，假设现在有两个个汽车的厂家：BWM、Benz。
Java设计模式之装饰器模式
李哈zzz的博客
03-27 4587
装饰器模式是什么 装饰器模式是指给一个类增强一些方法，对其做一些包装，但是不会影响改变原本类。 解决了什么问题： 假设有一个炸鸡接口，定义了一个制作炸鸡的方法，麦当劳和肯德基和德克士对其的制作炸鸡方法做了重写，每个厂商肯定都有自己的实现。现在假设国家规定当制作完炸鸡需要对成品做一个检查。此时我们有2个解决方案，就是直接去每个厂家制作炸鸡的方法的最后一行加上检查的逻辑，要不就是定义N个（看有多少个厂家）子类去继承原有厂家，然后重写制作炸鸡方法，先super调用父类的实现，再自己写检查的逻辑。这样就会有很
java常用设计模式-装饰器模式
08-26
Java 设计模式 - 装饰器模式 装饰器模式（Decorator Pattern）是一种结构性设计模式，它允许您在不影响同一类的其他对象的行为的情况下，静态或动态地向单个对象添加行为。该模式非常有用，当您想要在运行时添加或...
c++设计模式-结构型模式-装饰器模式
06-12
c++设计模式-结构型模式-装饰器模式；QT工程；c++简单源码； 装饰器（Decorator）模式的定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。
54-Spring设计模式之装饰器模式1
08-08
Spring 设计模式之装饰器模式详解 在软件设计中，经常会遇到需要在不修改原有代码的情况下，添加新的功能或行为。这时，装饰器模式便可以发挥其作用。在 Spring 设计模式中，装饰器模式是非常重要的一种设计模式。 ...
浅谈Java设计模式系列-装饰器模式
08-26
Java 设计模式系列 - 装饰器模式 Java 设计模式系列 - 装饰器模式是 Java 设计模式系列中的一种重要模式，它主要用于对目标方法进行增强，提供新的功能或者额外的功能。装饰器模式的主要特点是涉及的是单方，目标...
初探工厂抽象模式
weixin_42400404的博客
06-17 394
工厂模式之抽象工厂
Spring源码中是如何使用设计模式六大原则的
finally_vince的博客
06-20 796
V 哥建议，通过 Spring 源码来学习设计模式的六大原则具体应用，不仅能够掌握基本的概念，还能掌握实际应用场景中是如何使用的，正所谓知其然知其所以然，这样学习 JAVA 才带劲。威哥爱编程，JAVA 之路咱们一起搀扶前行，结伴同行，才能走得更远。
Java多线程设计模式之保护性暂挂模式
weixin_42824596的博客
06-17 1067
多线程编程中，为了提高并发性，往往将一个任务分解为不同的部分。将其交由不同的线程来执行。这些线程间相互协作时，仍然可能会出现一个线程等待另一个线程完成一定的操作，其自身才能继续运行的情形。保护性暂挂模式（Guarded Suspension）可以帮助我们解决上述的等待问题。该模式的核心思想是如果某个线程执行特定的操作前需要满足一定的条件，则在该条件未满足时将该线程暂停运行（即暂挂线程，使其处于waiting状态，直到该条件满足时才继续运行）。
Java常见设计模式入门与实践
lw_jack的博客
06-15 478
以上是一些常用设计模式的入门介绍及其Java实现示例。掌握这些设计模式有助于编写更加可维护、灵活和高效的代码。设计模式不仅仅是代码模板，更是一种思维方式，可以帮助开发者在面临复杂问题时找到最佳解决方案。通过不断的学习和实践，可以更好地理解和应用这些设计模式。
设计模式-代理模式
明戈戈的博客
06-14 1293
在对已有的方法进行使用的时候需要对原有方法进行改进或者修改，这时候有两种改进选择：修改原有方法来适应现在的使用方式，或者使用一个“第三者”方法来调用原有的方法，并且对方法产生的结果进行一定的控制。上面的代码表面上看很复杂，但它的作用其实很简单，就是告诉 DynamicProxy 类用一个指定的类加载器来动态创建一个对象，该对象要实现指定的接口(本例为Soucable)，并用提供的InvocationHandler来代替传统的方法主体。代理模式中的代理者就好比中介机构，它提供了对被代理对象的一切事物。
22种常用设计模式示例代码
m0_51390969的博客
06-18 575
仓库地址参考教程。
设计模式--动态代理
最新发布
weixin_46520767的博客
06-20 525
代理模式-之动态代理
设计模式的装饰器模式
10-20
装饰器模式是一种结构型设计模式，可以动态地为一个对象添加更多的功能，而不需要修改其原始类。通常，装饰器模式的实现方法是创建一个装饰器类来包装原始类，并在其中添加新的行为或功能。这个装饰器类具有与原始类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值