面向对象（四）+异常处理

• 封装，多态

• 类的约束

• super()

• 异常处理

封装，多态

封装：即类似于函数，封装功能

多态：Python默认支持多态，比如变量a可以给他str，可以dict，可以object，java中就不行

鸭子类型：看着像是鸭子，其实就是鸭子

python中处处都有鸭子类型

#鸭子类型
class A:
    def add(self):
        print('增加')

    def delete(self):
        print('删除')

class B:
    def add(self):
        print('这也是增加')

    def delete(self):
        print('这也是删除')

# str，list，tuple都有index方法，就互为鸭子类型
#
# 两个类虽然没有关系，但是隐形中遵循了一个标准
#     1.统一标准，减少词汇
#     2.A和B没有耦合性，某种意义上有统一了标准

　　

类的约束

# 比如老板让小明，做一个微信支付功能，在做一个支付宝支付功能
class Alipay:
    def pay(self,money):
        print(f'您用支付宝支付了{money}元')

class Wechatpay:
    def pay(self,money):
        print(f'您用微信支付了{money}元')

obj=Alipay()
obj.pay(100)
obj1=Wechatpay()
obj1.pay(200)

# 老板说这样实例化太麻烦，统一接口
def pay(obj,money):
    obj.pay(money)

pay(obj,9)

#某天来了个野生程序员，让其实现Applepayg功能
class Applepay:
    def zhifu(self,money):
        print(f'您用微信支付了{money}元')
        
#做测试的时候，发现不能用pay函数进行测试

　　

# 类的约束
# 1.主动抛出异常
# 2.利用abcmeta进行强制约束
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self,money):
        # raise Exception('请定义支付方法名字为pay！')
        pass

class Alipay(Payment):
    def pay(self,money):
        print(f'您用支付宝支付了{money}元')

class Wechatpay(Payment):
    def pay(self,money):
        print(f'您用微信支付了{money}元')

class Applepay(Payment):
    def zhifu(self,money):
        print(f'您用Apple支付了{money}元')

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

# obj=Applepay()
# pay(obj,100)#主动抛出异常：Exception: 请定义支付方法名字为pay！

obj=Applepay()
pay(obj,100)#强制约束：TypeError: Can't instantiate abstract class Applepay with abstract methods pay