设计模式之八——装饰者模式

最新推荐文章于 2024-09-26 21:53:35 发布
最新推荐文章于 2024-09-26 21:53:35 发布
阅读量385 收藏 1
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ruanjian_kj/article/details/107713233
版权

1.概念

1.1定义

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

也就是说，装饰者模式是对原有功能类增加一些新的功能（行为）。但是为原有功能类增加新的功能行为，继承或组合也能做，为什么要使用装饰者模式呢？这是因为要对原有功能类动态地同时增加多个功能行为（包括相同行为或不同行为），单独使用继承或组合实现将产生大量的子类（“类爆炸”），而使用装饰者模式则可以在保持良好的扩展性的同时避免“类爆炸”情况的出现。

1.2特点

  • 装饰者和被装饰者继承同一个基类。因为装饰者必须能够取代被装饰者，这里利用继承达到“类型匹配”，而不是利用继承获取“行为”
  • 装饰者拥有(has a)一个与被装饰者相同的基类类型属性
  • 可以用一个或多个装饰者类包装同一个对象
  • 装饰者可以在所委托被装饰者的行为之前或行为之后或行为之前与之后加上自己的行为，以达到特定的目的

为什么装饰者类和被装饰者需要继承同一个基础类呢？
主要有两个方面的原因。第一，装饰者必须能够取代被装饰者；第二，如果需要多个装饰对象对被装饰对象进行装饰（假设A是被装饰者，B和C用来装饰A），如果不使用继承，则先用B装饰A再用C装饰B时，需要B拥有A的对象，C拥有B的对象；而先用C装饰A再用B装饰C时，需要C拥有A的对象，B拥有C的对象，这使得装饰的顺序依赖于类的实现。而如果使用了继承，则只需要B和C同时拥有A的对象，然后在使用的地方用调用的顺序来完成装饰的顺序，这样不用破坏原有的类，有良好的扩展性。

为什么装饰者需要拥有(has a)一个和被装饰者相同的基础类类型作为自己属性呢？
主要是考虑多个不同的被装饰者的情况，如果使用继承，则装饰者必须继承自被装饰者，此时只能装饰一个类，而使用组合，则装饰者可以同时装饰多个类。这里也算是应用了策略模式吧。

1.3类图

在这里插入图片描述
在类图中有四种角色需要说明

  • Component：Component是一个接口或者是抽象类，即定义我们最核心的对象，也就是最原始的对象
  • ConcreateComponent：是最原始最基本的接口或者抽象类的实现，被装饰的对象
  • Decorator：一般是一个抽象类，实现接口或者抽象方法，它里面不一定有抽象的方法，但是它的属性中必然有一个private变量指向Component抽象构件
  • ConcreteDecoratorA和ConcreteDecoratorB：两个具体的装饰类，在里面需要写所想装饰的东西。
    装饰类通用的实现
    （1）、Component类
abstract class Component{
    public abstract void operate();
}

（2）、复制代码具体的实现类ConcreateComponent

class ConcreateComponent extends Component{
    @Override 
    public void operate() {
        System.out.println("do something");
    }
}

（3）、复制代码抽象的装饰类Decorator

abstract class Decorator extends Component {
    private Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operate() {
        this. component. operate();
    }
}

（4）、复制代码具体的装饰类ConcreteDecoratorA和ConcreteDecoratorB

class ConcreteDecoratorA extends Decorator{

    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    private void methodA(){
        System.out.println("MethodA装饰");
    }
    
    public void operate(){
        this.methodA();
        super.operate();
    }
}

class ConcreteDecoratorB extends Decorator{

    public ConcreteDecoratorB(Component component) {
        super(component);
    }

    private void methodB(){
        System.out.println("MethodB装饰");
    }
    
    public void operate(){
        this. methodB();
        super.operate();
    }
}

此处需要主要原始方法和装饰方法的执行顺序在具体的装饰类中时固定的，如果想要不同的顺序可以通过重载实现多种执行顺序。

2.案例实现1

对考试成绩进行装饰，在上学的时候，通常考试后，需要家长在成绩单上进行签字，如果成绩单上只有自己的成绩【语文：78】【数学：67】【英语：69】，想让家长签字是不太容易的。需要对成绩单进行装饰，在自己的成绩的基础上加上班内的最高分【语文：88】【数学：90】【英语：87】以及自己在班内的排名15名。

//Component抽象构件
public abstract class SchoolReport {
    public abstract void report();
    public abstract void sign(String name);
}

//ConcreteComponent具体构件 被装饰角色
public class FouthGradeSchoolReport extends SchoolReport {
    @Override
    public void report() {
        System.out.println("成绩单。。。。");
        System.out.println("您孩子的成绩为：【语文：78】【数学：67】【英语：69】");
    }
 
    @Override
    public void sign(String name) {
        System.out.println("家长签名:"+name);
    }
}

