基础DAY8-面向对象封装案例及私有属性私有方法

01　封装

将属性和方法封装到一个抽象的类中

外界使用类创建对象，然后让对象调用方法

对象方法的细节都被封装在类的内部

02 晓明爱跑步

需求：

1 晓明体重 75.0公斤

2 晓明每次跑步会减肥0.5公斤

3 晓明每次吃东西体重会增加1公斤

name

weight

__init__(self, name, weight):

__str__(self):

run(self):

eat(self):

class Person():
    def __init__(self, new_name, new_weight):
        self.name = new_name
        self.weight = new_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)

同一个类创建的多个对象之间，属性互不干扰

class Person():
    def __init__(self, new_name, new_weight):
        self.name = new_name
        self.weight = new_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)
xiaomei = Person("晓美",60.0)
xiaomei.run()
print(xiaomei)
print(xiaoming)

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.area = area
        self.free_area = area
        self.house_type = house_type
        self.item_list = []
    def __str__(self):
        # Python 能够自动将一对括号内部的代码链接在一起
        return ("户型：%s
总面积：%.2f[剩余：%.2f]
家具：%s "
                % (self.house_type, self.area,
                   self.free_area, self.item_list))
    def add_item(self, item):
        # 1 判断家具面积
        # 2 将家具名称添加到列表中
        # 3 计算剩余面积
        print("要添加%s" % item)
        if item.area > self.free_area:
            print("家具%s太大了，无法添加" % item.name)
            return
        self.item_list.append(item.name)
        self.free_area -= item.area

bed = HouseItem("席梦思", 4)
chest = HouseItem("衣柜", 2)
table = HouseItem("餐桌", 1.5)
house = House("三室", 60)
house.add_item(bed)
house.add_item(chest)
house.add_item(table)
print(house)

要添加席梦思 占地 4.00
要添加衣柜 占地 2.00
要添加餐桌 占地 1.50
户型：三室
总面积：60.00[剩余：52.50]
家具：['席梦思', '衣柜', '餐桌'] 

定义没有初始值的属性

可以设置为None关键字，表示什么都没有，表示一个空对象，没有方法，属性，是一个特殊的变量

可以把None赋值给任何一个变量

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

class Gun:
    def __init__(self, model):
        self.model = model
        self.bullet_count = 0
    def __str__(self):
        return "型号是%s" % self.model
    def add_bullet(self, count):
        self.bullet_count += count
    def shoot(self):
        # 1 判断子弹数量
        if self.bullet_count <= 0:
            print("没有子弹了")
            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
        # 1 定义姓名，定义枪
        # 2 枪-新兵没有枪
        self.gun = None
    def fire(self):
    # 1 判断是否有枪，没有枪没法冲锋
        if self.gun is None:
            print("没有枪没法冲锋")
            return
    # 2 喊一声口号
        print("有枪，冲锋,%s" % self.name)
    # 3 装填子弹
        self.gun.add_bullet(50)
    # 4 射击
        self.gun.shoot()
ak47 = Gun("AK47")
# 创建许三多
xusanduo = Soldier("许三多")
xusanduo.gun = ak47
xusanduo.fire()

身份运算符

比较两个对象的内存地址是否一致，是否是对同一个对象的引用

针对None比较 用is

is 用来两个变量引用的对象是否为同一个

== 用于判断引用变量的值是否相等

In [29]: a = [1, 2, 3]

In [30]: b = [1, 2, 3]

In [31]: b is a
Out[31]: False

In [32]: b == a
Out[32]: True

is  　　　　a is b 类似id(a)== id(b)

is not   　   a is not b 类似 id(a)！= id(b)

私有属性私有方法

对象不想公开的属性和方法

在定义属性或者方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性和方法

在对象的方法内部，是可以直接访问对象的私有属性的

class Women:
    def __init__(self, name):
        self.name = name
        self.__age = 18
    def secret(self):
        # 在对象的方法内部，是可以访问对象的私有属性的
        print("%s 的年龄是 %d" % (self.name,self.__age))
xiaofang = Women("小芳")
# 私有属性在外界不能被直接访问
#print(xiaofang.__age)
xiaofang.secret()

# 私有方法在外界不能被直接访问
xiaofang.__secret()

没有真正意义的私有，外界调用私有属性 or 私有属性 _类__属性 _类__方法,科普不要用

print(xiaofang._Women__age)

xiaofang._Women__secret()