python面向對象（封裝、繼承、多態）+ 面向對象小栗子

時間 2019-12-15

原文原文鏈接

　　你們好，下面我說一下我對面向對象的理解，不會講的很詳細，由於有不少人的博客都把他寫的很詳細了，因此，我儘量簡單的經過一些代碼讓初學者能夠理解面向對象及他的三個要素。python

摘要：
1、首先介紹一下面向對象
2、而後分別講一下封裝、繼承和多態
3、最後經過一段面向對象的案例來更好的理解一下面向對象

　　python是一門面向對象編程語言，對面相對象語言編碼的過程叫作面向對象編程。編程

　　面向對象時一種思想，與之相對對的是面向過程。咱們先簡單說一下面向過程。小程序

　　面向過程其實就是把過程當作設計核心，根據問題的發展順序，依次解決問題，儘量的把過程當中涉及到的問題完善解決。他有他的優勢，當拿到一個問題時，能夠方便的按執行的步驟寫代碼，可是當邏輯關係變得複雜時，有一個地方出現差錯就會致使整個程序無從下手。安全

　　既然主要是說python，那咱們仍是回來講說python的面向對象，面向對象的編程語言仍是不少的，例如C++、Java等等。編程語言

　　面向對象程序設計把計算機程序的執行看作一組對象的集合，每一個對象之間進行消息的傳送處理。有一個顯著的優勢就是，對某個對象進行修改，整個程序不會受到影響，自定義數據類型就是面向對象中的類的概念，而咱們須要把他們的接口處理好就很好辦了。說了這麼多話，有些小白已經看不下去了，那接下來咱們進入主題。ide

上面說了，自定義數據類型就是面向對象中的類的概念。咱們先介紹一下待會兒會用到的一些術語：

 1 # 我認爲仍是經過個例子更容易讓人理解
 2 
 3 # 首先咱們定義一個類
 4 class A(object):    # 這是一個類，class是建立一個類的標誌 
 5     # 類變量（類屬性）：類屬性是指類的屬性，屬性就是咱們剛學編程的時候聽過的變量。
 6     x = 7
 7     y = "asdf"
 8     
 9     def __init__(self,name,age):
10         self.name = name
11         self.age = age
12 
13     # 方法：方法就是在類外面咱們寫的函數，放在類裏就叫作一個方法
14     def func(self):
15         c = 8    # 實例變量：定義在方法中的變量只做用於當前實例的類
16         print("Hello World!")
17 
18 a = A()    # 建立一個對象，實例化

　　上面的部分代碼還須要再解釋一下：函數

object：
- 注意類名後面括號裏有個參數object，他表明全部類的基類，也叫做超類。
- 這就有了一個新式類和舊式類的概念：
- 當用到多繼承的時候，若是子類中沒有想用的方法名或屬性名，他會自動回到上面去找。那麼按廣度優先遍歷的方法去尋找就是新式類（object）；深度優先（括號裏啥也沒有）。
__init__()：構造函數，實例化的時候若不顯示的定義，那麼默認調用一個無參的，是初始化的意思。

1、封裝

　　含義：對外面隱藏對象的屬性和方法，僅提供接口。學習

　　做用：安全性（經過私有變量改變對外的使用），複用性ui

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 class Student(object):
 5     def __init__(self, name, score):
 6         # 屬性僅前面有兩個下劃線表明私有變量，外部沒法訪問，所以咱們定義了兩個新的方法，這樣能夠避免外部經過score亂改分數，僅當咱們本身知道接口才能夠修改
 7         self.__name = name
 8         self.__score = score
 9 
10     def info(self):
11         print('name: %s ; score: %d' % (self.__name,self.__score))
12 
13     def getScore(self):
14         return self.__score
15 
16     def setScore(self, score):
17         self.__score = score
18 
19 stu = Student('Tom',99)
20 print('修改前分數：',stu.getScore())
21 stu.info()
22 stu.setScore(59)
23 print('修改後分數：',stu.getScore())
24 stu.info()

