Python面向对象、内置方法、封装、继承、多态
一.面向对象
面向对象三大特征
1.封装：根据职责将属性和方法封装到一个抽象的类中
2.继承：实现代码的重用，相同的代码不需要重复的编写设计类的技巧，子类针对自己特有的需求，编写特定的代码。
3.多态：不同的对象调用相同的方法，产生不同的结果，增加代码的灵活度类的设计：
在程序开发中，要设计一个类，通常需要以下三个要求：
1.类名：这类事物的名字，满足大驼峰命名法
2.属性：这类事物具体有什么样的特征
3.方法：这类事物具有什么样的行为1.面向对象-01
需求：
小明今年18岁，身高1.75，每天早上要跑步，会去吃东西
小美今年17岁，身高163，小妹不跑步，小妹喜欢吃东西
Person()
name
age
height
run()
eat()
一只黄颜色的狗叫大黄
看见生人汪汪叫
看见家人摇尾巴
Dog()
name
color
shout()
shake()2.面向对象-02
面向对象的基础语法：
定义简单的类：
定义只包含方法的类：
class 类名：
def 方法1（self,参数列表）：
pass
def 方法2（self,参数列表）：
pass
当一个类定义完成之后，要使用这个类来创建对象，语法格式如下：
对象变量 = 类名（）需求
小猫爱吃鱼，小猫要喝水
3.面向对象-03
4.面向对象-04
初始化方法
我们现在已经知道了使用 类名（） 就可以创建一个对象
当使用类名（）创建对象时,python的解释器会自动执行以下操作：
1.为对象在内存中分配空间——创建对象
2.调用初始化方法为对象的属性设置初始值——初始化方法(__init__)
这个初始化方法就是__init__方法,__init__是对象的内置方法
__init__方法是专门用来定义一个类具有那些属性的方法
5.面向对象-05
二.内置方法
1.del方法
__del__方法：
在python中
当使用类名（）创建对象时，为对象分配完空间后,自动调用__init__方法
当一个对象被从内存中销毁前，会自动调用__del__方法
2.str方法
在python中，使用python输出对象变量
默认情况下，会输出这个变量引用的对象是由哪一个类创建的对象
以及在内存中的地址（十六进制表示）
如果在开发中，希望使用print输出对象变量时，
能够打印自定义的内容，就可以利用__str__这个内置方法了
三.封装
封装
1.封装是面向对象编程的一大特点
2.面向对象变成编程的第一步,将属性和方法封装到一个抽象的类中
3.外界使用类创建对象,然后让对象调用方法
4.对象方法的细节都被封装在类的内部1.封装-01练习
xx爱跑步
1.xx体重75.0公斤
2.xx每次跑步会减肥0.5公斤
3.xx每次吃东西体重会增加1公斤
2.士兵开枪练习：
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 '没有子弹了'
# 2.发射子弹
self.bullet_count -= 1
# 3.提示发射信息
print '%s biubiubiu %d' % (self.model,self.bullet_count)
class Soldier():
def __init__(self,name):
self.name = name
#不确定有没有枪
self.gun = None
def fire(self):
# 1.判断士兵没有枪
if self.gun == None:
print '%s 还没枪。。'
return
#2.高喊口号
print 'go!!! %s' %self.name
#3.让枪装填子弹
self.gun.add_bullet(50)
#4.让枪发射子弹
self.gun.shoot()
#1.创建枪对象
ak47 = Gun('AK47')
#ak47.add_bullet(50)
#ak47.shoot()
#创建士兵
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()
print ryan.gun
3.摆放家具练习
需求：
1.房子有户型，总面积和家具名称列表
新房子没有任何家具
2.家具有名字和占地面积，其中
床：4.6平米
衣柜：2平米
餐桌：3平米
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.判断家具面积
if item.area > self.free_area:
print '%s的面积太大了，无法添加' %item.name
#如果不满足，下方代码就不执行
return
# 2.将家具名称添加到列表中
self.item_list.append(item.name)
# 3.计算剩余面积
self.free_area -= item.area
# 创建家具
bed = houseitem('bed', 10)
print bed
chest = houseitem('chest', 1.5)
print chest
table = houseitem('table', 2)
print table
#创建房子对象
my_home = House('两室一厅',100)
#添加家具
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print my_home
四.继承
1.继承-01
单继承
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()
# 子类继承自父类，可以直接享受父类中已经封装好的方法
# 子类中应该根据自己的职责，封装子类特有的属性和方法
2.继承-02
继承的传递性：（爷爷 父亲 儿子）
1.C类从B类继承，B类又从A类继承
2.那么C类就具有B类和A类的所有属性和方法
子类拥有父亲以及父类的父类中封装的所有属性和方法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 '我可以说日语'
# 创建一个HelloKitty对象
kt = HelloKitty()
kt.speak()
kt.eat()
kt.drink()
kt.run()
kt.sleep()
kt.call()
3.继承-03
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 '我可以说日语'
class Dog(Animal):
def bark(self):
print '旺旺～'
# 创建一个HelloKitty对象
kt = HelloKitty()
#继承的传递性，子类拥有父类和父类的父类的属性和方法
kt.speak()
kt.eat()
kt.drink()
kt.run()
kt.sleep()
kt.call()
dog =Dog()
dog.sleep()
dog.bark()
4.继承-04
重写父类方法有两种情况：
1.覆盖父类的方法
2.对父类方法进行扩展
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 HelloKitty(Cat):
def speak(self):
print '我可以说日语'
def call(self):
print 'ouhayaogaozayimasi'
kt = HelloKitty()
kt.speak()
kt.call()
5.继承-05
对父类的方法进行扩展
如果在开发中，子类的方法实现包含有父类的方法实现
（父类原本封装的方法实现时子类方法的一部分
就可以使用扩展的方法）
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 HelloKitty(Cat):
def speak(self):
print '我可以说日语'
def call(self):
print 'ouhayaogaozayimasi'
# 调用本来在父类中封装的方法
Cat.call(self)
print '@#$#$%$&^^*&'
kt = HelloKitty()
kt.speak()
kt.call()
五.多态
class Dog(object):
def __init__(self,name):
self.name = name
def game(self):
print '%s 奔跑，使劲奔跑' % self.name
class xiaotianquan(Dog):
def game(self):
print '%s 会说话' % self.name
class Person(object):
def __init__(self,name):
self.name = name
def game_with_dog(self,dog):
print '%s 和 %s 快乐的玩耍' % (self.name,dog.name)
dog.game()
#1.创建一个狗对象
#mao = Dog('猫')
mao = xiaotianquan('大猫')
#2.创建一个对象
xiaolei = Person('小雷')
#让小雷和狗玩
xiaolei.game_with_dog(mao)