碼上快樂

相關內容    簡體    繁體

Python中的面向對象的三大特征_封裝、繼承、多態

本文轉載自   查看原文   2021-10-25 15:03   165    Python

封裝

  • 封裝 根據 職責 將 屬性 和 方法 封裝到一個 抽象的類 中
    • 將數據（屬性）和行為（方法）包裝到類對象中。在方法內部對屬性進行操作，在類對象的外部調用方法。這樣無需關心方法內部的具體實現，從而隔離了復雜度
  1. 封裝是面向對象編程的一大特點
  2. 面向對象編程的第一步。將屬性和方法封裝到一個抽象的類中
  3. 外界使用類創建對象，然后讓對象調用方法
  4. 對象方法的細節都封裝在類的內部

 

  • 前言：根據需求分析，完成案例
  •  1 class Person:
 2     def __init__(self,name,weight):
 3         self.name = name
 4         self.weight = weight
 5 
 6     # 內置函數，可設置print打印輸出地址時的特定顯示，因此必須要有返回值
 7     def __str__(self):
 8         return "我是%s,體重是%.1f公斤"%(self.name,self.weight)
 9 
10     def run(self):
11         self.weight -= 0.5
12         print("%s通過跑步體重減少"%self.name)
13     def eat(self):
14         self.weight+=1
15         print("%s吃太多，體重增加"%self.name)
16 
17 p1 = Person("小明",65)
18 print(p1)           #我是小明,體重是65.0公斤
19 p1.eat()            #小明吃太多，體重增加
20 p1.run()            #小明通過跑步體重減少
21 print(p1)           #我是小明,體重是65.5公斤
22 print("*"*25)
23 p2 = Person("小美",45)
24 print(p2)           #我是小美,體重是45.0公斤
25 p2.eat()            #小美吃太多，體重增加
26 p2.run()            #小美通過跑步體重減少
27 print(p2)           #我是小美,體重是45.5公斤
28 print(p1)           #我是小明,體重是65.5公斤
    小明愛跑步

    • 注意：在開發時，被使用的類需要先開發 

  •  1 #創建房子類
 2 class House:
 3     def __init__(self,house_type,area):
 4         self.house_type = house_type
 5         self.area = area
 6         self.free_area = area
 7         self.item_list = []
 8 
 9     #添加家具
10     def add_item(self,item):
11         #判斷面積是否足夠添加家具
12         if item.area<self.free_area:
13             self.item_list.append(item.name)
14             self.free_area -= item.area
15             print("添加%s，占用面積%.1f"%(item.name,item.area))
16         else:
17             print("面積不足無法添加")
18 
19     #輸出房子打印
20     def __str__(self):
21         #Python可以自動將一對括號內的代碼連接到一起
22         return ("該房子的戶型:%s\n總面積為:%.1f平米\n剩余面積為：%.1f平米\n家具:%s"
23                 %(self.house_type,self.area,self.free_area,self.item_list))
24 
25 #創建家具對象
26 jj1 = HouseItem("席夢思",4)
27 jj2 = HouseItem("衣櫃",2)
28 jj3 = HouseItem("餐桌",1.5)
29 print(jj1)      #家具席夢思,占地面積為：4.0平米
30 print(jj2)      #家具衣櫃,占地面積為：2.0平米
31 print(jj3)      #家具餐桌,占地面積為：1.5平米
32 print("-"*30)
33 #創建房子對象，並添加家具
34 hs = House("大平層",6)
35 hs.add_item(jj1)
36 hs.add_item(jj2)
37 hs.add_item(jj3)
38 print("-"*30)
39 print(hs)
40 
41 #運行結果
42 家具席夢思,占地面積為：4.0平米
43 家具衣櫃,占地面積為：2.0平米
44 家具餐桌,占地面積為：1.5平米
45 ------------------------------
46 添加席夢思，占用面積4.0
47 面積不足無法添加
48 添加餐桌，占用面積1.5
49 ------------------------------
50 該房子的戶型:大平層
51 總面積為:6.0平米
52 剩余面積為：0.5平米
53 家具:['席夢思', '餐桌']
    房子和家具