　　封裝仍是比較好理解的，不過其中還有一些，好比析構函數，重寫等等知識點最好在官方文檔過一遍。編碼

2、繼承

　　2.1.一、含義

　　前面咱們提到過，面向對象編程有個好處就是代碼複用，而其中一種方法就是經過繼承機制。繼承就是說定義的一個新類，繼承現有的類，得到現有類的非私有屬性、方法。提到個私有，就是上面提到的那個前面加兩個下劃線的那個東西，他在外部沒法調用，繼承他的子類也不能。被繼承的那個類稱爲基類、父類或超類，子類也能夠叫作派生類。

　　2.1.二、特色

　　　　一、在繼承中，基類的構造方法（__init__()方法）不會被自動調用，須要在子類的構造方法中專門調用。

　　　　二、在調用基類的方法時須要加上基類的類名前綴，並帶上self參數變量。區別於在類中調用普通函數時不須要帶self參數。

　　　　三、在python中，首先查找對應類型的方法，若是在子類中找不到對應的方法，纔到基類中逐個查找。

　　2.二、單繼承

　　　　直接上代碼，仔細理解一下里面的關係，我把講解都寫在註釋的地方。

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 # 這是定義了一個基類
 5 class Person(object):
 6     def __init__(self, name, age, money):
 7         self.name = name
 8         self.age = age
 9         self.__money = money # 私有屬性
10         # 被引入時，繼承不了，但他們的set，get函數能夠繼承
11 
12     def setMoney(self,money):
13         self.__money = money
14 
15     def getMoney(self):
16         return self.__money
17 
18     def run(self):
19         print("run")
20 
21     def eat(self):
22         print("eat")

　　下面是定義的一個子類，繼承自上方的類，來使用父類中的方法和屬性：

1 # 因爲我將每一個類寫在了不一樣的文件裏，因此須要引入一下，這就和咱們調用庫同樣
2 from 單繼承的實現.person import Person
3 
4 class Student(Person):
5     def __init__(self,name,age,stuid,money):
6         # 調用父類中的__init__()，supper括號中的內容，在python3之後能夠不寫，寫上更安全些
7         super(Student,self).__init__(name,age,money) # 讓父類的self當作子類的對象
8         # 子類能夠由一些本身獨有的屬性或者方法
9         self.stuid = stuid

　　建立對象，經過子類使用父類的屬性和方法：

1 from 單繼承的實現.student import Student
2 
3 stu = Student('Tom',18,111,999) # 建立Student對象
4 # 下列方法和屬性均是在父類Person中定義的，在Student繼承以後，即可以直接使用
5 print(stu.name, stu.age)
6 stu.run()
7 print(stu.getMoney())

　　2.三、多繼承

　　上面的單繼承要多理解一下，單繼承理解了以後，多繼承也就沒什麼了。

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 class Father(object):
 5     def __init__(self,money):
 6         self.money = money
 7     def play(self):
 8         print("play")
 9     def func(self):
10         print("func1")
11 
12 class Mother(object):
13     def __init__(self,facevalue):
14         self.facevalue = facevalue
15     def eat(self):
16         print("eat")
17     def func(self):
18         print("func2")
19 
20 
21 class Children(Father,Mother):
22     def __init__(self,money,facevalue):
23         # 多繼承時調用父類的屬性
24         Father.__init__(self,money)
25         Mother.__init__(self,facevalue)
26 
27 def main():
28     c = Children(300,100)
29     print(c.money,c.facevalue)
30     c.play()
31     c.eat()
32     # 注意：若是多個父類中有相同的方法名，默認調用括號中前面的類
33     c.func()
34 if __name__ == "__main__":
35     main()

View Code

3、多態

