008、面对对象的封装案例

面向对象封装案例

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

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

# 案例

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.0)

xiaoming.run()
xiaoming.eat()

print(xiaoming)

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

提示：

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

xiaomei = Person("小美", 45.0)
xiaomei.run()
xiaomei.eat()
print(xiaomei)
print(xiaoming)

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

# 案例，被使用的类通常先开发
# 家具类
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 \n [剩余：%.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("{} 的面积太大了，无法添加".format(item.name))
            
            return
        # 2.将家具名称添加到家具列表
        self.item_list.append(item.name)
        # 3.计算剩余面积
        self.free_area -= item.area
    
# 1、创建家具

bed = HouseItem("席梦思", 100)
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)

[席梦思]占地 100.00
[衣柜]占地 2.00
[餐桌]占地 1.50
要添加 [席梦思]占地 100.00
席梦思 的面积太大了，无法添加
要添加 [衣柜]占地 2.00
要添加 [餐桌]占地 1.50
户型： 两室一厅
总面积：60.00
[剩余：56.50]
家具：[‘衣柜’, ‘餐桌’]

#案例2

class Gun:
    
    def __init__(self, model):
        
        # 1. 抢的型号
        self.model = model
        
        #2.子弹数量
        self.bullet_count = 0
        
    def add_bullet(self, count):
        
        self.bullet_count += count
        
    def shoot(self):
        
        # 1.判断子弹数量
        if self.bullet_count <= 0:
            print("{}没有子弹了...".format(self.model))
            
            return
        #2.发射子弹
        self.bullet_count -= 1
        
        #3.提示发射信息
        print("{} 突突突...{}" .format(self.model, self.bullet_count))
        
        
        
class Soldier:
    
    def __init__(self, name):
        
        #1.姓名
        self.name = name
        
        #2.枪-新兵没有枪
        # 在定义属性的时候不知道赋什么值，就用None代替
        self.gun = None
        
    def fire(self):
        
        #1.判断士兵是否有枪
        #if self.gun == None:
        # 在使用None进行判断的时候，需要使用is进行规范，而不是 ==，进行判断。
        if self.gun is None:
            print("{}还没有枪...".format(self.name))
            
            return
        #2.高喊口号
        print("冲啊...{}".format(self.name))
        
        #3.让枪装满子弹
        self.gun.add_bullet(50)
        
        #4.让枪发射子弹
        self.gun.shoot()
        
# 一个对象的属性，可以使另外一个类创建的对象。       
# 1.创建枪对象
ak47 = Gun("AK47")

#2.创建许三多
xusanduo = Soldier("许三多")

xusanduo.gun = ak47
xusanduo.fire()

print(xusanduo.gun)

冲啊…许三多
AK47 突突突…49
<main.Gun object at 0x030D0E30>