设计原则——依赖倒置原则

1.全称

• Dependence Inversion Principle
• 缩写为：DIP

2.解释

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

3.接口隔离原则的实现方法

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

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

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

• 4.使用继承时尽量遵循里氏替换原则。

• 5.依赖倒置中的面向抽象类编程，核心思想就是多态，python语言，天生就是多态，所有类在实例化时，才会根据其属性被创建为具体的对象；而在Java、Go等语言中，类一旦被定义就被创建成一个具体的对象，所以在python中依赖倒置原则很常见，也很容易实现

1.场景：张三开车

• 1.张三开宝马
• 2.李四开奔驰
• 3.张三开奔驰

class Car:
    def __init__(self, branch):
        self.branch = branch

    def run(self):
        print(f"{self.branch}汽车正在柏油路面疾驰")


class Driver:
    def __init__(self, name, car: Car):
        self.name = name
        self.car = car

    def drive(self):
        print(f"{self.name}开着{self.car.branch}")
        self.car.run()


if __name__ == '__main__':
    c = Car("宝马")
    d = Driver("张三")
    d.drive(c)

    b = Car("奔驰")
    d.drive(b)

    d = Driver("李四")
    d.drive(c)

张三开着宝马
宝马汽车正在柏油路面疾驰
张三开着奔驰
奔驰汽车正在柏油路面疾驰
李四开着宝马
宝马汽车正在柏油路面疾驰

2.Go语言实现（静态语言）

• 换个人就要增加个类
• 换个车就要增加个类

package main

import (
	"fmt"
)


// ----------------------------抽象层----------------------------
type Car interface {
	Run()
}

type Driver interface {
	Drive(car Car)
}

// ----------------------------实现层----------------------------
// 如果新来一个司机，只需要增加一个司机实体（不会对原有类进行修改）
// 如果新增一个品牌的车，只需要增加一个品牌实体（不会对原有类进行修改）
type FtCar struct {}

func (f *FtCar) Run() {
	fmt.Println("丰田车开起来了...")
}

type BmCar struct {}

func (f *BmCar) Run() {
	fmt.Println("宝马车开起来了...")
}

type BzCar struct {}

func (f *BzCar) Run() {
	fmt.Println("奔驰车开起来了...")
}

type Zh3 struct {}

func (z *Zh3) Drive(car Car) {
	car.Run()
}


func main()  {
	// ----------------------------业务层----------------------------
	// 1.new一个司机张三
	zs := &Zh3{}
	// 2.new一个奔驰汽车
	car := &BzCar{}
	// 3.把汽车交给张三驾驶
	zs.Drive(car)
}

• 多态：是静态语言和动态语言很大的一个区别

4.依赖、倒置原则的作用

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

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

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

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