多態：是指一種事物的多種形態
多態性：多態性是指具備不一樣功能的函數可使用相同的函數名，這樣就能夠用一個函數名調用不一樣內容的函數。在面向對象方法中通常是這樣表述多態性：向不一樣的對象發送同一條消息，不一樣的對象在接收時會產生不一樣的行爲（即方法）。也就是說，每一個對象能夠用本身的方式去響應共同的消息。所謂消息，就是調用函數，不一樣的行爲就是指不一樣的實現，即執行不一樣的函數。
eg：在python中的「+」號，它既能夠表示數字的加法，也能夠表示字符串的拼接，（__add__()）

 1 class Animal(object):
 2     def __init__(self, name):
 3         self.name = name
 4 
 5     def run(self):
 6         pass
 7 
 8     def animalRun(self):
 9         self.run()
10 
11 
12 class Cat(Animal):
13     def run(self):
14         print('cat is running')
15 
16 
17 class Dog(Animal):
18     def run(self):
19         print('dog is running')
20 
21 
22 d = Dog('dog')
23 c = Cat('cat')
24 
25 Animal.animalRun(c)
26 Animal.animalRun(d)

View Code

4、面向對象案例

　　下面給一個小程序，是模擬反恐精英，保衛者和敵人。主要是讓你們看明白，只有簡單的幾個功能，但願你們能夠從中理解面向對象的思想。python中，任何都是對象。

　　首先，這是個人幾個類模塊，分開來寫比較清晰一點，寫在一塊兒也是沒問題的。接下來咱們一點一點的分析：

　　。。。。。。。。。。

　　得有人，好人和壞人

　　。。。。。。。。。。

　　人得有武器，先給他們兩種：槍和手榴彈

　　。。。。。。。。。。

　　槍還有個彈夾也能夠做爲對象

　　。。。。。。。。。。

　　想一想還有什麼，差很少了吧，那麼咱們就開始寫，想到什麼再補充

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 from cs.person import Person
 5 
 6 class Gengster(Person):
 7 
 8     # 初始化，血量默認爲100
 9     def __init__(self, gun, grenade, blood=100):
10         self.gun = gun
11         self.grenade = grenade
12         self.blood = blood
13 
14     # 人有開槍的功能
15     def fire(self,person):
16         person.blood.amount -= 5 # 對誰開槍，那我的就要減血
17         self.gun.shoot() # 這我的開槍，這又調用了槍的類，關於子彈的減小在槍的類裏
18 
19     # 扔手榴彈，其實是和槍同樣的
20     def fire2(self,person):
21         person.blood -= 10
22         self.grenade.damage() # 一樣經過另外一個類來控制數量的減小，使代碼看起來簡潔點
23 
24     # 給彈夾里加子彈
25     def fillbullet(self):
26         self.gun.bulletbox.bulletcount += 10
27 
28     # 補血，並保證滿血只能是100
29     def fillblood(self,num):
30         self.blood += num
31         if self.blood > 100:
32             self.blood = 100
33         print("補血後血量：" + str(self.blood))

壞蛋

 1 # 主要註釋和上一個相似，這裏不贅述
 2 
 3 #!/usr/bin/env python
 4 # -*- coding:utf-8 -*-
 5 
 6 from cs.person import Person
 7 
 8 class Profector(Person):
 9 
10     def __init__(self, gun, grenade, blood = 100):
11         self.gun = gun
12         self.grenade = grenade
13         self.blood = blood
14 
15     def fire(self, person):
16         person.blood -= 5
17         self.gun.shoot()
18         print(str(person) + "血量減小5，剩餘" + str(person.blood) )
19 
20     def fire2(self,person):
21         person.blood -= 10
22         self.grenade.damage()
23 
24     def fillbullet(self):
25         self.gun.bulletbox.bulletcount += 10
26 
27     def fillblood(self,num):
28         self.blood += num
29         if self.blood > 100:
30             self.blood = 100
31         print("補血後血量：" + str(self.blood))

