Python學習：15.Python面向對象（二、繼承的各種情況）

一、什麼是繼承

繼承是一種創建類的方法，在python中，一個類可以繼承來自一個或多個父。原始類稱為基類或超類。

#創建父類
class Parent1:
    pass

class Parent2:
    pass

# 繼承父類，單繼承
class Obj1(Parent1):
    pass

#繼承父類，多繼承
class Obj2(Parent1,Parent2):
    pass

二、什麼時候使用繼承

　　在已經創建的幾個類中，這幾哥類中的方法和變數有相同的，這種時候我們就可以使用類的繼承，將其它類中已有的方法和變數通過繼承的方式，在新創建的類中，使用正常的方式就可以調用父類中的方法。剩下自己特有的方法只要在自己類中定義就可以。

　　舉個列子：人都會吃，喝，玩，小明也是一個人，所以小明也會，所以小明繼承了人的屬性，特別的是小明還會背古詩，就基於以上的說法寫一個類的繼承。

class Man:

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

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

    def play(self):
        print('玩')


class XiaoMing(Man):

    def recite(self):
        print('背古詩')

xm = XiaoMing()
xm.eat()
xm.recite()


輸出結果：
吃
背古詩

三、單繼承與多繼承

單繼承：僅僅繼承一個父類，當查找方法的時候，首先在自己裡面查找，然後到父類裡面查找。

class Biology:
    def split(self):
        print(self.name+" accrue")

class Animal(Biology):#在類後面加括弧加上所要繼承類的名字，繼承的是類的方法
    def GoWhoring(self):
        print("i like go whoring")
    def eat(self):
        print(self.name+" eat")

class superman:
    def gamble(self):
        print("gamble is interesting")
    def GoWhoring(self):
        print("beautiful whoring")
        
class Cat(Animal):
    def GoWhoring(self):
        print("i don't like go whoring")
    def __init__(self,name):
        self.name = name
    def cry(self):
        print(self.name + " 喵")
                                                    #優先順序：自己，父類（左邊，右邊）
class Dog(Animal，superman):#在繼承多個父類時，在兩個父類都有同一個名字的方法時，優先選擇括弧左邊的父類的方法
    def __init__(self,name):
        self.name = name
    def cry(self):
        print(self.name + " 汪")

mimi = Cat("mimi")
mimi.eat()
mimi.cry()                #當基類里方法存在，派生類里也存在同名方法，優先找派生類里的方法
mimi.GoWhoring() #當父類里有一個方法自己也有一個同名的方法時，預設使用自己的方法
husike = Dog("erha")#雖然Dog里沒有eat和split但是由於Dog繼承了Animal和的方法，而Animal繼承了Biology的方法
husike.eat()            #所以Dog可以使用Biology的方法    
husike.cry()            #父類有一個名字叫"基類"  子類有一個名字叫"派生類"
husike.split()
husike.GoWhoring()
faker = Animal()
faker.GoWhoring()#優先使用自己的方法

派生類可以繼承基類里的所有功能。
當基類里方法存在，派生類里也存在同名方法，派生類優先找派生類里的方法（意思是優先找自己的）。
在Java、C#裡面一個子類只能繼承一個父類，多了報錯，但是在python里可以繼承多個父類

在經典類中，繼承是以深度優先，在新式類中，繼承是以廣度優先。

Python 2.x中預設都是經典類，只有顯式繼承了object才是新式類。

python 3.x中預設都是新式類,經典類被移除，不必顯式的繼承object。

深度優先：

class A():
    def save(self):
        print("This is from A")
class B(A):
    pass
class C(A):
    def save(self):
        print("This is from C")
class D(B,C):
    pass

fun =  D()
fun.save()

輸出結果：
This is from A"

深度優先的時候就是一條道走到黑，從左向右找，先把左邊的一個裡面的全部找完在找右邊的。

 廣度優先：

class A():
    def save(self):
        print("This is from A")
class B(A):
    pass

class C(A):
    def save(self):
        print("This is from C")
class D(B,C):
    pass

fun =  D()
fun.save()

輸出結果：
This is from C

首先在左邊的上一層父類中尋找，如果沒有就到右邊一個父類中尋找，沒有就到左邊父類的父類中尋找。

廣度優先多種情況解析

情況一

有A、B、C、D、E幾個類，A為B的父類，B為C的父類，E為D的父類，D為C的父類 現在C需要使用一個方法，只有在A，E里有，第一次C先去B中尋找沒有找到 然後就會去A裡面找，A里沒有就去D裡面找，然後再去E里找。

class A:
    def function(self):
        print("are you OK?A")

class B(A):
    def function_fake(self):
        print("are you OK?B")

class E:
    def function(self):
        print("are you OK?E")

class D(E):
    def function_fake(self):
        print("are you OK?D")

class C(B, D):
    def Sb(self):
        print("i am sb")

faker = C()
faker.function()

輸出結果：
are you OK?A

括弧里為查找順序。

情況二

它會先把沒有共同的父類尋找玩，然後再找共同的父類，因為在這種情況下它想找到和自己關係最近的。

class S:
    def function(self):
        print('are you Ok?S')

class A(S):
    def function_fake(self):
        print("are you OK?A")

class B(A):
    def function_fake(self):
        print("are you OK?B")

class E(S):
    def function(self):
        print("are you OK?E")

class D(E):
    def function_fake(self):
        print("are you OK?D")

class C(B, D):
    def Sb(self):
        print("i am sb")

faker = C()
faker.function()

輸出結果：
are you OK？E

情況三

當A、B、D、E、都沒有C所要找的函數時才會找右邊的F（括弧右邊）

class F():
    def function(self):
        print("are you OK?F")

class A:
    def function_fake(self):
        print("are you OK?A")

class E:
    def function_fake(self):
        print("are you OK?E")

class B(A,F):
    def function_fake(self):
        print("are you OK?B")

class D(E):
    def function_fake(self):
        print("are you OK?D")

class C(B, D):
    def Sb(self):
        print("i am sb")


faker = C()
faker.function()


輸出結果：
are you OK?F

情況四

首先面執行一個 c1 = C()；c1.xxx() ，xxx在D裡面而且xxx又執行了self.ooo() 而ooo在BDE里都有它會執行哪個？

class B:
    def ooo(self):
        print("B")


class E:
    def ooo(self):
        print("E")


class D(E):
    def xxx(self):
        self.ooo()

    def ooo(self):
        print("D")


class C(B, D):
    pass


c1 = C()
c1.xxx()

輸出結果：
B

解析：首先找到c1.xxx在D裡面，在D裡面又執行了self.ooo(),這個self代指c1，而c1為C類的對象，意思還是c1.ooo，所以尋找ooo時還是從C開始，因為先找左邊的所以，找到了B的ooo 以後找是誰執行的函數要看準self到底是誰的從self下手。

紅色為第二次尋找路徑（尋找ooo方法的次序）

今天的類的繼承主要是多繼承的時候父類中方法選擇的。