Python——面向对象三大核心思想：封装，继承和多态

封装

1.基本概念

• 将属性和方法封装到一个抽象的类中；外界使用类创建对象，对象调用方法；对象方法的细节都被封装再类的内部
• 封装就是把同一类型的东西放在一起，通过self.xxx去调用。
  举例一：

老李今年50岁，身高1.75，每天早上要跑步，会去吃东西
老吴今年36岁，身高1.85，老吴不跑步，老吴喜欢吃东西
类：Person
属性：name，age，height
方法：run()，eat()

代码如下：

class People():
    def __init__(self,name,age,height):
 	    #类里的self实质就是对象本身
        #self是对象，name是属性，self.name就是将对象和属性封装在一起
        self.name = name
        self.age = int(age)
        self.height = float(height)
        print('%s今年%d岁,身高%.2f' %(self.name,self.age,self.height))
    def run(self):
        print('每天早上要跑步')
    def eat(self):
        print('会去吃东西')
people = People('老李',50,1.75)
people.run()
people.eat()
people = People('老吴',36,1.85)
people.run()
people.eat()

举例二：

一只黄色的狗叫旺财
看见生人汪汪叫
看见家人摇尾巴
类：Dog
属性：name，color
方法：shout()，shake()

代码如下：

class Dog():
    def __init__(self,name,color):
        self.name = name
        self.color = color
        print('一只%s色的狗叫%s' %(self.color,self.name))
    def shout(self):
        print('看见生人汪汪叫')
    def shake(self):
        print('看见家人摇尾巴')
wangcai = Dog('旺财','黄')
wangcai.shout()
wangcai.shake()

举例三：

需求：
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('床',4)
# print(bed)
class House():
    def __init__(self,house_type,area):
        self.house_type = house_type
        self.total_area = area
        self.free_area = area   #新房子,没有任何家具，剩余面积等于总面积
        self.item_list = []
    def __str__(self):
        return '户型:%s\n总面积:%.2f[剩余面积:%.2f]\n家具: %s' %(self.house_type,self.total_area,self.free_area,self.item_list)
    def add_Furniture(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)
yigui = Furniture('yigui',2)
table = Furniture('table',1.5)

my_house = House('别墅',1000)
my_house.add_Furniture(bed)
my_house.add_Furniture(yigui)
my_house.add_Furniture(table)
print(my_house)

举例四：

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):
        if self.bullet_count <= 0:
            print('%s没有子弹了...' %self.model)
        else:
            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)  #给枪添加5发子弹
        self.gun.shoot()
ak47 = Gun('ak47')
ak47.add_bullet(20)
ak47.shoot()

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

继承

继承的基本概念

• 封装：根据职责将属性和方法封装到一个抽象的类中
• 继承：实现代码的重用，相同的代码不需要重复的写
  定义一个类，可以从现有的某个类继承
  新的类称为子类、扩展类(Subclass),被继承的称为父类、基类、超类(Baseclass、Superclass)
  举例一：

class Father():  #父类
    def __init__(self,name,age):
        #构造方法在时例化对象时会自动执行
        self.name = name
        self.agr = age
    def eat(self):
        print('%s正在吃...'%self.name)
    def sleep(self):
        print('%s正在睡...' %self.name)
class Son(Father):   #子类继承Father类
    def eat(self):
        # super(Son,self).eat()    #和Father.eat(self)效果相同
        Father.eat(self)
        print('%s倒立吃饭...' %self.name)
father = Father('老张',40)
son = Son('小张',18)
son.eat()  #实例化对象默认执行构造方法，子类没有的方法会调用父类的
son.sleep()

举例二：
继承具有传递性，子类拥有父类的父类的属性和方法

class Animal():
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def sleep(self):
        print('睡')
class Cat(Animal):
    def yell(self):
        print('喵~')
class HelloKitty(Cat):
    def speak(self):
        print('我会说话!')
hk = HelloKitty()
hk.eat()    #继承具有传递性,子类拥有父类的父类的属性和方法
hk.drink()
hk.sleep()
hk.yell()
hk.speak()

当父类的方法不能满足子类的需求的解决方法

• 对方法进行重写
• 覆盖父类的方法
• 对父类的方法进行扩展
  举例三：

class Animal():
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def sleep(self):
        print('睡')
class Cat(Animal):
    def yell(self):
        print('喵~')
class HelloKitty(Cat):
    def speak(self):
        print('我会说话!')
    def eat(self):    #对eat方法重写
        print('要减肥！')
hk = HelloKitty()
hk.eat()    
hk.yell()
hk.speak()

注：如果子类中重写了父类的方法，再运行时，只会调用在子类中重写的方法。

父类的继承顺序

举例四：

class A():
    def test(self):
        print('A --- test方法')
    def demo1(self):
        print('A --- demo1方法')
class B():
    def test(self):
        print('B --- test方法')
    def demo(self):
        print('B --- demo方法')
class C(B,A): #B在A前，所以执行B
    pass
c = C()   
c.test()   
c.demo1()

新式类和经典类

新式类和旧式(经典)类：
object是Python为所有对象提供的基类，提供有一些内置的属性和方法，可以使用dir函数查看

• 新式类：以object为基类的类，推荐使用
• 经典类：不以object为基类的类，不推荐使用

在python3.X中定义的类时，如果没有指定父类，会默认使用object作>为基类–python3.x中定义的类都是新式类
在python2.x中定义类时，如果没有指定父类，则不会以object作为基>类
为保证编写的代码能够同时在python2.x和python3.x运行，今后在定义类时，如果没有父类，建议统一继承自object

多态

• 对扩展开放：允许子类重写方法
• 对修改封闭：不修改，直接继承父类方法
• 子类和父类存在相同方法时，子类会覆盖父类方法
• 运行时总会调用子类方法–> 多态
  举例一：

class Student():
    def get_score(self):
        print('获取学生成绩')
class Chinese():
    def get_score(self):
        print('获取语文成绩...')
class Math():
    def get_score(self):
        print('获取数学成绩...')
student1 = Student()
student2 = Chinese()
student3 = Math()
student1.get_score()
student2.get_score()
student3.get_score()

举例二：

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()