希望计算机专业同学都知道这些博主

目录

1、概述

2、七大设计原则

2.1、开闭原则

2.2、里氏替换原则

2.3、依赖倒置原则

2.4、单一职责原则

2.5、接口隔离原则

2.6、迪米特法则

2.7、合成复用原则

3、最后

VC++常用功能开发汇总（专栏文章列表，欢迎订阅，持续更新...）https://blog.csdn.net/chenlycly/article/details/124272585C++软件异常排查从入门到精通系列教程（专栏文章列表，欢迎订阅，持续更新...）https://blog.csdn.net/chenlycly/article/details/125529931C++软件分析工具案例集锦（正在更新中...）https://blog.csdn.net/chenlycly/category_12279968.html       软件设计原则不仅和我们日常编写的代码质量有关，也是设计软件设计模式时遵循的原则，即设计原则是设计模式的基础。我们要学习软件设计模式，需要先了解软件架构设计的七大原则。今天我们就来讲讲软件设计原则相关的内容。

1、概述

       七大软件设计原则包括开闭原则、依赖倒置原则、 单一职责原则、接口隔离原则、迪米特法则、里氏替换原则、合成复用原则：

在软件开发中，为了提高软件系统的可维护性与可复用性，增加软件系统的可扩展性与灵活性，程序员要尽量遵循这七条原则去开发程序。遵循设计原则的开发，可以很好地提高软件开发效率、节约软件开发与维护成本。

       但在实际的软件开发实践中，并不是一定所有代码都遵循设计原则，而是要综合考虑人力、时间和成本，不刻意去追求完美，要在适当的场景下去遵循适用的设计原则。这是一种平衡取舍，可以帮助我们设计出更有质量、更优雅的代码。

2、七大设计原则

2.1、开闭原则

2.1.1、开闭原则的定义

       开闭原则（Open Closed Principle，OCP）由勃兰特·梅耶（Bertrand Meyer）提出，他在 1988 年的著作《面向对象软件构造》（Object Oriented Software Construction）中提出：软件实体应当对扩展开放，对修改关闭（Software entities should be open for extension，but closed for modification），这就是开闭原则的经典定义。这里的软件实体包括以下几个部分：项目中划分出的模块、类与接口和方法。

       当应用的需求改变时，在不修改软件实体的源代码或者二进制代码的前提下，可以扩展模块的功能，使其满足新的需求。

2.1.2、开闭原则的作用

       开闭原则是面向对象程序设计的终极目标，它使软件实体拥有一定的适应性和灵活性的同时具备稳定性和延续性。具体来说，其作用如下：

2.1.3、开闭原则的实现方法

        可以通过“抽象约束、封装变化”来实现开闭原则，即通过接口或者抽象类为软件实体定义一个相对稳定的抽象层，而将相同的可变因素封装在相同的具体实现类中。因为抽象灵活性好，适应性广，只要抽象的合理，可以基本保持软件架构的稳定。而软件中易变的细节可以从抽象派生来的实现类来进行扩展，当软件需要发生变化时，只需要根据需求重新派生一个实现类来扩展就可以了。

        下面以 Windows 的桌面主题为例介绍开闭原则的应用：

Windows的桌面主题类图如下所示：

2.2、里氏替换原则

2.2.1、里氏替换原则的定义

       里氏替换原则（Liskov Substitution Principle，LSP）由麻省理工学院计算机科学实验室的里斯科夫（Liskov）女士在 1987 年的“面向对象技术的高峰会议”（OOPSLA）上发表的一篇文章《数据抽象和层次》（Data Abstraction and Hierarchy）里提出来的，她提出：继承必须确保超类所拥有的性质在子类中仍然成立（Inheritance should ensure that any property proved about supertype objects also holds for subtype objects）。

       里氏替换原则主要阐述了有关继承的一些原则，也就是什么时候应该使用继承，什么时候不应该使用继承，以及其中蕴含的原理。里氏替换原是继承复用的基础，它反映了基类与子类之间的关系，是对开闭原则的补充，是对实现抽象化的具体步骤的规范。

