设计模式六大原则：依赖倒置原则

==================================================================================== 

目录： 

　　设计模式六大原则：单一职责原则： 

　　设计模式六大原则：接口隔离原则：https://www.cnblogs.com/az4215/p/11481076.html 

　　设计模式六大原则：依赖倒置原则：https://www.cnblogs.com/az4215/p/11462878.html 

　　设计模式六大原则：里氏替换原则：https://www.cnblogs.com/az4215/p/11462828.html 

　　设计模式六大原则：迪米特法则：https://www.cnblogs.com/az4215/p/11489748.html 

　　设计模式六大原则：开闭原则：https://www.cnblogs.com/az4215/p/11489712.html  

===================================================================================== 

依赖倒置原则(dependence inversion principle)：　　

　　1、高层模块不应该依赖底层模块，二者都应该依赖抽象。

　　2、抽象不应该依赖细节，细节应该依赖抽象。

　　3、依赖倒置的中心思想是面向接口编程。

　　4、依赖倒置原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础搭建的架构要稳定的多。

　　5、使用接口或抽象类的目的是指定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类来完成。

经典案例：

　　三二班有个小明，想要学习c#，于是买了本《深入理解c#》进行学习。 

 1 internal class program
 2 {
 3     private static void main(string[] args)
 4     {
 5         xiaoming xm = new xiaoming();
 6         xm.study(new csharp());
 7     }
 8 }
 9 
10 internal class csharp
11 {
12     public void showmsg()
13     {
14         console.writeline("《深入理解c#》");
15     }
16 }
17 
18 internal class xiaoming
19 {
20     public void study(csharp csharp)
21     {
22         csharp.showmsg();
23     }
24 }

　　过了一段时间，小明觉得光学习一门太没有意思了。听说linux比较好玩，于是买了本《鸟哥的私房菜linux》。

 1 internal class program
 2 {
 3     private static void main(string[] args)
 4     {
 5         xiaoming xm = new xiaoming();
 6         xm.study(new csharp());
 7         xm.study(new linux());
 8     }
 9 }
10 
11 internal class csharp
12 {
13     public void showmsg()
14     {
15         console.writeline("《深入理解c#》");
16     }
17 }
18 
19 internal class linux
20 {
21     public void showmsg()
22     {
23         console.writeline("《鸟哥的私房菜linux》");
24     }
25 }
26 
27 internal class xiaoming
28 {
29     public void study(csharp csharp)
30     {
31         csharp.showmsg();
32     }
33 
34     public void study(linux linux)
35     {
36         linux.showmsg();
37     }
38 }

　 小明是一个聪明的娃，过了一段时间学得差不多了，于是又想学习《设计模式》...就这样小明在不断学习中成长，而我们的代码却越来越臃肿，变得难以维护。由于xiaoming是一个高级模块并且是一个细节实现类，此类依赖了书籍csharp和linux又是一个细节依赖类，这导致xiaoming每读一本书都需要修改代码，这与我们的依赖倒置原则是相悖的。那如何解决xiaoming的这种问题呢？ 

 1 internal class program
 2 {
 3     private static void main(string[] args)
 4     {
 5         xiaoming xm = new xiaoming();
 6         xm.study(new csharp());
 7         xm.study(new linux());
 8     }
 9 }
10 
11 internal interface ibook
12 {
13     void showmsg();
14 }
15 
16 internal class csharp : ibook
17 {
18     public void showmsg()
19     {
20         console.writeline("《深入理解c#》");
21     }
22 }
23 
24 internal class linux : ibook
25 {
26     public void showmsg()
27     {
28         console.writeline("《鸟哥的私房菜linux》");
29     }
30 }
31 
32 internal class xiaoming
33 {
34     public void study(ibook book)
35     {
36         book.showmsg();
37     }
38 }

　　我们发现，只要让xiaoming依赖于抽象ibook，其他书籍依赖于该抽象，以后不管小明读什么书，哈哈都是so easy的。

依赖关系传递的三种方式：

　　1、通过接口传递(上述示例) 

1 internal class xiaoming
2 {
3     // 2.通过接口传递依赖对象
4     public void study(ibook book)
5     {
6         book.showmsg();
7     }
8 }

　　2、通过构造方法传递　　

 1 internal class xiaoming
 2 {
 3     private ibook _book;
 4 
 5     // 1.通过构造函数传递依赖对象
 6     public xiaoming(ibook book)
 7     {
 8         this._book = book;
 9     }
10 
11     public void study()
12     {
13         this._book.showmsg();
14     }
15 }

　　3、通过setter方法传递　　

 1 internal class xiaoming
 2 {
 3     private ibook _book;
 4 
 5     // 3.通过setter方法传递依赖对象
 6     public void setbook(ibook _book)
 7     {
 8         this._book = _book;
 9     }
10 
11     public void study()
12     {
13         this._book.showmsg();
14     }
15 }

依赖倒置原则的本质就是通过抽象(接口或抽象类)使各个类或模块的实现彼此独立，不互相影响，实现模块间的松耦合。我们在项目中使用这个原则要遵循下面的规则：

　　1、每个类尽量都有接口或者抽象类，或者抽象类和接口两都具备

　　2、变量的表面类型尽量是接口或者抽象类

　　3、任何类都不应该从具体类派生

　　4、尽量不要覆写基类的方法

　　5、如果基类是一个抽象类，而这个方法已经实现了，子类尽量不要覆写。类间依赖的是抽象，覆写了抽象方法，对依赖的稳定性会有一定的影响

　　6、结合里氏替换原则使用