接口隔离原则

前言：
接口（抽象类）隔离原则要求在开发过程中设计接口时，使用多个专门的接口而不是使用单一的庞大臃肿的总接口，一个类对另一个类的依赖应该是建立在最小的接口上的。要做到接口与角色一一对应，不应该让一个接口承担多个角色，同时也不应该让一个角色由多个接口承担。这样设计出的暧昧在应对未来可能出现的变化时，才会更具有灵活性和可扩展性。接口就是代码对外部提供的规范和契约，通过多个接口分散定义多个单一的接口的好处是可以降低耦合，可以预防和降低因需求变更而带来的代码修改和故障几率，提高了系统的灵活性，可扩展性和降低了维护成本。

定义

• 客户端不应该依赖它不需要的接口
• 类间的依赖关系应该建立在最小的接口上

实例代码

抽象类 ABFactory 对外约定了提供原材料预处理（preProcess），半成品加工工序流程（processA1，processA2，processB1，processB2），产品包装（packaging）等方法。

from abc import ABCMeta, abstractmethond

class ABFactory(metaclass=ABCMeta):
    @abstarctmethod
    def preprocess(self, material):
        pass

    @abstractmethod
    def ProcessA1(self, material):
        pass

    @abstractmethod
    def ProcessA2(self, material):
        pass

    @abstractmethod
    def ProcessB1(self, material):
        pass

    @abstractmethod
    def ProcessB2(self, material):
        pass

    @abstractmethod
    def Package(self, product):
        pass

非抽象子类 FactoryA 实现抽象类 ABFactory 以生产产品A

class FactoryA(ABFactory):
    def preprocess(self, material):
        return material + ", 预处理"

    def ProcessA1(self, material):
        return material + "A1 工序"

    def ProcessA2(self, material):
        return material + "A2 工序"

    def ProcessB1(self, material):
        pass

    def ProcessB2(self, material):
        pass

    def Package(self, product):
        return product + "打包出售."


if __name__ == "__main__":
    factory = FactoryA()
    x = factory.preprocess("原材料")
    y = factory.ProcessA1(x)
    x = factory.ProcessA2(y)
    print(factory.Package(x))

非抽象子类 FactoryB 实现抽象类 ABFactory ，以生产产品B

class FactoryB(ABFactory):
    def preprocess(self, material):
        return material + ", 预处理"

    def ProcessA1(self, material):
        pass

    def ProcessA2(self, material):
        pass

    def ProcessB1(self, material):
        return material + "B1 工序 '

    def ProcessB2(self, material):
        return material + "B2 工序 '

    def Package(self, product):
        return product + "打包出售."


if __name__ == "__main__":
    factory = FactoryB()
    x = factory.preprocess("原材料")
    y = factory.ProcessB1(x)
    x = factory.ProcessB2(y)
    print(factory.Package(x))

上述代码中抽象类 ABFactory 对于类 FactoryA 和 FactoryB 来说，均不是最小接口，因为 ABFactory 中存在着类 FactoryA 和 FactoryB 中使用不到的方法。但是作为抽象类 ABFactory 实现类 FactoryA 和 FactoryB 又不得不去实现抽象父类中自身使用不到的方法，因为抽象父类中的抽象方法在子类中是必须重写的，这种设计显然太过于死板不够灵活。为了解决这个问题我们可以按照接口隔离原则将抽象父类 ABFactory 按照如下方式拆分：
实例代码：

from abc import ABCMeta, abstractmethod

class sub_factory(metaclass=ABCMeta):
    @abstractmethod
    def preprocess(self, material):
        pass

    @abstractmethod
    def Package(self, product):
        pass

class ABProcessA(metaclass=ABCMeta):
    @abstractmethod
    def ProcessA1(self, material):
        pass
    
    @abstractmethod
    def ProcessA2(self, material):
        pass

class ABProcessB(metaclass=ABCMeta):
    @abstarctmethod
    def ProcessB1(self, material):
        pass

    @abstarctmethod
    def ProcessB2(self, material):
        pass

非抽象子类 FactoryA 实现抽象类ABFactory 以生产产品A

class FactoryA(sub_factory, ABProcessA):
    def preprocess(self, material):
        return material + "，预处理"

    def ProcessA1(self, material):
        return material + "A1 工序"

    def ProcessA2(self, material):
        return material + "A2 工序"

    def Package(self, product):
        return product + "打包出售"

非抽象子类 FactoryB 实现抽象类ABFactory 以生产产品B

class FactoryB(sub_factory, ABProcessB):
    def preprocess(self, material):
        return material + "，预处理"

    def ProcessB1(self, material):
        return material + "A1 工序"

    def ProcessB2(self, material):
        return material + "A2 工序"

    def Package(self, product):
        return product + "打包出售

综上采用了接口隔离原则与否的两组代码示例的输出结果都是相同的，在采用了接口隔离原则的代码中，非抽象子类 FactoryA 和 FactoryB 中都不用实现其使用不到的方法。若以后需求发生变化时，即便更改了抽象类 ABProcessA 也不会对抽象类 ABProcessB 造成任何影响，这样设计的代码在应对未来可能发生的变化时，才更具有灵活性和可扩展性。