面向对象三大特性之继承

面向对象的三大特性之继承

大体思路

    继承
        继承和抽象 两个概念
        单继承
            语法 ： 父类 子类
            继承与重用
                子类可以使用父类中的名字（变量和方法）
            继承与派生
                子类在父类的基础上又新创建了自己需要的方法和属性
            父类有的子类没有 - 子类对象直接调用 就会直接执行父类的方法
            父类有的子类也有 - 子类对象调用 直接执行子类中的方法
                              想在子类中使用父类的名字 ： 父类名、super()去调用
            规范的编程模式
                抽象类
        多继承
            语法
            接口
            新式类和经典类
                新式类中
                    所有的多继承关系寻找方法的顺序  -  遵循广度优先算法
                    继承object
                    mro方法
                    super : super不是单纯的找父类，而是遵循mro顺序的

                经典类
                    python2.x
                    不主动继承object
                    经典类在找父类中方法的过程中 遵循 —— 深度优先
                    不提供mro方法和super

 

先抽象  后继承

 

猫类 ：
    属性 ： 名字，品种，食物
    方法 ： 叫，抓老鼠，吃，喝
狗类 ：
    属性 ： 名字，品种，食物
    方法 ： 叫，看家，吃，喝
class Animal:
    def __init__(self,name,kind,food,laguage):
        self.name=name
        self.king=kind
        self.food=food
        self.language=laguage
    def yell(self):
        print('%s叫'%(self.language))
    def eat(self):
        print('吃%s'%(self.food))
    def drink(self):
        print('喝水')
class Cat(Animal):
    def catch_mouse(self):
        print('抓老鼠')
class Dog(Animal):
    def look_after_house(self):
        print('看家')
cat1=Cat('阿猫','橘猫','牛杂','喵喵')
print(cat1.name)　　#阿猫
cat1.drink()　　#喝水
cat1.eat()　　#吃牛杂
cat1.yell()　　#喵喵叫

 

继承
父类/超类/基类：Animal
子类/派生类：Cat  Dog
继承与重用---父类中所有的属性和方法都可以被子类使用了

class Animal:
    def __init__(self,name,kind,food,laguage):
        self.name=name
        self.king=kind
        self.food=food
        self.language=laguage
    def yell(self):
        print('%s叫'%(self.language))
    def eat(self):
        print('吃%s'%(self.food))
    def drink(self):
        print('喝水')
class Cat(Animal):
    def __init__(self,name,kind,food,laguage,eye_color):
        self.eye_color=eye_color    
        Animal.__init__(self,name,kind,food,laguage)
        super().__init__(name,kind,food,laguage)
    def catch_mouse(self):
        print('抓老鼠')
    def eat(self):
        Animal.eat(self)   # 在子类中调用父类的方法
        super().eat()        #功能是一样的
        self.weight=10
class Dog(Animal):
    def look_after_house(self):
        print('看家')
阿猫 = Cat('阿猫','橘猫','牛杂','喵喵','绿色')
print(阿猫.eye_color)
print(阿猫.food)
阿猫.catch_mouse()
阿猫.eat()
print(阿猫.weight)

 

当子类中有要被调用的方法的时候子类的对象会直接选择子类中的方法、变量，父类中的方法不会被自动执行。
如果我们既想执行子类的方法，又想执行父类的方法，那么需要在子类的方法中调用父类的方法。
父类名.方法(self......)
super().方法名(.......)　　帮助我们在子类中调用父类的方法
面试题：

class Foo:
    def  __init__(self):
        self.func()
    def func(self):
        print('in Foo')
class Son(Foo):
    def func(self):
        print('in Son')
s1=Son()

抽象类：
抽象类是一个规范，它基本不会实现什么具体的功能，抽象类不能被实例化。
要想写一个抽象类：
　　from abc import ABCMeta，abstractclassmethod
　　在这个类创建饿时候指定meteclass =ABCMeta
　　在你希望子类实现的方法上加上一个@abstractmethod装饰器
使用抽象类：
　　继承这个类
　　必须实现这个类中被@abstractmethod装饰器装饰的方法

多继承
　　多继承：python、c++
　　　　　　java、c#没有

多继承

天鹅  飞 游泳 走路
老虎  走路 游泳
鹦鹉  飞 说话 走路
class Animal:
    def __init__(self,name):
        self.name=name
class FlyAnimal(Animal):
    def fly(self):
        print('%s在飞'%self.name)
class WalkAnimal(Animal):
    def walk(self):
        print('%s再走路'%self.name)
class SwimAnimal(Animal):
    def swim(self):
        print('%s在游泳'%self.name)
class Tiger(SwimAnimal,WalkAnimal):
    pass
class Swan(SwimAnimal,WalkAnimal,FlyAnimal):
    pass
class Parrot(FlyAnimal,WalkAnimal):
    def talk(self):
        print('%s说话了'%self.name)
swan=Swan('天鹅')
swan.fly()
swan.walk()

新式类

在python3.X中，所有的类都是新式类

所有的新式类都有一个默认的父亲：object

python2.7

经典类与新式类共存

没有继承object的类是经典类

 

多继承的顺序：在新式类和经典类之间的区别

新式类中：

　　所有的多继承关系寻找方法的顺序——遵循广度优先算法

　　继承object

　　mro方法

　　super：super不是单纯的找父类，而是遵循mro顺序的

经典类：

python2.x

　　不主动继承object

　　经典类在找父类中方法的过程中遵循——深度优先

　　不提供mro和super

　　一条路走到头，再换下一条