面向对象开发中非常重要的一个原则，在大型的项目的开发中，通常都会采用分层的方式进行开发，即上层调用下层，上层依赖于下层，这样就是产生上层对下层的依赖。当下层设计产生变动时，上层代码也需要跟着做调整，这样会导致模块的复用性降低，这样大大的提高了开发成本。

例如网络层

面向对象编程中最大的优势在于起方便的对问题进行抽象，一般起概况下抽象层很少产生变化。依赖倒置原则的定义就是：高层模块不应该依赖底层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。

由于都对接口进行依赖，减少了类之间的耦合。
封闭了对类实现的修改，增强了程序的稳定性。
对开发过程来说，依赖倒置的原则核心是面向接口开发，减少了并行开发的依赖与风险。
提高代码的可读性和可复用性。

通过代码可以很好的理解依赖导致原则。
以顾客到商店购物为例子

class Customer{ //顾客
    func shopping(count : Int, store : FoodStore){
        print("用户购物")
        store.sell(count: count)

    }
}

class FoodStore { //商店
    func sell(count : Int)  {
        print("食品商店出售：\(count)份食品")
        
    }
}

let customer = Customer()
customer.shopping(count: 3, store: FoodStore())

顾客在普通商店购买，所以这里顾客跟商店之间存在耦合关系

但是现在新增一个需求，如果新增一个商店，例如百货商店，实现基本上课基本商店是一样的

class DepartmentStore{

    func sell(count : Int)  {
          print("百货商店出售：\(count)份百货")
          
      }
}

如果采用原来的代码，由Customer调用DeparmentStore，由于原来Customer和FoodSotre是耦合的，所以如果要调用DeparmentStore，那必须要对原来的Customer进行重构。

所以我们应该把通用的方法抽象出来

protocol StorePotocol{
    
    func sell(count : Int)
}

然后其他的代码重构后就变成了这个样子

class FoodStore : StorePotocol{ //商店
    func sell(count : Int)  {
        print("食品商店出售：\(count)份食品")
        
    }
}

class DepartmentStore : StorePotocol{

    func sell(count : Int)  {
          print("百货商店出售：\(count)份百货")
          
      }
}

class Customer{ //顾客
    func shopping(count : Int, store : StorePotocol){
        print("用户购物")
        store.sell(count: count)

    }
}

let customer = Customer()
customer.shopping(count: 3, store: FoodStore())
customer.shopping(count: 5, store: DepartmentStore())