python--面向对象封装案例

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.0
xiaoming = Person("小明", 75.0)
xiaoming.eat()
xiaoming.run()
print(xiaoming)
# 在对象的方法内部，是可以直接访问对象的属性的
# 同一个类创建的多个对象之间，属性互不干扰
# 小美爱跑步
xiaomei = Person("小美", 45.0)
xiaomei.eat()
xiaomei.run()
print(xiaomei)

• 输出

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

2. 摆放家具

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):
        print("要添加 %s" % item)
        # 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("席梦思", 40)
chest = HouseItem("衣柜", 2)
table = HouseItem("餐桌", 1.5)
print(bed)
print(chest)
print(table)

# 2.创建房子对象
my_home = House("两室一厅", 60)
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)

• 输出

[席梦思] 占地 40.00
[衣柜] 占地 2.00
[餐桌] 占地 1.50
要添加 [席梦思] 占地 40.00
要添加 [衣柜] 占地 2.00
要添加 [餐桌] 占地 1.50
户型：两室一厅
总面积：60.00[剩余：16.50]
家具：['席梦思', '衣柜', '餐桌']

• 小结

1. 创建了一个房子类，使用到__init__和__str__两个内置方法;
2. 准备了一个 adds.item 方法准备添加家具;
3. 使用房子类创建了一个房子对象;
4. 让房子对象调用了三次adds.item方法。将三件家具以实参传递到adds.item 内部;
5. 主程序只负责创建房子对象和家具对象;
6. 让房子对象调用 adds.item 方法将家具添加到房子中;
7. 面积计算、剩余面积、家具列表等处理都被封装到房子类的内部。

3. 士兵突击

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

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

    def add_bullet(self, count):
        self.bullet_count += count

    def shoot(self):
        # 1.判断子弹的数量
        if self.bullet_count <= 0:
            print("[%s] 没有子弹了..." % self.model)

            return
        # 2.发射子弹-1
        self.bullet_count -= 1
        # 3.提示发射信息
        print("[%s] 突突突... [%d]" % (self.model, self.bullet_count))
        
class Soldier:
    def __init__(self, name):
        # 定义没有初始值的属性，可以设置为None
        # 1.姓名
        self.name = name
        # 2.枪--新兵没有枪
        self.gun = None

    def fire(self):
        # 1.判断士兵是否有枪
        if self.gun == 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.fire()
xusanduo.gun = ak47
xusanduo.fire()

• 输出

[许三多] 还没有枪...
冲啊...[许三多]
[AK47] 突突突... [49]

• 扩展–身份运算符用于比较两个对象的内存地址是否一致；是否是对同一个对象的引用
  is与==区别:

1. is用于判断两个变量引用对象是否为同一个;
2. ==用于判断引用变量的值是否相等。

• 在Python 中针对None 比较时，建议使用is判断