• 装饰模式（Decorator）

    定义

    动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式比生成子类更加灵活、可作为继承的替代。又称装饰者模式（Wrapper）。

    类图

    在这里插入图片描述

    • Component:定义一个对象接口，可以给这些对象动态地添加职责；
    • ConcreteComponent:定义一个具体的Component，继承自ConcreateComponent，重写了Component类的虚函数；
    • Decorator:维持一个指向Component对象的指针，该指针指向需要被装饰的对象；并定义一个
    • Component接口一致的接口；

    ConcreteDecorator:向组件添加职责。

    实现

    优点

    可以动态为对象添加功能，相比于继承实现，组合的方式更加灵活而且代码量小很多

    缺点

    多层装饰会有无限剥离的问题，影响效率，性能，工作量大

    使用场景

    1. 在不影响其他对象的情况下，以动态的，透明的方式给单个对象添加职责；
    2. 处理那些可以撤销的职责；
    3. 当不能采用生成子类的方法进行扩充时。一种情况是，可能存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。

    注意事项

    1. 接口的一致性；装饰对象的接口必须与它所装饰的Component的接口是一致的，因此，所有的ConcreteDecorator类必须有一个公共的父类；这样对于用户来说，就是统一的接口；
    2. 省略抽象的Decorator类；当仅需要添加一个职责时，没有必要定义抽象Decorator类。因为我们常常要处理，现存的类层次结构而不是设计一个新系统，这时可以把Decorator向Component转发请求的职责合并到ConcreteDecorator中；、
    3. 保持Component类的简单性；为了保证接口的一致性，组件和装饰必须要有一个公共的Component类，所以保持这个Component类的简单性是非常重要的，所以，这个Component类应该集中于定义接口而不是存储数据。对数据表示的定义应延迟到子类中，否则Component类会变得过于复杂和臃肿，因而难以大量使用。赋予Component类太多的功能，也使得具体的子类有一些它们它们不需要的功能大大增大；

    与桥接模式的区别

    二者都是为了防止过度的继承，从而造成子类泛滥的情况。

    1. 桥接模式中所说的分离，其实是指将结构与实现分离（当结构和实现有可能发生变化时）或属性与基于属性的行为进行分离；而装饰者只是对基于属性的行为进行封闭成独立的类，从而达到对其进行装饰，也就是扩展。比如：异常类和异常处理类之间就可以使用桥接模式来实现完成，而不能使用装饰模式来进行设计；如果对于异常的处理需要进行扩展时，我们又可以对异常处理类添加Decorator，从而添加处理的装饰，达到异常处理的扩展，这就是一个桥接模式与装饰模式的搭配；
    2. 桥接中的行为是横向的行为，行为彼此之间无关联，注意这里的行为之间是没有关联的，就比如异常和异常处理之间是没有行为关联的一样；而装饰者模式中的行为具有可叠加性，其表现出来的结果是一个整体，一个各个行为组合后的一个结果。

    示例1

    游戏中的人物和时装。人物可以选择穿上帽子或穿上鞋子，或者都穿上，通过方法展示穿搭结果。
    比较容易想到的实现方法就是单纯通过继承，一个人物基类，继承出一个穿帽子的人物类，一个穿鞋子的人物类，再一个穿帽子+鞋子的人物类。在只有两种选择时，需要产生3个子类，这种实现方式每增加一种选择就要增加一倍+1数量的子类，非常不可取。
    实现方式：
    第一步，抽象出一个装饰基类，类中添加一个人物类指针，在构造时传入人物类指针。
    第二步，增加需要修饰的同名方法，在方法中通过指针调用原方法，再添加新修饰内容。
    第三步，将装饰基类继承自人物基类，为了使传入装饰类A进行装饰的指针能够传入装饰类B进行其他装饰，并且使传入装饰类A的指针可以指向该装饰类对象。
    最后一步，实现装饰基类，实现装饰内容。

    #ifndef DECORATOR_HPP
#define DECORATOR_HPP
#include <iostream>
using namespace std;
//人物基类
class Man
{
public:
    virtual ~Man(){}
    virtual void Show()//用于展示
    {
        cout << "A man." <<endl;
    }
};

//装饰器抽象类
class ManWithCloth:public Man//继承自Man，为了使被装饰的对象可以传入其他装饰器进行组合装饰
{
public:
    ManWithCloth(Man* pMan)
        :m_pMan(pMan){}
    virtual ~ManWithCloth()
    {
        if(NULL != m_pMan)
        {
            delete m_pMan;
            m_pMan = NULL;
        }
    }

