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

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

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

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

单继承与多继承区别：   

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

继承的性质特征：

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

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

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

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

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

案例1：

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

class F1:#父类，基类
   def show(self):
       print('show')
    def foo(self):
        print(self.name)
class F2(F1):#把F1的方法再次引用到F2；子类、派生类
   def __init__(self,name):
        self.name=name
    def bar(self):
        print('bar')
    def show(self):
        print('F2.show')
obj=F2('hh')
print('-----foo方法执行结果--------')
obj.foo()#执行结果：hh，需要去父类里面找
print('-----show方法执行结果--------')
obj.show()#执行结果F2.show，优先执行自己的方法，再执行父类的方法

执行结果：

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

#self一直代表的是对象自己
# 如果一个方法，自己有，则执行自己的方法，如果自己没有，再去往上去父类寻找
class S1:
    def F1(self):
        self.F2()
    def F2(self):
        print('S1.F2')
class S2(S1):
    def F3(self):
        self.F1()
    def F2(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：多继承，无共同的父类，执行顺序：从左（先往上）再往右。

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

#先左，在左上，左上找到顶层，则再往右边的类找
class c0:
    def f2(self):
        print('c0.f2')
class c1(c0):
    def f1(self):
        print('c1.f1')
class c2:
    def f2(self):
        print('c2.f2')
    def f4(self):
        print('c2.f4')
class c3(c1,c2):
    def f3(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：多继承，有共同的父类，执行到倒数第二层，再向右执行

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

class c0:
    def f4(self):
        print('c0.f2')
class c_2(c0):
    def f2(self):
        print('c_2.f2')
class c21(c_2):
    def f1(self):
        print('c21.f1')
class c_1(c0):
    def f1(self):
        print('c_1.f2')
class c11(c_1):
    def f1(self):
        print('c11.f1')
class c3(c11,c21):
    def f3(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等。

比如案例：

def func(arg):
    print(arg)

func(1)
func("hh")
func(["a","b",6])
func({"a":1,"c":2})

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