面向对象的三大特性
1.封装:根据职责将属性和方法封装到一个抽象的类中
2.继承:实现代码的重用,相同的代码不需要重复的写
3.多态:不同的对象调用相同的方法,产生不同的结果,
增加代码的灵活度
封装:
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步 将属性和方法封装到一个抽象的类中
3.外界使用类创建对象,然后让对象调用方法
4.对象方法的细节都被封装在类的内部
需求:xbw爱跑步
1.xbw体重75.0公斤
2.xbw每次跑步会减肥0.5公斤
3.xbw每次吃东西体重会增加1公斤
第一种方法:
class Person():
def __init__(self,name):
self.name = name
print '%s 爱跑步' %self.name
def run(self,weight):
self.weight = weight
self.weight -=0.5
print '%s 体重: %.2f ' %(self.name,self.weight)
def eat(self,weight):
self.weight = weight
self.weight +=1
print '%s 体重 %.2f ' %(self.name,self.weight)
xbw = Person('xbw')
xbw.eat(90)
xbw.run(90)
第二种方法:
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(self):
self.weight -=0.5
print '%s 爱跑步 ' %self.name
def eat(self):
self.weight +=1
print '%s 吃东西 ' %self.name
xbw = Person('xbw',75)
xbw.eat()
#xbw.run()
print xbw
例子:摆放家具
需求:
1.房子有户型,总面积和家具名称列表
新房子没有任何家具
2.家具有名字和占地面积,其中
床:占4平米
衣柜:占2平米
餐桌:占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时,要求输出:户型,总面积,剩余面积,家具名称列表
class Furnature():
def __init__(self,name,squre):
self.name = name
self.squre = squre
def __str__(self):
return '[%s] 占地 %.2f' %(self.name,self.squre)
class House():
def __init__(self,house_type,house_squre):
self.house_type = house_type
self.house_squre = house_squre
#剩余面积
self.free_squre = house_squre
#家具名称列表
self.item_list = []
def __str__(self):
return '户型:%s\n总面积:%.2f[剩余面积: %.2f]\n家具:%s' % (
self.house_type, self.house_squre, self.free_squre, self.item_list)
def add_item(self,item):
print '要添加 %s' %item
#1.判断家具的面积
if item.squre > self.free_squre:
print '%s 的面积太大了,无法添加' %item.name
return
#2.将家具名称加到列表中
self.item_list.append(item.name)
self.free_squre -= item.squre
#1.创建家具
bed = Furnature('bed',4)
print bed
chest = Furnature('chest',2)
print chest
desk = Furnature('desk',1.5)
print desk
#2.创建房子对象
my_home = House('两室一厅',100)
my_home.add_item(bed)
my_home.add_item(desk)
my_home.add_item(chest)
print my_home
例子:士兵上战场
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪能够发射子弹(把子弹发射出去)
4.枪能够装填子弹(增加子弹的数量)
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.发射子弹
self.bullet_count -= 1
# 3.提示发射子弹
print '%s 突突突 %d' %(self.model,self.bullet_count)
class Solider():
def __init__(self,name):
self.name = name
self.gun = None
def fire(self):
#1.判断士兵有没有枪
if self.gun == None:
print '%s 还没有枪。。' %self.name
return
#2.高喊口号
print 'go go go %s ' %self.name
#3.让枪装填子弹
self.gun.add_bullet(80)
#4.让枪发射子弹
self.gun.shoot()
#创建枪
ak47 = Gun('AWM')
#ak47.add_bullet(50)
#ak47.shoot()
#创建士兵
ryan = Solider('Ryan')
ryan.gun = ak47
ryan.fire()
#print ryan
继承
新式类:定义时,继承类括号里继承object这个基类
(经典类)旧式类:没有继承object这个基类,括号里可以不写
单继承
1.继承的概念:语法和特点
继承的概念:子类拥有父类u的所有方法和属性(子类只需封装自己特有的方法)
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 '喵喵~'
jiafei = Cat()
jiafei.eat()
jiafei.drink()
jiafei.run()
jiafei.sleep()
jiafei.call()
继承的传递性:
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 jiafeicat(Cat):
def speak(self):
print '我可以和人类交流'
jiafei = jiafeicat()
#继承的传递性,子类拥有父类和父类的父类的属性和方法
jiafei.eat()
jiafei.drink()
jiafei.run()
jiafei.sleep()
jiafei.call()
#子类可以继承自父类的所有属性和方法
jiafei.speak()
#子类继承自父类,可以直接享受父类中已经封装好的方法
#子类中应该根据自己的职责,封装子类特有的属性和方法
覆盖父类的方法:
如果在开发中,父类的方法的实现和子类方法的实现,
完全不同,就可以使用覆盖的方式,在子类中重新编写父类的方法
具体实现方式,就相当于在子类中定义了
一个和父类同名的方法并且实现
重写之后,在运行时,只会调用子类的重写方法,
而不会再调用父类封装的方法
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 jiafeicat(Cat):
def speak(self):
print '我可以和人类交流'
def call(self):
print '偶哈哟 空你吉哇'
jiafei = jiafeicat()
#如果子类中,重写了父类的方法
#在运行中,只会调用子类中重写的方法,不会调用父类的方法
jiafei.call()
对父类的方法进行扩展
如果在开发中,子类的方法实现包含有父类的方法
(父类原本封装的方法实现是子类方法的一部分就可以使用扩展方法)
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 jiafeicat(Cat):
def speak(self):
print '我可以和人类交流'
def call(self):
print '偶哈哟 空你吉哇'
Cat.call(self)
print '#$@$%#@@'
jiafei = jiafeicat()
jiafei.call()
继承的例子:定义一个狗类,再定义一个会唱歌的狗类
创建出来的狗对象会唱歌而且也会平常狗的叫声
class Dog():
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print 'Aaaaa...'
self.hungry = False
else:
print 'no thanks!'
class SongDog(Dog):
def __init__(self):
self.sound = 'lalalal'
Dog.__init__(self)
def sing(self):
print self.sound
dog = Dog()
#dog.eat()
littledog = SongDog()
littledog.eat()
littledog.sing()
多继承
子类拥有一个父类叫做单继承
子类可以拥有多个父类,并且具有所有父类的属性和方法
多继承时,如果不同类,有相同方法名,会继承首个继承的类
例如:孩子会继承自己父亲和母亲的特性
语法:
class 子类名 (父类名1,父类名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():
def hello(self):
print 'hello 方法'
#多继承时,如果不同类,有相同方法名,会继承首个继承的类
class D(B,A,C):
"""多继承可以让子类对象,同时具有多个父类的属性和方法"""
pass
d = D()
d.demo()
d.test()
d.hello()
多态
多态:
不同的子类(这是之前提到的继承的知识)
对象调用相同的方法,产生不同的执行结果
class Dog():
def __init__(self,name):
self.name = name
def game(self):
print '%s 蹦蹦跳跳的玩' %self.name
class God(Dog):
def game(self):
print '%s 飞到天上玩' %self.name
class Person(object):
def __init__(self,name):
self.name = name
def play_with_dog(self,dog):
print '%s 和 %s 快乐的玩耍' %(self.name,dog.name)
dog.game()
#创建一个狗对象
#duoduo = Dog('多多')
duoduo = God('多多')
#创建一个人对象
xiaoming = Person('小明')
#让人和狗玩
xiaoming.play_with_dog(duoduo)