Python全栈学习笔记day 25：抽象类和接口类、多态、鸭子类型

栗子面试题：说明下接口类和抽象类：

1、python中没有接口类，有抽象类（abc模块中的metaclass = ABCMeta，@abstructmethod）
2、接口类和抽象类本质是做代码规范用的，希望在子类中实现和父类方法名字完全一样的方法
3、在java的角度上看是有区别的
    3.1、java本来就支持单继承 所以就有了抽象类
    3.2、java没有多继承 所以为了接口隔离原则，设计了接口这个概念，支持多继承了
4、python及支持单继承也支持多继承，所以对于接口类和抽象类的区别就不那么明显了，甚至在python中没有内置接口类

一、接口类

python中没有接口类  ： python中自带多继承 所以我们直接用class来实现了接口类
抽象类、接口类 ： 都是面向对象的开发规范 所有的接口类和抽象类都不能实例化
接口类 ： python原生不支持
抽象类 ： python原生支持的

栗子：

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

class Applepay:
    '''
    apple pay支付
    '''
    def pay(self,money):
        print('apple pay支付了%s元'%money)


def pay(payment,money):        统一支付入口
    '''
    支付函数，总体负责支付
    对应支付的对象和要支付的金额
    '''
    payment.pay(money)


p = Alipay()
pay(p,200)

开发中容易出现问题：

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

class Applepay:
    '''
    apple pay支付
    '''
    def pay(self,money):
        print('apple pay支付了%s元'%money)

class Wechatpay:
    def fuqian(self,money):
        '''
        实现了pay的功能，但是名字不一样
        '''
        print('微信支付了%s元'%money)

def pay(payment,money):
    '''
    支付函数，总体负责支付
    对应支付的对象和要支付的金额
    '''
    payment.pay(money)


p = Wechatpay()
pay(p,200)   #执行会报错

借用abc模块来实现接口，规范！  记住格式！

from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self,money):
        pass


class Wechatpay(Payment):
    def fuqian(self,money):
        print('微信支付了%s元'%money)

p = Wechatpay()      不调用就不会报错了

使用abc模块后的父类，再被继承的话，一样的代码也是要再子类中在打一遍，因为使用abc模块后的父类只是一个规定了，继承这个父类的子类，必须按照使用abc模块后的父类中的格式。

二、抽象类

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

 

三、多态

python 天生支持多态 
多态：不同的子类对象调用相同的父类方法，产生不同的执行结果。多态可以增加代码的灵活度

多态栗子：

class List():
    def __len__(self):pass
class Tuple():
    def __len__(self):pass

def len(obj):
    return obj.__len__()

l = Tuple()
len(l)

四、鸭子类型

鸭子类型：两个类刚好相似，并不产生父类的子类的兄弟关系

栗子：  list tuple 这种相似，是自己写代码的时候约束的，而不是通过父类约束的

优点 ： 松耦合 每个相似的类之间都没有影响
缺点 ： 太随意了,只能靠自觉