阿宁的Python学习-----继承和多态

继承和多态

在OOP程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。继承最大的好处就是子类获得了父类的全部变量和方法的同时，又可以根据需要进行修改。拓展。

lass Foo(superA, superB,superC....):
class DerivedClassName(modname.BaseClassName):  ## 当父类定义在另外的模块时

Python支持多父类的继承机制，所以需要注意圆括号中基类的顺序，若是基类中有相同的方法名，并且在子类使用时未指定，Python会从左至右搜索基类中是否包含该方法。一旦查找到则直接调用，后面不再继续查找。

class people:
    def __init__(self,name,age,weight):
        self.name = name
        self.age = age
        self.__weight = weight
    def speak(self):
        print("%s 说: 我 %d 岁。" % (self.name, self.age))
#单继承
class Student(people):
    def __init__(self,name,age,weight,grade):
        #调用父类的实例化方法
        people.__init__(self,name,age,weight)
        self.grade = grade

    #重写父类的speak方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))
a = Student('小明',18,20,6)
a.speak()

#输出结果
小明 说: 我 18 岁了，我在读 6 年级

python继承机制

• 子类在调用某个方法或变量的时候，首先在自己内部查找，如果没有找到，则开始根据继承机制在父类里查找。
• 根据父类定义中的顺序，以深度优先的方式逐一查找父类！

class D:
    def show(self):
        print("i am D")
    pass
class C(D):
    pass
class B(C):
    pass
class G:
    pass
class F(G):
    pass
class E(F):
    def show(self):
        print("i am E")
    pass
class A(B,E):
    pass
a = A()
a.show()

#输出结果
i am D

继承结构关系中，搜索顺序

多态

class Animal:
    def kind(self):
        print('i am animal')
class Dog(Animal):
    def kind(self):
        print('i am dog')
class Cat(Animal):
    def kind(self):
        print('i am cat')
class Pig(Animal):
    def kind(self):
        print('i am pig')
# 这个函数接收一个animal参数，并调用它的kind方法
def show_kind(animal):
    animal.kind()

d = Dog()
c = Cat()
p = Pig()
show_kind(d)
show_kind(c)
show_kind(p)

#输出结果
i am dog
i am cat
i am pig

狗、猫、猪都继承了动物类，并各自重写了kind方法。show_kind()函数接收一个animal参数，并调用它的kind方法。可以看出，无论我们给animal传递的是狗、猫还是猪，都能正确的调用相应的方法，打印对应的信息。这就是多态。

重写了kind方法。show_kind()函数接收一个animal参数，并调用它的kind方法。可以看出，无论我们给animal传递的是狗、猫还是猪，都能正确的调用相应的方法，打印对应的信息。这就是多态。

实际上，由于Python的动态语言特性，传递给函数show_kind()的参数animal可以是 任何的类型，只要它有一个kind()的方法即可。动态语言调用实例方法时不检查类型，只要方法存在，参数正确，就可以调用。这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。