封装： 1.封装是面向对象编程的一大特点 2.面向对象编程的第一步，将属性和方法封装到一个抽象的类中（抽象是因为类不能被直接使用） 3.外界使用类创建对象，然后让那个对象调用方法 4.对象方法的细节都被封在类的内部
需求 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
xm = Person('小明',75.0)
xm.run()
xm.eat()
print xm
案例2：摆放家具 需求： 1.房子有户型，总面积和家具名称列表 新房子没有任何的家具 2.家具有名字和占地面积，其中 床：占4平米 衣柜：占2平面 餐桌：占1.5平米 3.将以上三件家具添加到房子中 4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表 被使用的类应该先开发
class Furniture:
def __init__(self,name,area):
self.name = name
self.area = area
def __str__(self,*args):
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):
if self.free_area < item.area:
print '%s 的面积太大了，无法添加' %item.name
return
self.item_list.append(item.name)
self.free_area -= item.area
bed = Furniture('bed',4)
chest = Furniture('chest',2)
table = Furniture('table',1.5)
# print bed
# print chest
# print table
my_house = House('两室一厅',60)
my_house.add_item(bed)
my_house.add_item(chest)
my_house.add_item(table)
print my_house
需求： 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 '[%s]没有子弹了。。。' %self.model
return
else:
self.bullet_count -= 1
print '[%s]tututu ，，，[%d]' %(self.model,self.bullet_count)
class Soldier:
def __init__(self,name):
self.name = name
def fire(self):
if self.gun == None:
print '没有枪'
return
print 'go'
self.gun.add_bullet(50)
self.gun.shoot()
ak47=Gun('AK47')
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()
print ryan.gun
私有属性和私有方法 应用场景及定义方式 应用场景 在实际开发中，对象的某些属性或方法可能只希望在对象的内部使用，而不希望在外部被访问到 私有属性 就是 对象 不希望公开的 属性 私有方法 就是 方法 不希望公开的 方法 定义方法 在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法
class Women:
def __init__(self,name):
self.name = name
self.__age = 18
def __secret(self):
print '%s 的年龄是 %d' %(self.name,self.__age)
lily = Women('lily')
print lily.name
# 私有属性，外界不能直接访问
#print lily.age
# 私有方法，外界不能直接调用
lily.secret()
面向对象的特征
1.封装：根据职责将属性和方法封装到一个抽象的类中
2.继承：实现代码的重用，相同代码不需要重复的写
3.多态：（以封装和继承为基础）不同的子类对象调用相同的方法产生不同的结果
单继承
继承：子类拥有父类的所有属性和方法
class 类名（父类）：
def 子类特有方法
子类也叫派生类
父类也叫基类
class Animal(object):
def eat(self):
print '吃'
def drink(self):
print '喝'
def run(self):
print '跑'
def sleep(self):
print '睡'
class Cat(Animal):
#子类拥有父类的所有属性和方法
def call(self):
print '喵喵'
class Dog(Animal):
def bark(self):
print '汪汪'
class Hellokitty(Cat):
def speak(self):
print '我可以说日语'
#创建一个猫对象，继承Animal的所有属性和方法
mao = Cat()
mao.call()
#创建一个狗对象，继承Animal的所有属性和方法
gou = Dog()
gou.run()
gou.bark()
#创建一个hellokitty对象，继承Cat的所有属性和方法
"""
继承的传递性：(爷爷 父亲 儿子)
1.c类从b类继承，b类又从a类继承
2.那么c类就具有b类和a类的所有属性和方法
子类拥有父亲以及父类的父类中的封装的所有属性和方法
"""
kt=Hellokitty()
kt.speak()
kt.run()
kt.call()
#子类继承自父类，可以直接享受父类中已经封装好的方法
#子类中应该根据自己的职责，封装子类特有的属性和方法
重写父类方法：
1.覆盖父类的方法
2.扩展父类的方法
class Animal:
def eat(self):
print '吃'
def drink(self):
print '喝'
def run(self):
print '跑'
class Cat(Animal):
#子类拥有父类的所有方法和属性
def call(self):
print '喵喵'
class Hellokitty(Cat):
def speak(self):
print '我可以说日语'
def call(self):
#针对子类特有的需求，编写代码
print '你好'
#调用原本在父类中封装的代码
Cat.call(self)
#增加其他的子类的代码
print '####'
kt = Hellokitty()
#如果子类中，重写了父类的方法
#在运行中，只会调用子类中重写的父类的方法而不会调用父类的方法
kt.call()
注意init方法也可以被覆盖所以要就加上
Bird.__init__(self)
class Bird:
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print '吃....'
self.hungry = False
else:
print 'No thants'
class SongBird(Bird):
def __init__(self):
Bird.__init__(self)
self.sound = 'Squawk!'
def sing(self):
print self.sound
littlebird = SongBird()
littlebird.eat()
littlebird.sing()
多继承的顺序
class C(A,B) 继承A(如果A，B的方法名称一样)
class C(B，A)继承B(如果A，B的方法名称一样)
类的私有属性和私有方法
1.子类对象不能在自动的方法内部，直接访问对象的私有属性和私有方法
2.子类对象可以通过父类的公有方法直接访问到私有属性和私有u方法
私有属性，私有方法，私有方法是对象的隐私，不对外公开，外界以及子类都不能直接访问
私有属性，私有方法常用做一些内部的事情
class A:
def __init__(self):
self.num1 = 100
self.__num2 = 200
def __test(self):
print '私有方法 %d %d' % (self.num1, self.__num2)
def test(self):
print '父类的共有方法 %d' % self.__num2
self.__test()
class B(A):
def demo(self):
# 在子类的对象方法中，不能访问父类的私有属性
# # print '访问父类的私有属性 %d '%self.__num2
# 在子类对象的方法中，不能调用父类的私有方法
# # self.__test()
self.test()
b = B()
b.demo()
# 在外界不能直接访问对象的私有属性/调用私有方法
print b.__num2
b.__test()
多态
3.多态：（以封装和继承为基础）不同的子类对象调用相同的方法产生不同的结果 比如人类由一个方法：work(self): 程序员 设计师调用这个相同的方法得到不同的结果
class Dog(object):
def __init__(self, name):
self.name = name
def play(self):
print '%s 玩皮球' % self.name
class Xiaotiandog(Dog):
#父类方法不能满足子类方法，重写play方法
def play(self):
#在使用继承时，子类拥有父类的所有属性和方法
print '%s 飞到天上' % self.name
class Person(object):
def __init__(self, name):
self.name = name
def play_with_dog(self,dog):
print '%s 和 %s 玩得很开心' %(self.name,dog.name)
dog.play()
#1.创建一个狗对象
# wangcai = Dog('旺财')
wangcai = Xiaotiandog('旺财')
#2.创建一个小明对象（小明是一个人）
xiaoming =Person('小明')
#3.让小明调用和狗玩的方法（把之前创建的狗对象传递出去）
xiaoming.play_with_dog(wangcai)