2.2.2、里氏替换原则的作用

       里氏替换原则的主要作用如下：

2.2.3、里氏替换原则的实现方法

       里氏替换原则通俗来讲就是，子类可以扩展父类的功能，但不能改变父类原有的功能。也就是说，子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。如果通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的概率会非常大。

       如果程序违背了里氏替换原则，则继承类的对象在基类出现的地方会出现运行错误。这时其修正方法是，取消原来的继承关系，重新设计它们之间的关系。

下面以“几维鸟不是鸟”为例来说明里氏替换原则：

相关类图如下：

程序代码如下：

// 鸟类
class Bird
{
public:
    void setSpeed(double speed)
    {
        flySpeed=speed;
    }
    
    double getFlyTime(double distance)
    {
        return(distance/flySpeed);
    }

private:
    double flySpeed;
};

// 燕子类
class Swallow : public Bird{};

// 几维鸟类
class BrownKiwi : public Bird
{
public:
    void setSpeed(double speed)
    {
       flySpeed=0;
    }
};


// 测试代码
Bird* pBird1=new Swallow();
Bird* pBird2=new BrownKiwi();
pBird1->setSpeed(120);
pBird2->setSpeed(120);
std::cout<<"如果飞行300公里："<<endl;

std::cout<<"燕子将飞行"<<bird1.getFlyTime(300)<<"小时."<<endl;
std::cout<<"几维鸟将飞行"<<bird2.getFlyTime(300)<<"小时。"<<endl;

程序的运行结果如下：

       程序运行错误的原因是，几维鸟类重写了鸟类的 setSpeed(double speed) 方法，这违背了里氏替换原则。正确的做法是，取消几维鸟原来的继承关系，定义鸟和几维鸟的更一般的父类，如动物类，它们都有奔跑的能力。几维鸟的飞行速度虽然为 0，但奔跑速度不为 0，可以计算出其奔跑 300 千米所要花费的时间。其类图如下所示：

2.3、依赖倒置原则

2.3.1、依赖导致原则的定义

       依赖倒置原则（Dependence Inversion Principle，DIP）是 Object Mentor 公司总裁罗伯特·马丁（Robert C.Martin）于 1996 年在 C++ Report 上发表的文章。

       依赖倒置原则的原始定义为，高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象（High level modules shouldnot depend upon low level modules.Both should depend upon abstractions.Abstractions should not depend upon details. Details should depend upon abstractions）。其核心思想是，要面向接口编程，不要面向实现编程。

       依赖倒置原则是实现开闭原则的重要途径之一，它降低了客户与实现模块之间的耦合。由于在软件设计中，细节具有多变性，而抽象层则相对稳定，因此以抽象为基础搭建起来的架构要比以细节为基础搭建起来的架构要稳定得多。这里的抽象指的是接口或者抽象类，而细节是指具体的实现类。使用接口或者抽象类的目的是制定好规范和契约，而不去涉及任何具体的操作，把展现细节的任务交给它们的实现类去完成。

2.3.2、依赖导致原则的作用

        依赖倒置原则的主要作用如下：

2.3.3、依赖倒置原则的作用 

      依赖倒置原则的目的是通过要面向接口的编程来降低类间的耦合性，所以我们在实际编程中只要遵循以下4点，就能在项目中满足这个规则。

2.4、单一职责原则

2.4.1、单一职责原则的定义

       单一职责原则（Single Responsibility Principle，SRP）又称单一功能原则，由罗伯特·C.马丁（Robert C. Martin）于《敏捷软件开发：原则、模式和实践》一书中提出的。这里的职责是指类变化的原因，单一职责原则规定一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分（There should never be more than one reason for a class to change）。

       该原则提出对象不应该承担太多职责，如果一个对象承担了太多的职责，至少存在以下两个缺点：

2.4.2、单一职责原则的优点

       单一职责原则的核心就是控制类的粒度大小、将对象解耦、提高其内聚性。如果遵循单一职责原则将有以下优点。

