设计模式（一）

2023-10-08

字数统计: 1.3k字 | 阅读时长≈ 4分

设计模式的原则

面向对象：

封装：隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别
继承：子类继承父类的属性和行为，使得子类对象（实例）具有父类的属性和方法，还可以定义自己的属性和方法，其目的为复用
多态：方法只有在运行时在确定其具体属性和实现

面向对象的设计原则：

依赖倒置原则：针对接口编程，不要针对实现编程
开放-封闭原则：对扩展开放，对修改封闭->类模块应该是可以扩展的（增加新的内容），但是不可修改（修改原有内容）
单一职责原则：类模块应该只有一个引起它变化的原因不应有过多的方法
里氏替换原则：在父类出现的地方，其子类都可以替代父类使用 Is-a关系
接口隔离原则：接口应小而完备，不提供过多的对外接口
优先使用对象组合，而不是类继承：继承在某种程度上破坏了封装性，会增加耦合度；而组合只要求被组合对象有良好的接口
封装变化点：将变化与稳定代码分离

模板方法模式

定义：定义一个操作中的算法的骨架（稳定），而将一些步骤延迟（变化）到子类中，使得子类可以不改变（复用）一个算法的结构即可重定义该算法的某些特定步骤。
通过虚函数的晚绑定机制来实现

代码事例：

class A
{
public:    
    void Run()
    {
        Step1();

        if(Step2()){
            Step3();
        }
    }

    void Step1()
    {
        cout << "step1" << endl;
    }

    virtual bool Step2();

    void Step3()
    {
        cout << "Step3" << endl;
    }

    virtual ~A()
    {

    }
}

class B : public A
{
    virtual bool Step2() override;
}

int main()
{
    A *a = new B();
    a->Run();
    delete a;
}

上述代码中Step2中支持变化，它在A类中定义，在B中实现，这样B类可以不改变A类中的Step2方法，而实现对Step2的复用。
将A的析构函数设为虚函数，使得B的析构函数可以被调用，防止内存泄漏。

策略模式

策略模式与模板方法模式有着异曲同工之处，该模式将算法进行封装，将算法的变化与算法的使用分离。

定义：定义一系列算法，将它们一个个封装起来，并且使它们可以相互替换(支持变化)。策略模式使得算法可以独立于使用它的客户而变化。

代码事例：

/*
对于一般而言，可以使用一个switch来针对不同枚举类型来实现不同的方法
但这种方法并不灵活，不易于扩展->只有方法只有绝对不变是使用if或者switch来实现
另一方面来说，if种的很多代码可能是很少用到的，使用策略可以在某种程度上优化性能
因此我们实现一个税计算的基类，针对不同的税类型设计出不同的子类
*/
enum Tax
{
    CN_Tax,
    US_Tax
}

class TaxCalculator
{
public:
    Tax tax;
    double Calculate(double amount)
    {
        switch(tax){
            //...
        }
    }
}

//------------------------------

//使用策略模式->我们将不同的算法改为不同的子类
class BaseTaxCalculator
{
public:
    virtual double Calculate(double amount, Tax tax) = 0;
    virtual ~TaxCalculator()
    {
        //...
    }
}

class CNTaxCalculator : public BaseTaxCalculator
{
public:
    double Calculate(double amount, Tax tax) override
    {
        //...
    }
}

class USTaxCalculator : public BaseTaxCalculator
{
public:
    double Calculate(double amount, Tax tax) override
    {
        //...
    }
}

//使用工厂模式选择调用哪一个方法计算

观察者模式

/*
定义：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己。

代码事例：

/*
现在有一个窗口，用于分割文件，并添加一个进度条
一般说，我们使用一个进度条类，并使用一个窗口类来显示进度条
但是，如果我们需要在不同的窗口上创建不同类型的进度条（例如使用···），则需要创建多个进度条造成代码冗余
所以我们使用观察者模式，创建一个BaseProgressBar类，让窗口继承它
*/

class BaseProgressBar
{
public:
    virtual void SetProgress(double progress) = 0;
    virtual ~BaseProgressBar()
    {
        //...
    }
};

class MainWindow:public BaseProgressBar
{
public:
    //BaseProgressBar* progressBar;  
    //抽象通知机制 MainWindow 持有进度条的指针,作为观察者之一
    //但是目前只支持一个观察者，如果要支持多个观察者，则需要再进一步改良
    
    std::vector<BaseProgressBar*> ProgressBarVector; 
    //抽象通知机制，支持多个观察者   
    //同时添加Add和Remove方法用于操作观察者 添加OnProgressBar用于通知观察者

    void AddProgressBar(BaseProgressBar* progressBar);
    void RemoveProgressBar(BaseProgressBar* progressBar);
    void OnProgressBar();
    
    void SetProgressBar(BaseProgressBar* progressBar)
    {
        //...
    }

    void SetProgress(double progress) override;
};

本文作者： KongXinQing
本文链接： https://13114987559.github.io/2023/10/08/note/设计模式/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！