好人

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 class Gun(object):
 5 
 6     # 初始化，把彈夾放裏面，經過人來控制槍，再來控制彈夾
 7     def __init__(self,bulletbox):
 8         self.bulletbox = bulletbox
 9 
10     def shoot(self):
11         if self.bulletbox.bulletcount == 0:
12             print('沒子彈了')
13         else:
14             self.bulletbox.bulletcount -= 1
15             print(str(self) + '開一槍，還剩%d顆子彈' % (self.bulletbox.bulletcount))

槍

 1 # 與槍相似
 2 
 3 #!/usr/bin/env python
 4 # -*- coding:utf-8 -*-
 5 
 6 class Grenade(object):
 7 
 8     def __init__(self,grenadecount):
 9         self.grenadecount = grenadecount
10 
11     def damage(self):
12         if self.grenadecount == 0:
13             print('手雷沒有了')
14         else:
15             self.grenadecount -= 1
16             print(str(self) + "轟他一炮，手雷還剩%d顆" % (self.grenadecount))

手榴彈

1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 
4 class Bulletbox(object):
5 
6     # 彈夾只需控制數量就行了
7     def __init__(self,bulletcount):
8         self.bulletcount = bulletcount

彈夾

　　這下差很少了，人也有了，武器也有了，能夠開展了

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 from cs.grenade import Grenade
 5 from cs.gun import Gun
 6 from cs.bulletbox import Bulletbox
 7 from cs.gengster import Gengster
 8 from cs.profector import Profector
 9 # 參數：槍，手榴彈，血（默認100，且上限爲100）
10 
11 # 建立彈夾，槍，手榴彈的對象，以備人使用
12 bulletbox = Bulletbox(10)
13 gun = Gun(bulletbox)
14 grenade = Grenade(20)
15 
16 # 建立人對象
17 good1 = Profector(gun,grenade)
18 good2 = Profector(gun,grenade)
19 bad1 = Gengster(gun,grenade)
20 bad2 = Gengster(gun,grenade)
21 
22 print("好人1開槍打壞人1和2")
23 good1.fire(bad1)
24 good1.fire(bad2)
25 print("好人2開槍打壞人1和2")
26 good2.fire(bad1)
27 good2.fire(bad2)
28 print("壞人1炸好人1和2")
29 bad1.fire2(good1)
30 bad1.fire2(good2)
31 print("壞人2炸好人1和2")
32 bad2.fire2(good1)
33 bad2.fire2(good2)
34 print("壞人1補血3個")
35 bad1.fillblood(3)

main

　　如今這一套流程就結束了，剛開始看也許看不太懂，要仔細看一下每一個類之間的關係，先想清楚了，再來看代碼是如何實現的

　　有沒有看出來點區別，面向過程編程是就事論事，而面向對象，先把對象找出來，經過對象之間的關係把他們聯繫起來。想一想若是要用面向過程來實現這個，代碼會寫成什麼樣子呢。

　　然而並無結束，記不記得前面的類中有兩對是比較相似的，好人和壞人，槍和手榴彈（這個裏面的類還不太同樣），那麼想到了什麼沒有，前面提到的繼承的優勢是什麼來着，----複用。咱們能夠能夠用繼承來寫一下呢，若是你說這個也沒少幾行代碼嘛，那麼，若是在實際當中你要建立成百上千的對象呢，難道還要每一個都複製粘貼改代碼嗎，還佔空間對不對。

　　那麼咱們寫一我的類，畢竟好人和壞人都是人：

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 class Person(object):
 5 
 6     def __init__(self, gun, grenade, blood):
 7         self.gun = gun
 8         self.grenade = grenade
 9         self.blood = blood
10 
11     def fire(self, person):
12         person.blood -= 5
13         self.gun.shoot()
14         print(str(person) + "血量減小5，剩餘" + str(person.blood) )
15 
16     def fire2(self, person):
17         person.blood -= 10
18         self.grenade.damage()
19         print(str(person) + "血量減小10，剩餘" + str(person.blood) )
20 
21     def fillbullet(self):
22         self.gun.bulletbox.bulletcount += 10
23 
24     def fillblood(self,num):
25         self.blood += num
26         if self.blood > 100:
27             self.blood = 100
28         print(str(self) + "補血後血量：" + str(self.blood))

