python--面向对象—接口

开放封闭原则
依赖导致原则
接口隔离原则
继承多态
抽象类和接口类
    编程思想：为子类做规范
 归一化设计：几个类都实现了相同的方法
 抽象类：最好单继承，且可以简单的实现功能
 接口类：可以多继承，且最好不实现具体功能
 实现接口类和抽象类的语法

 from abc import abstractclassmethod,ABCMeta
 class Xx(metaclass=ABCMeta):
   @abstractclassmethod
   def Yy():pass

钻石继承问题

    python的新式类，和经典类在继承顺序上的不同
 新式类：广度优先
    查看继承顺序  子类名.mro()
 经典类：深度优先
新式类和经典类的区别：定义阶段，经典类有object新式类不用，子类执行父类中的同名方法上，继承问题
多态
    python天生支持多态 

接口类

class Applepay:
     def payment(self,money):
  print('苹果 支付了%d元'%money)
class Alipay:
     def payment(self,money):
  print('支付宝 支付了%d元'%money)
def payment(pay_obj,money):
 pay_obj.payment(money)
apple=Applepay()
ali=Alipay()
payment(apple,100)
payment(ali,100)

归一化设计

from abc import abstractmethod,ABCMeta
class Payment(metaclass=ABCMeta): #抽象类/接口类
      @abstractmethod            #给接口类加装饰器
   def payment(self,money):pass
class Applepay(Payment):
     def payment(self,money):
     print('苹果 支付了%d元'%money)
  def payment(pay_obj,money):
     pay_obj.payment(money)
class Alipay(Payment):
     def payment(self,money):
      print('支付宝 支付了%d元'%money)
  def payment(pay_obj,money):
     pay_obj.payment(money)
class We(Payment):
     def fuqian(self,money)
  print('微信支付了%d元'%money)
apple=Applepay()
ali=Alipay()
we=We()
payment(apple,100)
payment(ali,100)
payment(we,100)

这样的话，如果子类里面没有要用的方法的话，在实例化对象的时候就会报错
如果有这个方法的话，实例化和使用的时候都不会报错。
主要是用来限制和规定某一类必须要用到某个方法
归一化设计：
1.接口类 不实现具体的方法，并且可以多继承
2.实现具体内容，做一些基础实现，并且不推荐多继承

多继承

from abc import abstractclassmethod,ABCMeta
class Fly_Animal(metaclass=ABCMeta):
    @abstractclassmethod                   #限制必须用fly方法
    def fly(self):
        print('飞')
class Walk_Animal:
    def walk(self):
        print('走')
class Swim_Animal:
    def swim(self):
        print('游泳')
class Tiger(Walk_Animal):
       def si(self):
           pass
class Tiane(Walk_Animal,Swim_Animal,Fly_Animal):   #多继承
    def fly(self):
        super().fly()
class Qingwa(Walk_Animal,Swim_Animal):
    def fd(self):
        pass
tiane=Tiane()
tiane.fly()

多继承限制

class D:
    def test(self):
        print('D')
class B(D):                    #B要是没有找D
    def test(self):
        print('B')
class C(D):
    def test(self):
        print('C')
class A(B,C):
    pass
    # def test(self):          #如果没有就去找B，B和D都没有再C
    #     print('A')
a=A()
a.test()

深度优先↑  新式类广度优先
所有类继承的基类object新式类 python3中不用强制继承
.mro()看顺序