前言：面向对象的三大特征
1.封装:根据职责将属性和方法封装到一个抽象的类中
2.继承:实现代码的重用，相同的代码不需要重复的写
3.多态:不同的对象调用相同的方法,产生不同的结果,增加代码的灵活度
一、封装
1.基本概念
封装是从业务逻辑中抽象对象时，要赋予对象相关数据与操作，将一些数据和操作打包在一起的过程
封装是面向对象的一大特点,
面向对象编程的第一步 将属性和方法封装到一个抽象的类中
外界使用类创建对象,然后让对象调用方法
对象方法的细节都被封装在类的内部
2.实例演示
需求<1>：跑步类型
xx爱跑步 1.xx 的体重是75.0公斤 2.xx 每次跑步之后体重减轻0.5公斤 3.xx 每次吃东西之后体重增加1公斤
具体代码如下：
class Person:
def __init__(self, new_name, weight):
self.name = new_name
self.weight = weight
def __str__(self):
return 'my name is %s weight is %.2f' % (self.name, self.weight)
def run(self):
print '%s likes to run ' % self.name
# 在对象的方法内部,是可以直接访问对象的属性
self.weight -= 0.5
def eat(self):
print '%s likes to eat ' % self.name
self.weight += 1
tom = Person('tom', 75.0)
tom.run()
tom.eat()
print tom
lily = Person('lily', 50.0)
lily.run()
lily.eat()
print lily执行结果如下：
需求<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.判断家具的面积
if item.area > self.free_area:
print '%s 面积过大,无法放置' % item
# 如果不满足,下方代码不执行
return
# 2.将家具的名称添加至列表中
self.item_list.append(item.name)
# 3.计算剩余面积
self.free_area -= item.area
# 创建家具对象
bed = HouseItem('bed', 4)
print bed
chest = HouseItem('chest', 2)
print chest
table = HouseItem('table', 1.5)
print table
# 创建房子对象
my_home = House('三室两厅', 100)
# 添加家具
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print my_home代码执行结果如下:
需求<3>：士兵射击
1.士兵瑞恩有一把AK47
2.士兵可以开火
3.枪能够发射子弹（减少子弹数量 ）
4.枪能够装填子弹 （增加子弹的数量）
代码如下:
lass 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.发射子弹
self.bullet_count -= 1
# 3.提示发射信息
print '%s biu biu biu %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
self.gun.add_bullet(50)
print 'go ! %s' % self.name
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.基础概念
继承是为代码复用而设计的，是面向对象的重要特性之一。当设计一个新类的时候，如果可以继承一个已有的设计良好的类然后进行二次开发，无疑会大幅度减少工作量。
在继承关系中，已有的、设计好的类称为父类或基类，新设计的类称为子类或派生类，派生类可以继承弗雷的公有成员，但不能继承其私有成员。
Python支持多继承，如果父类中有相同的方法名，而在子类中使用时内有指定父类名，则pyhton解释器将从左向右按顺序进行搜索
2.单继承
子类拥有父类的所有属性和方法（子类只需封装自己特有的方法）
继承的语法： class 类名（父类）
def 子类特有的方法
# 继承的传递性,子类可以继承父类和父类的父类的所有属性和方法
实例<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 'miaomiao~'
class Hellokitty(Cat):
def speak(self):
print '我会说日语'
cat = Hellokitty()
cat.call()
cat.drink()
cat.eat()
cat.run()
cat.sleep()
cat.speak()
实例<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 'miaomiao~'
class Hellokitty(Cat):
def speak(self):
print '我会说日语'
def call(self):
print '你好！'
#覆盖原本在父类中封装的方法
cat = Hellokitty()
cat.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 'miaomiao~'
class Hellokitty(Cat):
def speak(self):
print '我会说日语'
def call(self):
print '你好！'
#调用原本在父类中封装的方法
Cat.call(self)
cat = Hellokitty()
cat.call()运行结果：
实例<3>：对初始化方法的重写
class Bird():
def __init__(self):
self.hunger = True
def eat(self):
if self.hunger:
print '嗝!~~'
self.hunger = False
else:
print 'no,thanks !'
class SongBird(Bird):
def __init__(self):
self.sound = 'jijizhazha!'
Bird.__init__(self)
def sing(self):
print self.sound
Vbird = SongBird()
Vbird.eat()
Vbird.sing()
3.多继承
子类拥有一个父类叫做单继承
子类可以拥有多个父类,并且具有所有父类的属性和方法
语法：
class 子类名称 (父类名1,父类名2...)
pass
实例1：
class A():
def test(self):
print 'test 方法'
class B():
def demo(self):
print 'demo 方法'
class C(A,B):
pass
c = C()
c.test()
c.demo()
实例2：
当两个父类同时拥有相同的方法名，只执行子类继承中先出现的父类的方法
class A():
def test(self):
print 'A----test 方法'
def demo(self):
print 'A----demo方法'
class B():
def demo(self):
print 'B----demo方法'
def test(self):
print 'B----test方法'
class C(B,A):
"""多继承可以让子类对象同时具有多个父类的属性和方法"""
pass
c = C()
c.test()
c.demo()
三、多态
1.基础概念
不同的子类对象调用相同的方法，产生不同的执行结果
多态意味着多种形式，当用面向对象时，它是指对象是怎么回应一个依赖于对象类型或种类的消息。多态的作用是让程序在不同情况下用一个函数名启用不同的方法
2.实例演示
class Dog(object):
def __init__(self, name):
self.name = name
def game(self):
print '%s 蹦蹦跳跳' % self.name
class Xtdog(Dog):
def game(self):
print '%s 欢欢乐乐' % self.name
class Person(object):
def __init__(self, name):
self.name = name
def play_with(self, dog):
print '%s 和 %s 欢乐的玩' % (self.name, dog.name)
dog.game()
# 1.创建一个DOG对象
dog = Xtdog('中华田园犬')
# 2.创建一个person对象
lee = Person('lee')
# 让lee和dog玩耍
lee.play_with(dog)
另一个状态：
四、新式类、旧式类
1.新式类[object为基类]
In [1]: class A(object):
...: pass
...:
In [2]: a = A()
# dir可以查看调用的方法有哪些
In [3]: dir(a)
2.旧式类[经典类]
In [5]: class B():
...: pass
...:
In [6]: b = B()
In [7]: dir(b)
