设计模式学习1

设计模式是什么？

设计模式是指在软件开发过程中，经过验证的，用于解决特定环境下，重复出现的，特定问题的解决方案。

也就是解决问题的固定套路，但也要慎用设计模式。

设计模式解决了什么问题？

前提：既有稳定点，也有变化点。

如果全是稳定点则不需要设计模式，如果全是变化点，如游戏开发，只需要通过脚本语言进行热更新。

期望修改少量的代码，就可以适应需求的变化（让变化点在有限范围内变化）

设计模式基础

面向对象的思想：

封装：隐藏实现细节，实现模块化
继承：无需修改原有类的基础上，通过继承实现对功能的扩展
多态：
- 静态多态：函数重载overload，编译期完成
- 动态多态：虚函数的重写override，运行期完成
- Base *p = new Subject(); 早绑定 p->vf(); 晚绑定

设计原则：

依赖倒置

高层模块不应该依赖低层模块，两者都应该依赖抽象；
抽象不应该依赖具体实现，具体实现应该依赖于抽象；

开放封闭

一个类应该对扩展（组合和继承）开放，对修改关闭；

面向接口

不将变量类型声明为某个特定的具体类，而是声明为某个接口；
客户程序无需获知对象的具体类型，只需要知道对象所具有的接口；
减少系统中各部分的依赖关系，从而实现“高内聚、松耦合”的类
型设计方案；

封装变化点

将稳定点和变化点分离，扩展修改变化点；让稳定点和变化点的实现层次分离；

单一职责

一个类应该仅有一个引起它变化的原因；

里氏替换

子类型必须能够替换掉它的父类型；主要出现在子类覆盖父类实现，原来使用父类型的程序可能出现错误；覆盖了父类方法却没有实现父类方法的职责；

接口隔离

不应该强迫客户依赖于它们不用的方法；
一般用于处理一个类拥有比较多的接口，而这些接口涉及到很多
职责；
客户端不应该依赖它不需要的接口。一个类对另一个类的依赖应
该建立在最小的接口上。

组合优于继承

继承耦合度高，组合耦合度低；

最小知道原则

如何学习设计模式？

明确目的

在现有设计模式的基础上，扩展代码
做功能抽象，如何选择设计模式

学习步骤

该设计模式解决了什么问题
- 稳定点
- 变化点
设计模式的代码结构
符合哪些设计原则
如何在现有代码基础上扩展代码——应对变化点
设计模式的典型应用场景
- 联系工作场景
- 开源框架

模板方法

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

稳定点：算法骨架

变化点：算法的需要变化

#include <iostream>
using namespace std;

// 开闭
class ZooShow {
public:
    void Show() {
        // 如果子表演流程没有超时的话，进行一个中场游戏环节；如果超时，直接进入下一个子表演流程
        if (Show0())
            PlayGame();
        Show1();
        Show2();
        Show3();
    }
    
private:
    void PlayGame() {
        cout << "after Show0, then play game" << endl;
    }
    bool expired;
    // 对其他用户关闭，但是子类开放的
protected:
    virtual bool Show0() {
        cout << "show0" << endl;
        if (! expired) {
            return true;
        }
        return false;
    }
    virtual void Show2() {
        cout << "show2" << endl;
    }
    virtual void Show1() {

    }
    virtual void Show3() {

    }
};

// 框架
// 模板方法模式
class ZooShowEx10 : public ZooShow {
protected:
    virtual void Show0() {
        if (! expired) {
            return true;
        }
        return false;
    }
}

class ZooShowEx1 : public ZooShow {
protected:
    virtual bool Show0() {
        cout << "ZooShowEx1 show0" << endl;
        if (! expired) { // 里氏替换
            return true;
        }
        return false;
    }
    virtual void Show2(){
        cout << "show3" << endl;
    }
};

class ZooShowEx2 : public ZooShow {
protected:
    virtual void Show1(){
        cout << "show1" << endl;
    }
    virtual void Show2(){
        cout << "show3" << endl;
    }
};

class ZooShowEx3 : public ZooShow {
protected:
    virtual void Show1(){
        cout << "show1" << endl;
    }
    virtual void Show3(){
        cout << "show3" << endl;
    }
    virtual void Show4() {
        //
    }
};
/*
*/
int main () {
    ZooShow *zs = new ZooShowEx10; // 晚绑定还是早绑定
    // ZooShow *zs1 = new ZooShowEx1;
    // ZooShow *zs2 = new ZooShowEx2;
    zs->Show();
    return 0;
}

