普通继承

重写静态方法

更正，第十行是类方法

扩展父类的静态方法

换一种调用形态

多继承的情况

新增一个Mother类

执行顺序

使用基类的方法时，关注顺序

换个顺序

小结继承的规则

子类继承了类1和类2

需要用基类方法时

会先在类1中找

找不到才去类2中找

例子，当前Mother中没有str方法了，所以结果

父类方法调用母类方法

明确为什么会发生这样的事情

明确c是什么

代码备份

class Father:
    @classmethod
    def stc(cls):
        # c = super(Father, cls)
        c = super()
        c.eat()

    def let_run(self):
        print('父类 letrun 运行')
        c = super()
        c.run()

class Mother:
    @classmethod
    def eat(cls):
        print('母类的eat方法')

    def run(self):
        print('母类 run')

class Son(Father,Mother):
    pass

Son.stc()

研究此时的c是什么

Father的父类会是什么？ Father除了object类外，没有父类了呀！

》猜想， c是不是Son类？

给Son类再添加一个类方法

class Father:
    @classmethod
    def stc(cls):
        # c = super(Father, cls)
        c = super()
        c.eat()
        c.sleep()

    def let_run(self):
        print('父类 letrun 运行')
        c = super()
        c.run()

class Mother:
    @classmethod
    def eat(cls):
        print('母类的eat方法')

    def run(self):
        print('母类 run')

class Son(Father,Mother):
    @classmethod
    def sleep(cls):
        print('son 在睡觉')

Son.stc()

结果

表明，c不是Son类

》猜想，c是不是Father类

class Father:
    @classmethod
    def stc(cls):
        # c = super(Father, cls)
        c = super()
        c.one()

    @classmethod
    def one(cls):
        print('father de one')


class Mother:
    @classmethod
    def eat(cls):
        print('母类的eat方法')

    def run(self):
        print('母类 run')

class Son(Father,Mother):
    @classmethod
    def sleep(cls):
        print('son 在睡觉')

Son.stc()

结果

表明这个c也不是Father类

而且也明显不应该为Father类

》c是不是Mother类？

母类中新定义一个静态方法

让c来调drink

发现可以

那么表明，c 有可能代表了Mother类

但是，它一定就是Mother类吗？

如果Son类有第三个类继承， c有可能是第三个基类吗？

新定义一个老师类

让c调teach方法

结果可以出来

小结，本例的c到底是什么

》c代表了Son的基类，不包含Father类

所以在c调用一个方法时

会先去Mother类中找，如果有就用

如果没有，就会去Teacher类中找，如果有就用

代码

class Father:
    @classmethod
    def stc(cls):
        # c = super(Father, cls)
        c = super()
        c.teach()

    @classmethod
    def one(cls):
        print('father de one')


class Mother:
    @classmethod
    def eat(cls):
        print('母类的eat方法')

    @classmethod
    def drink(cls):
        print('母类在drink')

    def run(self):
        print('母类 run')


class Teacher:
    @classmethod
    def teach(cls):
        print('老师类，teach方法')

class Son(Father,Mother,Teacher):
    @classmethod
    def sleep(cls):
        print('son 在睡觉')

Son.stc()

子类的类方法调父类的类方法，明确父类中cls是什么

class Father:
    @classmethod
    def stc(cls):
        print('father stc')
        print('father cls', cls)
        print('father name', )

class Mother:
    @classmethod
    def stc(cls):
        print('mother stc')


class Son(Father, Mother):
    name = '桑'
    @classmethod
    def stc(cls):
        # super().stc()  # Father()   Father
        super(Son, cls).stc()
        print('son stc')
        print('son cls', cls)
        print('son name', )


Son.stc()

结论就是

父类中的cls，就是子类的地址引用

子类调用方法，触发父类的方法，也触发母类的方法

class Father:
    @classmethod
    def stc(cls):
        print('father stc 1')
        m = super()
        # m = super(Father, cls)  # 抽象的一个父类 super参数一是否是Father，待观察
        m.eat()

class Mother:
    @classmethod
    def eat(cls):
        print('mother eat 2')

class Son(Father, Mother):
    @classmethod
    def stc(cls):
        super().stc()
        # super(Son,cls)

Son.stc()