依赖倒置原则

定义

依赖倒置？大家可能会觉得高深莫测。但是相信听我一翻解说之后，你就会恍然大悟，甚至你早已掌握到它的精髓了。我们先看一下依赖倒置原则的定义：

High level modules should not depend upon low level modules. Both should depend upon abstractions. Abstractions should not depend upon details. Details should depend upon abstractions.（高层模块不应该依赖低层模块，它们都应该依赖其抽象。抽象不应该依赖细节，细节应该依赖抽象。）

意思就是说，无论是高层模块、低层模块还是细节，都应该依赖抽象，所以依赖倒置原则也可以理解为“依赖抽象原则”。那么，什么是依赖呢？假设我们有类A和类B，如果类A需要使用到类B（B是A的属性，或者A会调用到B的方法等），那么可以说类A依赖类B。那么什么又是抽象呢？抽象类、协议都属于抽象。所以，“依赖抽象”就是说当类A用到类B时，尽量引用类B的抽象类或者协议。把依赖倒置原则理解为依赖抽象原则更有助于理解。

大家可能会觉得奇怪，为什么说依赖抽象就是依赖倒置呢？因为在日常生活中，人们习惯于依赖于具体事务（细节），而不是抽象。比如说我们说开车就是具体的车，用电脑就是用具体的电脑。那么如果要倒过来去依赖抽象，就是依赖倒置。

那么为什么要依赖倒置呢？按照人们的直觉依赖正置（依赖具体事务）不好吗？下面就举个依赖正置的例子，来说明依赖正置的问题。

很简单，我们的任务是声明一个司机类和一个奔驰车类，然后让司机开车。我们按照我们现实生活的直觉来，两个类都是具体类，司机就是司机，奔驰车就是奔驰车，没有抽象类的存在。

宝马车类：

@interface BMWCar : NSObject
- (void)run;
@end

@implementation BMWCar
- (void)run{
    NSLog(@"宝马车开动了");
}
@end

司机类：

#import "BMWCar.h"

@interface Driver : NSObject
- (void)driveCar:(BMWCar *)car;
@end

@implementation Driver
- (void)driveCar:(BMWCar *)car{
    [car run];
}
@end

这样就可以让我们的老司机老王开车了：

Driver *wang = [Driver new];
BMWCar *bmw = [BMWCar new];
[wang driveCar:bmw];

上面的代码好像没有什么问题。但是如果现在新增一辆奔驰车，我们的老司机老王却没办法开，因为他目前只有开宝马车的方法！如果要开奔驰车，可能需要为他新增开奔驰车的方法。那么如果现在又要新增特斯拉、奥迪、罗斯莱斯等车呢？难道要为每一辆新增的车去修改司机类？这显然是荒唐的。依赖于具体类，会导致类之间的耦合性太强，这就是在代码中依赖具体类的问题。

虽然说代码是现实世界的反映，但是代码和现实世界还是有所区别的，你需要“倒置”一下。解决上述问题的方法自然是依赖倒置，让司机依赖于抽象的车，而不是具体的车。

抽象车类：

 

@interface Car : NSObject
- (void)run;
@end

@implementation Car
- (void)run{
}
@end

司机类（记得司机类现在依赖的是抽象的车类，而不是具体的车类）：

#import "Car.h"

@interface Driver : NSObject
- (void)driveCar:(Car *)car;
@end

@implementation Driver
- (void)driveCar:(Car *)car{
    [car run];
}
@end

然后，就是我们的具体车类了。只要具体的车类继承自抽象车类，那么无论它是奔驰车，还是宝马车...我们的司机都可以开。

奔驰车：

@interface BenzCar : Car
@end

@implementation BenzCar
- (void)run{
    NSLog(@"奔驰车开动了");
}
@end

让我们的老王开开奔驰：

Driver *wang = [Driver new];
Car *benz = [BenzCar new];
[wang driveCar:benz];

宝马车：

@interface BMWCar : Car
@end

@implementation BenzCar
- (void)run{
    NSLog(@"宝马车开动了");
}
@end

让我们的老王也开开宝马：

Driver *wang = [Driver new];
Car *bmw = [BMWCar new];
[wang driveCar:bmw];

可见通过依赖倒置，现在无论新增多少种车，都不需要去修改司机类了。

优点

通过上面的例子，相信大家已经领略到在代码中使用依赖倒置原则的重要性了。总结一下依赖倒置原则的优点：

1. 减少类之间的耦合；
2. 降低并行开发引起的风险；
3. 提高代码的可读性和可维护性。

关于上面第2点需要强调一下，依赖倒置对于并行开发非常重要，可以说是必不可少。因为在多个人一起进行开发的时候，如果没有抽象类或者接口，你要等到别人完成具体的类才能进行开发，那么谈何并行开发？相反我们只需要先定好抽象类或者接口，大家就能开工了。所以在并行开发的时候一定要遵守依赖倒置原则。

实践

到这里相信大家已经知道依赖倒置原则是怎么回事了。也许这你是第一次听说依赖倒置原则，但是你很可能听说过面向接口编程。面向接口编程是依赖倒置原则的最佳实践，如果你熟悉面向接口编程，那么恭喜你已经掌握了依赖倒置原则的精髓。

如果还是觉得抽象，下面列举一些具体的点，让大家可以有法可依：

1. 每个类尽量都有接口或抽象类，或者两者具备。抽象是依赖倒置原则的基本要求；
2. 变量的表面类型尽量是接口或者抽象类；
3. 任何类都尽量不要从具体类派生。如果一个类是从具体类派生，那么这个类和它的非抽象的父类就形成强耦合；
4. 尽量不要覆写基类的方法。如果基类是一个抽象类，而且这个方法已经实现了，子类尽量不要覆写。类间的依赖是抽象，覆写了抽象方法，会影响依赖的稳定性；
5. 结合里氏替换原则使用。

注意

1. 依赖倒置原则的优点很难在小项目中体现出来，在大型项目才能感受到它的重要性；
2. 依赖倒置原则是6大设计原则中最难实现的；
3. 有些情况还是需要依赖于细节。