1概述編輯
所謂依賴倒置原則（Dependence Inversion Principle）就是要依賴於抽象，不要依賴於具體。簡單的說就是要求對抽象進行
編程，不要對實現進行編程，這樣就下降了客戶與實現模塊間的耦合。
2意圖編輯
面向過程的開發，上層調用下層，上層依賴於下層，當下層劇烈變更時上層也要跟着變更，這就會致使模塊的複用性下降並且大大提升了開發的成本。
面向對象的開發很好的解決了這個問題，通常狀況下抽象的變化機率很小，讓
用戶程序依賴於抽象，實現的細節也依賴於抽象。即便實現細節不斷變更，只要抽象不變，客戶程序就不須要變化。這大大下降了客戶程序與實現細節的
耦合度。
面向過程思想的結構圖：
圖一
背景1：公司是福特和本田公司的金牌合做夥伴，現要求開發一套自動駕駛系統，只要汽車上安裝該系統就能夠實現無人駕駛，該系統能夠在福特和本田車上使用，只要這兩個品牌的汽車使用該系統就能實現自動駕駛。因而有人作出了分析如圖一。
對於圖一分析：咱們定義了一個AutoSystem類，一個FordCar類，一個HondaCar類。FordCar類和HondaCar類中各有三個方法:Run(啓動Car)、Turn(轉彎Car)、Stop(中止Car)，固然了一個汽車確定不止這些功能，這裏只要能說明問題便可。AutoSystem類是一個自動駕駛系統，自動操縱這兩輛車。
3代碼實現編輯
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
publicclassHondaCar{
publicvoidRun()
{
Console.WriteLine(
"本田開始啓動了"
);
}
publicvoidTurn()
{
Console.WriteLine(
"本田開始轉彎了"
);
}
publicvoidStop()
{
Console.WriteLine(
"本田開始停車了"
);
}
}
publicclassFordCar
{
publicvoidRun()
{
Console.WriteLine(
"福特開始啓動了"
);
}
publicvoidTurn()
{
Console.WriteLine(
"福特開始轉彎了"
);
}
publicvoidStop()
{
Console.WriteLine(
"福特開始停車了"
);
}
}
publicclassAutoSystem
{
publicenumCarType{Ford,Honda};
privateHondaCarhcar=newHondaCar();
privateFordCarfcar=newFordCar();
privateCarTypetype;
publicAutoSystem(CarTypetype)
{
this
.type=type;
}
privatevoidRunCar()
{
if
(type==CarType.Ford)
{
fcar.Run();
}
else
{
hcar.Run();
}
}
privatevoidTurnCar()
{
if
(type==CarType.Ford)
{
fcar.Turn();
}
else
{
hcar.Turn();
}
}
privatevoidStopCar()
{
if
(type==CarType.Ford)
{
fcar.Stop();
}
else
{
hcar.Stop();
}
}
}
|
代碼分析：上面的程序確實可以實現針對Ford和Honda車的無人駕駛，可是軟件是在不斷變化的，軟件的需求也在不斷的變化。
背景2：公司的業務作大了，同時成爲了通用、三菱、大衆的金牌合做夥伴，因而公司要求該自動駕駛系統也可以安裝在這3種公司生產的汽車上。因而咱們不得不變更AutoSystem：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
publicclassAutoSystem
{
publicenumCarType{Ford,Honda,Bmw};
HondaCarhcar=newHondaCar();
FordCarfcar=newFordCar();
BmwCarbcar=newBmwCar();
privateCarTypetype;
publicAutoSystem(CarTypetype)
{
this
.type=type;
}
privatevoidRunCar()
{
if
(type==CarType.Ford)
{
fcar.Run();
}
elseif(type==CarType.Honda)
{
hcar.Run();
}
elseif(type==CarType.Bmw)
{
bcar.Run();
}
}
privatevoidTurnCar()
{
if
(type==CarType.Ford)
{
fcar.Turn();
}
elseif(type==CarType.Honda)
{
hcar.Turn();
}
elseif(type==CarType.Bmw)
{
bcar.Turn();
}
}
privatevoidStopCar()
{
if
(type==CarType.Ford)
{
fcar.Stop();
}
elseif(type==CarType.Honda)
{
hcar.Stop();
}
elseif(type==CarType.Bmw)
{
bcar.Stop();
}
}
}
|
分析：這會給系統增長新的相互依賴。隨着時間的推移，愈來愈多的車種必須加入到AutoSystem中，這個「AutoSystem」模塊將會被if/else語句弄得很亂，並且依賴於不少的低層模塊，只要低層模塊發生變更，AutoSystem就必須跟着變更，
它最終將變得僵化、脆弱。
致使上面所述問題的一個緣由是，含有高層策略的模塊，如AutoSystem模塊，依賴於它所控制的低層的具體細節的模塊（如HondaCar()和FordCar()）。若是咱們可以找到一種方法使AutoSystem
模塊獨立於它所控制的具體細節，那麼咱們就能夠自由地複用它了。咱們就能夠用這個模塊來生成其它的程序，使得系統可以用在須要的汽車上。OOD給咱們提供了一種機制來實現這種「依賴倒置」。
4結構圖編輯
圖二
看圖 2中這個簡單的類圖。這兒有一個「AutoSystem」類，它包含一個「ICar」接口。這個「AutoSystem」類根本不依賴於「FordCar」和「HondaCar」。因此，依賴關係被「倒置」了：「AutoSystem」模塊依賴於抽象，那些具體的汽車操做也依賴於相同的抽象。
因而能夠添加ICar
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
publicinterfaceICar
{
voidRun();
voidTurn();
voidStop();
}
publicclassBmwCar:ICar
{
publicvoidRun()
{
Console.WriteLine(
"寶馬開始啓動了"
);
}
publicvoidTurn()
{
Console.WriteLine(
"寶馬開始轉彎了"
);
}
publicvoidStop()
{
Console.WriteLine(
"寶馬開始停車了"
);
}
}
publicclassFordCar:ICar
{
publicvoidRun()
{
Console.WriteLine(
"福特開始啓動了"
);
}
publicvoidTurn()
{
Console.WriteLine(
"福特開始轉彎了"
);
}
publicvoidStop()
{
Console.WriteLine(
"福特開始停車了"
);
}
}
publicclassHondaCar:ICar
{
publicvoidRun()
{
Console.WriteLine(
"本田開始啓動了"
);
}
publicvoidTurn()
{
Console.WriteLine(
"本田開始轉彎了"
);
}
publicvoidStop()
{
Console.WriteLine(
"本田開始停車了"
);
}
}
publicclassAutoSystem
{
privateICaricar;
publicAutoSystem(ICaricar)
{
this
.icar=icar;
}
privatevoidRunCar()
{
icar.Run();
}
privatevoidTurnCar()
{
icar.Turn();
}
privatevoidStopCar()
{
icar.Stop();
}
}
|
如今AutoSystem系統依賴於ICar 這個抽象，而與具體的實現細節HondaCar、FordCar、BmwCar無關，因此實現細節的變化不會影響AutoSystem。對於實現細節只要實現ICar 便可，即實現細節依賴於ICar 抽象。
綜上：
一個應用中的重要策略決定及業務模型正是在這些高層的模塊中。也正是這些模型包含着應用的特性。可是，當這些模塊依賴於低層模塊時，低層模塊的修改將會直接影響到它們，迫使它們也去改變。這種境況是荒謬的。應該是處於高
層的模塊去迫使那些低層的模塊發生改變。應該是處於高層的模塊優先於低層的模塊。不管如何高層的模塊也不該依賴於低層的模塊。並且，咱們想可以複用的是高層的模塊。經過
子程序庫的形式，咱們已經能夠很好地複用低層的模塊了。當高層的模塊依賴於低層的模塊時，這些高層模塊就很難在不一樣的環境中複用。可是，當那些高層
模塊獨立於低層模塊時，它們就能很簡單地被複用了。這正是位於框架設計的最核心之處的原則。
總結：依賴倒置原則
A.高層次的模塊不該該依賴於低層次的模塊，他們都應該依賴於抽象。
B.抽象不該該依賴於具體，具體應該依賴於抽象。