    virtual void Show()//上述实现方式中的第二步
    {
        m_pMan->Show();//通过指针调用原指针所指对象的方法，然后添加方法进行修饰
        DressUp();//对原方法增加修饰
    }
    virtual void DressUp() = 0;//修饰方法在实现类中实现

private:
    Man* m_pMan;
};

//装饰器实现类
class ManWearAHat:public ManWithCloth
{
public:
    ManWearAHat(Man* pMan)
        :ManWithCloth(pMan){}
    virtual void DressUp()
    {
        cout << "Wear a Hat." << endl;
    }
};

class ManWearShoes:public ManWithCloth
{
public:
    ManWearShoes(Man* pMan)
        :ManWithCloth(pMan){}
    virtual void DressUp()
    {
        cout << "Wear shoes." << endl;
    }
};

#endif // DECORATOR_HPP

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    #include <iostream>
#include "decorator.hpp"
using namespace std;

int main()
{
    Man* pMan = new Man();
    pMan->Show();

    cout << "=====Wear Hat=====" << endl;
    pMan = new ManWearAHat(pMan);
    pMan->Show();

    cout << "====Wear Shoes====" << endl;
    pMan = new ManWearShoes(pMan);
    pMan->Show();

    delete pMan;
    pMan = NULL;

    return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    运行结果：

    A man.
=====Wear Hat=====
A man.
Wear a Hat.
====Wear Shoes====
A man.
Wear a Hat.
Wear Shoes.

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    示例2

    #include <iostream>

//抽象组件角色:给出一个抽象接口,以规范准备接收附加责任的对象
class Component{
public:
    virtual ~Component(){}
    
    virtual void Configuration() = 0;
};

//具体组件类
class Car: public Component {
public:
    void Configuration() override {
        std::cout << "------Car-------" << std::endl;
    }
};

//装饰角色:持有一个组件对象的实例,并实现一个与抽象组件接口一致的接口
class DecorateCar : public Component {
public:
    DecorateCar(Component* car) : car_(car) {}
    void Configuration() override {
        car_->Configuration();
    }

private:
    Component* car_;
};


//具体装饰角色:负责给组件对象添加额外的责任
class DecorateLED: public DecorateCar {
public:
    DecorateLED(Component* car) : DecorateCar(car){}
    
    void Configuration() override {
        DecorateCar::Configuration();
        AddLED();
    }

private:
    void AddLED() {
        std::cout << "--------AddLED" << std::endl;
    }
};

//具体装饰角色:负责给组件对象添加额外的责任
class DecoratePC : public DecorateCar {
public:
    DecoratePC(Component* car) : DecorateCar(car) {}
    
    void Configuration() override {
        DecorateCar::Configuration();
        AddPC();
    }

private:
    void AddPC() {
        std::cout << "-----------AddPC-----------" << std::endl;
    }
};

int main() {
    Car car;
    DecorateLED ledCar(&car);
    DecoratePC pcCar(&car);
    
    ledCar.Configuration();
    pcCar.Configuration();
    
    return 0;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74

    示例3-python

    #coding=utf-8
import os


class Person:
    def __init__(self, name):
        self.name = name

    def show(self):
        print('打扮的' + self.name)


class Finery(Person):
    def __init__(self):
        self.component = None

    def decorate(self, component):
        self.component = component

    def show(self):
        if self.component is not None:
            self.component.show()


class TShirt(Finery):
    def show(self):
        print '大T恤',
        self.component.show()


class BigTrouser(Finery):
    def show(self):
        print '垮裤',
        self.component.show()


class Sneaker(Finery):
    def show(self):
        print '运动鞋',
        self.component.show()


if __name__ == '__main__':
    p = Person('大熊')
    upClothes = TShirt()
    downClothes = BigTrouser()
    shoes = Sneaker()
    upClothes.decorate(p)
    downClothes.decorate(upClothes)
    shoes.decorate(downClothes)
    shoes.show()

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51

    运行结果：
    运动鞋 垮裤 大T恤 打扮的大熊

  • 相关阅读:
    VUE3 之 使用标签实现动画与过渡效果（下） - 这个系列的教程通俗易懂，适合新手
    JavaScript基础知识13——运算符：一元运算符，二元运算符
    MVVM与Vue响应式的实现
    Live800在线客服系统：跨越时空做生意，从每次互动开始
    ChatGPT工作提效之使用python开发对接百度地图开放平台API的实战方案（批量路线规划、批量获取POI、突破数量有限制、批量地理编码）
    Rust 1.79.0发布
    02.接口隔离原则（Interface Segregation Principle）
    pycharm中运行jupyter notebook
    数组对象根据id去重（javascript方法）
    【面试精讲】深克隆和浅克隆的实现方式？深克隆和浅克隆有什么区别？
  • 原文地址：https://blog.csdn.net/weixin_43956958/article/details/125449564