私有屬性和私有方法

  • 提高程序的安全性
      • 在實際開發中，對象的某些屬性或方法只希望在類的內部被使用，而不希望在外部被訪問到
      • 在Python中沒有專門的修飾符用於屬性的私有，如果該屬性不希望在類對象外部被訪問，前面使用兩個“   _    ”（私有屬性）
        • 在Python中其實並沒有真正的私有屬性、私有方法：
           給屬性、方法命名時，實際是對名稱做了一些特殊處理，使得類對象無法直接訪問。
           但是如果一定要從外界訪問私有屬性、私有方法的話，那么只需要在私有屬性、私有方法前加上_類名
           例：stu_1._Student__age stu_1._Student__show_1() 注意：切記在開發時，不要以這種方式去訪問私有屬性和私有方法
      •  1 #私有屬性、私有方法
 2 class Student:
 3     def __init__(self,name,age):
 4         self.name = name
 5         self.__age = age        #使用(__屬性名)的方式將age聲明為私有屬性
 6 
 7     def show(self):
 8         print(self.name,"的年齡為：",self.__age)     #可以在類的內部使用私有屬性
 9 
10     def __show_1(self):          #使用(__方法名)的方式將show_1定義為私有方法
11         print("這是{}的私有方法".format(self.name))
12 
13 stu_1 = Student("張三",20)
14 stu_1.show()        #由此可見可以在類的內部使用私用屬性
15 print(stu_1.name)
16 #print(stu_1.__age) #代碼報錯，因為在類對象中並不能訪問類的私有屬性
17 
18 #stu_1.__show_1()    #代碼報錯，因為在類對象中並不能訪問類的私有屬性
19 
20 """
21 在Python中起始並沒有真正的私有屬性、方法：
22     給屬性、方法命名時，實際是對名稱做了一些特殊處理，使得類對象無法直接訪問。
23     但是如果一定要從外界訪問私有屬性、方法的話，那么只需要在私有屬性、方法前加上_類名
24     例：stu_1._Student__age    stu_1._Student__show_1()
25 """
26 print(stu_1._Student__age)
27 stu_1._Student__show_1()
28 
29 #運行結果
30 張三 的年齡為： 20
31 張三
32 20
33 這是張三的私有方法
        私有方法、私有屬性
    注意：
      子類能繼承父類的私有屬性和私有方法 
      •  1 class A:
 2     def __init__(self):
 3         self.num1 = 100
 4         self.__num2 = 200
 5 
 6     def __fun(self):
 7         print("這是一個私有方法",self.__num2)
 8 
 9 class B(A):
10     pass
11 
12 b = B()
13 print(b._A__num2)
14 # print(b._b__num2)     #代碼報錯，因為子類不能繼承父類的私有方法和私有屬性
15 b._A__fun()
16 # b._B__fun()
17 print(dir(b))
18 """
19 運行結果：
20 200
21 這是一個私有方法 200
22 ['_A__fun', '_A__num2', '__class__', 
23 '__delattr__', '__dict__', '__dir__', 
24 '__doc__', '__eq__', '__format__', '__ge__',
25  '__getattribute__', '__gt__', '__hash__', 
26  '__init__', '__init_subclass__', 
27  '__le__', '__lt__', '__module__', 
28  '__ne__', '__new__', '__reduce__', 
29  '__reduce_ex__', '__repr__', '__setattr__', 
30  '__sizeof__', '__str__', '__subclasshook__', 
31  '__weakref__', 'num1']
32 """
        子類繼承父類的私有屬性和私有方法

         

      • 子類對象可以調用父類的公有方法，在父類的公有方法中調用父類的私有方法和私有屬性，那么子類對象就可以間接的使用該共有方法訪問父類的私有屬性和私有方法

繼承

  • 實現代碼的重用，相同的代碼不需要重復編寫
  • 繼承的語法格式 
    • class  類名(父類名)：
        pass
    • 子類 繼承 父類，可以直接 享受  父類中已經封裝好的方法，不需要再次開發
    • 子類 中應該根據 職責，封裝 子類特有的 屬性和方法
    • 繼承的傳遞性：子類擁有父類以及父類和父類中封裝的所有屬性和方法
  •  1 #單繼承
 2 class Animal:
 3     def eat(self):
 4         print("吃")
 5     def drink(self):
 6         print("喝")
 7     def run(self):
 8         print("跑")
 9     def sleep(self):