2.4.3、单一职责原则的实现方法

      单一职责原则是最简单但又最难运用的原则，需要设计人员发现类的不同职责并将其分离，再封装到不同的类或模块中。而发现类的多重职责需要设计人员具有较强的分析设计能力和相关重构经验。

       下面以大学学生工作管理程序为例介绍单一职责原则的应用。

大学学生工作管理程序的类图如下：

注意：单一职责同样也适用于方法。一个方法应该尽可能做好一件事情。如果一个方法处理的事情太多，其颗粒度会变得很粗，不利于重用。

2.5、接口隔离原则

2.5.1、接口隔离原则的定义

       接口隔离原则（Interface Segregation Principle，ISP）要求程序员尽量将臃肿庞大的接口拆分成更小的和更具体的接口，让接口中只包含客户感兴趣的方法。

       2002 年罗伯特·C.马丁给“接口隔离原则”的定义是，客户端不应该被迫依赖于它不使用的方法（Clients should not be forced to depend on methods they do not use）。该原则还有另外一个定义：一个类对另一个类的依赖应该建立在最小的接口上（The dependency of one class to another one should depend on the smallest possible interface）。

       以上两个定义的含义是，要为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。接口隔离原则和单一职责都是为了提高类的内聚性、降低它们之间的耦合性，体现了封装的思想，但两者是不同的：

2.5.2、接口隔离原则的优点

       接口隔离原则是为了约束接口、降低类对接口的依赖性，遵循接口隔离原则有以下 5 个优点。

2.5.3、接口隔离原则的实现方法

       在具体应用接口隔离原则时，应该根据以下几个规则来衡量。

       下面以学生成绩管理程序为例介绍接口隔离原则的应用：

学生成绩管理程序的类图如下：

相关代码如下：

// 输入模块接口
class IInputModule
{
public:
    void insert();
    void delete();
    void modify();
};

// 统计模块接口
class ICountModule
{
public:
    void countTotalScore();
    void countAverage();
};

// 打印模块接口
class IPrintModule
{
public:
    void printStuInfo();
    void queryStuInfo();
};

// 实现类
class StuScoreList ：public IInputModule, public ICountModule, public IPrintModule
{
private:
    StuScoreList(){};
public:
    static IInputModule* getInputModule()
    {
        return (IInputModule*)new StuScoreList();
    }

    static CountModule getCountModule()
    {
        return (ICountModule*)new StuScoreList();
    }

    static IPrintModule getPrintModule()
    {
        return (IPrintModule*)new StuScoreList();
    }

    void insert()
    {
        std::cout<<"输入模块的insert()方法被调用！"<<endl;
    }

    void delete()
    {
        std::cout<<"输入模块的delete()方法被调用！"<<endl;
    }

    void modify()
    {
        std::cout<<"输入模块的modify()方法被调用！"<<endl;
    }

    void countTotalScore()
    {
        std::cout<<"统计模块的countTotalScore()方法被调用！"<<endl;
    }

    void countAverage()
    {
        std::cout<<"统计模块的countAverage()方法被调用！"<<endl;
    }

    void printStuInfo()
    {
        std::cout<<"打印模块的printStuInfo()方法被调用！"<<endl;
    }

    void queryStuInfo()
    {
        std::cout<<"打印模块的queryStuInfo()方法被调用！"<<endl;
    }
};

// 测试代码
IInputModule* pInput =StuScoreList::getInputModule();
ICountModule* pIount =StuScoreList::getCountModule();
IPrintModule* pPrint =StuScoreList::getPrintModule();
pInput->insert();
pCount->countTotalScore();
pPrint->printStuInfo();

程序的运行结果如下：

2.6、迪米特法则

