初學(xué)依賴倒轉(zhuǎn)原則和里氏代換原則時(shí)，由于筆者水平有限，并沒(méi)有看懂書(shū)上的專業(yè)術(shù)語(yǔ)的解釋，經(jīng)過(guò)反復(fù)摸索和學(xué)習(xí)，發(fā)現(xiàn)里氏代換原則和依賴倒轉(zhuǎn)原則可以一言以蔽之：

里氏代換原則：開(kāi)發(fā)時(shí)以抽象為核心，針對(duì)抽象編程，能夠抽象為一個(gè)抽象類或者接口的，就將其抽象為抽象類或者接口，然后用子類來(lái)進(jìn)行實(shí)現(xiàn)

依賴倒轉(zhuǎn)原則：將代碼分為3層考慮，業(yè)務(wù)邏輯層，抽象層和實(shí)現(xiàn)層，其中業(yè)務(wù)邏輯層依賴抽象層，實(shí)現(xiàn)層也依賴抽象層

那么在代碼中使用依賴倒轉(zhuǎn)原則和里氏代換原則有什么好處嗎？

只要能抽象你就進(jìn)行抽象，然后不管高層模塊（業(yè)務(wù)邏輯層）還是低層模塊（實(shí)現(xiàn)層），它們都依賴于抽象，具體一點(diǎn)就是接口或抽象類，只要接口是穩(wěn)定的，那么任何一個(gè)的更改都不用擔(dān)心其他受到影響，即降低了耦合度。

光看理論，肯定還是一頭霧水，下面通過(guò)一個(gè)例子來(lái)理清里氏代換原則和依賴倒轉(zhuǎn)原則。

我們現(xiàn)在有張三司機(jī)和李四司機(jī)，有寶馬和奔馳汽車，需求包括張三開(kāi)寶馬，李四開(kāi)奔馳。

#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;
}

那如果我們要拓展業(yè)務(wù)需求，張三既要開(kāi)奔馳，也要開(kāi)寶馬，李四既要開(kāi)奔馳也要開(kāi)寶馬，那也很簡(jiǎn)單，只需要在張三類和李四類中各增加一個(gè)方法即可。

#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;
}

這是一個(gè)耦合度極高的設(shè)計(jì)，那以后拓展了新功能，張三開(kāi)豐田，李四開(kāi)奧迪，那我得設(shè)計(jì)一個(gè)新豐田類，新奧迪類，然后在張三類中進(jìn)行修改，在李四類中進(jìn)行修改，我每次拓展新功能，都要修改其它模塊中的內(nèi)容，這樣的一個(gè)設(shè)計(jì)顯然是一個(gè)耦合度極高的設(shè)計(jì)。

如果一個(gè)系統(tǒng)有上百個(gè)模塊，那么再添加一個(gè)新模塊，新功能的時(shí)候，那可能還得修改幾百個(gè)模塊的內(nèi)容，這樣顯然是極不方便的。

那如果我們利用里氏代換原則和依賴倒轉(zhuǎn)原則，能抽象就抽象，并將代碼分為3層考慮，分別是業(yè)務(wù)邏輯層，抽象層和實(shí)現(xiàn)層，具體思路就是將奔馳，寶馬，豐田等等汽車抽象為一個(gè)汽車類，汽車類包含一個(gè)公共接口run，將張三，李四，王五等等人物抽象為一個(gè)人物類，人物類中包含一個(gè)公共接口drive，drive中的參數(shù)也是抽象的汽車類，然后假設(shè)我們需要李四開(kāi)奔馳，我們就在實(shí)現(xiàn)層去實(shí)現(xiàn)一個(gè)具體的奔馳類，在實(shí)現(xiàn)層實(shí)現(xiàn)一個(gè)具體的李四類，然后在業(yè)務(wù)邏輯層創(chuàng)建一個(gè)李四對(duì)象，創(chuàng)建一個(gè)奔馳對(duì)象，將奔馳汽車對(duì)象傳給李四對(duì)象中的drive方法，就實(shí)現(xiàn)了李四開(kāi)奔馳，如果想要實(shí)現(xiàn)李四開(kāi)寶馬，那么同樣，只需要在實(shí)現(xiàn)層新實(shí)現(xiàn)一個(gè)寶馬類，然后去業(yè)務(wù)邏輯層創(chuàng)建一個(gè)寶馬對(duì)象，再將寶馬對(duì)象傳給李四對(duì)象中的drive方法，就實(shí)現(xiàn)了李四開(kāi)寶馬，后面我們?cè)傧肴ネ卣构δ?，只要接口不需要發(fā)生變化，我們就無(wú)需去動(dòng)之前的代碼，只需要增加新的代碼即可，這也符合開(kāi)放-封閉原則，如果我們想去修改一些功能代碼，比如把李四開(kāi)寶馬修改為李四開(kāi)奔馳，只需要在業(yè)務(wù)邏輯層更換參數(shù)即可，無(wú)需動(dòng)其它模塊的內(nèi)容，顯然極大降低了代碼之間的耦合度。

使用依賴倒轉(zhuǎn)原則后，我們?cè)偃ネ卣剐碌墓δ芑蛘咝薷囊恍┕δ芫蜔o(wú)需去更改其它模塊中的內(nèi)容了。

具體代碼如下：

#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;
};
//實(shí)現(xiàn)層
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 << "張三在開(kāi)" << car.getName() << endl;
		car.run();
	}
};
class Li4 :public Person
{
public:
	virtual void drive(Car& car)
	{
		cout << "李四在開(kāi)" << car.getName() << endl;
		car.run();
	}
};
//業(yè)務(wù)邏輯層
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;
}

通過(guò)上述解釋，我們清楚了里氏代換原則和依賴倒轉(zhuǎn)原則對(duì)代碼的作用，但是在代碼中還有一個(gè)值得注意的地方，很顯然，實(shí)現(xiàn)層依賴了抽象層，而在業(yè)務(wù)邏輯層，我們要注意要讓父類（抽象類）指針指向子類對(duì)象，這樣業(yè)務(wù)邏輯層才是依賴了抽象層，才符合依賴倒轉(zhuǎn)原則。

到此這篇關(guān)于C++依賴倒轉(zhuǎn)原則和里氏代換原則有什么好處的文章就介紹到這了,更多相關(guān)C++依賴倒轉(zhuǎn)原則內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論