基于linux下python学习（封装）

一、面向对象

类的设计：在程序开发中，要设计一个类，通常需要满足以下三个要求：

1、类名  这类事物的名字，满足大驼峰命名法

2、属性 这类事物具有什么样的特征

3、 方法  这类事物具有什么样的行为

eg:小明今年18岁，身高1.75，每天早上要跑步，会去吃东西

类名：Person（）  属性：name，age，height    方法：run（） eat（）

（1）

# 小猫爱吃鱼，小猫要喝水

class  Cat():
    def eat(self):
        print '小猫爱吃鱼'
    def  drink(self):
        print '小猫要喝水'
tom = Cat()     # 创建猫对象
tom.eat()
tom.drink()

# 小狗爱睡觉，小狗爱吃肉

class  Dog():
    def sleep(self):
        print '小狗爱睡觉'
    def eat(self):
        print '小狗爱吃肉'
xiaoxiao = Dog()
xiaoxiao.sleep()
xiaoxiao.eat()

（2）

class  Dog():
    def sleep(self):
        print '小狗爱睡觉'
    def eat(self):
        print '小狗爱吃肉'
xiaoxiao = Dog()
xiaoxiao.name = 'xiaoxiao'
xiaoxiao.sleep()
xiaoxiao.eat()
print xiaoxiao
# addr = id(xiaoxiao)
# print '%x' %addr
# print '%d' %addr

#再创建一个狗对象
benben = Dog()
benben.name = 'benben'
benben.eat()
benben.sleep()
print  benben

（3）

初始化方法
我们已经知道了使用类名（） 就可以创建一个对象
当使用类名（)创建对象时，python的解释器会自动执行以下操作：
1、为对象在内存中分配空间 --创建对象
2、调用初始化方法为对象的属性设置初始值   初始化方法（__init__)这个初始化方法就是__init__方法，是对象的内置方法

专门是用来定义一个类具有那些属性的方法
class  Dog():
    def  __init__(self,new_name):
        self.name = new_name
    def sleep(self):
        print '%s 爱睡觉'  % self.name
xiaoxiao = Dog('xiaoxiao')   # 使用类名（）创建对象的时候，会自动调用初始化方法__init__
print xiaoxiao.name
xiaoxiao.sleep()

benben = Dog('benben')
benben.sleep()

二、内置方法

（1）__del__

1、在python中
当使用类名（）创建对象时，为对象分配万空间后，自动调用__init__
当一个对象被从内存中销毁前，会自动调用__del__方法

"""
class Dog():
    def __init__(self,new_name):
        self.name = new_name
        print '%s 来了' %self.name
    def __del__(self):
        print '%s 走了' %self.name
xiaoxiao = Dog('xiaoxiao')
print xiaoxiao.name
print '_' * 50

2、

class Dog():
    def __init__(self,new_name):
        self.name = new_name
        print '%s 来了' %self.name
    def __del__(self):
        print '%s 走了' %self.name
xiaoxiao = Dog('xiaoxiao')
print xiaoxiao.name
del xiaoxiao
print '_' * 50

（2）__str__

1、在python中，使用python输出对象变量
默认情况下，会输出这个变量引用的对象是由哪一个类创建的对象
以及在内存中的地址（十六进制表示）
如果在开发中，希望使用print输出对象变量时
能够打印自定义的内容，就可以利用__str__这个内置方法了

"""
class Dog():
    def __init__(self,name):
        self.name = name
tom = Dog('tom')
print tom

 

2、

class Dog():
    def __init__(self,name):
        self.name = name
    def __str__(self): #必须返回一个字符串
        return '我是%s' %self.name
tom = Dog('tom')
print tom

三、封装

1、封装是面向对象编程的一大特点

2、面向对象编程的第一步，将属性和方法封装到一个抽象的类中

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

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

(1)

需求：
1、tom和xiaoxiao都爱吃东西爱跑步
2、tom体重75
3、xiaoxiao体重50
4、每次跑步都会减少0.5公斤
5、每次吃东西都会增加1公斤

"""
class person():
        def __init__(self, name,weight):
            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

tom = person('tom',75.0)
tom.run()
tom.eat()
print tom

xiaoxiao = person('xiaoxiao',50.0)
xiaoxiao.run()
xiaoxiao.eat()
print xiaoxiao

(2)

需求：
1、房子有户型，总面积和家具名称列表
    新房子没有任何的家具
2、家具有名字和占地面积，其中
  床：占4平方
  衣柜：占2平方
  餐桌：占1.5平方
3、将以上三件家具添加到房子中
4、打印房子时，要求输出：户型，总面积，剩余面积，家具名称列表
"""
class  HouseItem():
    def __init__(self, name,square):
        self.name = name
        self.square = square
    def __str__(self): #必须返回一个字符串
        return '%s的占地面积为%.2f' %(self.name,self.square)
chuang= HouseItem ('chuang',4)
print chuang
yigui = HouseItem('yigui',2)
print yigui
canzhuo =HouseItem('canzhuo',1.5)

class  House():
    def __init__(self,huxing,square):
        self.huxing = huxing
        self.square = square
        self.free_square = square   # 剩余面积
        self.item_list = []         # 家具名称列表
    def __str__(self):
        return '户型：%s\n总面积：%.2f\n剩余面积：%.2f\n家具列表：%s' % (self.huxing,self.square,self.free_square,self.item_list)
    def  add_item(self,item):
        print '要添加的家具%s' % item
        if item.square > self.free_square:
            print '%s面积太大无法添加' %item.square
            return
        self.item_list.append(item.name)
        self.free_square -=item.square
my_home = House('两室一厅',180)  # 创建房子

# 添加家具
my_home.add_item(chuang)
my_home.add_item(yigui)
my_home.add_item(canzhuo)
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
    def shoot(self):
        if self.bullet_count <= 0:  #  判断子弹的数量
            print '没有子弹了'
        self.bullet_count -= 1   #发射子弹
        print '%s 突突突 %d' %(self.model,self.bullet_count)
class  Soldier():
    def  __init__(self,name):
        self.name = name
        self.gun = None
    def fire(self):
        if self.gun == None:
            print  '%s没有枪' %self.name
            return
        print 'go!!!'
        self.gun.add_bullet(50)
        self.gun.shoot()

ak47 = Gun('ak47')
ak47.add_bullet(50)
ak47.shoot()

ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()
print  ryan.gun