python--------面向对象封装案例

封装

• 封装是面向对象编程的一大特点
• 面向对象编程的第一步 —— 将属性和方法封装到一个抽象的类中
• 外界使用类创建对象，然后让对象调用方法
• 对象方法的细节都被封装在类的内部

小明爱跑步
需求：

1. 小明和小美都爱跑步
2. 小美 体重45.0公斤
3. 小明 体重 75.0 公斤
4. 每次 跑步 会减肥 0.5 公斤
5. 每次 吃东西 体重增加 1 公斤

分析：

1. 类：人
2. 属性：名字 体重
3. 方法：跑步 吃东西

注意：

• 在 对象的方法内部，是可以 直接访问对象的属性 的
• 同一个类 创建的 多个对象 之间，属性 互不干扰

class Person:

    def __init__(self,name,weight):

        self.name=name

        self.weight=weight

    def __str__(self):
        return '我的名字叫%s体重%.2f公斤'%(self.name,self.weight)

    def run(self):

        print('%s爱跑步，跑步锻炼身体'%self.name)
        self.weight-=0.5

    def eat(self):

        print('%s是吃货，吃完这顿再减肥'%self.name)
        self.weight+=1

xiaoming=Person('小明',75.0)
xiaomei=Person('小美',45.0)

xiaoming.run()
xiaoming.eat()

xiaomei.eat()

print(xiaoming)
print(xiaomei)

运行结果

小明爱跑步，跑步锻炼身体
小明是吃货，吃完这顿再减肥
小美是吃货，吃完这顿再减肥
我的名字叫小明体重75.50公斤
我的名字叫小美体重46.00公斤

摆放家具

1. 房子(House) 有 户型、总面积 和 家具名称列表

• 新房子没有任何的家具

2. 家具(HouseItem) 有 名字 和 占地面积，其中

• 席梦思(bed) 占地 40 平米

• 衣柜(chest) 占地 20 平米

• 餐桌(table) 占地 1.5 平米

3. 将以上三件 家具 添加 到 房子 中
4. 打印房子时，要求输出：户型、总面积、剩余面积、家具名称列表

分析：

• 在创建房子对象时，定义一个 剩余面积的属性，初始值和总面积相等
• 当调用 add_item 方法，向房间 添加家具 时，让 剩余面积 -= 家具面积
• 房子要使用到家具，被使用的类，通常应该先开发，所以先开发家具类

#创建家具
class HouseItem:

    def __init__(self,name,area):
        self.name=name
        self.area=area

    def __str__(self):
        return '%s 占地 %.2f 平米'%(self.name,self.area)


#创建房间
class House:

    def __init__(self,house_type,area):
        self.hous_type=house_type
        self.area=area
        #剩余面积和总面积一样
        self.free_area=area
        #家具名称列表  没有任何家具
        self.item_list=[]

    def __str__(self):
        #Python 能够自动的将一对括号内部的代码连接在一起
        return ('户型： %s\n总面积：%.2f[剩余:%.2f]\n家具：%s'
                %(self.hous_type,self.area,
                  self.free_area,self.item_list))

    #添加家具
    def add_item(self,item):
        print('要添加%s'%item)
        #1.判断家具的面积
        if item.area>self.free_area:
            print('%s 的面积太大了，无法添加'% item.name)
            #执行return下方的代码就不会再执行
            return
        #2.将家具的名称添加到列表中
        self.item_list.append(item.name)
        #3.计算剩余面积
        self.free_area-=item.area


#创建家具
bed=HouseItem('席梦思',40)
chest=HouseItem('衣柜',20)
table=HouseItem('餐桌',1.5)

#创建房子对象
my_home=House('两室一厅',60)

#添加家具
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)

print(my_home)

运行结果

要添加席梦思 占地 40.00 平米
要添加衣柜 占地 20.00 平米
要添加餐桌 占地 1.50 平米
餐桌 的面积太大了，无法添加
户型： 两室一厅
总面积：60.00[剩余:0.00]
家具：['席梦思', '衣柜']

士兵突击

需求

• 士兵 许三多 有一把 AK47
• 士兵 可以 开火
• 枪 能够 发射 子弹
• 枪 装填 装填子弹 —— 增加子弹数量

分析：

• 类 ：士兵 枪

• 士兵：

  1. 属性：名字 枪

• 方法：开火

• 枪：

  1. 属性：类型 子弹数量(可以不从外界获取)
  2. 方法：添加子弹 发射

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

注意：我们假设每一个新兵都没有枪

定义没有初始值的属性

在定义属性时，如果不知道设置什么初始值，可以设置为 None

• None 关键字 表示 什么都没有
• 表示一个 空对象，没有方法和属性，是一个特殊的常量
• 可以将 None 赋值给任何一个变量

#枪类
class Gun:
    def __init__(self,model):
        #枪的类型
        self.module=model
        #子弹数量
        self.bullet_count=0

    #添加子弹
    def add_bullet(self,count):
        self.bullet_count+=count

    #发射子弹
    def shoot(self):
        #判断是否还有子弹
        if self.bullet_count<=0:
            print('没有子弹了...')
        #发射一颗子弹
        self.bullet_count-=1
        #输出发射状态
        print('%s 发射子弹，剩余 %d'%(self.module,self.bullet_count))

#士兵类
class Soldier:
    def __init__(self, name):
        # 姓名
        self.name = name
        # 枪，士兵初始没有枪 None 关键字表示什么都没有
        self.gun = None

    def fire(self):
        # 1. 判断士兵是否有枪
        if self.gun is None:
            print("[%s] 还没有枪..." % self.name)
            return
        # 2. 高喊口号
        print("冲啊...[%s]" % self.name)
        # 3. 让枪装填子弹
        self.gun.add_bullet(50)
        # 4. 让枪发射子弹
        self.gun.shoot()


#创建枪对象
ak47=Gun('AK47')

#创建许三多
xusanduo=Soldier('许三多')

#给许三多配枪
xusanduo.gun=ak47

#让许三多开火
xusanduo.fire()

运行结果

冲啊...[许三多]
AK47 发射子弹，剩余 49