15面向物件特性-有解無憂

面向物件特性

封裝

在程式設計中，封裝（Encapsulation）是對具體物件的一種抽象，即將某些部分隱藏起來，在程式外部看不到，其含義是其他程式無法呼叫，要了解封裝，離不開“私有化”，就是將類或者是函式中的某些屬性限制在某個區域之內，外部無法呼叫，
封裝的作用：
- 1、保護隱私（把不想別人知道的東西封裝起來）
- 2、隔離復雜度（比如：電視機，我們看見的就是一個黑匣子，其實里面有很多電器元件，對于用戶來說，我們不需要清楚里面都有些元件，電視機把那些電器元件封裝在黑匣子里，提供給用戶的只是個按鈕介面，通過按鈕就能實作對電視機的操作，）
封裝其實分為兩個層面，但無論哪種層面的封裝，都要對外界提供好訪問你內部隱藏內容的介面（介面可以理解為入口，有了這個入口，使用者無需且不能夠直接訪問到內部隱藏的細節，只能走介面，并且我們可以在介面的實作上附加更多的處理邏輯，從而嚴格控制使用者的訪問）
- 第一個層面的封裝（什么都不用做）：創建類和物件會分別創建二者的名稱空間，我們只能用類名.或者obj.的方式去訪問里面的名字，這本身就是一種封裝，
- 第二個層面的封裝：類中把某些屬性和方法隱藏起來(或者說定義成私有的)，只在類的內部使用、外部無法訪問，或者留下少量介面（函式）供外部訪問，

class Person:
    def __init__(self, name, age):
        self.__name = name
        self.age = age

    # 私有方法
    def __getname(self):
        # print(self.__name)
        print(f'{self.__name}')

    # 實體方法
    def printinfo(self):
        print(f'{self.__name},{self.age}')

p = Person('zhangsan', 18)
p.printinfo()

繼承

繼承是面向物件程式設計的重要特征，也是實作代碼復用的重要手段，如果一個新類繼承自一個設計好的類，就直接具備了已有類的特征，就大大降低了作業難度，已有的類，我們稱為父類或者基類，新的類，我們稱為子類或者派生類，

單繼承

單繼承指的是子類只繼承一個父類當物件呼叫方法時，查找順序先從自身類找，如果自身沒找到，則去父類找，父類無，再到父類的父類找，直到object類，若還無，則報錯，這也稱為深度優先機制，

# 單繼承
class Grandfather:
    def __init__(self):
        print('Grandfather')

    def sleep(self):
        print("sleep")

class Father(Grandfather):
    def eat(self):
        print("eat")

    def drink(self):
        print("drink")

class Son(Father):
    def study_python(self):
        print("python")

s = Son()
s.study_python()
s.eat()
s.sleep()

多繼承

多繼承指的是子類繼承了多個父類，并且具有它們的特征，

"""情景1"""
class Father1:
    def run(self):
        print("father1 run")

class Father2:
    def run(self):
        print("father2 run")

class Son(Father1, Father2):  # 擁有相同方法時，左邊優先執行
    pass

s = Son()
s.run()

"""情景2"""
class Grandfather:
    def sleep(self):
        print("Grandfather sleep")

class Father1(Grandfather):
    def run(self):
        print("father1 run")

class Father2:
    def sleep(self):
        print(" Father2 sleep")

class Son(Father1, Father2):  # 必須要左邊的執行完了,才會執行右邊的父類
    pass

s = Son()
s.sleep()

"""情景3"""
class Grandfather1:
    def sleep(self):
        print("sleep 12")

class Father1(Grandfather1):
    def run(self):
        print("father1 run")

class Father2(Grandfather1):
    def sleep(self):
        print("sleep 6")

class Son(Father1, Father2):  # 如果同根的話，根是最后才執行的
    pass

s = Son()
s.sleep()


print(Son.__mro__)  # 通過mro方法可以程式執行或者繼承順序的情況
# (<class '__main__.Son'>, <class '__main__.Father1'>, <class '__main__.Father2'>, <class '__main__.Grandfather1'>, <class 'object'>)

