一、封装
1）封装：是面向对象的一大特点；将属性和方法封装在一个抽象类中。外界使用类创建对象，然后让对象调用内部方法。对象方法的细节都被封装在类的内部。
class Person():
def __init__(self,name,weight): # 初始化方法
self.name = name
self.weight = weight
def __str__(self): # 定义返回方法
return 'my name is %s,my weight is %.2f.' %(self.name,self.weight)
def run(self): # 定义跑步方法
self.weight -= 0.5
print '每次跑步会减重0.5公斤。'
def eat(self): # 定义吃方法
self.weight += 1.0
print '每次吃东西会增重1.0公斤'
# 创建类的实例化对象，并调用方法
ming = Person('小明',65)
ming.run()
ming.eat()
print ming
lili = Person('lili',45)
lili.run()
print lili
2)举例1：
需求：摆放家具
1、房间有户型，总面积和家具名称列表。新房间五家具
2、家具上有名字和占地面积
3、将家具添加在房子中
解析如下：
# 定义一个家具类。有姓名和占地面积的属性；
class fortn():
def __init__(self,name,area):
self.name = name
self.area = area
def __str__(self):
return '%s的占地面积是%.2f' %(self.name,self.area)
# 定义房子类。有户型、总面积、剩余面积、家具的属性；方法为添加家具
class home():
def __init__(self,name,area):
self.name = name
self.area = area
self.leaveArea = area # 剩余面积初始值为总面积
self.fortn_list = []
def __str__(self):
return '户型：%s ,总面积：%.2f ,剩余面积：%.2f , 家具：%s' %(self.name,self.area,self.leaveArea,self.fortn_list)
def add_thing(self,argc):
print "要添加%s" %argc.name
if self.leaveArea < argc.area:
print "%s占地面积太大，不能添加" %argc.name
return
self.fortn_list.append(argc.name)
self.leaveArea -= argc.area
# 创建家具对象
bed = fortn('bed',4)
chest = fortn('chest',2)
table = fortn('table',1.5)
# 创建房子对象
my_house = home('两室一厅',200)
my_house.add_thing(bed)
my_house.add_thing(chest)
my_house.add_thing(table)
print my_house
举例2：
需求：士兵有枪，当枪里有子弹才可以射击
解析如下：
# 创建枪类
class Gun():
def __init__(self,model):
self.model = model
self.bullet_count = 0
def shoot(self):
if self.bullet_count <= 0:
print "%s没有子弹" %self.model
return
self.bullet_count -= 1
print '发射一次，子弹还有%s' %self.bullet_count
def add_bullet(self,count):
self.bullet_count += count
# 创建士兵类
class Sodlier():
def __init__(self,name):
self.name = name
self.gun = None # 当属性不确定的时候，可以使用None来初始化
def fire(self):
if self.gun == None:
print "%s还没有枪" %self.name
print "go to fire!%s" %self.name
self.gun.add_bullet(10)
self.gun.shoot()
# 定义枪对象
ak47 = Gun('AK47')
# ak47.add_bullet(10)
# ak47.shoot()
# 定义士兵对象
ryan = Soldier（'Ryan'）
ryan.gun = ak47
ryan.fire()
print ryan.gun
二、继承
1）继承实现的是代码的重用，相同部分代码不需要重写，分为单继承和多继承。多继承：一个子类可以继承多个父类。
2)单继承：一个子类只能继承一个父类
class Animal():
def call(self):
print "我会叫"
def run(self):
print "我会跑"
# 定义子类Cat,并重写父类的call方法
class Cat(Animal):
def call(self): # 由于和父类中的call方法重名，所以实现重写
print "我会喵喵叫～～～"
# 定义HelloKitty子类，继承Cat类
class HelloKitty(Cat):
def speak(self):
print "我会说"
# 创建对象
tom = HelloKitty()
tom.run() # 在子类中没有定义run方法，但在父类和祖父类中有
tom.call()
tom.speak(）
3)多继承：一个子类可以有多个父类
# 定义父类1
class A():
def test(self):
print "A ---> test"
def demo(self):
print "A ---> demo"
# 定义父类2
class B():
def test(self):
print "B ---> test"
def demo(self):
print "B ---> demo"
# 定义子类C，继承父类A和B的方法和属性
class C(A,B):
# 当父类中的方法同名时，按括号中父类的先后顺序继承
pass
# 定义子类的实例化对象
c = C()
c.test() # 此时调用的均为父类A的结果
c.demo()
4）继承中的重写问题：在开发过程中，若父类方法和子类方法的实现完全不同，可以重写父类方法，实现方法覆盖。
# 定义父类
class Animal():
def call(self):
print "我会叫"
def run(self):
print "我会跑"
# 定义子类Cat,并重写父类的call方法
class Cat(Animal):
def call(self): # 由于和父类中的call方法重名，所以实现重写
print "我会喵喵叫～～～"
tom.run() # 此时可以使用创建出来的对象，调用父类的方法
# 创建对象
tom = Cat()
tom.call() # 此时，调用call显示的为：我会喵喵叫
5）继承中的扩展问题 class Animal(): def call(self): print "我会叫" def run(self): print "我会跑" # 定义子类Cat,并重写父类的call方法 class Cat(Animal): def call(self): # 由于和父类中的call方法重名，所以实现重写 print "我会喵喵叫～～～" # 创建对象 tom = Cat() tom.call() # 此时，调用call显示的为：我会喵喵叫
三、多态
1）同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果
class Dog(object):
def __init__(self,name):
self.name = name
def game(self):
print "%s是一只普通的狗" %self.name
class amazing(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()
wangcai = amazing("旺财")
xiaoming = Person("小明")
xiaoming.game_with_dog(wangcai)