面向对象（接口和抽象）

抽象类和接口类
    编程思想
    归一化设计
    实现接口类和抽象类的语法：
钻石继承问题--重点
    python的新式类和经典类在继承顺序上的不同
多态
    python天生支持多态



接口类
思想：归一化设计

from abc import abstractmethod,ABCMeta
class Payment(metaclass=ABCMeta):#接口类/抽象类,子类的规范（约束子类必须要有这个里的方法，不然就抛异常）
    @abstractmethod # 加了一个装饰器
    def payment(self,money):
        raise NotImplemented
class Applepay(Payment):
    def payment(self,money):
        print("apple 支付了 %d元"%money)

class Alipay(Payment):
    def payment(self,money):
        print("支付宝 支付了 %d元"%money)

class Wechatpay(Payment):
    def huaqian(self,money):
        print("微信 支付了 %d元"%money)

def payment(pay_obj,money):
    pay_obj.payment(money)

apple = Applepay()
ali = Alipay()
payment(apple,200)
payment(ali,100)
wechat = Wechatpay()
wechat.payment(wechat,100)
#因为他没有payment方法，所以会报错
    #TypeError: Can't instantiate abstract class Wechatpay with abstract methods payment

 

python中：
    接口类---不实现具体的方法，并且可以多继承
    抽象类---可以做一些基础实现，并且不推荐多继承

    在抽象类中，我们可以对一些抽象方法做出基础实现；
    而在接口类中，任何方法都只是一种规范，具体的功能需要子类实现


抽象类---抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化
　　如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。

from abc import abstractmethod,ABCMeta
class Foo(metaclass=ABCMeta):  #抽象类
    @abstractmethod
    def read(self): #抽象类去实现了方法
        f = open()
        f.read()
        f.close()
    def write(self):
        f = open()
        f.write()
        f.close()
class File(Foo):
    def read(self):
        super().read()
    def write(self):
        super().write()

class Disk(Foo):
    def read(self):
        super().read()
    def write(self):
        super().write()

 

抽象类和接口类
编程思想：为子类做规范
    归一化设计：几个类都实现了相同的方法
    抽象类：最好单继承，且可以简单的实现功能
    接口类：最好多继承，且最好不实现具体功能
    实现接口类和抽象类的语法：
    from abc import abstractmethod,ABCMeta
    class 父类(metaclass=ABCMeta):
        @abstractmethod
         def 方法
开放封闭原则：扩展是开放的，修改是封闭的
依赖倒置原则：
    高层模块不应该依赖低层模块，二者都应该依赖其抽象；
    抽象不应该应该依赖细节；细节应该依赖抽象。
    换言之，要针对接口编程，而不是针对实现编程
接口隔离原则：
    使用多个专门的接口，而不使用单一的总接口。即客户端不应该依赖那些不需要的接口。


多继承--一般情况下不用

class Walk_Animal:
    def walk(self):
        pass

class Swim_Animal:
    def swim(self):
        pass

class Fly_Animal:
    def fly(self):
        pass

class Tiger(Walk_Animal):
    def walk(self):
        print("tiger is walking")

class Forg(Walk_Animal,Swim_Animal):
    def walk(self):
        pass
    def swim(self):
        pass

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

 

 经典类和新式类的区别：
    定义顺序
    子类执行父类中的同名方法
    继承问题

python2里有经典类和新式类之分
    　经典类--深度优先

　　 新式类--广度优先     子类名.mro---查看子类继承的父类的顺序

在python3中，object是所有类的基类  

class A:#经典类
    pass
class B(object):#新式类
    pass

 

钻石继承

class F:
    def test(self):
        print("F")

class E(F):
    pass
    def test(self):
        print("E")

class D(F):
    pass
    def test(self):
        print("D")

class C(E):
    pass
    def test(self):
        print("C")

class B(D):
    pass
    def test(self):
        print("B")

class A(B,C):
    pass
    def test(self):
        print("A")

a = A()
a.test()
A-B-D-C-E-F

 

class D():
    pass
    def test(self):
        print("D")

class C():
    pass
    def test(self):
        print("C")

class B(D):
    pass
    def test(self):
        print("B")

class A(B,C):
    pass
    def test(self):
        print("A")

a = A()
a.test()

#这里有个小发现，这个的继承是A-B/C，B-D，C没有父类
#这种情况下，A中没有时,先找B,B中没有时先找D，D里边没有的时候，就找C

 

多态---各类数据类型都支持
　　多态指的是一类事物有多种形态