方法的重寫

當子類與父類擁有同名稱的方法時，子類物件呼叫該方法優先執行自身的方法，那么實際上就是子類的方法覆寫父類的方法，也稱為重寫，實際的開發中，遵循開放封閉原則，我們并不會完全的重寫父類的方法，而是希望同時實作父類的功能，

# 相對而言是我們B的父類
class A:
    # init同時也能夠被繼承
    def __init__(self):
        print('A')

    def test(self):
        print("aaaa")

# B繼承了A 子類
class B(A):
    def __init__(self):
        print('B')
        # A.__init__(self)
        super(B, self).__init__()

    # 子類重寫父類的同名方法
    def test(self):
        print("bbbb")
        # 對該方法進行重寫，同時實作子類和父類的功能 三個方法都可以
        # super(B, self).test()
        # super().test()
        # A.test(self)   # 通過類名.方法名 強寫 不推薦


b = B()  # 創建了B的物件
b.test()  # bbbb
"""
若將test方法里的注釋放開，則也會列印A中test方法中的aaaa
"""

多型

Python中函式的引數是沒有型別限制的，所以多型在python中的體現并不是很嚴謹，多型的概念是應用于Java和C#這一類強型別語言中，而Python崇尚“鴨子型別”，python是弱語言型別，

多型（polymorphism）：指的是一類事物有多種形態，一個抽象類有多個子類（因而多型的概念依賴于繼承），不同的子類物件呼叫相同的方法，產生不同的執行結果，多型可以增加代碼的靈活度

1、實作多型的步驟：

1）定義一個父類（Base），實作某個方法（比如：run）
2）定義多個子類，在子類中重寫父類的方法（run），每個子類run方法實作不同的功能
3）假設我們定義了一個函式，需要一個Base型別的物件的引數，那么呼叫函式的時候，傳入Base類不同的子類物件，那么這個函式就會執行不同的功能，這就是多型的體現，

class Animal(object):
    """動物類"""
    def func(self):
        print('動物發出了聲音')

class Cat(Animal):
    """貓類"""
    def func(self):
        print('喵 喵 喵')

class Dog(Animal):
    """狗類"""
    def func(self):
        print('汪 汪 汪 ')

class Hero:
    def func(self):
        print('這個是英雄類的方法，不是動物類的物件')

def work01(Animal):
    Animal.func()


work01(Dog())  # 傳入的物件 結果：汪 汪 汪 
work01(Animal())  # 動物發出了聲音
# 傳入不同的物件，產生不同的結果
# 呼叫靈活 更容易撰寫出通用的代碼

多型的意義：

(1)在程式運行程序中展現出動態的特性，在程式編譯的時候無法知道呼叫哪個函式
(2)函式重寫必須多型實作，否則沒有意義
(3)多型是面向物件組件化程式設計的基礎特性

注意點：Python中函式的引數是沒有型別限制的，所以多型在python中的體現并不是很嚴謹，多型的概念是應用于Java和C#這一類強型別語言中，而Python崇尚“鴨子型別”，

鴨子型別

鴨子型別概念：他并不要求嚴格的繼承體系，關注的不是物件的型別本身，而是它是否具有要呼叫的方法（行為）

class Duck:
    def quack(self):
        print("嘎嘎嘎嘎，，，，，")

class Bird:
    def quack(self):
        print("bird imitate duck....")

class geese:
    def quack(self):
        print("geese imitate duck....")

def in_the_forest(duck):
    duck.quack()


duck = Duck()
bird = Bird()
geese = geese()
for x in [duck, bird, geese]:
    in_the_forest(x)
"""
嘎嘎嘎嘎，，，，，
bird imitate duck....
geese imitate duck....
"""

本文來自博客園，作者：大-鍋，轉載請注明原文鏈接：https://www.cnblogs.com/daguo118/p/17347492.html

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/550922.html

標籤：其他

上一篇：【Qt6】QWindow類可以做什么

下一篇：返回列表