Python面向对象2：继承、多态特征

面向对象的第二个特征是继承。

可以将多个类共有的方法提取到父类中，子类仅需继承父类；

基本语法为class新类名（父类1，父类2,..）

单继承与多继承区别：

Python同时支持单继承与多继承，当只有一个父类时为单继承，当存在多个父类时为多继承。

继承的性质特征：

子类会继承父类的所有的属性和方法，子类也可以覆盖父类同名的变量和方法。

调用方法执行顺序：（见案例）

在调用方法时，先调用子类自己的方法，子类无，再去父类中查找。查找顺序是自左（从上往下）向右。

如果多个父类，再无共同的父类，则自左执行到顶，再往右执行。

如果有共同的父类，则自左执行到倒数第二层，再向右执行，最后再执行最顶层。

案例1：

F2继承F1：类似于把F1中的功能在F2中又写了一遍，如果有一个方法F2自己无，则去父类F1中去找找看

classF1:#父类，基类

defshow(self):

print('show')

deffoo(self):

print(self.name)

classF2(F1):#把F1的方法再次引用到F2；子类、派生类

def__init__(self,name):

self.name=name

defbar(self):

print('bar')

defshow(self):

print('F2.show')

obj=F2('hh')

print('-----foo方法执行结果--------')

obj.foo()#执行结果：hh，需要去父类里面找

print('-----show方法执行结果--------')

obj.show()#执行结果F2.show，优先执行自己的方法，再执行父类的方法

执行结果：

案例2：如果父类和子类有相同的方法，则优先执行子类自己的方法，如果子类无再去父类找

#self一直代表的是对象自己

# 如果一个方法，自己有，则执行自己的方法，如果自己没有，再去往上去父类寻找

classS1:

defF1(self):

self.F2()

defF2(self):

print('S1.F2')

classS2(S1):

defF3(self):

self.F1()

defF2(self):

print('S2.F2')

print('----S1.F2-------------')

#实例化s1

obj1 = S1()

obj1.F1()# 先去S1执行F1，再看S1中有没有F2，有，则执行自己的F2

print('----S2.F3-------------')

#实例化s2

obj2=S2()

#1）先去s2执行F3,因为s2自己无F1，去S1中执行F1，F1方法需要执行F2

#2）self代表s2本身，因s2自己有F2，再执行S2的F2

obj2.F3()

执行结果：

案例3：多继承，无共同的父类，执行顺序：从左（先往上）再往右。

左右类无共同父类封顶的继承及执行的顺序：

#先左，在左上，左上找到顶层，则再往右边的类找

classc0:

deff2(self):

print('c0.f2')

classc1(c0):

deff1(self):

print('c1.f1')

classc2:

deff2(self):

print('c2.f2')

deff4(self):

print('c2.f4')

classc3(c1,c2):

deff3(self):

pass

obj=c3()#实例化c3对象

print('------c3.f2-------')

obj.f2()#先去找c3，c3无f2，再去c1，c1无f2，则去c0找

print('------c3.f1-------')

obj.f1()#先去找c3，c3无f1，再去c1

print('------c3.f4-------')

obj.f4()#先去找c3，c3无f4，再去c1,c1无f4，则去c0找,c0无f4，再去c2

执行结果：

案例4：多继承，有共同的父类，执行到倒数第二层，再向右执行

#找到倒数第二层停止，再往后找，最后找共同

classc0:

deff4(self):

print('c0.f2')

classc_2(c0):

deff2(self):

print('c_2.f2')

classc21(c_2):

deff1(self):

print('c21.f1')

classc_1(c0):

deff1(self):

print('c_1.f2')

classc11(c_1):

deff1(self):

print('c11.f1')

classc3(c11,c21):

deff3(self):

print('c3.f3')

#实例化对象

obj=c3()

obj.f3()#依次找寻c3找到，执行结果c3.f3

obj.f1()#依次找寻c3,c11找到，执行结果c11.f1

obj.f2()#依次找寻c3,c11,c_1,c21,c_2,找到，执行结果c_2.f2

obj.f4()#依次找寻c3,c11,c_1,c21,c_2,c0找到，执行结果，c0.f2

执行顺序：

面向对象的第三个特征是多态：指参数的“有多种形式”、多种形态，意味着就算不知道变量所引用的对象类是什么，还是能对它进行操作，而它也会根据对象（或类）类型的不同而表现出不同的行为。

其他编程语言如java在定义参数时，需要制定参数类型，且传入参数时，需要符合类型要求。但python基本上不用管这个特征，因为python定义变量时，可以不指定类型。如下案例，可以传入不同的参数类型，比如字典、列表、数字、string等。

比如案例：

deffunc(arg):

print(arg)

func(1)

func("hh")

func(["a","b",6])

func({"a":1,"c":2})

案例链接：https://pan.baidu.com/s/1skU53lV 密码：ifah