依赖倒转原则

2020-12-20

依赖倒置原则指的是高层模块（稳定）不应该依赖于底层模块（变化），二者都应该依赖于抽象（稳定）。抽象（稳定）不应该依赖于实现（变化），实现应该依赖于抽象（稳定）。它的中心思想就是面向接口编程而不是面向细节编程。

在依赖倒置原则中，相对于细节的多变性，抽象要稳定的多。以抽象为基础搭建的框架要比以细节的框架要稳定的多。使用接口的目的是为了指定好的规范而不涉及任何细节操作。

以细节为基础的代码示例：

#include <iostream>
class Car{
public:
    //车具有运行的功能
    void Run(){
        std::cout << "I am running in the road" << std::endl;
    }
};
class Person{
public:
    //完成开车的功能
    void Drive(Car _car) {
        _car.Run();
    }
};
int main(int argc,char *argv[])
{
    Person p;
    p.Drive(Car());
    return 0;
}

运行结果：

如果新增加一种车，Person就需要新建一个函数来实现对新的车的运行，车与人之间的耦合度过高。人开车太过依赖与车的类型，改进方法是使用接口实现人与车之间的解耦合，不需要让人开车的动作太过依赖于车的类型。

示例代码如下：

#include <iostream>
class Car{
public:
    Car(){}
    virtual ~Car(){}
    //车具有运行的功能
    virtual void Run()  {
        std::cout << "No car run" << std::endl;
    }
};
class Maserati : public  Car{
public:
    void Run() override {
        std::cout << "I am Maserati ,I am running in a fast speed" << std::endl;
    }
};
class Lamborghini : public Car{
public:
    void Run() override {
        std::cout << "I am Lamborghini ,I am running in a fast speed" << std::endl;
    }
};
class Person{
public:
    //完成开车的功能
    void Drive(Car& _car) {
        _car.Run();
    }

};
int main(int argc,char *argv[])
{
    Person p;
    Lamborghini lam;
    Maserati mas;
    p.Drive(lam);
    p.Drive(mas);
    return 0;
}