需求：士兵突进
- 士兵许三多有一把 AK47
- 士兵可以开火
- 枪能够发射子弹
- 枪装填子弹，可以增加子弹数量
需求分析
- 很明显有两个类：士兵类，枪类
- AK47 是枪名，是枪类的属性，每把枪都有子弹数，所以子弹数也是一个属性
- 发生子弹是一个行为，所以是一个方法
- 装填子弹也是一个行为，也是一个方法
- 许三多是姓名，是士兵类的属性；士兵拥有枪，所以枪也是一个属性，对应的是枪类【一个对象的属性可以是另外一个类创建的对象】
- 开火是士兵类的一个行为，所以是一个方法，开火会发射子弹，所以应该调用枪的发射方法
类图
本次实战采用封装思想，将所有属性私有化，并且每个属性都有 setter、getter 方法
代码实现
- 面向对象编程的第一步：将属性和方法封装到一个抽象的类中
- 外接使用类创建对象，然后让对象调用方法
- 对象方法的细节都被封装在类的内部
先开发枪类还是士兵类？
枪类，因为士兵类依赖枪类，被依赖的类应该优先开发
枪类
假设每把枪一开始都没子弹，需要先手动装弹
代码语言：javascript复制class Gun:
# 构造方法
def __init__(self, name):
# 封装 - 将实例属性私有化
self.__name = name
self.__bullet_count = 0
# 自定义打印对象方法
def __str__(self):
return f"枪名：{self.__name} 子弹数：{self.__bullet_count}"
# name - getter
@property
def name(self):
return self.__name
# name - setter
@name.setter
def name(self, name):
self.__name = name
# count - getter
@property
def bulletCount(self):
return self.__bullet_count
# count - setter 相当于装子弹
@bulletCount.setter
def bulletCount(self, count):
self.__bullet_count = count
# shot 发射
def shoot(self):
# 1、判断是否能发射
if self.__bullet_count <= 0:
print(f"{self.__name} 没有子弹了，请先装弹")
return
# 2、发射
print(f"枪名：{self.__name} 发射")
# 3、减少子弹
self.__bullet_count -= 1士兵类
假设每一个新兵一开始都没有枪
代码语言：javascript复制class Solider:
# 构造方法
def __init__(self, name):
self.__name = name
# 默认没有枪
self.__gun = None
# 自定义打印对象方法
def __str__(self):
return f"士兵名字：{self.__name} 拿着一把：{self.__gun.name}"
# name - getter
@property
def name(self):
return self.__name
# name - setter
@name.setter
def name(self, name):
self.__name = name
# gun - getter
@property
def gun(self):
return self.__gun
@gun.setter
def gun(self, gun):
self.__gun = gun
def fire(self):
# 1、先判断是有枪
if self.__gun is None:
print(f"{self.__name} 士兵没有枪，不能发射！！请先装备枪！！")
return
# 2、有枪也要有子弹呀！上膛！
self.__gun.bulletCount = 10
# 3、拿枪射击！
self.__gun.shoot()拿枪射击，其实是
执行代码块
代码语言：javascript复制# 声明一个枪
ak47 = Gun("ak47")
print(ak47)
# 声明一个士兵
xusanduo = Solider("许三多")
# 给士兵带上 AK47！
xusanduo.gun = ak47
# 开火！
xusanduo.fire()
print(xusanduo)
# 输出结果
枪名：ak47 子弹数：0
枪名：ak47 发射
士兵名字：许三多 拿着一把：ak47
