1.面向对象的三大特性
（1）封装：
根据职责将属性和方法封装到一个抽象的类中定义的准则
（2）继承：
实现代码的重用,相同的代码不需要重复的编写,设计类的技巧,子类针对自己特有的需求,编写特定的代码
（3）多态:
不同的子类对象调用相同的方法,产生不同的执行结果
1.封装
（1）.封装是面向对象编程的一大特点
（2）.面向对象编程的第一步，将属性和方法封装到一个抽象的类中
（3）.外界使用类创建对象，然后让对象调用的方法
（4）.对象方法的细节的都被封装在类的内部
例1：
xxx喜欢跑步
1.xxx体重为75.0公斤
2.xxx每次跑步会减肥0.5公斤
3.xxx每次吃定西会增加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_dec(self):
print '%s 喜欢跑步' % self.name
self.weight -= 0.5
def eat_inc(self):
print '%s 喜欢吃东西' % self.name
self.weight += 1
lily = Person('lily',75)
lily.run_dec()
lily.eat_inc()
print lily
执行结果：
例2：
1.xxx和xxx喜欢跑步
2.xxx体重为75.0公斤
3.xxx每次跑步会减肥0.5公斤
4.xxx每次吃定西会增加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_dec(self):
print '%s 喜欢跑步' % self.name
self.weight -= 0.5
def eat_inc(self):
print '%s 喜欢吃东西' % self.name
self.weight += 1
# 创建类对象lily
lily = Person('lily', 75)
lily.run_dec()
lily.eat_inc()
print lily
# 创建类对象tom
tom = Person('tom', 45)
tom.run_dec()
tom.eat_inc()
print tom
执行结果：
实例：
1.摆放家具
需求：
1.房子有户型，总面积和家具名称列表
新房子没有任何家具
2.家具有名字和占地面积，其中
床：占4平方米
衣柜：占2平方米
餐桌：占1.5平方米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出：户型，总面积，剩余面积，家具名称列表
代码：
# 定义家具类
class Further():
# 初始化方法定义属性
def __init__(self, name, area):
self.name = name
self.area = area
def __str__(self):
return '%s 占地面积为 %.2f' % (self.name, self.area)
# 创建家具对象
bed = Further('bed', 5)
chest = Further('chest', 3)
desk = Further('desk', 4)
# 定义房子类
class Home():
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 \n剩余面积%.2f： \n家具名称列表%s：'% (self.house_type, self.area, self.free_area,self.item_list)
def add_item(self, item):
print '要添加 %s' % item
# 1.判断家具的面积
if item.area > self.free_area:
print '%s 的面积太大了,无法添加！' % item.name
# 2.将家具的名称添加到列表中
self.item_list.append(item.name)
# 3. 计算剩余面积
self.free_area -= item.area
# 创建房子对象
my_home = Home('两室一厅', 100)
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(desk)
print my_home
执行结果：
2.士兵开枪
需求：
1.士兵瑞恩有一把AK47
2.士兵可以开火
3.枪能够发射子弹
4.枪能够装填子弹
代码：
class Gun():
def __init__(self,model):
# 枪的型号
self.model = model
# 子弹的数量
self.buttet_count = 0
def add_buttet(self,count):
self.buttet_count += count
def shoot(self):
# 1.判断子弹的数量
if self.buttet_count <= 0:
print '%s没有子弹了'%self.model
return
# 2.发射子弹
self.buttet_count -= 1
# 3.提示发射信息
print '%s突突突%d' %(self.model,self.buttet_count)
class Soldier():
def __init__(self,name):
self.name = name
self.gun = None
def fire(self):
# 1.判断士兵有没有枪
if self.gun == None:
print '%s没有枪！！！'%self.name
# 2.高喊口号
print 'go!!!!%s' %self.name
# 3.让枪装填子弹
self.gun.add_buttet(50)
# 4.发射子弹
self.gun.shoot()
# 1.创建枪对象
ak47 = Gun('Ak47')
# 2.创建士兵
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()
print ryan.gun
执行结果：
2.继承
（1）单继承：
1.继承的概念：
子类拥有父类的所有方法和属性,只需要封装自己特有的属性和方法
2.语法格式：
class 类名(父类):
def 子类特有的方法和属性
代码：
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 '喵喵'
fentiao= Cat()
#子类拥有父类的所有属性和方法
fentiao.eat()
fentiao.drink()
fentiao.run()
fentiao.sleep()
fentiao.call()
#子类继承自父类,可以直接享受父类中已经封装好的方法
#子类中应该根据自己的职责,封装子类特有的属性和方法
执行结果：
3.继承的传递性：（爷爷，父亲，儿子）
C类从B类继承，B类从A类继承
那么C类具有A类和B类的所有方法和属性
代码：
class Animal():
def eat(self):
print '吃'
def drink(self):
print '喝'
def run(self):
print '跑'
def sleep(self):
print '睡'
# 继承Animal类
class Cat(Animal):
# 子类拥有父类的所有属性和方法
def call(self):
print '喵喵'
# 继承Cat类
class Hollekitty(Cat):
def speak(self):
print '我可以说日语'
kt = Hollekitty()
# 由继承的传递性知Hollekitty类具有Cat类和Animal类的所有方法和属性
kt.speak()
kt.call()
kt.eat()
kt.drink()
kt.run()
kt.sleep()
执行结果：
（3)多继承：
子类拥有多个父类，并且具有所有父类的属性和方法
例如：孩子会继承自己父亲和母亲的特性
语法格式：
class 子类名（父类名1，父类名2...）
代码1：
class A():
def test(self):
print 'test'
class B():
def kisk(self):
print 'kisk'
# 多继承可以让子类对象,同时具有多个父类的属性和方法
class C(A, B):
pass
c = C()
c.test()
c.kisk()
执行结果：
代码2：
class A():
def test(self):
print 'test'
def kisk(self):
print 'A---kisk'
class B():
def kisk(self):
print 'B---kisk'
# 继承的两个父类具有相同的方法按照继承顺序进行继承
class C(B, A):
pass
c = C()
c.test()
# 当父类A与父类B拥有同名的方法时
# 调用子类的此方法时，会执行放在前边的父类
c.kisk()
执行结果：
(4)重写父类有两种情况：
1.覆盖父类的方法
使用情景：
如果在开发中，父类的方法的实现和子类的方法的实现完全不同
就可以使用覆盖的方法在子类中重写父类的方法
具体实现方式：
在子类中定义一个和父类同名的方法，并且实现重写之后
在运行时，只会调用子类的重写方法，而不会调用父类的重写方法
代码：
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 Hollekitty(Cat):
def speak(self):
print '我可以说日语'
# 覆盖父类的方法
def call(self):
print '欧哈哟,空尼其瓦'
kt = Hollekitty()
kt.call()
执行结果：
2.扩展父类的方法
具体实现方式：
（1）在子类中重写父类的方法（方法名要相同）
（2）在需要的位置使用 父类名.方法名(self) 来调用父类原有的方法
（3）在其他的位置针对子类的需求，编写子类特有的属性和方法
代码：
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 Hollekitty(Cat):
# 子类特有的方法
def speak(self):
print '我可以说日语'
def call(self):
print '欧哈哟,空尼其瓦'
# 调用原本在父类中封装的方法
Cat.call(self)
# 子类特有的功能
print '#@!$%'
kt = Hollekitty()
kt.call()
执行结果：
覆盖与扩展的实例：
代码：
class Bird():
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print 'Enenenen....'
self.hungry = False
else:
print 'No Thanks'
class SongBird(Bird):
def __init__(self):
self.sound = 'Squawk'
# 调用Bird类原有的属性
Bird.__init__(self)
# 子类特有的方法
def sing(self):
print self.sound
bird = Bird()
bird.eat()
littlebird = SongBird()
littlebird.eat()
littlebird.sing()
执行结果：
3.多态
不同的子类对象调用相同的方法，产生不同的执行结果
代码：
class Dog(object):
def __init__(self, name):
self.name = name
def play(self):
print '%s 蹦蹦跳跳的玩耍' % self.name
# 继承
class Xiaotianquan(Dog):
def play(self):
print '%s 飞到天上玩耍' % self.name
# 定义一个人类,让人和狗一起玩耍
class Person(object):
def __init__(self, name):
self.name = name
def person_with_dog(self, dog): # dog为形参
print '%s 和 %s 一起开心的玩耍' % (self.name, dog.name)
dog.play()
# wangcai = Dog('旺财')
wangcai = Xiaotianquan('旺财')
xiaohua = Person('小花')
# wangcai 与 wangcai = Xiaotianquan('旺财') 联系
xiaohua.person_with_dog(wangcai)
执行结果：
2.私有属性和私有方法
应用场景：
在实际开发中，对象的某些属性或方法只希望在对象内部使用，而不希望在对象外部使用
私有属性就是对象不希望公开的属性；私有方法就是方法不希望公开的方法
定义方法：
在定义属性或方法时，在属性或方法前面加两个下划线，定义的就是私有属性和私有方法
代码：
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.age
# 在外界，无法直接访问私有方法
lily.secret()
# 程序会报错无法访问
执行结果：
3.父类的私有属性和私有方法
私有属性：私有属性是对象的隐私，不对外公开，外界以及子类都不能直接访问
私有方法：私有方法常用做一些内部的事情
注意：
1.子类对象不能在自己的方法内部,直接访问父类的私有属性和私有方法
2.子类对象不能在外部直接访问父类的私有属性和私有方法
解决方案：
子类对象可以通过父类的公有方法间接访问到私有属性和私有方法
代码：
class A(object):
def __init__(self):
self.num1 = 1
# 初始化方法创建私有属性
self.__num2 = 2
# 创建私有方法
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()
#创建子类对象
b = B()
print b
# 无法访问父类的私有属性
# print b.__num2
# 无法调用父类的私有方法
# b.test
b.test()
执行结果：
4.类的结构：
实例：
1.使用面向对象开发，第一步是设计类
2.使用类名()创建对象，创建对象的动作有两步
1.在内存中为对象分配空间
2.调用__init__初始化方法为对象初始化
3.对象创建后，内存中就有了一个对象的实实在在的存在--->实例
因此：
1.创建出来的对象叫做类的实例
2.创建对象的动作叫做实例化
3.对象的属性叫做实例属性
4.对象调用的方法叫做实例方法
在程序执行时：
1.对象各自调用自己的实例属性
2.调用对象的方法，可以通过self
访问自己的属性
调用自己的方法
结论：
1.每一个对象有自己独立的内存空间，保存各自不同的属性
2.多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的传递到方法内部
(1）类属性
类是一个特殊的对象
python中的所有对象
class A： 定义的类属性属于类对象
obj1 = A： 属于实例对象
在运行程序时,类同样会被加载到内存，在python中,类是一个特殊的对象 -- 类对象
除了封装 实例（对象）的属性和方法外,类对象还可以有自己的属性
通过 类名.属性名/方法名 的方式直接访问类的属性或者方法
代码：
"""使用附值语句定义类属性，记录所有工具的数量"""
class Tool(object):
count = 0 # count 为 类属性
def __init__(self, name):
self.name = name # name 为 实例属性
# 计数
Tool.count += 1
# 创建工具对象时,会自动调用初始化方法
# 故创建一个工具便会自加1,达到计数的目的
tool1 = Tool('斧头')
tool2 = Tool('榔头')
tool3 = Tool('梯子')
# 输出工具对象的数目
# 必须是 类名.属性名
print Tool.count
执行结果：
(2)类方法
类属性就是针对类对象定义的方法
在类方法内部就可以直接访问类属性或者调用其他类方法
语法结构：
@classmethod
def 类方法名(cls):
pass
通过类名.类方法名 来调用
代码：
""" 利用类方法，记录所有玩具的数量 """
class Toy(object):
count = 0
# 类方法
@classmethod
def show_toy_count(cls):
# 在类方法的内部，访问当前的类属性
print '玩具对象的数量为： %d' % cls.count
def __init__(self, name):
self.name = name
Toy.count += 1
# 创建类对象
toy1 = Toy('乐高')
toy2 = Toy('小珠佩琦')
toy3 = Toy('叮当猫')
# 在方法的内部,可以直接访问类属性
# 调用 类对象
Toy.show_toy_count()
执行结果：
（3）静态方法
在开发时，如果需要在类中封装一个方法,这个方法既不需要访问实例属性或者调用实例方法
也不要需要访问类属性或者调用类方法,此时便可以把这个方法封装成一个静态方法
语法结构：
@staticmethod
def 静态方法名():
pass
静态方法需要修饰器@staticmethod来标识,告诉解释器这是一个静态方法
通过类名.静态方法名 来调用
代码：
class Cat(object):
# 静态方法不需要传递参数self
@staticmethod
def call():
print '小猫喵喵叫～'
# 通过类名.静态方法名 调用
# 不需要创建对象,可以直接使用
Cat.call()
执行结果：
实例：
需求
1.设计一个Game类
（1）属性：
记录游戏的历史最高分(类属性，因为它只与游戏类有关，而与游戏对象无关)
记录当前游戏玩家的玩家姓名(实例属性)
（2）方法：
显示游戏帮助信息(静态方法)
显示历史最高分(类方法)
开始当前玩家的游戏(实例方法)
2.主程序
查看那帮助信息
查看历史最高分
创建游戏对象,开始游戏
代码：
class Game(object):
# 类属性
top_scorce = 103
# 实例属性
def __init__(self,name):
self.name = name
# 静态方法
@staticmethod
def show_help():
print '帮助手册'
# 类方法
@classmethod
def show_top_scorce(cls):
print '历史最高分为： %d ' % cls.top_scorce
# 实例方法
def start_game(self):
print '%s 开始游戏!' % self.name
# 查看游戏帮助信息
Game.show_help()
# 查看历史最高分
Game.show_top_scorce()
# 创建类对象,开始游戏
lily = Game('lily')
lily.start_game()
执行结果：
案例小结：
1.实例方法：方法内部需要访问实例属性
2.类方法： 方法内部只需要访问类属性
3.静态方法：方法内部不需要访问实例属性和类属性
如果方法内部，既要访问实例属性，又要访问类属性，应该定义实例方法
5.设计模型
需求：模拟播放器 一个播放器同一时刻只能播放一首歌曲！
代码1：（不会自动执行初始化）
class MusicPlayer(object):
# 在创建对象时,new方法会自动被调用,new方法为对象分配内存空间
# 重写new方法（覆盖）
def __new__(cls, *args, **kwargs):
# cls 表示哪一个类调用就传递哪一个类
# *args 表示多值参数
# **kwargs 表示多值的字典参数
print '创建对象,分配空间'
# 创建对象时 会自动执行初始化方法
# 实际上 在创建对象时 执行初始化之前会
# 自动执行原本的new方法对象分配内存空间
def __init__(self):
print '播放器初始化'
player = MusicPlayer()
print player
""" 以覆盖的形式重写new方法后，创建类对象时便不会给它分配内存空间，
故此时便无法自动执行初始化方法"""
执行结果：
代码2：（可以自动执行初始化，但会因对象不同，而使其分配的内存地址不同）
class MusicPlayer(object):
# 扩充new方法
def __new__(cls, *args, **kwargs):
# 1.创建对象 new方法会自动被调用
print '创建对象,分配空间'
# 2.为对象分配空间
# 调用object基类原本的new方法,并将其赋值给instance
instance = object.__new__(cls)
# 3. 返回对象引用（地址）
return instance
def __init__(self):
print '播放器初始化'
player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2
""" 以扩充的方式重写new方法，创建类对象时便不会影响自动执行初始化方法"""
执行结果：
代码3：（虽对象不同但分配的内存地址仍然相同，但初始化会执行两次）
class MusicPlayer(object):
instance = None
# 创建对象时 new方法会自动被调用
def __new__(cls, *args, **kwargs):
if cls.instance is None:
cls.instance = object.__new__(cls)
return cls.instance
def __init__(self):
print '播放器初始化'
player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2
执行结果：
代码4：（初始化只执行1次）
class MusicPlayer(object):
instance = None
init_flag = False
# 创建对象 new方法会自动被调用
def __new__(cls, *args, **kwargs):
if cls.instance is None:
cls.instance = object.__new__(cls)
return cls.instan
def __init__(self):
if MusicPlayer.init_flag:
return
print '播放器初始化'
MusicPlayer.init_flag = True
player1 = MusicPlayer()
print player1
player2 = MusicPlayer()
print player2
执行结果：