10         print("睡")
11 
12 class Dog(Animal):
13     def bark(self):
14         print("叫")
15 
16 class Cat(Animal):
17     def catch(self):
18         print("抓老鼠")
19 
20 class XiaoTianQuan(Dog):
21     def fly(self):
22         print("飛")
23 
24 xtq = XiaoTianQuan()
25 xtq.eat()
26 xtq.bark()
27 #xtq.catch()    #報錯，因為xiaotianquan的父類及父類的父類都沒有該方法
    哮天犬和他的父類
  • 方法的重寫
    • 如果在子類中重寫了父類的方法，在子類對象調用方法時，會調用子類重寫的方法
    •  1 #方法重寫
 2 class Animal:
 3     def eat(self):
 4         print("吃")
 5     def drink(self):
 6         print("喝")
 7     def run(self):
 8         print("跑")
 9     def sleep(self):
10         print("睡")
11 
12 class Dog(Animal):
13     def bark(self):
14         print("叫")
15 
16 class Cat(Animal):
17     def catch(self):
18         print("抓老鼠")
19 
20 class XiaoTianQuan(Dog):
21     def fly(self):
22         print("飛")
23 
24     def bark(self):
25         print("像神一樣的叫")
26 
27 xtq = XiaoTianQuan()
28 xtq.bark()      #像神一樣的叫
      重寫父類方法

 

    • 在子類方法中調用父類方法 
      • 方法一：使用super().方法名   推薦使用
      • 方法二：使用父類名.方法名(self)   在python2.x中 只能使用這個方式
    •  1 #在子類方法中調用父類方法
 2 class Animal:
 3     def eat(self):
 4         print("動物吃")
 5     def drink(self):
 6         print("動物喝")
 7     def run(self):
 8         print("動物跑")
 9     def sleep(self):
10         print("動物睡")
11 
12 class Dog(Animal):
13     def bark(self):
14         print("狗叫")
15 
16 class Cat(Animal):
17     def catch(self):
18         print("抓老鼠")
19 
20 class XiaoTianQuan(Dog):
21     def fly(self):
22         print("像神一樣的飛")
23     def bark(self):
24         #1.針對子類特有的需求，編寫的代碼
25         print("像神一樣的叫")
26         #2.方法一：使用super().調用原本封裝在父類中的方法
27         super().bark()
28         #3.方法二：使用super().調用原本封裝在父類中的方法
29         Dog.bark(self)
30         #4.增加子類其他的代碼
31         print("------------------")
32 xtq = XiaoTianQuan()
33 xtq.bark()
34 """
35 運行結果：
36 像神一樣的叫
37 狗叫
38 狗叫
39 ------------------
40 """
      子類方法調用父類方法

       

多繼承

  • 概念：
    • 子類 可以擁有 多個父類，並且具有 所有父類的屬性 和 方法
    • 例如：孩子 會繼承自己 父親 和 母親 的特性
    •  1 #多繼承
 2 class A:
 3     def text(self):
 4         print("這是A類的text方法")
 5 class B:
 6     def fun(self):
 7         print("這是B類的fun方法")
 8 class C(A,B):
 9     pass
10 c = C()
11 c.text()        #這是A類的text方法
12 c.fun()         #這是B類的fun方法
      多繼承
  • 注意事項：
    • 如果 不同的父類 擁有相同的屬性名或者相同的方法名，子類對象在調用方法和屬性時，會調用那個父類的呢？
    • 提示：在開發時，應該盡量避免這種容易產生混淆的情況！  ——如果父類之間存在同名屬性或者同名方法，應該盡量避免使用多繼承

    • Python中的mro --方法搜索順序（知道）

      • Python中針對 類 提供了一個內置屬性 __mro__ 可以查看 方法的搜索順序

      • MRO 是 method  tesolution  order  ，主要用於 在多繼承判斷 方法 、屬性 的調用路徑

        • 子類對象在執行父類的同名方法時，是按照MRO輸出的從做到右的順序去執行的
      •  1 #多繼承屬性、方法同名
 2 class A:
 3     num = 100
 4     def text(self):
 5         print("這是A類的text方法")
 6 class B:
 7     num = 200
 8     def text(self):
 9         print("這是B類的fun方法")
