01 面向对象封装案例

封装案例1.

小明爱跑步：

需求

1. 小明体重75.0公斤
2. 小明每次跑步会减肥0.5公斤
3. 小明每次吃东西体重增加1公斤

既然是小明，因此需要定义一个人人类

然后会有体重，名字等属性

跑步以后会怎样，吃东西以后会怎样，这些便是函数

Person
name weight
__ init __（self，name,weight）
__ str __(self)
run(self)跑步需求
eat(self)吃东西需求

class Person:
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
    def __str__(self):
        return "我的名字叫做%s,我的体重%.2f是Kg"%(self.name,self.weight)
    def run(self):
        print("%s爱跑步，跑步锻炼身体"%self.name)
     	self.weight -= 0.5
        return self.weight
    def eat(self):
        print("%s是吃货，吃完这顿在减肥"%self.name)
        self.weight += 1
        return self.weight


#这一步只是用类创建了一个对象，并且赋值，而相关属性的操作和改变都是在类的里面完成    
xiaoming = Person("小明",75)
xaioming.eat()
xiaoming.run()
print(xiaoming)
#现在增加，  小美  也爱跑步，相应属性一样变化
xiaomei = Person("小美"，65)
xaiomei.eat()
xiaomei.run()
print(xiaomei)

#####现在试问：小美的变化会影响小明吗？
#答案：不会，多个对象在多个不同内存空间，各属性互不影响

封装案例2.

摆放家具：

需求

1. 房子（House）有户型，总面积，和家具名称列表

   • 新房子没有任何的家具

2. 家具（Houseitem）有名字和占地面积，其中

   • 席梦思（bed） 占地4平米
   • 衣柜（chest） 占地2平米
   • 餐桌（table） 占地1.5平米

3. 将以上三件家具*添加到房子中

4. 打印房子时，要求你输出：户型，总面积，家具名称列表

5. 一个对象的属性可以是另外一个类创建的对象

6. HouseItem	House
   name area	house_type area
   __ init __(self,…,…)	free_area add_item
   __ str __(self,…,…)

class HouseItem:
    def __init__(self,name,area):
        self.name = name
        self.area = area
    def __str__(self):
        return "我是%s,占地面积是%.2f"%(self.name,self.area) 
bed = HouseItem("席梦思",20)
chest = HouseItem("衣柜",13)
table = HouseItem("桌子",9)
print(bed)
class House:
    def __init__(self,house_type,area):
        self.house_type = house_type
        self.area = area
        #剩余面积等于总面积减去家具面积,初始值是房子总面积
        self.free_area = area
        self.item_list = []
    def __str__(self):
        return("我的房子类型是%s\n总面积是%.2f[剩余面积是%.2f]\n含有的家具：%s"
        %(  self.house_type,
            self.area,
            self.free_area,
            self.item_list))
    def add_item(self,item):
        #首先需要判断家具面积是否过大，过大则不会添加
        #其次便是相关操作
        if item.area > self.free_area:
            return "面积过大无法添加"       #这一步是为了  执行这一步便不会执行后面的代码
        self.free_area  -= item.area
        self.item_list.append(item.name)
my_house = House("两室一厅",90)
my_house.add_item(bed)
my_house.add_item(chest)
my_house.add_item(table)
print(my_house)

封装案例3.

士兵突击：

一个对象的属性可以是另外一个类创建的对象

士兵的 枪 是类gun 的对象

01需求：(名词提炼法则，)

1. 士兵 许三多有一把AK47

2. 士兵可以开火

3. 枪能够发射子弹

4. 枪能够装填子弹–增加子弹数量

5. 新兵没有枪 当初始值不知道设置什么时候，可以使用赋值语句None

   Soldier	Gun
   name gun	modle bullet_count
   __ init __(self): fire(self):	__ init __(self): add_bullet(self,count): shot(self):

   (哪一个类被另一个使用，先开发谁)

class Gun:
    def __init__(self,model):
        # 1 枪的型号
        self.model = model
        # 2 枪的初始化数量
        self.bullet_count = 0           #初始化之所以不添加形参bullet_count是因为后面会影响
    
    def add_bullet(self,count):
        self.bullet_count += count      #枪的装填
    
    def shot(self):
        # 判断子弹数量达到一定数量以后是否可以开枪
        if self.bullet_count<=0:
            print("%s没有子弹了"%self.model)
            return                                             #如有这种情况，这不会运行此后代码
        # 发射子弹   子弹数量减少
        self.bullet_count -= 1
        # 提示发射信息
        print("[%s] 突突突... [剩余子弹：%d]"%(self.model,self.bullet_count))   
ak47 = Gun("AK47")

class Soldier:
    def __init__(self,name):
        #因为新兵没有枪，所以初始值不知道是什么时候。可以设置None
        self.name = name 
        self.gun =  None
    def fire(self):
        #判断士兵的持枪情况
        if self.gun == None:
            print("对不起，新兵没有枪支，无法开枪。")
            return                                         #如果含有此种情况，从这里开始结束，不在运行下面代码
        # 大喊口号
        print("冲啊 ！firehome")
        # 让枪支装填子弹
        self.gun.add_bullet(50)                                #   实际上该代码不可能实现
        # 开始射击
        self.gun.shot()            
                                  #   实际上该代码不可能实现     因为士兵的枪属性没有装弹与设计程序，这些程序是枪类拥有
                                                                                  
xu_sanduo = Soldier("许三多")                                                        
xu_sanduo.gun = ak47               
xu_sanduo.fire()          # 因此需要调用枪对象,这就是这句话解释:一个对象的属性可以是另外一个类创建的对象