【python入門到精通】python面向物件三大特點：封裝，繼承，多型

🚀 作者 ：“大資料小禪”

🚀 粉絲福利 ：加入小禪的大資料社群

🚀 歡迎小伙伴們 點贊👍、收藏?、留言💬

python語言是一門面向物件的語言，面向程序其實就是把程序當做設計核心，根據問題的發展順序，依次解決問題，盡可能的把程序中涉及到的問題完善解決，他有他的優點，當拿到一個問題時，可以方便的按執行的步驟寫代碼，但是當邏輯關系變得復雜時，有一個地方出現差錯就會導致整個程式無從下手，類似面向物件的編程語言有很多，例如C++ ， java等，而面向物件的三大特點就是-----封裝，繼承，多型，下面將詳細說明這三大特點的理解與用法，

開始文章前先解釋下object引數：

object：
注意類名后面括號里有個引數object，他代表所有類的基類，也叫作超類，
這就有了一個新式類和舊式類的概念：
當用到多繼承的時候，如果子類中沒有想用的方法名或屬性名，他會自動回到上面去找，那么按廣度優先遍歷的方法去尋找就是新式類（object）；深度優先（括號里啥也沒有），

一，python面向物件的特點------封裝

可以簡單的理解為隱藏一切可以隱藏的實作細節，只向外界提供簡單的編程介面，我們在類中定義的方法其實就是把資料和資料的操作封裝起來了，在我們創建了物件之后，只需要給物件發送一個訊息（呼叫方法）就可以執行方法中的代碼，也就是說我們只需要知道方法的名字和傳入的引數（方法的外部視圖），而不需要知道方法內部的實作細節（方法的內部視圖）

面向物件第一步 ： 將屬性和方法封裝到一個抽象的類中
外界使用類創建物件，然后讓物件呼叫方法
物件方法的細節都封裝在類的內部

• 含義：對外面隱藏物件的屬性和方法，僅提供介面，
• 作用：安全性（通過私有變數改變對外的使用），復用性

下面兩個例子對封裝進行理解：

例子1：
1.TOM體重76.0公斤
2.TOM每次跑步會減肥0.5公斤
3.TOM每次吃東西會增重1攻擊

class Test():
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight

    def __str__(self):
        return '我的名字叫%s 體重是%d' %(self.name,self.weight)

    def run(self):
        print('%s愛跑步' %self.name)
        self.weight -= 0.5

    def eat(self):
        print('%s吃東西' %self.name)
        self.weight += 1

TOM = Test('TOM',76.0)
print(TOM)
TOM.run()
print(TOM)
TOM.eat()
print(TOM)

輸出：

我的名字叫TOM 體重是76.00
TOM愛跑步
我的名字叫TOM 體重是75.50
TOM吃東西
我的名字叫TOM 體重是76.50

例子2：
對tom分數的修改，

class Student(object):
      def __init__(self, name, score):
          # 屬性僅前面有兩個下劃線代表私有變數，外部無法訪問，因此我們定義了兩個新的方法，這樣可以避免外部通過score亂改分數，僅當我們自己知道介面才可以修改
          self.__name = name
          self.__score = score

      def info(self):
         print('name: %s ; score: %d' % (self.__name,self.__score))

      def getScore(self):
         return self.__score

      def setScore(self, score):
         self.__score = score

stu = Student('Tom',99)
print('修改前分數：',stu.getScore())
stu.info()
stu.setScore(59)
print('修改后分數：',stu.getScore())
stu.info()

二，python面向物件的特點------繼承

含義：

面向物件編程有個好處就是代碼復用，而其中一種方法就是通過繼承機制，繼承就是說定義的一個新類，繼承現有的類，獲得現有類的非私有屬性、方法，提到個私有，就是上面提到的那個前面加兩個下劃線的那個東西，他在外部無法呼叫，繼承他的子類也不能，被繼承的那個類稱為基類、父類或超類，繼承的類叫子類也可以叫做派生類，
私有屬性（補充）：
在Python中，這一約定一般只是用來避免錯誤的方法呼叫，但完全無法阻止從外部呼叫這些被認為是“私有”的屬性
python并沒有真正的私有屬性
用__定義的屬性，只是被改名換姓而已
用_定義的屬性，意義在于喚起用戶的注意，看成私有屬性
類變數：類變數在整個實體化的物件中是公用的，類變數定義在類中且在函式體之外，類變數通常不作為實體變數使用，
方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個程序叫方法的覆寫（override），也稱為方法的重寫，

