python面向对象特征（一）封装

封装：

一层面的封装：创建类和对象时，分别创建两者的名称空间。只能通过类加“.”或者obj.的方式访问里面的名字

第二层面的封装，类中把某些属性和方法隐藏起来，或者定义为私有，只在类的内部使用，在类的外部无法访问，或者留下少量的接口（函数）供外部访问
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步，将属性和方法封装到一个抽象的类中(为什么类是抽象的？)
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部

例：1.

小明和小美爱跑步
1.小明体重75.0公斤
小美体重45.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):
        # pass
        print '%s 爱跑步' % self.name
        # 在对象方法的内部，是可以直接访问对象的属性
        self.weight -= 0.5
    def eat(self):
        #pass
        print '%s 吃东西' % self.name
        self.weight += 1

xiaoming = Person('小明',75.5)

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

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

# 同一个类创建的多个对象之间，属性互补干扰
print xiaomei
print xiaoming

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

剩余面积：
1.在创建房子对象的时候，定义一个剩余面积的属性，初始值和总面积相等
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):
        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.创建家具
        # 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.判断家具的面积是否超过剩余面积，如果超过了房子的大小，提示不能添加
# 2.将 家具的名称 追加到 家具名称列表中
# 3.用 房子的剩余面积 - 家具面积



bed = HouseItem('bed', 400)
print bed
chest = HouseItem('chest', 20)
print chest
table = HouseItem('table', 1.5)
print table

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

# 将三个家具添加到房子里面去
# 以实参的形式传递到add_item内部
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print my_home

3、演练重点：一个对象的属性可以是另外一个类创建的对象
示例:士兵射击
需求：
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪能够发射子弹(把子弹发射出去)
4.枪能够装填子弹 --增加子弹的数量

class Gun:
    def __init__(self, model):
        # 枪的型号
        self.model = model
        # 子弹的数量
        self.bullet_count = 0
    def add_bullet(self,count):
        self.bullet_count += count
    # 只要子弹的数量足够，就能发射，所有shoot方法不需要传递参数
    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.创建枪对象
ak = Gun('AK47')
# 枪不能自己发射子弹，枪不能自己开火 需要士兵去完成
# ak.add_bullet(50)
# ak.shoot()

# 2.创建瑞恩
ryan = Soldier('Ryan')
#ryan.gun = ak
ryan.fire()
print ryan.gun

python面向对象特征（一）封装

封装：

猜你喜欢