python学习笔记 day25 接口类的多继承 VS 抽象类单继承

1. 接口隔离原则：

为实现不同的功能需要实现多个专门的接口类，不要去实现一个单一的总接口；

比如下面这个例子，就是子类需要多继承，需要使用多个功能不同的接口类来规范子类的方法：

from abc import abstractmethod,ABCMeta
class Walk_Animal(metaclass=ABCMeta): # 父类必须继承元类
    @abstractmethod  # 用于规范子类的方法，必须使用装饰器
    def walk(self):  # 需要继承Walk_Animal接口类的子类必须实现walk()方法
        pass         # 一般接口类只是用来规范子类的代码，里面的方法不实现

class Swim_Animal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self): # 需要继承Swim_Animal这个接口类的子类，必须实现swim()方法
        pass
class Fly_Animal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):
        pass

class Tiger(Walk_Animal,Swim_Animal): # Tiger类继承了两个接口类，必须实现这两个接口类的所有方法
    def walk(self):  # walk()方法必须要实现，因为Tiger类继承了Walk_Animal接口类，必须实现里面的walk()方法
        print("老虎在走...")
    def swim(self):
        print("老虎会游泳...")
class Swan(Walk_Animal,Swim_Animal,Fly_Animal):
    def walk(self):
        print("天鹅会走...")
    def swim(self):
        print("天鹅会游泳")
    def fly(self):
        print("天鹅会飞")
class Fish(Swim_Animal,Fly_Animal):
    def swim(self):
        print("鱼会游")
    def fly(self):
        print("鱼会飞...嘻嘻我编的")
    def func(self):
        print("在子类中当然可以实现其他的方法，最基本的就是实现所继承的接口类中的所有方法")
tiger=Tiger()  # 现在只是对子类进行了实例化，不用调用方法，也可以检测出子类实现的是否规范，就是子类中必须实现所继承的接口类中的所有方法
swan=Swan()
fish=Fish()

为实现不同的功能，需要继承不同的接口类，但是子类必须实现所继承的接口类中的所有方法，接口类就是用来规范子类的方法实现；

接口类---->是一种面向对象的开发规范，一般在多继承时使用接口类，子类为了实现不同的功能需要继承多个接口类；一般在接口类的方法中不实现，只是告诉子类需要实现我父类（接口类）中的所有方法，进行了一种约束；

 

抽象类也是一种面向对象的开发规范，用来约束子类，子类中继承抽象类，必须实现抽象类的所有方法，而且在抽象类中的方法可以有代码的实现；

from abc import abstractmethod,ABCMeta
class All_File(metaclass=ABCMeta):
    @abstractmethod
    def read(self):
        print("抽象类中的方法可以有代码的实现，因为子类单继承这个抽象类，一般继承这个抽象类的很多子类实现的方法功能一般相同")

    @abstractmethod
    def write(self):
        print("继承这个抽象类的很多子类，必须继承这个方法，而且他们所继承的方法完成的功能大致相同")

class Txt(All_File): # 继承All_File这个抽象类，必须实现All_File中的所有方法
    def read(self):
        All_File.read(self)  # 在子类定义了一个跟父类（抽象类）一样的重名方法（这是抽象类对子类的约束，必须在子类中实现抽象类的所有方法）
                             # 如果调用子类对象的read()方法肯定是执行子类的read()但是如果也想执行父类的read()方法，也就是扩展父类的read()可以这样父类名.方法(self,其他参数)
        # super().read()  # 相当于All_file(self,其他参数)，执行父类中的该重名方法
        print("在子类中可以写专属于这个类的方法")
    def write(self):
        print("子类必须实现所继承的抽象类中的所有方法")
class Process(All_File):
    def read(self):   # 必须实现read()方法
        print("Process子类继承抽象类All_File，必须实现抽象类中的所有方法")
    def write(self):  # 必须实现write()方法
        super().write() # 实现父类抽象类中的该write()方法
        print("可以实现自己的方法")
txt=Txt() # 实例化子类Txt
process=Process()
txt.read()
print("***********分割线****************")
process.write()

运行结果：

总结：

一般情况下，单继承实现的功能都是一样的，所以在抽象类中可以有一些简单的基础实现；

多继承的情况由于功能比较复杂，不易抽象出相同的功能，所以接口类中的方法代码不要实现；