2.6.1、迪米特法则的定义

        迪米特法则（Law of Demeter，LoD），又叫做最少知识原则（Least Knowledge Principle，LKP)，产生于 1987 年美国东北大学（Northeastern University）的一个名为迪米特（Demeter）的研究项目，由伊恩·荷兰（Ian Holland）提出，被 UML 创始者之一的布奇（Booch）普及，后来又因为在经典著作《程序员修炼之道》（The Pragmatic Programmer）提及而广为人知。

       迪米特法则的定义是，只与你的直接朋友交谈，不跟“陌生人”说话（Talk only to your immediate friends and not to strangers）。其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。

       迪米特法则中的“朋友”是指，当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。

2.6.2、迪米特法则的优点

        迪米特法则要求限制软件实体之间通信的宽度和深度，正确使用迪米特法则将有以下两个优点。

但是，过度使用迪米特法则会使系统产生大量的中介类，从而增加系统的复杂性，使模块之间的通信效率降低。所以，在釆用迪米特法则时需要反复权衡，确保高内聚和低耦合的同时，保证系统的结构清晰。

2.6.2、迪米特法则的实现方法

       从迪米特法则的定义和特点可知，它强调以下两点：

所以，在运用迪米特法则时要注意以下 6 点：

      下面以明星与经纪人的关系实例来讲解这一规则：

明星与经纪人的类图：

相关代码如下：

// 经纪人
class Agent
{
public:
    void setStar(Star* pStar)
    {
        this.pMyStar=pStar;
    }

    void setFans(Fans* pFans)
    {
        this.pMyFans=pFans;
    }

    void setCompany(Company* pCompany)
    {
        this.pMyCompany=pCompany;
    }

    void meeting()
    {
        std::cout<<myFans.getName()<<"与明星"<<myStar.getName()<<"见面了。"<<endl;
    }

    void business()
    {
        std::cout<<myCompany.getName()<<"与明星"<<myStar.getName()<<"洽淡业务。"<<endl;
    }

private:
    Star* pMyStar;
    Fans* pMyFans;
    Company* pMyCompany;
};

// 明星
class Star
{
public:
    Star(const char* pName)
    {
        this.name=pName;
    }

    char* getName()
    {
        return name.c_str();
    }

private:
    string name;
};

// 粉丝
class Fans
{
public:
    Fans(const char* pName)
    {
        this.name=pName;
    }

    char* getName()
    {
        return name.c_str();
    }

private:
    string name;
};

// 媒体公司
class Company
{
public:
    Company(String name)
    {
        this.name=name;
    }

    String getName()
    {
        return name;
    }

private:
    String name;
};

// 测试代码
Agent agent;
agent.setStar(new Star("张颂文"));
agent.setFans(new Fans("粉丝小李"));
agent.setCompany(new Company("XXXXX公司"));
agent.meeting();
agent.business();

程序的运行结果如下：

2.7、合成复用原则

2.7.1、合成复用原则的定义

      合成复用原则（Composite Reuse Principle，CRP）又叫组合/聚合复用原则（Composition/Aggregate Reuse Principle，CARP）。它要求在软件复用时，要尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

       如果要使用继承关系，则必须严格遵循里氏替换原则。合成复用原则同里氏替换原则相辅相成的，两者都是开闭原则的具体实现规范。

2.7.2、合成复用原则的重要性

       通常类的复用分为继承复用和合成复用两种，继承复用虽然有简单和易实现的优点，但它也存在以下缺点：

       采用组合或聚合复用时，可以将已有对象纳入新对象中，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点：

2.7.3、合成复用原则的实现方法

       合成复用原则是通过将已有的对象纳入新对象中，作为新对象的成员对象来实现的，新对象可以调用已有对象的功能，从而达到复用。下面以汽车分类管理程序为例来介绍合成复用原则的应用：

用继承关系实现的汽车分类的类图：

从上图可以看出用继承关系实现会产生很多子类，而且增加新的“动力源”或者增加新的“颜色”都要修改源代码，这违背了开闭原则，显然不可取。

       但如果改用组合关系实现就能很好地解决以上问题，用组合关系实现的汽车分类的类图如下：

3、最后

        上述软件设计七大原则可以使用一句话概括，如下所示：