python之面向对象（封装，继承，多态）

面向对象的三大特性

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()
#子类继承自父类,可以直接享受父类中已经封装好的方法
#子类中应该根据自己的职责,封装子类特有的属性和方法

覆盖父类的方法：

如果在开发中,父类的方法的实现和子类方法的实现,
完全不同,就可以使用覆盖的方式,在子类中重新编写父类的方法

扫描二维码关注公众号，回复： 2339179 查看本文章

具体实现方式,就相当于在子类中定义了
一个和父类同名的方法并且实现
重写之后,在运行时,只会调用子类的重写方法,
而不会再调用父类封装的方法

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)