10 class C(B,A):
11     pass
12 c_1 = C()
13 c_1.text()
14 print(c_1.num)
15 #確定C類對象的調用方法的路徑
16 print(C.__mro__)
17 """
18 運行結果：
19 這是B類的fun方法
20 200
21 (<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
22 """
        多繼承屬性、方法同名
  • 新式類和經典類
    • object 是 Python 為所有對象提供的基類，提供有內置的屬性和方法，可以使用dir來查看 
      •  1 class A(object):
 2     pass
 3 print(dir(A))
 4 
 5 """
 6 運行結果所顯示的屬性和方法都是由object提供的，因為我並沒有為A類設置任何的屬性和方法
 7 ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
 8  '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', 
 9  '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', 
10  '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
11   '__str__', '__subclasshook__', '__weakref__']
12 """
        object提供的內置屬性和方法

         

    • 新式類：以object為基類，推薦使用
    • 經典類：不以object為基類，不推薦使用
    • 在python3.x中定義類，如果沒有指定父類，會默認使用object類作為該類的基類，因此，python3.x中所有的類都是新式類
    • 在python2.x中定義類，如果沒有指定父類，不會使用object作為基類。
    • 經典類和新式類在多繼承時——會影響到方法的搜索順序

 

    • 為了保證編寫的代碼在Python2.x和Python3.x都能夠運行，在定義類的時，如果沒有父類，建議統一繼承object 
      • class 類名(object):
            pass

         

多態

  • 不同的對象，調用相同的方法，產生不同的執行結果，增加代碼的靈活度
    • 多態可以增加代碼的靈活度
    • 以繼承和重寫父類方法為前提
    • 是調用方法的技巧，不會影響到類的內部設計
  •  1 #多態的案例演示
 2 """
 3 1.定義Dog類，並中封裝方法game
 4     普通的狗子蹦蹦跳跳
 5 2.定義GodDog類，繼承自狗類，並重寫game方法
 6     神狗在天上玩耍
 7 3.定義ErHa類，繼承自狗類，並重寫game方法
 8     傻狗在地上滾
 9 4.定義Person類，並封裝一個和狗玩的方法game_with_dog方法
10     在方法內部，直接讓 狗對象 調用game方法
11 """
12 class Dog(object):
13     def __init__(self,name):
14         self.name = name
15 
16     def game(self):
17         print("蹦蹦跳跳")
18 
19 class GodDog(Dog):
20     def game(self):
21         print("%s在天上飛"%self.name)
22 
23 class ErHa(Dog):
24     def game(self):
25         print("%s這個傻狗在地上滾"%self.name)
26 
27 class Person(object):
28     def __init__(self,name):
29         self.name = name
30     def ame_with_dog(self,dog):
31         print("%s在和%s玩耍"%(self.name,dog.name))
32         dog.game()
33 
34 #創建二哈
35 eh = ErHa("哈士奇")
36 #創建哮天犬
37 xtq = GodDog("哮天犬")
38 #創建二郎神
39 els = Person("二郎神")
40 els.ame_with_dog(eh)
41 print("*"*30)
42 els.ame_with_dog(xtq)
43 """
44 運行結果
45 二郎神在和哈士奇玩耍
46 哈士奇這個傻狗在地上滾
47 ******************************
48 二郎神在和哮天犬玩耍
49 哮天犬在天上飛
50 """
    多態的案例演示

    　　由上面代碼可以看出，二郎神在調用和狗玩的方法時，當傳入的狗對象不同時，代碼的運行結果也不相同

 


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 面向對象三大特征------封裝、繼承、多態 Python面向對象中的繼承、多態和封裝 Java面向對象概述及三大特征（封裝，繼承和多態） Java面向對象-封裝、繼承和多態 面向對象三大特性-----封裝、繼承、多態 Java學習：面向對象的三大特征：封裝性、繼承性、多態性之繼承性 面向對象語言（.Net）的封裝繼承多態（OOP） 面向對象、繼承封裝、多態小例子(馬士兵) JS面向對象基礎篇（封裝 繼承 多態） JS面向對象編程之：封裝、繼承、多態
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM