python之路 -- 继承接口和多态

继承

接口类和抽象类

什么时候用接口类和抽象类

• 当几个子类的父类，有相同的功能需要被实现时，就用抽象类
• 当几个子类有相同的功能，但是实现各不相同的时候，使用接口类

什么是接口类 （在python里默认是没有的）

• 约束继承接口类的子类必须实现被abstractmethod装饰的方法
• 在接口类中不能做实现
• 接口类不能被实例化

接口类和抽象类在java里面的区别

• 接口类支持多继承
• 抽象类只支持单继承

抽象类（在python里默认有的）

• 父类的方法，子类必须实现
• 抽象类不能被实例化
• 抽象类的方法，可以被简单实现

开发原则：

抽象类最好不要用多继承，而接口类可以

经典类和新式类(python2.7区分,python3.6只有新式类)

1. 新式类：广度优先
2. 经典类：深度优先

多继承

模拟支付接口

from abc import ABCMeta,abstractmethod
class Payment(metaclass = ABCMeta): # 元类
    @abstractmethod
    def pay(self,moeny):pass   # 接口
class Applepay(Payment): # class Applepay(object)等于class Applepay: 默认继承object
    def pay(self,money):
        print('apple pay 支付了%s'% money)
class Alipay(Payment):
    def pay(self,money):
        print('支付宝 支付了%s'% money)
class Wechatpay(Payment):   # 不调用就报错了
    def fuqian(self, money):
        print('微信 支付了%s' % money)
    def pay(self,moeny):pass

def payment(pay_obj,money): # 伪接口
    pay_obj.pay(money)
apple1 = Applepay()
# apple1.pay(200)
ali1 = Alipay()
# ali1.pay(200)
payment(ali1,200)
wechatpay1 = Wechatpay

接口隔离

from abc import ABCMeta,abstractmethod
class Fly_Animal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self): pass
class Swim_Animal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self): pass
class Walk_Animal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self): pass
class Dog(Swim_Animal,Walk_Animal):
    def swim(self):
        print('dog is swimming')
    def walk(self):
        print('dog is walking')
class Parrot(Fly_Animal,Swim_Animal):
    pass
d = Dog()
# p = Parrot()

抽象类

from abc import ABCMeta,abstractmethod
class Animal(metaclass = ABCMeta):
    @abstractmethod
    def eat(self):
        print('打开粮食的袋子')
        print('放一个吃饭的碗')
        print('把粮食倒在碗里')

    @abstractmethod
    def sleep(self):
        pass
class Dog(Animal):
    def eat(self):
        print('dog is eating')
    def sleep(self):
        print('dog is sleeping')

新式类：广度优先

class A:
    def test(self):
        print('from A')
class B(A):pass
    # def test(self):
    #     print('from B')
class C(A):
    def test(self):
        print('from C')
class E(B):pass
    # def test(self):
    #     print('from E')
class F(C):
    def test(self):
        print('from F')
class D(E,F):pass

D().test()


print(D.mro())      # 查看广度优先的优先级

python2.7中的深度查找和广度查找

经典类：深度查找

# python2.7
# 经典类：深度查找
class A:
    def test(self):
        print('from A')
class B(A):pass
    # def test(self):
    #     print('from B')
class C(A):
    def test(self):
        print('from C')
class E(B):pass
    # def test(self):
    #     print('from E')
class F(C):
    def test(self):
        print('from F')
class D(E,F):pass

D().test()

新式类：广度查找

# 新式类：广度查找
class A(object):    # python2.7中继承object类，就是新式类，不继承就是经典类
    def test(self):
        print('from A')
class B(A):pass
    # def test(self):
    #     print('from B')
class C(A):
    def test(self):
        print('from C')
class E(B):pass
    # def test(self):
    #     print('from E')
class F(C):
    def test(self):
        print('from F')
class D(E,F):pass

D().test()

多态

python 自带多态：

1. 同一类事物的不同状态
2. 操作的时候不需要关系这个对象的数据类型，只要用就行了

来自为知笔记(Wiz)