面向對象編程 封裝 繼承 多態（三大特徵）（第三篇）

封裝

封裝是面向對象編程的三大特徵之一。

封裝有兩方面的含義：

1.將數據（屬性）和行爲（方法）包裝到類對象中。方法內部對屬性進行操作，在類對象的外部調用方法。這樣，無需關心方法內部的具體實現細節，從而隔離了複雜度。

2.在類對象的內部通過訪問控制把某些屬性和方法隱藏起來，不允許在類對象的外部直接訪問，而是在類對象的內部對外提供公開的接口方法以訪問隱藏的信息。這樣，就對隱藏的信息進行了保護。

class Student(object):
    def __init__(self):
        self.__a = 90
    def get_a(self):
        return self.__a
    def set_a(self,a):
        if 0 <= a <= 100:
            self.__a = a
        else:
            raise ValueError("成績必須在0~100之間")

s = Student()
s.get_a()
>90

s = Student()
s.set_a(88)
print(s.get_a())
>88

s.set_a(123)
>---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-14-1c4873c0a02d> in <module>()
----> 1 s.set_a(123)

<ipython-input-11-fc87181632fe> in set_a(self, a)
      8             self.__a = a
      9         else:
---> 10             raise ValueError("成績必須在0~100之間")

ValueError: 成績必須在0~100之間

繼承

當幾個類對象中有共同的屬性和方法時，就可以把這些屬性和方法抽象並提取到一個基類中，每個類對象特有的屬性和方法還是在本類對象中定義，這樣，只需要讓每個類對象都繼承這個基類，就可以訪問基類中的屬性和方法了。繼承基類的每個類對象被稱爲派生類。基類也被稱爲父類或超類，派生類也被稱爲子類。

python中的所有類對象都繼承自一個統一的基類：object。這就是爲什麼我們在定義類對象時要在類名後面添加（object）。

除了封裝，繼承也是面向對象編程的三大特徵之一。繼承是實現代碼複用的重要手段。

class Animal(object):
    def eat(self):
        print("吃飯")
    def drink(self):
        print("喝水")

class Bird(Animal):
    def fly(self):
        print("飛")

class Dog(Animal):
    def swim(self):
        print("游泳")

dog = Dog()
dog.eat()
>吃飯

bird = Bird()
bird.drink()
>喝水

bird.fly()
>飛

• 單繼承：子類只有一個直接父類時稱爲單繼承
• 多繼承：子類有多個直接父類時稱爲多繼承
• 子類會繼承所有父類（包括所有直接父類和所有間接父類）的所有屬性和方法

重寫

• 如果子類對繼承自父類的某個屬性或方法不滿意，可以在子類中對其進行重寫從而提供自定義的實現
• 重寫的方式爲：在子類中定義與父類中同名的屬性或方法（包括裝飾器）
• 子類重寫父類的屬性或方法後，通過子類或其實例對象只能訪問子類中重寫後的屬性或方法，而無法再訪問父類中被重寫的屬性

class ParentClass(object):
    a = "a(父)"
    def __init__(self):
        print("__init__()被調用了（父）")
    @classmethod
    def cm(cls):
        print("cm()被調用了（父）")

class ChildClass(ParentClass):
    a = "a(子)"
    def __init__(self):
        print("__init__()被調用了（子）")
    @classmethod
    def cm(cls):
        print("cm()被調用了（子）")

cc = ChildClass()
print(ChildClass.a)
print(cc.a)
ChildClass.cm()
cc.cm()
>__init__()被調用了（子）
a(子)
a(子)
cm()被調用了（子）
cm()被調用了（子）

父類中被重寫的名爲xxx的方法，在子類重寫後的方法中可以通過super().xxx()進行調用 要分清實例方法和類方法

MRO（方法解析順序method resolution order）

對於一顆類繼承樹，可以調用最底層類對象最底層類對象的方法mro()或訪問最底層類對象的特殊屬性__mro__,獲得這棵樹的MRO

class A(object):
    def f(self):
        print("A.f")
class B(A):
    def f(self):
        print("B.f")
class C(A):
    def f(self):
        print("c.f")
class D(B,C):
    def f(self):
        print("D.f")

print(D.__mro__)
>(<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

print(D.mro())
>[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

如果想調用指定父類中被重寫的方法，可以給super（）傳入兩個實參：super(a_type,obj) 其中，第一個實參是個類對象，第二個實參是個實例對象，這樣，被指定的父類是：obj所對應類對象的MRO中，a_type後面那個類對象

class A(object):
    def f(self):
        print("A.f")
class B(A):
    def f(self):
        print("B.f")
class C(A):
    def f(self):
        print("C.f")
class D(B,C):
    def f(self):
        super().f()

d = D()
d.f()
>B.f

class A(object):
    def f(self):
        print("A.f")
class B(A):
    pass
class C(A):
    def f(self):
        print("C.f")
class D(B,C):
    def f(self):
        super().f()

d = D()
d.f()
>C.f

class A(object):
    def f(self):
        print("A.f")
class B(A):
    pass
class C(A):
    pass
class D(B,C):
    def f(self):
        super().f()

d = D()
d.f()
>A.f

多態（在不考慮對象類型的情況下使用對象）

除了封裝和繼承，多態也是面向對象編程的三大特徵之一。

簡單地說，多態就是“具有多種形態“，它指的是：即便不知道一個變量所引用的對象到底是什麼類型，仍然可以通過這個變量調用方法，在運行過程中根據變量所引用對象的類型，動態地決定調用哪個對象中的方法

如果子類中不存在指定名稱的方法，回到父類中去查找，如果在父類中找到了，則調用父類中的方法。