笔记;python基础之面向对象——继承：接口类&抽象类

一、接口类
书本推荐：《设计模式》、《算法导论》
设计模式—— 接口：来源于Java,总结了不同类型的开发模式.
接口类 ： python原生不支持
抽象类 ： python原生支持的

from abc import abstractmethod,ABCMeta
class Payment(metaclass=ABCMeta):  # 元类 默认的元类 type，这里的Payment就是一个规范，可以帮助在写代码的过程中发现问题，而不是到最后调用时才发现
    @abstractmethod  #装饰器
    def pay(self,money):pass   # 没有实现这个方法
# 规范 ：被称为接口类或者抽象类都可以（对子类的规范）
# 接口类 默认多继承，接口类中的所有的方法都必须不能实现 （函数pass）—— java
# 抽象类 不支持多继承，抽象类中方法可以有一些代码的实现 —— java
class Wechat(Payment):
    def pay(self,money):
        print('已经用微信支付了%s元'%money)

class Alipay(Payment):
    def pay(self,money):
        print('已经用支付宝支付了%s元' % money)

class Applepay(Payment):
    def pay(self,money):
        print('已经用applepay支付了%s元' % money)

def pay(pay_obj,money):# 统一支付入口
    pay_obj.pay(money)

# wechat = Wechat()
# ali = Alipay()
app = Applepay()
# wechat.pay(100)
# ali.pay(200)
pay(app,200)→已经用applepay支付了200元

接口类的多继承
接口类 刚好满足接口隔离原则 面向对象开发的思想 规范
接口隔离原则：使用多个专门的接口，而不适用单一的总接口，即客户端不应该依赖那些不需要的接口。

# tiger 走路 游泳
# swan 走路 游泳 飞
# oldying 走路 飞
from abc import abstractmethod,ABCMeta
class Swim_Animal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self):pass

class Walk_Animal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):pass

class Fly_Animal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):pass

class Tiger(Walk_Animal,Swim_Animal):
    def walk(self):
        pass
    def swim(self):
        pass
class OldYing(Fly_Animal,Walk_Animal):pass
class Swan(Swim_Animal,Walk_Animal,Fly_Animal):pass

二、抽象类
如果说类是从一堆对象中抽取相同的内容而来，那抽象类就是从一堆类中抽取相同的内容而来，内容包括数据属性和函数属性。
系统中一切皆文件。

import abc #利用abc模块实现抽象类

class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        with open('filaname') as f:
            pass

    @abc.abstractmethod #定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')
    def write(self):
        print('文本数据的读取方法')

class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')

wenbenwenjian=Txt()
yingpanwenjian=Sata()
jinchengwenjian=Process()

#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

#输出：
文本数据的读取方法
硬盘数据的读取方法
进程数据的读取方法
file
file
file

抽象类 ： 规范

• 一般情况下 单继承 能实现的功能都是一样的，所以在父类中可以有一些简单的基础实现
• 多继承的情况 由于功能比较复杂，所以不容易抽象出相同的功能的具体实现写在父类中

抽象类还是接口类 ： 面向对象的开发规范 所有的接口类和抽象类都不能实例化

java：

• java里的所有类的继承都是单继承,所以抽象类完美的解决了单继承需求中的规范问题
• 但对于多继承的需求，由于java本身语法的不支持，所以创建了接口Interface这个概念来解决多继承的规范问题

python
python中没有接口类 ：

• python中自带多继承 所以我们直接用class来实现了接口类
• python中支持抽象类 ： 一般情况下 单继承 不能实例化 且可以实现python代码