快速入门设计模式Ⅰ—模式设计原则、模板方法、观察者模式

模式设计原则

• 依赖倒置原则

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

• 开放封闭原则

  • 一个类应该对扩展开放，对修改关闭

• 面向接口编程

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

• 封装变化点

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

• 单一职责原则

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

• 里式替换原则

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

• 接口隔离原则

  • 不应该强迫客户依赖于他们不同的方法；
  • 一般用于处理一个类拥有比较多的接口，而这些接口涉及到很多职责；
  • 继承耦合度高，组合耦合度低

什么时候我们需要使用设计模式

设计模式我们不是上来就用的，我们必须满足明确如下几点：

• 系统的关键依赖点
• 能明确找到变化点，演进方向
• 能明确找到复用方向
• 对需求变化方向熟悉

常用设计模式

模板方法

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

• 要点

  • 非常常用的设计模式，子类可以复写父类的子流程，使父类的大流程更丰富；
  • 反向控制流程的典型应用；
  • 父类protected保护子类需要复写的子流程；这样子类的子流程只能父类来调用
  • 充分体现依赖倒置原则

• 例子
  某个马戏团，有一套固定表演流程，单其中有若干个子表演受欢迎程度低，希望将这几个子表演进行创新，迭代更新表演流程。

• 示例代码

#include <iostream>
using namespace std;

class ZooShow {
public:
    // 固定流程封装到这里
    void Show() {
        Show0();
        Show1();
        Show2();
        Show3();
    }
protected:
    // 子流程 使用protected保护起来 不被客户调用 但允许子类扩展
    virtual void Show0(){
        cout << "show0" << endl;
    }
    virtual void Show2(){
        cout << "show2" << endl;
    }
    virtual void Show1() {

    }
    virtual void Show3() {

    }
};
class ZooShowEx : public ZooShow {
protected:
    virtual void Show1(){
        cout << "show1" << endl;
    }
    virtual void Show3(){
        cout << "show3" << endl;
    }
    virtual void Show4() {
        //
    }
};

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

class ZooShowEx2 : public ZooShow {
protected:
    virtual void Show1(){
        cout << "show1" << endl;
    }
    virtual void Show2(){
        cout << "show3" << endl;
    }
};
/*
依赖倒置原则
单一职责原则
接口隔离原则

反向控制：应用程序 框架 应用程序（变化的）应该依赖框架（稳定的），应该是框架去调应用程序，而不是应用程序去调框架
*/
int main () {
    ZooShow *zs = new ZooShowEx;
    ZooShow *zs1 = new ZooShowEx1;
    ZooShow *zs2 = new ZooShowEx2;
    zs->Show();
    return 0;
}

观察者模式

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

• 要点

  • 观察者模式使得我们可以独立改变目标与观察者，使得二者关系松耦合
  • 观察者自己决定是否要订阅通知，目标对象并不关注谁订阅了
  • 观察者不要依赖通知顺序，目标对象也不知道通知顺序；
  • 常使用在基于事件的ui框架中，也是MVC的组成部分
  • 常使用在分布式系统中，actor框架中

• 例子
  气象站发布气象资料给数据中心，数据中心经过处理，将气象信息更新高各个终端

• 代码

#include <vector>

class IDisplay {
public:
    virtual void Show(float temperature) = 0;
    virtual ~IDisplay() {}
};

class DisplayA : public IDisplay {
public:
    virtual void Show(float temperature);
};

class DisplayB : public IDisplay{
public:
    virtual void Show(float temperature);
};

class WeatherData {
};

class DataCenter {
public:
    void Attach(IDisplay * ob);
    void Detach(IDisplay * ob);
    void Notify() {
        float temper = CalcTemperature();
        for (auto iter = obs.begin(); iter != obs.end(); iter++) {
            (*iter)->Show(temper);
        }
    }

private:
    virtual WeatherData * GetWeatherData();

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

int main() {
    DataCenter *center = new DataCenter;
    IDisplay *da = new DisplayA();
    IDisplay *db = new DisplayB();
    center->Attach(da);
    center->Attach(db);
    center->Notify();
    
    //-----
    center->Detach(db);
    center->Notify();
    return 0;
}