代码结构 `template.cpp`

基类中有骨架流程接口
所有子流程对子类开放并且是虚函数（里氏替换原则）
多态使用方式

符合哪些设计原则

单一职责
开闭
依赖倒置
- 子类扩展时，需要依赖基类的虚函数实现
- 使用者只依赖接口
封装变化点： protected
接口隔离
最小知道原则

如何扩展

实现子类继承基类，复写子流程
通过多态调用方式使用

#include <iostream>
#include <list>
#include <algorithm>
using namespace std;
//
class IDisplay {
public:
    virtual void Show(float temperature) = 0;
    virtual ~IDisplay() {}
};

class DisplayA : public IDisplay {
public:
    virtual void Show(float temperature) {
        cout << "DisplayA Show" << endl;
    }
private:
    void decr();
};

class DisplayB : public IDisplay{
public:
    virtual void Show(float temperature) {
        cout << "DisplayB Show" << endl;
    }
};

class DisplayC : public IDisplay{
public:
    virtual void Show(float temperature) {
        cout << "DisplayC Show" << endl;
    }
};

class DisplayD : public IDisplay{
public:
    virtual void Show(float temperature) {
        cout << "DisplayC Show" << endl;
    }
};

class WeatherData {
};

// 应对稳定点，抽象
// 应对变化点，扩展（继承和组合）
class DataCenter {
public:
    void Attach(IDisplay * ob) {
        //
        obs.push_back(ob);
    }
    void Detach(IDisplay * ob) {
        //
        obs.remove(ob);
    }
    void Notify() {
        float temper = CalcTemperature();
        for (auto &ob : obs) {
            ob->Show(temper);
        }
    }

// 接口隔离
private:
    WeatherData * GetWeatherData();

    float CalcTemperature() {
        //WeatherData * data = GetWeatherData();
        // ...
        float temper/* = */;
        return temper;
    }
    std::list<IDisplay*> obs;
};

int main() {
    // 单例模式
    DataCenter *center = new DataCenter;
    // ... 某个模块
    IDisplay *da = new DisplayA();
    center->Attach(da);

    // ...
    IDisplay *db = new DisplayB();
    center->Attach(db);
    
    IDisplay *dc = new DisplayC();
    center->Attach(dc);

    center->Notify();
    
    //-----
    center->Detach(db);
    center->Notify();

    center->Notify();
    return 0;
}

观察者模式 `observertory`

定义对象间的一种一对多（变化）的依赖关系，以便当一个对象(Subject)的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。

稳定点：一对多的依赖关系，“一”变化，“多”跟着变化
变化点：“多”增加或减少

符合哪些设计原则

面向接口编程
接口隔离
封装变化点
- attach
- detach

如何扩展

继承实现接口

class Context {

};

// 稳定点：抽象去解决它
// 变化点：扩展（继承和组合）去解决它
class ProStategy {
public:
    virtual double CalcPro(const Context &ctx) = 0;
    virtual ~ProStategy(); 
};
// cpp
class VAC_Spring : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){
    }
};

class VAC_Spring_v2 : public VAC_Spring {
public:
    virtual double CalcPro(const Context &ctx){
        //....
    }
};

class VAC_worker : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};

// cpp
class VAC_QiXi : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
class VAC_QiXi1  : public VAC_QiXi {
public:
    virtual double CalcPro(const Context &ctx){}
};
// cpp
class VAC_Wuyi : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
// cpp
class VAC_GuoQing : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};
class VAC_GuoQing2 : public VAC_GuoQing {
public:
    virtual double CalcPro(const Context &ctx){}
};

class VAC_Shengdan : public ProStategy {
public:
    virtual double CalcPro(const Context &ctx){}
};

// 设计原则：接口隔离原则
// 组合、继承
// 组合基类指针
// 两种方法：1. 采用具体接口选择算法  2. 依赖注入
class Promotion {
public:
    Promotion(ProStategy *sss = nullptr) : s(sss){}
    ~Promotion(){}
    void Choose(ProStategy *sss) {
        // 条件选择
        if (sss != nullptr) {
            s = sss;
        }
    }
    double CalcPromotion(const Context &ctx){
        if (s != nullptr) {
            return s->CalcPro(ctx);
        }
        return 0.0L;
    }
private:
    ProStategy *s;
};

int main () {
    Context ctx;
    ProStategy *s = new VAC_QiXi1();
    Promotion *p = new Promotion(s);
    p->Choose(new VAC_GuoQing2());
    p->CalcPromotion(ctx);
    return 0;
}