继承的进阶---多继承新式类广度优先，多继承经典类深度优先

继承的进阶

继承：单继承，多继承(有python有多继承，java没有)
类：经典类，新式类
新式类：凡是继承object类都是新式类
python3X 中所有的类都是新式类,因为python3x中的类都默认继承object

经典类：不继承object类都是新式类，只存在python2（既有新式类，又有经典类）里面，所有的类都是默认经典类。可以加object，变成新式类。

单继承：新式类，经典类查询顺序一样

自己有，先执行自己类里面的

class A:
    def func(self):
        print("IN A")


class B(A):
    def func(self):
        print("IN B")


class C(B):
    def func(self):
        print("IN C")


c1 = C()
c1.func()
# 结果
# IN C

自己没有了，执行父类的

class A:
    def func(self):
        print("IN A")


class B(A):
    def func(self):
        print("IN B")


class C(B):
    pass


c1 = C()
c1.func()
# 结果
# IN B

父类没有了，在向上面找

class A:
    def func(self):
        print("IN A")


class B(A):
    pass


class C(B):
    pass


c1 = C()
c1.func()
# 结果
# IN A

多继承：
新式类：查询顺序广度优先
经典类：查询顺序深度优先

多继承的新式类：
广度优先：每个节点有且只走一次。是一个很复杂的算法。
这样理解：最顶上那个基类，如果别的路能够到达，自己这条路就不走了。
最顶上的基类，如果别的路走不通，就一定走。（有图，钻石继承）

多继承的新式类 广度优先：一条路走到倒数第二级，判断,如果其他路能走到终点则返回走另一条路如果不能，则走到终点

下面是在一步一步验证多继承
1

class A:
    def func(self):
        print("IN A")


class B(A):
    def func(self):
        print("IN B")


class C(A):
    def func(self):
        print("IN C")


class D(B):
    def func(self):
        print("IN D")


class E(C):
    def func(self):
        print("IN E")


class F(D, E):  # 这就是多继承
    def func(self):
        print("IN F")


f1 = F()
f1.func()
# 结果：
# IN F

2

class A:
    def func(self):
        print("IN A")


class B(A):
    def func(self):
        print("IN B")


class C(A):
    def func(self):
        print("IN C")


class D(B):
    def func(self):
        print("IN D")


class E(C):
    def func(self):
        print("IN E")


class F(D, E):  # 这就是多继承
    pass


f1 = F()
f1.func()
# 结果：
# IN D

3

class A:
    def func(self):
        print("IN A")


class B(A):
    def func(self):
        print("IN B")


class C(A):
    def func(self):
        print("IN C")


class D(B):
    pass


class E(C):
    def func(self):
        print("IN E")


class F(D, E):  # 这就是多继承
    pass


f1 = F()
f1.func()
# 结果：
# IN B

4

class A:
    def func(self):
        print("IN A")


class B(A):
    pass


class C(A):
    def func(self):
        print("IN C")


class D(B):
    pass


class E(C):
    def func(self):
        print("IN E")


class F(D, E):  # 这就是多继承
    pass


f1 = F()
f1.func()
# 结果：
# IN E

5

class A:
    def func(self):
        print("IN A")


class B(A):
    pass


class C(A):
    def func(self):
        print("IN C")


class D(B):
    pass


class E(C):
    pass


class F(D, E):  # 这就是多继承
    pass


f1 = F()
f1.func()
# 结果：
# IN C

6

class A:
    def func(self):
        print("IN A")


class B(A):
    pass


class C(A):
    pass


class D(B):
    pass


class E(C):
    pass


class F(D, E):  # 这就是多继承
    pass


f1 = F()
f1.func()
# 结果：
# IN A

可以通过类名.mro()查看类的继承顺序。
如下：

class A:
    def func(self):
        print("IN A")


class B(A):
    pass


class C(A):
    pass


class D(B):
    pass


class E(C):
    pass


class F(D, E):  # 这就是多继承
    pass


f1 = F()
f1.func()
print(F.mro())
# 结果：
# IN A
# [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

多继承的经典类：深度优先（python2环境），一条路走到底

总结：

继承：
继承的优点：

• 1.节省代码
• 2.规范代码，定一个规范，让别的类继承

继承初识：

• 只执行本类的方法

• 只执行父类的方法

• 既执行本类的又执行父类的方法

  • 父类名.方法名(参数)

  • super().方法名(参数(除了self))

单继承，多继承
类：新式类，经典类

单继承：

• 新式类，经典类一样

多继承：

• 新式类：广度优先 类名.mro()
• 经典类：深度优先