封装案例

封装

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

面向对象封装案例一

• 需求

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

class Person:

    def __init__(self, name, weight):
        # self.属性名 = 形参
        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)

xiaoming.run()
xiaoming.eat()
print(xiaoming)  # 输出字符串方法


输出结果：
小明 爱跑步，跑步锻炼身体
小明 是个吃货，吃完这顿再减肥
我的名字叫 小明, 体重是 75.50 公斤

改进：创建多个对象

class Person:

    def __init__(self, name, weight):
        # self.属性名 = 形参
        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)

xiaoming.run()
xiaoming.eat()
print(xiaoming)  # 输出字符串方法

xiaomei = Person('小美', 45)
xiaomei.eat()
xiaomei.run()
print(xiaomei)


输出结果：
小明 爱跑步，跑步锻炼身体
小明 是个吃货，吃完这顿再减肥
我的名字叫 小明, 体重是  75.50 公斤
小美 是个吃货，吃完这顿再减肥
小美 爱跑步，跑步锻炼身体
我的名字叫 小美, 体重是  45.50 公斤

面向对象案例二 ---- 摆放家具

需求

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

• 新房子没有任何的家具

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

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

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

剩余面积
1.创建房子对象时，定义一个剩余面积的属性，初始值和总面积相等
2.当调用 add_item方法，向房间添加家具时，让剩余面积 -= 家具面积
思考：应该先开发哪一个类？
答案 ----- 家具类
1.家具简单
2.房子要使用到家具，被使用的类，通常应该先开发

添加家具

• 1>判断 家具的面积 是否 超过剩余面积，如果超过，提示不能添加这件家具
• 2>将 家具的名称 追加到 家具名称列表 中
• 3>用 **房子的剩余面积 - 家具面积 **

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.house_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.house_type, self.area, self.free_area, self.item_list))

    # 添加家具
    def add_item(self, item):    # item表示要添加的家具对象
        print('要添加 %s' % item)  # 这里 item是一个家具对象，所以输出的时候会返回它的名字和面积，即（要添加 [席梦思] 占地 4.00平米...）

        # 1.判断家具的面积
        if item.area > self.free_area:
            print('%s 的面积太大了，无法添加' % item.name)
            return   # 如果面积太大就不需要执行下面的代码了

        # 2.将家具的名称添加到列表中
        self.item_list.append(item.name)

        # 3.计算剩余面积
        self.free_area -= item.area


# 1.创建家具
bed = HouseItem('席梦思', 4)
chest = HouseItem('衣柜', 2)
table = HouseItem('餐桌', 1.5)

print(bed)
print(chest)
print(table)
print('')  # 换行

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

my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print('')
print(my_home)


输出结果：
[席梦思] 占地 4.00平米
[衣柜] 占地 2.00平米
[餐桌] 占地 1.50平米

要添加 [席梦思] 占地 4.00平米
要添加 [衣柜] 占地 2.00平米
要添加 [餐桌] 占地 1.50平米

户型：两室一厅
总面积：90.00 [剩余面积：82.50]
家具：['席梦思', '衣柜', '餐桌']

'''将下面这段代码
 # 添加家具
    def add_item(self, item):    # item表示要添加的家具对象
        print('要添加 %s' % item)
        改为  '''
         # 添加家具
    def add_item(self, item):    # item表示要添加的家具对象
        print('要添加 %s' % item.name)  # 返回的就只是 item 对象的名字了

及最后输出为：
[席梦思] 占地 4.00平米
[衣柜] 占地 2.00平米
[餐桌] 占地 1.50平米

要添加  席梦思
要添加  衣柜
要添加  餐桌

户型：两室一厅
总面积：90.00 [剩余面积：82.50]
家具：['席梦思', '衣柜', '餐桌']

小结

• 主程序只负责创建 房子 对象和 家具 对象
• 让房子对象调用 add_item方法，将家具添加到房子中
• 面积计算、剩余面积、家具列表 等处理都被 封装 到 房子类的内部