特點：

1、在繼承中，基類的構造方法（init()方法）不會被自動呼叫，需要在子類的構造方法中專門呼叫，
2、在呼叫基類的方法時需要加上基類的類名前綴，并帶上self引數變數，區別于在類中呼叫普通函式時不需要帶self引數，
3、在python中，首先查找對應型別的方法，如果在子類中找不到對應的方法，才到基類中逐個查找，

在程式中繼承是描述事物之間的所屬關系，例如貓和狗都屬于動物，程式中便可以描述為貓和狗繼承自動物；同理，波斯貓和巴厘貓都繼承自貓，而沙皮狗和斑點狗都繼承自狗，子類可以繼承父類的公有屬性和公共方法，父類中的私有屬性不能被繼承，

1，單繼承

一般只繼承一個父類就叫單繼承，在java等靜態語言中只能繼承一個父類，也就不存在單繼承和多繼承了，下面看一個實體理解單繼承：

# 定義一個父類，如下:
class Cat(object):

    def __init__(self, name, color="白色",source=90):        #關鍵字引數
        self.name = name
        self.color = color
        self.source=source
    def run(self):
        print("%s--在跑"%self.name)


# 定義一個子類，繼承Cat類如下:
class Bosi(Cat):
    # 子類沒有實作__init__方法，則自動呼叫父類的__init__方法

    def setNewName(self, newName):
        self.name = newName

    def eat(self):
        print("%s--在吃"%self.name)


bs = Bosi("波斯貓")
print('波斯貓的名字為:%s'%bs.name)
print('波斯貓的顏色為:%s'%bs.color)
print('波斯貓的評分是:%d'%bs.source)
bs.eat()
bs.setNewName('印度貓')
bs.run()

輸出（這里可以看到子類Bosi繼承了父類的共有方法和公有屬性）：

波斯貓的名字為:波斯貓
波斯貓的顏色為:白色
波斯貓的評分是:90
波斯貓--在吃
印度貓--在跑

這兩個類不寫在一起也是可以的，例如將Cat這個類寫到另一個模塊animal中，
這時候只要前面的匯入模塊的知識將這個Cat類匯入到有Bosi類的模塊中即可跟上面輸出的結果一樣完成繼承，
語法示例： from animal import Cat

有一點要注意：要列印關鍵詞引數的話，子類要呼叫init后面的關鍵字引數才不會報錯，
要呼叫除了init的其他方法關鍵字引數就需要別的辦法

2 ，多繼承

含義：多繼承，即子類有多個父類，并且具有它們的特征，與單繼承差別不大類似格式如下，

class A:        # 定義類 A
.....

class B:         # 定義類 B
.....

class C(A, B):   # 繼承類 A 和 B
.....

3 ， 重寫父類的方法

所謂重寫，就是子類中，有一個和父類相同名字的方法，在子類中的方法會覆寫掉父類中同名的方法，例子如下：

class Cat:
    def sayHello(self):
        print("hello-----1")

class Bosi(Cat):

    def sayHello(self):
        print("hello-----2")
        
class Bali(Cat):

    def sayHello(self):
        print("hello-----3")

bosi = Bosi()
bali= Bali()
bosi.sayHello()
bali.sayHello()
"""
輸出結果：
hello-----2
hello-----3
"""

三.python面向物件的特點------多型

通過方法重寫我們可以讓父類的同一個行為在子類中擁有不同的實作版本，當我們呼叫這個經過子類重寫的方法時，不同的子類物件會表現出不同的行為，這個就是多型（poly-morphism），如上面的例子，