面向对象设计原则-依赖倒置原则

依赖倒置原则的定义

高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。其核心思想是：要面向接口编程，不要面向现实编程。

依赖倒置原则是实现开闭原则的重要途径之一，他降低了客户与实现之间的耦合。

由于在软件设计中，细节具有多变性，而抽象层相对稳定，因此以抽象为基础搭建起来的架构要比以细节为基础搭建起来的架构要稳定的多。这里的抽象指的是接口或者是抽象类，而细节是指具体的实现类。

使用接口或者抽象类的目的是规定好规范和契约，而不去设计任何具体的操作，把展现细节的任务交给他们的实现类去完成。

依赖倒置原则的作用

1.依赖倒置原则可以降低类间的耦合性。

2.依赖倒置原则可以提高系统的稳定性。

3.依赖倒置原则可以减少并行开发引起的风险。

4.依赖倒置原则可以提高代码的可读性和可维护性。

依赖倒置原则的实现方法

依赖倒置原则的目的是通过要面向接口编程来降低类间的耦合性，所以我们在实际编程中只要遵循一下4点，就能在项目中满足这个规则。

1.每个类尽量提高接口或抽象类，或者两者都具备。

2.变量的声明类型尽量是接口或者是抽象类。

4.任何类都不应该从具体类派生。

下面以“顾客购物程序”为例来说明依赖倒置原则的应用。

【例1】依赖倒置原则在“顾客购物程序”中的应用。

分析：本程序反映了 “顾客类”与“商店类”的关系。商店类中有 sell() 方法，顾客类通过该方法购物以下代码定义了顾客类通过韶关网店 ShaoguanShop 购物：

1. class Customer {
2. public void shopping(ShaoguanShop shop) {
3. //购物
4. System.out.println(shop.sell());
5. }
6. }

但是，这种设计存在缺点，如果该顾客想从另外一家商店（如婺源网店 WuyuanShop）购物，就要将该顾客的代码修改如下：

1. class Customer {
2. public void shopping(WuyuanShop shop) {
3. //购物
4. System.out.println(shop.sell());
5. }
6. }

顾客每更换一家商店，都要修改一次代码，这明显违背了开闭原则。存在以上缺点的原因是：顾客类设计时同具体的商店类绑定了，这违背了依赖倒置原则。解决方法是：定义“婺源网店”和“韶关网店”的共同接口 Shop，顾客类面向该接口编程，其代码修改如下：

1. class Customer {
2. public void shopping(Shop shop) {
3. //购物
4. System.out.println(shop.sell());
5. }
6. }

这样，不管顾客类 Customer 访问什么商店，或者增加新的商店，都不需要修改原有代码了，其类图如图 1 所示。
 

图1 顾客购物程序的类图

程序代码如下：

1. package principle;
2.  
3. public class DIPtest {
4. public static void main(String[] args) {
5. Customer wang = new Customer();
6. System.out.println("顾客购买以下商品：");
7. wang.shopping(new ShaoguanShop());
8. wang.shopping(new WuyuanShop());
9. }
10. }
11.  
12. //商店
13. interface Shop {
14. public String sell(); //卖
15. }
16.  
17. //韶关网店
18. class ShaoguanShop implements Shop {
19. public String sell() {
20. return "韶关土特产：香菇、木耳……";
21. }
22. }
23.  
24. //婺源网店
25. class WuyuanShop implements Shop {
26. public String sell() {
27. return "婺源土特产：绿茶、酒糟鱼……";
28. }
29. }
30.  
31. //顾客
32. class Customer {
33. public void shopping(Shop shop) {
34. //购物
35. System.out.println(shop.sell());
36. }
37. }

程序的运行结果如下：

顾客购买以下商品：
韶关土特产：香菇、木耳……
婺源土特产：绿茶、酒糟鱼……