前两节我们详细介绍了面向对象设计原则中的开闭原则和里氏替换原则，在本节中我们来介绍依赖倒置原则。

依赖倒置原则的定义

依赖倒置原则（Dependence Inversion Principle，DIP）是 Object Mentor 公司总裁罗伯特·马丁（Robert C.Martin）于 1996 年在 C++ Report 上发表的文章。

依赖倒置原则的原始定义为：高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象（High level modules shouldnot depend upon low level modules.Both should depend upon abstractions.Abstractions should not depend upon details. Details should depend upon abstractions）。其核心思想是：要面向接口编程，不要面向实现编程。

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

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

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

依赖、倒置原则的作用

依赖倒置原则的主要作用如下。

依赖倒置原则可以降低类间的耦合性。
依赖倒置原则可以提高系统的稳定性。
依赖倒置原则可以减少并行开发引起的风险。
依赖倒置原则可以提高代码的可读性和可维护性。

依赖倒置原则的实现方法

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

每个类尽量提供接口或抽象类，或者两者都具备。
变量的声明类型尽量是接口或者是抽象类。
任何类都不应该从具体类派生。
使用继承时尽量遵循里氏替换原则。

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

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

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

class Customer {public void shopping(ShaoguanShop shop) {//购物System.out.println(shop.sell());}
}

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

class Customer {public void shopping(WuyuanShop shop) {//购物System.out.println(shop.sell());}
}

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

class Customer {public void shopping(Shop shop) {//购物System.out.println(shop.sell());}
}

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

图1 顾客购物程序的类图

程序代码如下：

package principle;
public class DIPtest {public static void main(String[] args) {Customer wang = new Customer();System.out.println("顾客购买以下商品：");wang.shopping(new ShaoguanShop());wang.shopping(new WuyuanShop());}
}
//商店
interface Shop {public String sell(); //卖
}
//韶关网店
class ShaoguanShop implements Shop {public String sell() {return "韶关土特产：香菇、木耳……";}
}
//婺源网店
class WuyuanShop implements Shop {public String sell() {return "婺源土特产：绿茶、酒糟鱼……";}
}
//顾客
class Customer {public void shopping(Shop shop) {//购物System.out.println(shop.sell());}
}

程序的运行结果如下：

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

进阶阅读

如果您想了解依赖倒置原则在实际项目中的应用，可以猛击阅读《使用依赖倒置原则解决实际问题》文章。

使用依赖倒置原则解决实际问题

下面来看一个实例，以 C语言中文网的教程为例，首先创建一个学员类 ZhangSan。

package net.biancheng.c.dip;
public class ZhangSan {public void studyJava() {System.out.println("张三正在学习Java教程");}public void studyCplus() {System.out.println("张三正在学习C++教程");}
}

然后编写客户端测试代码并调用。

public static void main(String[] args) {ZhangSan zhangSan = new ZhangSan();zhangSan.studyJava();zhangSan.studyCplus();
}

目前张三正在学习 Java 和 C++ 教程，随着学习兴趣的暴涨，张三还想学习 Python 教程。这时就需要业务扩展，代码需要从底层开始修改，即：在 ZhangSan 类中添加 studyPython() 的方法，在高层（这里指的是 main() 方法）也要追加调用该方法。这样发布系统，实际上是非常不稳定的，在修改代码的同时会带来意想不到的风险。

下面我们优化代码，首先创建教程的抽象接口 Course。

package net.biancheng.c.dip;
public interface Course {void study();
}

然后编写 JavaCourse 类。

package net.biancheng.c.dip;
public class JavaCourse implements Course {@Overridepublic void study() {System.out.println("张三在学习Java教程");}
}

同样，编写 CplusCourse 类。

package net.biancheng.c.dip;
public class CplusCourse implements Course {@Overridepublic void study() {System.out.println("张三在学习C++教程");}
}

最后修改 ZhangSan 类。

public class ZhangSan {public void study(Course course) {course.study();}
}

客户端测试代码如下。

public static void main(String[] args) {ZhangSan zhangSan = new ZhangSan();zhangSan.study(new JavaCourse());zhangSan.study(new CplusCourse());
}

这个时候再看代码，无论张三要学习什么新教程，只需要建一个类，通过传参的方式告诉 ZhangSan 即可，而不需要修改底层代码。有的小伙伴可能已经发现了，这是大家非常熟悉的依赖注入。

注入的方式还有构造方法注入和 Setter 注入。下面来看构造方法注入。

public class ZhangSan {private Course course;public ZhangSan(Course course) {this.course = course;}public void study(Course course) {course.study();}
}

客户端代码如下，将 JavaCourse 对象作为 ZhangSan 对象的构造参数注入。

public static void main(String[] args) {ZhangSan zhangSan = new ZhangSan(new JavaCourse());zhangSan.study();
}

根据构造方法注入，调用时每次都要创建实例。如果 ZhangSan 是全局单例，只能选择 Setter 注入方式，继续修改 ZhangSan 类的代码。

package net.biancheng.c.dip;
public class ZhangSan {private Course course;public void setCourse(Course course) {this.course = course;}public void study() {course.study();}
}

来看客户端代码，调用 ZhangSan 对象的 setCourse() 方法，将 JavaCourse 对象作为参数。

public static void main(String[] args) {ZhangSan zhangSan = new ZhangSan();zhangSan.setCourse(new JavaCourse());zhangSan.study();zhangSan.setCourse(new CplusCourse());zhangSan.study();
}

最终得到的类图如下。

转载于：http://c.biancheng.net/design_pattern/

依赖倒置原则——面向对象设计原则相关推荐

8.接口隔离原则——面向对象设计原则
面向对象设计原则除了开闭原则.里氏替换原则.依赖倒置原则和单一职责原则以外,还有接口隔离原则.迪米特法则和合成复用原则.本节将详细介绍接口隔离原则. 接口隔离原则的定义接口隔离原则(Interfac ...
接口隔离原则——面向对象设计原则
接口隔离原则的定义接口隔离原则(Interface Segregation Principle,ISP)要求程序员尽量将臃肿庞大的接口拆分成更小的和更具体的接口,让接口中只包含客户感兴趣的方法. 2 ...
开闭原则——面向对象设计原则，使用开闭原则解决实际问题
在软件开发中,为了提高软件系统的可维护性和可复用性,增加软件的可扩展性和灵活性,程序员要尽量根据 7 条原则来开发程序,从而提高软件开发效率.节约软件开发成本和维护成本.我们将在下面的几节中依次来介绍 ...
里氏替换原则——面向对象设计原则
里氏替换原则的定义里氏替换原则:继承必须确保超类所拥有的性质在子类中仍然成立里氏替换原则抓哟阐述了有关继承的一些原则,也就是什么时候应该使用继承,什么时候不应该使用继承,以及其中蕴含的道理.里氏替 ...
7.12 其他面向对象设计原则3: 依赖倒置原则DIP
其他面向对象设计原则3: 依赖倒置原则DIP  The Dependency Inversion Principle 7.1 依赖倒置原则DIP The Dependency Inversion P ...
面向对象设计原则-03依赖倒置原则
面向对象设计原则-03依赖倒置原则依赖倒置原则的定义依赖倒置原则(Dependence Inversion Principle,DIP)是 Object Mentor 公司总裁罗伯特·马丁(Rob ...
02面向对象设计原则
技术交流QQ群:1027579432,欢迎你的加入! 1.为什么需要面向对象设计变化是复用的天敌!面向对象设计最大的优势在于抵御变化! 2.重新认识面向对象理解隔离变化从宏观层面上来看,面向对象 ...
C++面向对象设计原则详解
概述 C++面向对象设计原则主要包括以下几点: 依赖倒置原则开放封闭原则单一职责原则里氏替换原则接口隔离原则封装变化点原则面向接口编程原则优先使用对象组合,而不是类继承接下来详细的分析 ...
代码质量评判标准、设计模式、面向对象设计原则速查表
文章目录代码质量评判标准软件腐化的原因提高系统可复用性的几点原则可维护性与可复用性并不完全一致面向对象设计原则 1. 面向对象设计的六大设计原则表 2. 图解面向对象涉及的六大原则 1. 开 ...

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