设计模式-依赖倒转原则

依赖倒转原则：依赖于抽象（接口），不依赖于具体的实现类。即针对接口的编程。

一 依赖于具体的类（即不使用依赖倒转原则时）

#include <iostream>

using namespace std;

class Benz
{
public:
    void run()
    {
        cout<<"奔驰开起来，秀一下！"<<endl;
    }
};

class BMW
{
public:
    void run()
    {
        cout<<"宝马开起来了，别摸我！"<<endl;
    }
};

class Boss
{
public:
    Boss(Benz *benz){
        this->benz=benz;
    }

    Boss(BMW *bmw){
        this->bmw=bmw;
    }

    void drivebenz(){
        benz->run();
    }

    void drivebmw(){
        bmw->run();
    }

private:
    Benz *benz;
    BMW *bmw;
};  //此时若老板还想开宝马，必须还要再有一个BMW *bmw私有变量，还要定义相应的构造函数和方法

int main()
{
    //张老板开奔驰的业务
    Benz benz;
    Boss Zhang(&benz);
    cout<<"张老板准备开奔驰了，都闪开！"<<endl;
    Zhang.drivebenz();

    //李老板开宝马业务
    BMW bmw;
    Boss Li(&bmw);
    cout<<"李老板来秀宝马了，都给我打！"<<endl;
    Li.drivebmw();

    return 0;
}

可以看出如果我们要新建汽车，要重新建立新类。如果人要多开几辆车，人物类中就会多出很多构造函数，方法与变量。这也不符合开闭原则。

这是很复杂的连接与耦合过程，当人和车越来越多，业务越来越多时，这显然书写代码容易出错，维护也不容易。若某一个类出现错误，会严重影响其它类的正常使用。

二 不依赖于具体的类（依赖倒转原则）

整个框架被分为抽象层，实现层，逻辑业务层。

当添加别的老板或者别的车，生成别的业务就很简单了。也不会发生某一个类出错的连锁反应。

#include <iostream>
using namespace std;

//--------抽象类-------
class Car
{
public:
    virtual void run()=0;
};

class Driver
{
public:
    virtual void drive()=0;
};

//-------实现层-------      向抽象层靠拢
class Benz:public Car    //面向抽象类开发
{
public:
    virtual void run()
    {
        cout<<"奔驰开起来，秀一下！"<<endl;
    }
};

class BMW:public Car
{
public:
    virtual void run()
    {
        cout<<"宝马开起来了，别摸我！"<<endl;
    }
};

class Zhang:public Driver  //面向抽象类开发
{
public:
    Zhang(Car *car)
    {
        this->car=car;
    }
    virtual void drive()
    {
        cout<<"张老板开车了"<<endl;
        car->run();
    }

private:
    Car *car;
};

class Li:public Driver
{
public:
    Li(Car *car)
    {
        this->car=car;
    }
    virtual void drive()
    {
        cout<<"李老板开车了"<<endl;
        car->run();
    }

private:
    Car *car;
};

//---------业务逻辑类-----------  向抽象层看齐
int main()
{
    //张老板开宝马业务
    Car *bmw=new BMW;
    Driver *boss_zhang=new Zhang(bmw);
    boss_zhang->drive();

    //李老板开奔驰业务
    Car *benz=new Benz;
    Driver *boss_li=new Li(benz);
    boss_li->drive();

    return 0;
}

（1）高层模块不应该依赖于低层模块，2个都应该依赖于抽象。

（2）抽象不应该依赖于细节，细节应该依赖抽象。