面向对象补充

接口类

c# 、java 都是面向对象编程的语言。在开发的过程中，有一种设计模式叫做接口。

• 接口类：python原生不支持
• 抽象类：python原生支持的

from abc import abstractmethod,ABCMeta

class Payment(metaclas=ABCMeta): # 元类，默认的元类，type
    @abstractmethod
    def pay(self,money):pass #没有实现这个方法

规范：接口类或者抽象类都可以

接口类：支持多继承，接口类中的所有方法都必须不能实现--Java

抽象类：不支持多继承，抽象类中方法可以有一些代码的实现--Java

class Wechat(Payment):
    def pay(self,money):
        print(f'已经用微信支付了{money}元')
        
class Alipay(Payment):
    def pay(self,money):
        print(f'已经用支付宝支付了{money}元')
        
class Applepay(Payment):
    def pay(self,money):
        print(f'已经使用applepay支付了{money}元')

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

    

# wechat = Wechat()
alipay = Alipay()
# app = Applepay()
# wechat.pay(100)
# alipay.pay(200)
p = Payment()

接口类的多继承

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(metclass = 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

#接口类 刚好满足接口隔离原则，面向对象开发的思想  规范

抽象类

python中一切皆文件

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

class All_File(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无序实现功能
    def read(self):
        '''子类必须实现read功能'''
        pass
    
    @abstractmethod # 定义抽象方法，无需实现功能
    def write(self):
        '''子类必须实现write功能'''
        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(jinchengewenjian.all_type)

抽象类 是一种开发规范。

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

多继承的情况：由于功能比较复杂，所以不容易抽象出相同的功能的具体实现写在父类中

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

扩展

Java：Java里的所有类的继承都是单继承，所以抽象类完美的解决了单继承需求中的规范问题。

相对于多继承的需求，由于Java本身语法的不支持，所以创建了接口Interface这个概念来解决多继承的规范问题。

python：python中没有接口类。python中自带多继承，所以我们直接用class来实现了接口类。

python中支持抽象类：一般情况下 单继承 不能实例化。python可以代码实现

多态

什么是多态？

python是动态强类型的语言。崇尚鸭子类型。

优点：松耦合，每个相似的类之间都没有影响。

缺点：太随意了，只能靠自觉

类和对象的绑定方法和非绑定方法

@property

让类内部的函数方法变成属性

@bmi.setter 和 @bmi.deleter

让这个函数方法 bmi() 可以进行属性一样的修改和删除，
所以 @bmi.setter 和 @bmi.deleter 装饰的函数方法名必须是property装饰的函数方法名bmi()，而不可以是随意定义的函数名字，如果换成其他名字会报错，显示的就是该属性（实际是个函数）无法进行修改或删除。

随意定义函数方法名是 类属性方法使用property 可以拥有的，把这个记混了。