设计原则 | 开放封闭原则

一、开放封闭原则（OCP：Open-Closed Principle）

1、原理

软件实体（类、模块、函数等等）应该是可以扩展的，但是不可修改的。如果程序中的一处改动就会引发连锁反应，导致一些列相关模块的修改，那么设计就会有僵化性的臭味。OCP建议应该对系统进行重构，这样以后再对系统进行修改，就不会导致更多的修改，就只需要添加新的代码，而不必修改已经正常运行的代码。

2、描述

开放封闭原则有两个主要的特征，它们是：

• 对于扩展是开放的：这意味着模块的行为是可以扩展的，当需求改变时，可以对模块进行扩展，使其具有新的行为
• 对于修改是封闭的：对模块的行为进行扩展时，不必修改模块原有的代码

这两个特征好像是互相矛盾的，扩展模型行为的方式通常是修改模块源代码，不允许修改的模块常常被认为是具有固定的行为。怎么才能在无需对模块进行修改的情况下就改变它的功能呢？

3、关键是抽象

在C++或其它编程语言中，可以创建出固定却能够描述一组任意个可能行为的抽象体（接口）。这个抽象体就是抽象基类，而这任意组可能的行为则表现为可能的派生类。 模块可以操作一个抽象体，由于模块依赖一个固定的抽象体，所以它对于修改可以是封闭的。同时，通过从这个抽象体派生，也可以扩展此模块的行为。

在不需要对原有的系统进行修改的情况下，实现灵活的系统扩展。而如何能做到这一点呢？ 要面向接口编程，而不是面向实现编程。实现开放封闭的核心思想就是对抽象编程，而不对具体编程。因为抽象相对稳定，让类依赖于固定的抽象，所以对修改就是封闭的；而通过面向对象的继承和对多态机制，通过接口可以派生出新的类，实现新功能的扩展，所以对于扩展就是开放的，这是实施开放封闭原则的基本思路。

4、结论

在许多方面，OCP都是面向对象设计的核心所在。遵循这个原则可以带来面向对象技术所声称的巨大好处（灵活性、可重用性以及可维护性）。然而，对于应用程序中的每个部分都肆意进行抽象同样不是一个好主意。正确的做法是，开发人员应该仅仅对程序中呈现出频繁变化的部分做出抽象，拒绝不成熟的抽象与抽象本身一样重要。

5、示例

做一个绘制图形的小程序，代码如下

5.1、版本一

#include <iostream>
using namespace std;

// Shape相关的类
class Shape
{
public:
    int m_type;
};

class SquareShape : public Shape
{
public:
    SquareShape()
    {
        m_type = 0;
    }
};

class RectangleShape : public Shape
{
public:
    RectangleShape()
    {
        m_type = 1;
    }
};

// GraphicEditor类
class GraphicEditor
{
public:
    void DrawShape(const Shape &shape)
    {
        switch(shape.m_type)
        {
        case 0:
            DrawSquare();
            break;
        case 1:
            DrawRectangle();
            break;
        }
    }

    void DrawSquare()
    {
        cout << "draw square" << endl;
    }

    void DrawRectangle()
    {
        cout << "draw rectangle" << endl;
    }
};

int main()
{
    // 创建图形对象
    SquareShape squareShape;
    RectangleShape rectangleShape;

    GraphicEditor obj;
    obj.DrawShape(squareShape);
    obj.DrawShape(rectangleShape);

    return 0;
}

上述代码存在的问题

• 不符合OCP原则，当新增一个Shape类时，就要对原有的DrawShape函数进行修改

5.2、版本二

为了解决前面遇到的不封闭问题，可以给Shape类增加一个Draw虚函数，DrawShape函数直接调用Draw方法进行绘制，派生类负责实现Draw方法，改进后的代码如下：

#include <iostream>
using namespace std;

class Shape
{
public:
    virtual void Draw() const
    {

    }
public:
    int m_type;
};

class SquareShape : public Shape
{
public:
    SquareShape()
    {
        m_type = 0;
    }

    void Draw() const
    {
        cout << "draw square" << endl;
    }
};

class RectangleShape : public Shape
{
public:
    RectangleShape()
    {
        m_type = 1;
    }

    void Draw() const
    {
        cout << "draw rectangle" << endl;
    }
};

// GraphicEditor类
class GraphicEditor
{
public:
    void DrawShape(const Shape &shape)
    {
        shape.Draw();
    }
};

int main()
{
    // 创建图形对象
    SquareShape squareShape;
    RectangleShape rectangleShape;

    GraphicEditor obj;
    obj.DrawShape(squareShape);
    obj.DrawShape(rectangleShape);

    return 0;
}

如果此时需要新增一个Shape类，只需要新增一个派生类，并不需要修改DrawShape函数的逻辑