Python中的面向对象（二）封装、继承和多态

一、封装
封装是面向对象编程的一大特点

1）将属性和方法封装到一个抽象的类中
2）外界使用类创建对象，对象调用方法
3）对象方法的细节都被封装在类的内部

例1：
需求
1.李雷体重75.0公斤
2.李雷每次跑步会减肥0.5公斤
3.李雷每次吃东西体重会增加1公斤

需求
1.李雷和韩梅梅都爱跑步
2.韩梅梅体重45.0公斤
3.李雷体重75.0公斤
4.每次跑步都会减少0.5公斤
5.每次吃东西都会增加1公斤

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):
        print('%s爱跑步' %self.name)
        self.weight -= 0.5

    def eat(self):
        print('%s吃东西' %self.name)
        self.weight += 1

Lilei = Person('李雷',75.0)
Lilei.run()
print(Lilei)
Lilei.eat()
print(Lilei)
结果：
李雷爱跑步
我的名字叫 李雷 体重是 74.50
李雷吃东西
我的名字叫 李雷 体重是 75.50

练习一：
需求：
1.房子有户型，总面积和家具名称列表
新房子没有任何的家具

2.家具有名字和占地面积，其中
床：占4平米
衣柜：占2平米
餐桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表

class Furniture():

    def __init__(self,name,area):
        self.name = name
        self.area = area

    def __str__(self):
        return '[%s]占地: %.2f' %(self.name,self.area)


# bed = Furniture('bed',4)
# print(bed)

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):
        #1.判断家具的面积
        if item.area > self.free_area:
            print('%s 的面积太大，无法添加' %item.name)

        #2.添加家具
        self.item_list.append(item.name)

        #3.计算剩余面积
        self.free_area -= item.area

bed = Furniture('bed',4)
print(bed)
yigui = Furniture('yigui',200)
print(yigui)
table = Furniture('table',1.5)
print(table)

my_house = House('独门独栋',400)

my_house.add_item(bed)
my_house.add_item(yigui)
my_house.add_item(table)
print(my_house)

结果：
[bed]占地: 4.00
[yigui]占地: 200.00
[table]占地: 1.50
户型: 独门独栋
总面积: 400.00[剩余面积: 194.50]
家具:['bed', 'yigui', 'table']

练习二：
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量

Soldier                     Gun
-------------               -----------------
name                        model
gun                         bullet_count #子弹数量足够多才能完
                                          成射击的动作
-------------               -----------------
__init__(self):                 __init__(self):
fire(self):                 add_bullet(self,count):#装填子弹的
                                                    方法
                            shoot(self):

代码：

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):
        if self.bullet_count <= 0:
            print('%s没有子弹了...' %self.model)

        self.bullet_count -= 1
        print('%s ... %s' %(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)

        self.gun.add_bullet(5)
        self.gun.shoot()


ak47 = Gun('ak47')
ak47.add_bullet(20)
ak47.shoot()

ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()

结果：
ak47 ... 19
ak47 ... 23

二、继承

封装：根据职责将属性和方法封装到一个抽象的类中
继承：实现代码的重用，相同的代码不用重复写

1.继承

子类继承父类，可以直接享受父类中已经封装好的方法
子类中应该根据职责，封装子类特有的属性和方法

2.继承的传递性

子类可以继承弗雷所有的属性和方法
继承具有传递性，子类拥有父类的属性和方法

3.对父类重写

当父类的方法不能满足子类的需求时，可以对父类进行重写
1）覆盖父类的方法
2）对父类的方法进行拓展

如果子类中重写了父类的方法，运行时只会调用子类中重写的方法，不会调用父类的方法

4.多继承

如果两个类的方法一样的话，前面的类会把后面类的方法覆盖掉

例1：继承

class Animal():

    def eat(self):
        print('吃')

    def drink(self):
        print('喝')

    def run(self):
        print('跑')

    def sleep(self):
        print('睡')

class Cat(Animal):
    # def eat(self):
    #     print('吃')
    #
    # def drink(self):
    #     print('喝')
    #
    # def run(self):
    #     print('跑')
    #
    # def sleep(self):
    #     print('睡')
    def shout(self):
        print('喵')
##创建一个猫对象
fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.run()
fentiao.sleep()
fentiao.shout()
结果：
吃
喝
跑
睡
喵

例2：继承的传递性

class Animal():

    def eat(self):
        print('吃')

    def drink(self):
        print('喝')

    def run(self):
        print('跑')

    def sleep(self):
        print('睡')

class Cat(Animal):
    def shout(self):
        print('喵')


class Hellokitty(Cat):
    def speak(self):
        print('我会说日语')

class Dog(Animal):
    def bark(self):
        print('汪')

kt = Hellokitty()
kt.speak()
kt.shout()
kt.eat()
kt.sleep()
结果：
我会说日语
喵
吃
睡

例3：覆盖父类的方法

class Animal():

    def eat(self):
        print('吃')

    def drink(self):
        print('喝')

    def run(self):
        print('跑')

    def sleep(self):
        print('睡')

class Cat(Animal):
    def shout(self):
        print('喵')

class Hellokitty(Cat):
    def speak(self):
        print('我可以说日语')
    def shout(self):    ##覆盖父类的方法
        print('@#$%%@$#@#@$')

kt = Hellokitty()
kt.shout()
结果：
@#$%%@$#@#@$

例4：前后顺序

class A():
    def test(self):
        print('A --- test方法')
    def demo(self):
        print('A --- demo方法')

class B():
    def test(self):
        print('B --- test 方法')
    def demo(self):
        print('B --- demo方法')

class C(A,B):
    pass

c = C()
c.test()
c.demo()
结果：
A --- test方法
A --- demo方法

5.新式类和旧式(经典)类：
object是Python为所有对象提供的基类，提供有一些内置的属性和方法
，可以使用dir函数查看
新式类：以object为基类的类，推荐使用
经典类：不以object为基类的类，不推荐使用
在python3.X中定义的类时，如果没有指定父类，会默认使用object作>为基类–python3.x中定义的类都是新式类
在python2.x中定义类时，如果没有指定父类，则不会以object作为基>类
为保证编写的代码能够同时在python2.x和python3.x运行
今后在定义类时，如果没有父类，建议统一继承自object

三、多态

子类和父类存在相同方法时，子类会覆盖父类方法
运行时总会调用子类方法---->多态
多态(以封装和继承为前提)
不同的子类对象调用相同的方法，产生不同的执行结果
例：

class Animal(object):
    def run(self):
        print('running...')
    def cry(self):
        print('crying...')

class Dog(Animal):
    def run(self):
        print('dog running...')

    def eat(self):
        print('dog eating...')

class Cat(Animal):
    def run(self):
        print('cat running...')

cat = Cat()
cat.run()

dog = Dog()
dog.run()

结果：
cat running...
dog running...