封装与多态
封装
将属性和方法封装到一个抽象的类种，外界使用类创建对象，调用其方法，具体内部的细节外部不需要知道
class Gun:
def __init__(self,model):
self.model = model
self.bullet_count = 0
def add_bullet(self,count):
self.bullet_count += count
def shoot(self):
while True:
if self.bullet_count == 0:
print('没子弹啦！')
break
else:
print('突')
self.bullet_count -= 1
class Soldier:
def __init__(self,name,gun=None):
self.name = name
self.gun = gun
def fire(self):
if self.gun == None:
print("你没有枪呀！")
else:
self.gun.add_bullet(30)
self.gun.shoot()
AK = Gun("AK47")
zhangsan = Soldier('张三',AK)
zhangsan.fire()多态
不同的子类对象继承相同的父类，通过重写父类方法，产生不同的执行结果，增加代码的灵活性
class Phone:
def __init__(self,name):
self.name = name
def func(self):
print('bibibibi，来电话了')
class Nokia(Phone):
def func(self):
print("砸个核桃给秀儿吃")
class Samsung(Phone):
def func(self):
print("嘀嘀嘀嘀嘀嘀......Booooooooooom!")
class Person:
def __init__(self,name):
self.name = name
def use_phone(self,phone):
print(f'{self.name}正在使用{phone.name}')
phone.func()
诺基亚 = Nokia('诺基亚')
三星Note7 = Samsung('三星Note7')
张三 = Person('张三')
张三.use_phone(诺基亚)
张三.use_phone(三星Note7)
我们可以对类进行约束来达到标准化的目的：
- 父类中定义方法，但是这个方法啥都不干，或者使用元类来描述一个抽象方法
- 子类中再具体实现方法
#抽象类写法
# import abc
# class Payment(metaclass=abc.ABCMeta):
# @abc.abstractmethod
# def pay(self,money):
# raise AttributeError('子类必须实现这个方法')
class Payment:
def pay(self,money):
print('你还没有实现具体的pay方法')
class QQpay(Payment):
def pay(self,money):
print(f'QQ支付{money}元')
class Wechatpay(Payment):
def pay(self,money):
print(f'微信支付{money}元')
class Alipay(Payment):
def pay(self,money):
print(f'支付宝支付{money}元')
def pay(obj,money):
obj.pay(money)
a = QQpay()
b = Wechatpay()
c = Alipay()
pay(a,200)
pay(b,200)
pay(c,200)