//Decorator装饰角色
public abstract class Decorator extends SchoolReport{
    private SchoolReport sr;
 
    public Decorator(SchoolReport sr){
        this.sr = sr;
    }
 
    public void report(){
        this.sr.report();
    }
 
    public void sign(String name){
        this.sr.sign(name);
    }
 
}

//具体装饰角色
public class HighScoreDecorator extends Decorator {
 
    public HighScoreDecorator(SchoolReport re){
        super(re);
    }
 
    private void reportHighScore(){
        System.out.println("汇报最高成绩");
        System.out.println("这次班里的最高分：【语文：88】【数学：90】【英语：87】");
    }
 
    @Override
    public void report() {
       this.reportHighScore();
       super.report();
    }
}

//具体装饰角色
public class SortDecorator extends Decorator {
    public SortDecorator(SchoolReport _sr) {
        super(_sr);
    }
    private void reportSort(){
        System.out.println("这次排名：15名！");
    }
 
    @Override
    public void report(){
        super.report();
        this.reportSort();
    }
}

//场景类
public class Father {
    public static void main(String[] args) {
        SchoolReport schoolReport;
        schoolReport = new FouthGradeSchoolReport();
        schoolReport = new HighScoreDecorator(schoolReport);
        schoolReport = new SortDecorator(schoolReport);
 
        schoolReport.report();
        schoolReport.sign("老三");
    }
}

运行结果：

这次班里的最高分：【语文：88】【数学：90】【英语：87】
您孩子的成绩为：【语文：78】【数学：67】【英语：69】
这次排名：15名！
家长签名：老三

2.案例实现2

星巴克咖啡订单项目（咖啡馆）：

  1. 咖啡种类/单品咖啡：Espresso(意大利浓咖啡)、ShortBlack、LongBlack(美式咖啡)、Decaf(无因咖啡)
  2. 调料：Milk、Soy(豆浆)、Chocolate
  3. 要求在扩展新的咖啡种类时，具有良好的扩展性、改动方便、维护方便
  4. 使用OO的来计算不同种类咖啡的费用: 客户可以点单品咖啡，也可以单品咖啡+调料组合。

2.1方案1-解决星巴克咖啡订单项目

类图：
在这里插入图片描述
问题分析：

  1. Drink 是一个抽象类，表示饮料
  2. des就是对咖啡的描述, 比如咖啡的名字
  3. cost() 方法就是计算费用，Drink 类中做成一个抽象方法.
  4. Decaf 就是单品咖啡， 继承Drink, 并实现cost
  5. Espress && Milk 就是单品咖啡+调料， 这个组合很多
  6. 问题：这样设计，会有很多类，当我们增加一个单品咖啡，或者一个新的调料，类的数量就会倍增，就会出现类爆炸

2.2方案2-解决星巴克咖啡订单项目

前面分析到方案1因为咖啡单品+调料组合会造成类的倍增，因此可以做改进，将调料内置到Drink类，这样就不会造成类数量过多。从而提高项目的维护性

类图：
在这里插入图片描述
问题分析：

  1. 方案2可以控制类的数量，不至于造成很多的类
  2. 在增加或者删除调料种类时，代码的维护量很大
  3. 考虑到用户可以添加多份调料时，可以将hasMilk 返回一个对应int
  4. 考虑使用 装饰者 模式

2.3装饰者模式-解决星巴克咖啡订单项目

类图：
在这里插入图片描述
说明

  1. Drink 类就是前面说的抽象类， Component
  2. LongBlack 就单品咖啡
  3. Decorator 是一个装饰类，含有一个被装饰的对象(Drink obj)
  4. Decorator 的cost 方法 进行一个费用的叠加计算，递归的计算价格

代码实现：
在这里插入图片描述
Drink 类

public abstract class Drink {
    public String des;
    private Float price;

    public String getDes() {
        return des;
    }

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

    public Float getPrice() {
        return price;
    }

    public void setPrice(Float price) {
        this.price = price;
    }

    //定义抽象方法，用来计算费用，该方法需要子类去实现
    public abstract float cost();
}

Coffee

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

LongBlack

public class LongBlack extends Coffee{
    public LongBlack(){
        setDes("LongBlack咖啡");
        setPrice(10f);
    }
}

Decorator

public class Decorator extends Drink{
    private Drink drink;
    public Decorator(Drink drink){  //组合
        this.drink=drink;
    }
    @Override
    public float cost() {
        return super.getPrice()+drink.cost();
    }
}

Milk

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

Chocolate

public class Chocolate extends Decorator{
    public Chocolate(Drink drink){
        super(drink);
        setDes("巧克力");
        setPrice(3.5f);
    }
}

测试类CoffeeBar

