面向对象3：三大特性，继承，封装，多态，类的约束，super

python面向对象的三大特性

继承：子类可以继承父类的除了私有属性外的其他所有内容。

封装：把很多数据封装到对象中，把功能封装到一个代码块，函数，对象，模块

　　对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。

多态：同一个对象，多种形态，例如a = 10 ,a = "abc",变量a开始是整型，又变成了字符串

类的约束

鸭子类型

看着像鸭子，就是鸭子

两个类有同名的方法，属性，虽然两个类没有实际关系，但是他们遵循了一个标准

1.同一标准，减少代码词汇量

2.A和B没有任何耦合性，但是可以产生关系，A的对象会“使用”B的方法

主动抛出错误

class Payment:
    """
    此类什么都不做，就是制定一个标准，谁继承我，必须定义我里面的方法。
    """
    def pay(self,money):
        raise Exception("你没有实现pay方法")

class QQpay(Payment):
    def pay(self,money):
        print('使用qq支付%s元' % money)

class Alipay(Payment):
    def pay(self,money):
        print('使用阿里支付%s元' % money)

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


def pay(obj,money):
    obj.pay(money)

a = Alipay()
b = QQpay()
c = Wechatpay()
pay(a,100)
pay(b,200)
pay(c,300)

引入抽象类

from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):#抽象类接口类，规范和约束，metaclass指定的是一个元类
    @abstractmethod
    def pay(self):pass  # 抽象方法

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

class QQpay(Payment):
    def pay(self,money):
        print('使用qq支付了%s元'%money)

class Wechatpay(Payment):
    # def pay(self,money):
    #     print('使用微信支付了%s元'%money)
    def recharge(self):pass

def pay(a,money):
    a.pay(money)

a = Alipay()
a.pay(100)
pay(a,100)    # 归一化设计：不管是哪一个类的对象，都调用同一个函数去完成相似的功能
q = QQpay()
q.pay(100)
pay(q,100)
w = Wechatpay()
pay(w,100)   # 到用的时候才会报错


# 抽象类和接口类做的事情 ：建立规范
# 制定一个类的metaclass是ABCMeta，
# 那么这个类就变成了一个抽象类(接口类)
# 这个类的主要功能就是建立一个规范

super()深入了解

super，严格按照类的继承顺序执行

class A:
    def f1(self):
        print('in A f1')
    def f2(self):
        print('in A f2')

class B(A):
    def f1(self):
        super().f2()　　#跳过本类
        print('in B f1')
    def f2(self):
        print('in B f2')

obj = B()
obj.f1()

例2：

class A:
    def f1(self):
        print('in A')

class B(A):
    def f1(self):
        super().f1()
        print('in B')

class C(A):
    def f1(self):
        print('in C')

class D(B,C):
    def f1(self):
        super().f1()
        print('in D f1')

print(D.mro())
obj = D()
obj.f1()

# [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>,
# <class '__main__.A'>, <class 'object'>]
# in C
# in B
# in D f1

例3：

class A:
    def f1(self):
        print('in A')

class B(A):
    def f1(self):
        super().f1()
        print('in B')

class C(A):
    def f1(self):
        print('in C')

class D(B,C):
    def f1(self):
        super(B,self).f1()
        print('in D f1')

print(D.mro())
obj = D()
obj.f1()

# [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, 
# <class '__main__.A'>, <class 'object'>]
# in C
# in D f1

 

 

 

 

 

 

面向对象