person

　　如今咱們就沒必要把好人壞人都重寫了，只須要繼承一下人類就行了：

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 from cs.person import Person
 5 
 6 class Profector(Person):
 7 
 8     def __init__(self, gun, grenade, blood = 100):
 9         super(Profector,self).__init__(gun, grenade, blood)
10 
11 
12 class Gengster(Person):
13 
14     def __init__(self, gun, grenade, blood=100):
15         super(Gengster, self).__init__(gun, grenade, blood)
16 
17 # 這裏面有個supper，他就是對父類的繼承

好人和壞人

　　我知道你們看的有點迷了，我把他整在一塊兒了，不過仍是建議你們先根據每一個小模塊學習，順便理解一下引入自定義模塊。下面是完整代碼，能夠直接粘貼：

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 class Bulletbox(object):
 5     def __init__(self,bulletcount):
 6         self.bulletcount = bulletcount
 7 
 8 
 9 class Gun(object):
10     def __init__(self,bulletbox):
11         self.bulletbox = bulletbox
12 
13     def shoot(self):
14         if self.bulletbox.bulletcount == 0:
15             print('沒子彈了')
16         else:
17             self.bulletbox.bulletcount -= 1
18             print(str(self) + '開一槍，還剩%d顆子彈' % (self.bulletbox.bulletcount))
19 
20 
21 class Grenade(object):
22     def __init__(self,grenadecount):
23         self.grenadecount = grenadecount
24 
25     def damage(self):
26         if self.grenadecount == 0:
27             print('手雷沒有了')
28         else:
29             self.grenadecount -= 1
30             print(str(self) + "轟他一炮，手雷還剩%d顆" % (self.grenadecount))
31 
32 
33 class Person(object):
34     def __init__(self, gun, grenade, blood):
35         self.gun = gun
36         self.grenade = grenade
37         self.blood = blood
38 
39     def fire(self, person):
40         person.blood -= 5
41         self.gun.shoot()
42         print(str(person) + "血量減小5，剩餘" + str(person.blood) )
43 
44     def fire2(self, person):
45         person.blood -= 10
46         self.grenade.damage()
47         print(str(person) + "血量減小10，剩餘" + str(person.blood) )
48 
49     def fillbullet(self):
50         self.gun.bulletbox.bulletcount += 10
51 
52     def fillblood(self,num):
53         self.blood += num
54         if self.blood > 100:
55             self.blood = 100
56         print(str(self) + "補血後血量：" + str(self.blood))
57 
58 
59 class Profector(Person):
60     def __init__(self, gun, grenade, blood = 100):
61         super(Profector,self).__init__(gun, grenade, blood)
62 
63 
64 class Gengster(Person):
65     def __init__(self, gun, grenade, blood=100):
66         super(Gengster, self).__init__(gun, grenade, blood)
67 
68 
69 bulletbox = Bulletbox(10)
70 gun = Gun(bulletbox)
71 grenade = Grenade(20)
72 
73 good1 = Profector(gun,grenade)
74 good2 = Profector(gun,grenade)
75 bad1 = Gengster(gun,grenade)
76 bad2 = Gengster(gun,grenade)
77 
78 print("好人1開槍打壞人1和2")
79 good1.fire(bad1)
80 good1.fire(bad2)
81 print("好人2開槍打壞人1和2")
82 good2.fire(bad1)
83 good2.fire(bad2)
84 print("壞人1炸好人1和2")
85 bad1.fire2(good1)
86 bad1.fire2(good2)
87 print("壞人2炸好人1和2")
88 bad2.fire2(good1)
89 bad2.fire2(good2)
90 print("壞人1補血3個")
91 bad1.fillblood(3)