依赖倒转原则和里氏代换原则详解

初学依赖倒转原则和里氏代换原则时，由于笔者水平有限，并没有看懂书上的专业术语的解释，经过反复摸索和学习，发现里氏代换原则和依赖倒转原则可以一言以蔽之：

里氏代换原则：开发时以抽象为核心，针对抽象编程，能够抽象为一个抽象类或者接口的，就将其抽象为抽象类或者接口，然后用子类来进行实现

依赖倒转原则：将代码分为3层考虑，业务逻辑层，抽象层和实现层，其中业务逻辑层依赖抽象层，实现层也依赖抽象层

那么在代码中使用依赖倒转原则和里氏代换原则有什么好处吗？

只要能抽象你就进行抽象，然后不管高层模块（业务逻辑层）还是低层模块（实现层），它们都依赖于抽象，具体一点就是接口或抽象类，只要接口是稳定的，那么任何一个的更改都不用担心其他受到影响，即降低了耦合度。

光看理论，肯定还是一头雾水，下面通过一个例子来理清里氏代换原则和依赖倒转原则。

我们现在有张三司机和李四司机，有宝马和奔驰汽车，需求包括张三开宝马，李四开奔驰。

#include<iostream>
using namespace std;

class Benz
{
public:
	void run()
	{
		cout << "Benz is running" << endl;
	}
};

class BMW
{
public:
	void run()
	{
		cout << "BMW is runnning" << endl;
	}
};

class Zhang3
{
public:
	void driveBenz(Benz* benz)
	{
		cout << "zhang3 drives Benz" << endl;
		benz->run();
	}
};

class Li4
{
public:
	void driveBMW(BMW* bmw)
	{
		cout << "li4 drives BMW" << endl;
		bmw->run();
	}
};

int main()
{
	Benz benz;
	BMW bmw;
	Zhang3 zhang3;
	Li4 li4;
	zhang3.driveBenz(&benz);
	li4.driveBMW(&bmw);

	return 0;
}

那如果我们要拓展业务需求，张三既要开奔驰，也要开宝马，李四既要开奔驰也要开宝马，那也很简单，只需要在张三类和李四类中各增加一个方法即可。

#include<iostream>
using namespace std;

class Benz
{
public:
	void run()
	{
		cout << "Benz is running" << endl;
	}
};

class BMW
{
public:
	void run()
	{
		cout << "BMW is runnning" << endl;
	}
};

class Zhang3
{
public:
	void driveBenz(Benz* benz)
	{
		cout << "zhang3 drives Benz" << endl;
		benz->run();
	}

	void driveBMW(BMW* bmw)
	{
		cout << "zhang3 drives BMW" << endl;
		bmw->run();
	}
};

class Li4
{
public:
	void driveBenz(Benz* benz)
	{
		cout << "li4 drives Benz" << endl;
		benz->run();
	}

	void driveBMW(BMW* bmw)
	{
		cout << "li4 drives BMW" << endl;
		bmw->run();
	}
};

int main()
{
	Benz benz;
	BMW bmw;
	Zhang3 zhang3;
	Li4 li4;
	zhang3.driveBenz(&benz);
	zhang3.driveBMW(&bmw);
	li4.driveBenz(&benz);
	li4.driveBMW(&bmw);

	return 0;
}

这是一个耦合度极高的设计，那以后拓展了新功能，张三开丰田，李四开奥迪，那我得设计一个新丰田类，新奥迪类，然后在张三类中进行修改，在李四类中进行修改，我每次拓展新功能，都要修改其它模块中的内容，这样的一个设计显然是一个耦合度极高的设计。

如果一个系统有上百个模块，那么再添加一个新模块，新功能的时候，那可能还得修改几百个模块的内容，这样显然是极不方便的。

那如果我们利用里氏代换原则和依赖倒转原则，能抽象就抽象，并将代码分为3层考虑，分别是业务逻辑层，抽象层和实现层，具体思路就是将奔驰，宝马，丰田等等汽车抽象为一个汽车类，汽车类包含一个公共接口run，将张三，李四，王五等等人物抽象为一个人物类，人物类中包含一个公共接口drive，drive中的参数也是抽象的汽车类，然后假设我们需要李四开奔驰，我们就在实现层去实现一个具体的奔驰类，在实现层实现一个具体的李四类，然后在业务逻辑层创建一个李四对象，创建一个奔驰对象，将奔驰汽车对象传给李四对象中的drive方法，就实现了李四开奔驰，如果想要实现李四开宝马，那么同样，只需要在实现层新实现一个宝马类，然后去业务逻辑层创建一个宝马对象，再将宝马对象传给李四对象中的drive方法，就实现了李四开宝马，后面我们再想去拓展功能，只要接口不需要发生变化，我们就无需去动之前的代码，只需要增加新的代码即可，这也符合开放-封闭原则，如果我们想去修改一些功能代码，比如把李四开宝马修改为李四开奔驰，只需要在业务逻辑层更换参数即可，无需动其它模块的内容，显然极大降低了代码之间的耦合度。

使用依赖倒转原则后，我们再去拓展新的功能或者修改一些功能就无需去更改其它模块中的内容了。

具体代码如下：

#include<iostream>
#include<string>
using namespace std;

//抽象层
class Car
{
	string name;
public:
	virtual void run() = 0;
	Car(string _name):name(_name){}
	string getName()
	{
		return name;
	}
};

class Person
{
public:
	virtual void drive(Car& car) = 0;
};

//实现层
class Benz :public Car
{
public:
	Benz(string _name) :Car(_name) {}
	virtual void run()
	{
		cout << "奔驰正在奔跑" << endl;
	}
};

class BMW :public Car
{
public:
	BMW(string _name) :Car(_name) {}
	virtual void run()
	{
		cout << "宝马正在奔跑" << endl;
	}
};

class Zhang3 :public Person
{
public:
	virtual void drive(Car& car)
	{
		cout << "张三在开" << car.getName() << endl;
		car.run();
	}
};

class Li4 :public Person
{
public:
	virtual void drive(Car& car)
	{
		cout << "李四在开" << car.getName() << endl;
		car.run();
	}
};

//业务逻辑层
int main()
{
	Person* person = new Zhang3;
	Person* person2 = new Li4;
	Car* car1 = new Benz("奔驰");
	Car* car2 = new BMW("宝马");
	person->drive(*car1);
	person2->drive(*car2);
	return 0;
}

通过上述解释，我们清楚了里氏代换原则和依赖倒转原则对代码的作用，但是在代码中还有一个值得注意的地方，很显然，实现层依赖了抽象层，而在业务逻辑层，我们要注意要让父类（抽象类）指针指向子类对象，这样业务逻辑层才是依赖了抽象层，才符合依赖倒转原则。