封装

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

小明爱跑步

需求

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

面相对象封装 - 图1

提示：在对象的方法内部，是可以直接访问对象的属性的！

  • 代码实现： ```python class Person: “””人类”””

    def init(self, name, weight):

    1.   self.name = name
    2.   self.weight = weight

    def str(self):

    1.   return "我的名字叫 %s 体重 %.2f 公斤" % (self.name, self.weight)

    def run(self):

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

    def eat(self):

    1.   """吃东西"""
    3.   print("%s 是吃货，吃完这顿再减肥" % self.name)
    4.   self.weight += 1

xiaoming = Person(“小明”, 75)

xiaoming.run() xiaoming.eat() xiaoming.eat()

print(xiaoming)

  1. <a name="aK8OR"></a>
  2. ### 摆放家具
  3. **需求**
  5. 1. 房子(House)有户型、总面积和家具名称列表
  6.    - 新房子没有任何的家具
  7. 2. 家具(HouseItem)有名字和占地面积，其中
  8.    - **席梦思(bed)** 占地 4 平米
  9.    - **衣柜(chest)** 占地 2 平米
  10.    - **餐桌(table)** 占地 2.5 平米
  11. 3. 将以上三件**家具添加**到**房子**中
  12. 3. 打印房子时，要求输出：**户型**、**总面积**、**剩余面积**、**家具名称列表**
  14. ![](https://cdn.nlark.com/yuque/0/2021/png/21397054/1618572772390-347ee541-3f87-47ee-82e7-e7c2d6f2d941.png#from=url&id=daI2l&margin=%5Bobject%20Object%5D&originHeight=271&originWidth=1086&originalType=binary&ratio=1&status=done&style=none)<br />**剩余面积**
  16. 1. 在创建房子对象时，定义一个 **剩余面积的属性**，**初始值和总面积相等**
  17. 1. 当调用 add_item 方法，向房间 **添加家具** 时，让 **剩余面积** -= **家具面积**
  19. **思考**：应该先开发哪一个类？<br />**答案**——**家具类**
  21. 1. 家具简单
  22. 1. 房子要使用到家具，**被使用的类**，通常应该先开发
  23. <a name="O4ToG"></a>
  24. ### 1.创建家具
  25. ```python
  26. class HouseItem:
  28.     def __init__(self, name, area):
  29.         """
  31.         :param name: 家具名称
  32.         :param area: 占地面积
  33.         """
  34.         self.name = name
  35.         self.area = area
  37.     def __str__(self):
  38.         return "[%s] 占地面积 %.2f" % (self.name, self.area)
  41. # 1. 创建家具
  42. bed = HouseItem("席梦思", 4)
  43. chest = HouseItem("衣柜", 2)
  44. table = HouseItem("餐桌", 1.5)
  46. print(bed)
  47. print(chest)
  48. print(table)

小结

  1. 创建了一个 家具类，使用到 init 和 str 两个内置方法

  2. 使用 家具类 创建了 三个家具对象，并且 输出家具信息

    2.创建房间

    ```python class House:

    def init(self, house_type, area):

    1.  """
    3.  :param house_type: 户型
    4.  :param area: 总面积
    5.  """
    6.  self.house_type = house_type
    7.  self.area = area
    9.  # 剩余面积默认和总面积一致
    10.  self.free_area = area
    11.  # 默认没有任何的家具
    12.  self.item_list = []

    def str(self):

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

    def add_item(self, item):

    1.  print("要添加 %s" % item)

…

2. 创建房子对象

my_home = House(“两室一厅”, 60)

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

print(my_home)

  1. **小结**
  3. 1. 创建了一个 **房子类**，使用到 __init__ 和 __str__ 两个内置方法
  4. 1. 准备了一个 add_item 方法 **准备添加家具**
  5. 1. 使用 **房子类** 创建了 **一个房子对象**
  6. 1. 让 **房子对象** 调用了三次 add_item 方法，将 **三件家具** 以实参传递到 add_item 内部
  7. <a name="PmJf0"></a>
  8. ### 3.添加家具
  9. **需求**
  11. - 1> **判断家具的面积** 是否 **超过剩余面积**，**如果超过**，提示不能添加这件家具
  12. - 2> 将 **家具的名称** 追加到 **家具名称列表** 中
  13. - 3> 用 **房子的剩余面积** - **家具面积**
  14. ```python
  15. def add_item(self, item):
  17.         print("要添加 %s" % item)
  18.         # 1. 判断家具面积是否大于剩余面积
  19.         if item.area > self.free_area:
  20.             print("%s 的面积太大，不能添加到房子中" % item.name)
  22.             return
  24.         # 2. 将家具的名称追加到名称列表中
  25.         self.item_list.append(item.name)
  27.         # 3. 计算剩余面积
  28.         self.free_area -= item.area

4.小结

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