python#继承，多态

今天的目录

1.继承

1.继承

需求原因：实现代码的重用，相同的代码不需要重复的编写
概念：子类 拥有 父类 的所有 方法 和 属性

class Animal:

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

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

    def sleep(self):
        print('睡')


class Dog(Animal):
    # def eat(self):
    #     print("吃")
    #
    # def drink(self):
    #     print("喝")
    #
    # def run(self):
    #     print("跑")
    #
    # def sleep(self):
    #     print('睡')

    def brak(self):
        print("叫")


# 创建一个对象 - 狗
wangcai = Dog()

wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()
wangcai.brak()

总结：子类有父类所有的，变量方法。 子类（父类），而言，你 把你爹的名字放括号里

继承的传递性，爷爷类，父亲类，可以用，儿子类，可以用父亲和爷爷类的

继承中的方法重写

需求：父类的方法实现，不能满足子类的实现

class Animal:

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

    def drink(self):
        print("喝")

    def run(self):
        print("跑")

    def sleep(self):
        print('睡')


class Dog(Animal):
    # def eat(self):
    #     print("吃")
    #
    # def drink(self):
    #     print("喝")
    #
    # def run(self):
    #     print("跑")
    #
    # def sleep(self):
    #     print('睡')

    def brak(self):
        print("叫")


class XiaoTianQuan(Dog):
    def fly(self):
        print("我会飞")
        
    def brak(self):
        print("老子是神")


# 创建一个对象 - 狗
wangcai = XiaoTianQuan()

wangcai.brak()

总结： 子类中 定义了一个 和父类同名的方法并且实现，重写之后，在运行时，只会调用 子类中重写的方法，而不再会调用 父类封装的方法

方法的从写

super----使用的场景就是在 重写父类方法时，调用 在父类中封装的方法实现

class XiaoTianQuan(Dog):
    def fly(self):
        print("我会飞")

    def brak(self):
        # 1. 针对子类特有的需求，编写代码
        print("老子是神")
        # 2. 使用 super().调用原本在父类中封装的方法
        super().brak()
        # 3.增加其他子类的代码
        print("%%%%((*^&**")

输出—老子是神
叫
%%%%((*^&**

多继承

class A:

    def test(self):
        print("test 方法")


class B:
    def dmo(self):
        print("demo方法")


class C(A, B):
     pass



# 创建子类对象
c = C()
c.test()
c.dmo()

子类可以拥有多个父类， 可以拥有多个方法

这时候问题就来，那么2个父类要是有同一个方法怎么办呢？

看如下演示:

class A:

    def test(self):
        print("AAAA-----test 方法")


class B:
    def test(self):
        print("BBBBB-----demo方法")


class C(A, B):
     pass



# 创建子类对象
c = C()
c.test()

结果......
AAAA-----test 方法

class A:

    def test(self):
        print("AAAA-----test 方法")


class B:
    def test(self):
        print("BBBBB-----demo方法")


class C(B, A):
     pass



# 创建子类对象
c = C()
c.test()

结果------>
BBBBB-----demo方法

说明了 C（B， A） B 和 A那个在前面 哪个就先调用

类的一个调用方法

C.mro 可以知道

class A:

    def test(self):
        print("AAAA-----test 方法")


class B:
    def test(self):
        print("BBBBB-----demo方法")


class C(B, A):
     pass


# C 类调用方法的顺序
print(C.__mro__)

结果
(<class ‘main.C’>, <class ‘main.B’>, <class ‘main.A’>, <class ‘object’>)
先从C 开始 找，没有就去B 然后去 A

如果，此类没有父类，请主动加入object ，避免python2.x的出错，在python 3.x以后没写的自动继承object

2.多态

class Dog(object):
    def __init__(self, name):
        self.name = name

    def play(self):
        print('%s 蹦蹦跳跳的玩耍' % self.name)


class XiaoTianQuan(Dog):

    def play(self):
        print("%s 飞到天上去" % self.name)  # self.name 是父类的名字，因为哮天犬继承了Dog


class Person(object):
    def __init__(self, name):
        self.name = name

    def game_with_dog(self, dog):
        print('%s 和 %s 快乐的玩耍 ' % (self.name, dog.name))

        # 让狗玩耍
        dog.play()


# 1.创建一个狗对象
# 由 哪一个对象 调用的方法，方法内的 self 就是 哪一个对象的引用
# 此时，wangcai 这个对象调用了 def __init__(self, name):这个方法输入了名字所以此时 self 是 wangcai
wangcai = Dog('旺财')
wangcai1 = XiaoTianQuan('飞天旺财')

# 2，创建一个小明的对象

xiaoming = Person('小明')

# 3，让小明调用和狗玩的方法
xiaoming.game_with_dog(wangcai1)
print(wangcai.name)