面向对象编程——多重继承（七）

1.继承

继承：至少两个类，表达的是什么是什么的关系。继承存在单继承和多继承。

子类要是没有__init__，就调用父类的，子类要是有__init__，就调用自己的，也可以引用父类的。

class Animal(object):
    def __init__(self,name,aggressivity,life_value):
        self.name = name  # 每一只狗都有自己的昵称;
        self.aggressivity = aggressivity  # 每一只狗都有自己的攻击力;
        self.life_value = life_value  # 每一个角色都有自己的生命值;
    def eat(self):
        self.life_value += 100

class Dog(Animal):  # 定义一个狗类
    def __init__(self, name, breed, aggressivity, life_value):
        # Animal.__init__(self,name,aggressivity,life_value)
        super().__init__(name,aggressivity,life_value)
        self.breed = breed
    def bite(self,people):
        people.life_value -= self.aggressivity

class Person(Animal):  # 定义一个人类
    def __init__(self, name, aggressivity, life_value, money):
        # Animal.__init__(name,aggressivity,life_value)
        super().__init__(name,aggressivity,life_value)
        self.money = money

    def eat(self):
        print("woshi666")

taibai = Person('taiba',50,250,200)  #创建一个对象
print(taibai.life_value)    #可以调用类的属性初始化
taibai.eat()     #调用子类的函数
Animal.eat(taibai)   #就是要调取父类
super(Person,taibai).eat()   #就是要调取父类
print(taibai.life_value)

子类之中有，但又想调用父类之中的，有两种方法：

（1）类名.方法（实例）

（2）super(类，对象).方法

2.钻石继承

在python中，允许子类继承多个基类，这种特性就是通常所说的多重继承。

在python3之前版本中存在经典类，所谓的经典类没有指定基类的类，不过在python3中，已经不存在经典类，没有指定基类的以object作为基类。

在经典类中，继承的法则是深度优先。

 

>>> class D:
...     def eat(self):
...         print("D")
...
>>> class C(D):
...     def eat(self):
...         print('C')
...
>>> class B(D):
...     pass
...
>>> class A(B,C):  #在B里，会选择D而不会选B，这就是深度优先
...     pass
...
>>> a = A()
>>> a.eat()
D 

在新式类中，继承的法则是广度优先。

 

 

>>> class D(object):
...     def eat(self):
...         print('D')
...
>>> a.eat()
D
>>> class C(D):
...     def eat(self):
...         print("C")
...
>>> class B(D):
...     pass
...
>>> class A(B,C):
...     pass
...
>>> a = A()
>>> a.eat()   #C和D之间选C，
C

一般情况类的继承不会超过4层，下面列出几种稍微复杂的情况。

 

class F(object):
    def eat(self):
        print("F")

class E(F):
    def eat(self):
        print("E")

class D(F):
    def eat(self):
        print("D")

class C(E):
    def eat(self):
        print("C")

class B(D):
    def eat(self):
        print("B")

class A(B,C):
    pass
    def eat(self):
        print("A")

在python3中可以查询继承的顺序。

print(A.mro())

[<class '__main__.A'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.C'>, <class '__main__.E'>, <class '__main__.F'>, <class 'object'>]

 

相关知识：

在python2.2之前，python中使用经典类，经典类是一种没有继承的类，所有类型都是type类型，如果经典类作为父类，子类调用父类构造函数会报错。

在python2.2开始，为了使类的内置类型更加统一，引入了新式类，新式类每个类都继承自一个基类，默认自object，子类可以调用基类的构造函数，由于所有类都有一个公共的祖先类，所以新式类不能使用深度优先（DFS）。

 

转载于:https://www.cnblogs.com/yangmingxianshen/p/7873884.html