学习python之路只面向对象编程的三大特点之一——封装

面向对象编程有三大特点：封装、继承、多态

一、封装的概念

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

封装的用法：根据职责将属性和方法封装的一个抽象的类中

二、实例

1.需求：小明爱跑步

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

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

xx = Person('小明',75.0)
xx.run()
xx.eat()
print xx

2、摆放家具（被使用的类应该先开发）

需求:

1. 房子有户型，总面积和家具名称列表，新房子没有任何家具
2. 家具有名字和占地面积，其中，床：占4平米；衣柜：占2平米；餐桌：占1.5平米
3. 将一上三件家具添加到房子中
4. 打印房子时，要求输出：户型，总面积，剩余面积，家具名称列表

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):
        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.判断家具的面积是否超过房子的面积，如果超过了，提示不能添加这个家具
        2.将 家具的名称 追加到 家具名称列表中去
        3.用 房子的剩余面积 - 家具的面积
        """
        if item.area > self.free_area:
            print '%s 的面积太大了，无法添加' %item.name
            # 如果不满足，下方的代码就不执行
            return
        # 将家具的名称添加到列表中
        self.item_list.append(item.name)
        # 计算剩余面积
        self.free_area -= item.area

# 1.创建家具
bed = HouseItem('bed', 400)
print bed
chest = HouseItem('chest', 2)
print chest
table = HouseItem('table', 1.5)
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

 3.士兵打枪（一个对象的属性可以是另外一个类创建的对象）

需求：

1. 士兵瑞恩有一把AK47
2. 士兵可以开火（士兵开火扣动的是扳机）
3. 枪能够发射子弹（把子弹发射出去）
4. 枪能够装填子弹--增加子弹的数量

分析：

Soldier                     Gun
-------------               -----------------
name                        model
gun                         bullet_count #子弹数量足够多才能完成射击的动作
-------------               -----------------
__init__(self):		        __init__(self):
fire(self):                 add_bullet(self,count):#装填子弹的方法
	       shoot(self):

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):
        self.name = name
        """
        在定义属性的时候，如果不知道设置什么初始值，可以设置为None
        None表示什么都没有
        表示一个空对象，没有方法和属性，是一个特殊的常量
        可以将None赋值给任何一个变量
        """
        self.gun = None
    def fire(self):
        # 1.判断士兵是否有枪
        if self.gun == None:
            print '[%s] 还没有枪' %self.name
            return
        print 'go!!! [%s]' %self.name
        # 士兵让枪装填子弹
        self.gun.add_bullet(50)
        # 士兵让枪发射子弹
        self.gun.shoot()


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

# 2.创建士兵对象
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()