多继承 与 多重继承

Posted 2023-04-16

参考技术A

多继承是指 一个子类继承多个父类 。多继承对父类的个数没有限制，继承方式可以是公共继承、保护继承和私有继承。不写继承方式， 默认是私有继承 。

多继承下派生类的定义格式如下：

按照继承的规定，派生类 C 的成员 包含了基类 A、B 中成员以及该类本身的成员 。

派生类构造函数执行顺序是先执行所属基类的构造函数，再执行派生类本身构造函数，处于同一层次的各基类构造函数的执行顺序取决于定义派生类时所指定的各基类顺序，与派生类构造函数中所定义的成员初始化列表的各项顺序无关。

下面通过一个例子来说明派生类构造函数的构成及其执行顺序：

该程序的输出结果为：

在该程序中，作用域运算符 :: 用于解决作用域冲突的问题。在派生类 A 中的 print() 函数的定义中，使用了 B1::print; 和 B2::print(); 语句分别指明调用哪一个类中的 print() 函数，否则会出现 二义性问题 。

如果是基类和派生类中出现同名函数，不存在二义性问题，规定派生类的成员将支配基类中的同名成员，即派生类的对象只会使用派生类的该函数。

当一个派生类 C 从多个基类派生（B1、B2...），而这些基类又有一个共同的基类 A，则对该 A 类中声明的成员进行访问时，也可能会出现二义性。应以作用域 B1:: 或 B2:: 等来限定。

由于二义性的原因，一个类不可以从同一个类中直接继承一次以上，例如：

当 B 类从 A 类派生，C 类从 B 类派生，此时称为多重继承。

当实例化子类时，会首先依次调用所有基类的构造函数，最后调用该子类的构造函数；销毁该子类时则相反，先调用该子类的析构函数，再依次调用所有基类的析构函数。

无论继承的层级有多少层，子类都可以与其直接父类或间接父类构成 “is a” 的关系，并且能够通过父类的指针对直接子类或间接子类进行相应的操作，子类对象可以给直接父类或间接父类的对象或引用赋值或初始化。

python super()函数的用法与多重继承

super()函数可以用于继承父类的方法，语法如下：

    super(type[, object-or-type])

虽然super()函数的使用比较简单，但是需要根据单继承和多继承来分析函数的调用关系。

首先，当类之间的继承关系为单继承时，函数调用关系也比较简单，可以参考如下的例子：

 1 #!/usr/bin/env python3
 2 
 3 class A(object):
 4     def __init__(self):
 5         print(‘class A‘)
 6 
 7 class B(A):
 8     def __init__(self):
 9         super(B, self).__init__()
10         print(‘class B‘)
11 
12 b = B()

上述代码运行结果如下：

class A
class B

从结果可以看出，子类B在实例化时调用了父类A的__init__()方法。

当进行多重继承时，需要考虑MRO的问题。所谓MRO，即Method Resolution Order，自Python2.3以来，MRO采用广度优先（区别于深度优先）的规则定义。为了更好的理解这个问题，让我们先来看如下的代码：

 1 #!/usr/bin/env python3
 2 
 3 class A(object):
 4     def __init__(self):
 5         self.n = 10
 6     
 7     def minus(self, m):
 8         print(‘minus in class A start‘)
 9         self.n -= m
10         print(‘minus in class A end‘)
11 
12 class B(A):
13     def __init__(self):
14         self.n = 7
15 
16     def minus(self, m):
17         print(‘minus in class B start‘)
18         super(B, self).minus(m)
19         self.n -= 2
20         print(‘minus in class B end‘)
21 
22 class C(A):
23     def __init__(self):
24         self.n = 12
25 
26     def minus(self, m):
27         print(‘minus in class C start‘)
28         super(C, self).minus(m)
29         self.n -= 5
30         print(‘minus in class C end‘)
31 
32 class D(B,C):
33     def __init__(self):
34         self.n = 15
35 
36     def minus(self, m):
37         print(‘minus in class D start‘)
38         super(D, self).minus(m)
39         self.n -= 2
40         print(‘minus in class D end‘)
41 
42 print(‘The MRO of class D is :‘)
43 print(D.__mro__)
44 
45 d = D()
46 d.minus(2)
47 print(d.n)

代码运行结果：

The MRO of class D is :
(<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>)
minus in class D start
minus in class B start
minus in class C start
minus in class A start
minus in class A end
minus in class C end
minus in class B end
minus in class D end
4

从运行结果可以看出，子类D的MRO为(<class ‘__main__.D‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>)，也就是子类D的minus函数在调用父类函数时的调用顺序依次为BCA，而后续的调试打印信息也正好验证了该顺序。