public class CoffeeBar {
    public static void main(String[] args) {
        /*
        * 一份份巧克力+一份牛奶
        */
        //1.点一份DeCaf
        Drink order=new LongBlack();
        System.out.println(order.getDes()+":"+order.getPrice());
        //2.加一份巧克力
        order=new Chocolate(order);
        System.out.println(order.getDes()+":"+order.getPrice());
        //3.加一份牛奶
        order=new Milk(order);
        System.out.println(order.getDes()+":"+order.getPrice());
        System.out.println("费用共计："+order.cost());
    }
}

运行结果：

无因咖啡:10.0
巧克力:3.5
牛奶:2.0
费用共计：15.5

3.装饰者模式的优缺点及使用场景

优点

  • 装饰类和被装饰类可以独立发展，不会相互耦合，换句话说，Component类无需知道Decorator的类，Decorator类是从外部来扩展Component类的功能。
  • 装饰模式是继承关系的一个替代方案，我们可以看到在装饰类中Decorator无论装饰了多少层，返回的对象还是Component
  • 装饰模式可以动态的扩展一个实现类的功能

缺点：
多层的装饰是比较复杂的—尽量减少装饰类的数量，以便降低系统的复杂度

装饰类的使用场景

  • 需要扩展一个类的功能，或给一个类增加附加功能
  • 需要动态的给一个对象增加功能，这些功能可以再动态的撤销
  • 需要为一批的兄弟类进行改装或加装功能

最佳实践

  • 装饰模式是对继承的有力补充，增加了其灵活性，解决了类膨胀的问题
  • 装饰模式可以动态地增加功能
  • 装饰模式的扩展性非常好，对于业务的变更，通过装饰模式来重封装一个类，而不是通过继承来完成
海底小霸王
关注
专栏目录
设计模式（八）——装饰者模式
壹升茉莉清的博客
09-09 414
使用继承存在的问题： 拓展性不好： 如果要再加一种配料，我们还需要再定义子类，产生过多的子类。 装饰者模式中的角色： 抽象构件角色：定义一个抽象接口来规范准备接收附加责任的对象。 具体构件角色：实现抽象构件，通过装饰者角色为其添加一些指责。 抽象装饰角色：继承或实现抽象构件，并包含具体构件的实例，可以通过其子类拓展具体构件的功能。 具体装饰角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。
装饰者模式
weixin_33835103的博客
09-21 124
2019独角兽企业重金招聘Python工程师标准>>> ...
装饰模式
热门推荐
lenotang的专栏
06-26 1万+
       看过请留个言，转载请注明出处，尊重作者劳动成果，谢谢！ 现在我们来学习装饰模式。说实话，真不想写这个，因为提到这个装饰，程序员就很伤感(我也是)，就想到了遥远地她和虚无缥缈地房子。房子都还没着落，谈什么装修和粉饰啊。一堵粗糙的墙，刷上白白地粉，再贴上几张壁画，整个一焕然一新。多美的事啊。哎，既然想到了，就咬着牙多想会，至少心里还有个期盼。真心祝愿大家看完这篇文章后都能够梦想成
设计模式基础概念（结构型模式）：装饰模式 (Decorator)
最新发布
учёба
09-26 862
是一种结构型设计模式， 允许你通过将对象放入包含行为的特殊封装对象中来为原对象绑定新的行为。
设计模式之美——教你写出高质量代码
04-10
"设计模式之美——教你写出高质量代码"这个主题旨在帮助开发者更好地理解和应用设计模式，从而提升代码的质量和可维护性。设计模式不仅对面试有所帮助，也是职场发展中的必备技能，无论你使用哪种开发语言。 设计...
JAVA设计模式学习12——装饰器模式
04-21
装饰器模式是面向对象设计模式的一种，主要用于在不改变原有对象结构的情况下，动态地为对象增加新的功能。这种模式在Java中尤其常见，因为它允许我们遵循“开闭原则”——对扩展开放，对修改关闭。 装饰器模式的...
.NET中的设计模式——一步步发现装饰模式
02-27
学习设计模式的基本目标是要用它，尤其是帮助那些有扎实的OOP基础，而对设计模式很困惑的人在设计中应用它。我不会为不同设计模式写很全面的参考，但我希望这些文章能让你入门。设计模式与特定的语言无关。虽然我用...
装饰 模式
风二中的博客
04-02 111
装饰模式：动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活 component是定义一个对象接口，可以给这些对象动态地添加职责。 ConcreComponent是定义了一个具体的对象，也可以给这个对象添加一些职责。 Decorator装饰抽象类，继承了Component，从外类来扩展component类的功能，但对于componet来说，是无需知道Decorator的存在的。 ConcreteDecorator是具体的装饰对象，起至给Component添加职责的功..
Java设计模式解析：装饰者模式实战与应用
"Java设计模式-装饰者模式" 装饰者模式是一种结构型设计模式，它允许在不修改已有对象的前提下，通过动态添加责任来扩展对象的功能。这种模式在Java中尤其有用，因为它遵循了开闭原则——对扩展开放，对修改关闭。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值