前言

自己在写一些工程的时候，发现各种模块要重写很多次，感觉自己“思路不清晰”…毕竟自己不是科班出身，实际干起活就感觉差点东西。

后来在网上学习的时候，发现了一些有关“面向对象编程的设计原则”的文章。小看一眼，感觉灵光一现，好东西！

然而网上大多数教程都是用Java来写的，这里就使用python来重写一下，顺便理理自己的思路。

定义

这里就照搬了：

1、上层模块不应该依赖底层模块，它们都应该依赖于抽象。

2、抽象不应该依赖于细节，细节应该依赖于抽象。

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类的变化，则说名B类依赖于A类。

浅显点的理解

按照上面的定义，抽象类应该是最大的，所有属性或者实例的变更，都不能去影响这个抽象类。写代码的时候，各种类应该由抽象类派生出来，然后依照抽象类对其进行再加工或者是继承之类的。

一个案例

先看把目光看向一个披萨店，按照我们在现实中的思维来想：先有披萨店，然后才有顾客来买披萨，然后由披萨店产出了披萨，大概如下图所示：

图中解释的会有些抽象，具体来说是这样：

因为是由披萨店产出的披萨，披萨归属于披萨店所有，也就是说披萨是披萨店的一部分。那么按照“假设A类的变化引起了B类的变化，则说名B类依赖于A类”的原则，披萨的变动就是披萨店的变动。

这种设计放在编程中就比较戏剧性了，负责设计披萨的程序员新增一种披萨，结果披萨店要因此装修改动一番？！

因此就出现了“依赖倒置原则”，在本案例中，如果按照本原则进行设计，呈现的效果会如下图所示：

按照定义里的话来解释，披萨是一种“抽象”，各种各样的披萨由该抽象类衍生。比如定义了个抽象披萨类，有两个具体属性：下层面饼，上层食料。其他的披萨，比如芝士披萨，海鲜披萨，都需要实现下层面饼，和上层食料各是什么样的。

而披萨店这个类，实现一个出“抽象”披萨的方法，这样一来由披萨设计程序员设计的任何披萨类，都能直接由披萨店产出，而无需对披萨店进行任何改动。

Python代码实现

如果按照现实思路来设计代码的话，代码如下所示

class PizzaStore:
    def __init__(self):
        # 按照我们的想法先设计一个披萨店
        print('披萨店构建完成咯')
        self.store = []  # 假设这是一个餐车吧，做完餐就加入这个列表

    def _make_CheesePizza(self):
        # 私有方法，制作一个CheesePizza，不让外部调用
        self.store.append(CheesePizza())

    def order_CheesePizza(self):
        self._make_CheesePizza()  # 接到点单，启动做披萨函数，餐车披萨+1
        return self.store.pop()  # 然后从餐车弹出披萨给顾客

    def _make_SeafoodPizza(self):
        # 可以看出每新增一个披萨种类，都要设计一组新函数
        self.store.append(SeafoodPizza())

    def order_SeafoodPizza(self):
        self._make_SeafoodPizza()
        return self.store.pop()


class CheesePizza:
    def __init__(self):
        self.name = '芝士披萨'
        print('做出了个 芝士披萨')


class SeafoodPizza:
    def __init__(self):
        self.name = '海鲜披萨'
        print('做出了个 海鲜披萨')


if __name__ == '__main__':
    # 先出现个披萨店
    pizza_store = PizzaStore()
    pizza = pizza_store.order_CheesePizza()
    print(f'拿到手的是{pizza.name}')
    pizza = pizza_store.order_SeafoodPizza()
    print(f'拿到手的是{pizza.name}')

上述代码运行结果如下

披萨店构建完成咯
做出了个 芝士披萨
拿到手的是芝士披萨
做出了个 海鲜披萨
拿到手的是海鲜披萨

很显然这样设计披萨店实在是太繁琐了，维护成本炸裂。所以运用依赖倒置原则：

from abc import ABC, abstractmethod  #


class Pizza(ABC):
    # Pizza继承了ABC(Abstract Class)，成为了抽象类，任何继承该类的子类都应该实现对应的方法
    def __init__(self):
        pass

    @abstractmethod
    def get_name(self) -> str:
        # 这里就简单点，任何披萨都应该有一个名字，将其返回
        pass


class CheesePizza(Pizza):
    def __init__(self):
        super().__init__()
        self.name = '芝士披萨'
        print(f'做出了个 {self.name}')

    def get_name(self) -> str:
        return self.name


class SeafoodPizza(Pizza):
    def __init__(self):
        super().__init__()
        self.name = '海鲜披萨'
        print(f'做出了个 {self.name}')

    def get_name(self) -> str:
        return self.name


class PizzaStore:
    def __init__(self, menu):
        # 先有了披萨，那根据披萨这个抽象类设计整个PizzaStore的架构
        # 由于不能依赖具体的披萨的披萨架构，因此披萨店就根据一份菜单来进行披萨的生产，menu是一个字典
        print('披萨店构建完成咯')
        self.menu = menu

    def _make_pizza(self, pizza_name):
        # 私有方法，按照菜单，制作一个Pizza
        return self.menu[pizza_name]()  # 这里加括号是要将其实例化

    def order_pizza(self, pizza_name):
        return self._make_pizza(pizza_name)


if __name__ == '__main__':
    # 根据现有的披萨设计一份菜单
    my_menu = {'芝士披萨': CheesePizza, '海鲜披萨': SeafoodPizza}
    # 出现披萨店，披萨店的运营需要一份菜单
    pizza_store = PizzaStore(my_menu)

    # 开始点单
    pizza = pizza_store.order_pizza('海鲜披萨')
    print(f'拿到手的是{pizza.get_name()}')

上述代码运行后的结果就是

披萨店构建完成咯
做出了个 海鲜披萨
拿到手的是海鲜披萨

显然可维护性高了不少。

参考

《设计模式》——依赖倒置原则 - 简书

六大设计原则之依赖倒置原则（DIP） - 简书