依赖倒转原则:依赖于抽象(接口),不依赖于具体的实现类。即针对接口的编程。
一 依赖于具体的类(即不使用依赖倒转原则时)
#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)抽象不应该依赖于细节,细节应该依赖抽象。