一.封装
封装
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步 将属性和方法封装到一个抽象的类中(为什么说是抽象的，因为类不能直接使用)
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部
eg:小明爱跑步
需求
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
# 同一个类创建出来的多个对象之间，属性互补干扰
xm = Person('小美',45.0)
xm.run()
xm.eat()
print xm
print xx
案例2：摆放家具
需求：
1.房子有户型，总面积和家具名称列表
新房子没有任何的家具
2.家具有名字和占地面积，其中
床：占4平米
衣柜：占2平面
餐桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表
被使用的类应该先开发
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.判断家具的面积是否超过房子的面积，如果超过了，提示不能添加这个家具
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
需求：
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')
# ak47.add_bullet(50)
# ak47.shoot()
# 2.创建士兵对象
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()
#print ryan.gun
二.继承
面向对象三大特征
1.封装：根据职责将属性和方法封装到一个抽象的类中
2.继承:实现代码的重用，相同的代码不需要重复的写
3.多态
单继承
继承的概念:子类拥有父类的所有属性和方法
继承的语法
class 类名(父类)：
def 子类特有的方法
"""
Cat类是Animal类的子类，Animal类是Cat类的父类，Cat从Animal类继承
Cat类是Animal类的派生类，Animal类是Cat类的基类，Cat类从Animal类派生
"""
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 '我可以说日语'
# 创建一个猫对象
fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.run()
fentiao.sleep()
fentiao.call()
# 创建一个hellokitty对象
kt = Hellokitty()
kt.speak()
kt.call()
# 继承的传递行，子类拥有父类的父类的属性和方法
"""
继承的传递性：（爷爷 父亲 儿子）
1.C类从B类继承，B类又从A类继承
2.那么C类就具有B类和A类的所有属性和方法
子类拥有父类以及父类的父类中封装的所有属性和方法
"""
kt.eat()
kt.drink()
kt.run()
kt.sleep()
# 子类继承自父类，可以直接享受父类中已经封装好的方法
# 子类中应该根据自己的职责，封装子类特有的属性和方法
2.重写父类方法
1.覆盖父类的方法
2.扩展父类的方法
class Animal:
def eat(self):
print '吃'
def drink(self):
print '喝'
def run(self):
print '跑'
def sleep(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()
3.覆盖错误案例
class Bird:
def __init__(self):
self.hungry = True
# 鸟吃过了以后就不饿了
def eat(self):
if self.hungry:
print 'Aaaaahhh...'
self.hungry = False
else:
print 'No thanks'
class SongBird(Bird):
def __init__(self):
self.sound = 'Squawk!'
def sing(self):
print self.sound
littlebird = SongBird()
littlebird.eat()
littlebird.sing()
此时会提示：
正确代码为：
class Bird:
def __init__(self):
self.hungry = True
# 鸟吃过了以后就不饿了
def eat(self):
if self.hungry:
print 'Aaaaahhh...'
self.hungry = False
else:
print 'No thanks'
class SongBird(Bird):
def __init__(self):
self.sound = 'Squawk!'
Bird.__init__(self)
def sing(self):
print self.sound
littlebird = SongBird()
littlebird.eat()
littlebird.sing()
3.多继承
class A:
def test(self):
print 'A-----test 方法'
def demo(self):
print 'A-----demo 方法'
class B:
def test(self):
print 'B------test 方法'
def demo(self):
print 'B-------demo方法'
class C(B,A):
"""多继承可以让子类对象，同时具有多个父类的属性和方法"""
pass
# 创建子类对象
c = C()
c.test()
c.demo()
4.新式类和旧式类
新式类和旧式(经典)类：
object是Python为所有对象提供的基类，提供有一些内置的属性和方法，可以使用dir函数查看
新式类：以object为基类的类，推荐使用
经典类：不以object为基类的类，不推荐使用
在python3.X中定义的类时，如果没有指定父类，会默认使用object作为基类--python3.x中定义的类都是新式类
在python2.x中定义类时，如果没有指定父类，则不会以object作为基类
####推荐使用新式类#############
新式类和旧式类在多继承时---会影响到方法的搜索顺序
为保证编写的代码能够同时在python2.x和python3.x运行
今后在定义类时，如果没有父类，建议统一继承自object
5.私有属性和私有方法
类的私有属性和私有方法
1.子类对象不能在自己的方法内部，直接访问父类的私有属性和私有方法
2.子类对象可以通过父类的公有方法间接访问到私有属性或私有方法
私有属性，私有方法是对象的隐私，不对外公开，外界以及子类都不能直接访问
私有属性，私有方法常用做一些内部的事情
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()
# b.test()
# 在外界不能直接访问对象的私有属性/调用私有方法
# print b.__num2
# b.__test()
三.综合练习
需求： 图书管理系统
图书管理系统
1. 查询
2. 增加
3. 借阅
4. 归还
5. 退出