python——面向對象編程

面向對象編程

面向對象編程是一種編程方式，此編程方式須要使用 「類」 和 「對象」 來實現，因此，面向對象編程其實就是對 「類」 和 「對象」 的使用。

• 類(class)就是一個模板，模板裏能夠包含多個函數，函數裏實現一些功能
• 對象則是根據模板建立的實例，經過實例對象能夠執行類中的函數

 1 # 建立類
 2 class Foo(object):    #新式類（經典類 class Foo:）
 3 
 4     def Bar(self):
 5 
 6         print 'Bar'
 7 
 8     def Hello(self, name):
 9 
10         print 'i am %s' %name
11 
12 # 根據類Foo建立對象obj
13 
14 obj = Foo()
15 
16 obj.Bar()            #執行Bar方法
17 
18 obj.Hello('x54256') #執行Hello方法

面向對象3大特色：

1、封裝 

封裝，顧名思義就是將內容封裝到某個地方，之後再去調用被封裝在某處的內容。

因此，在使用面向對象的封裝特性時，須要：

• 將內容封裝到某處
• 從某處調用被封裝的內容（在類中的其餘函數中須要經過self來間接的調用被封裝的內容）

 1 class Foo(object):
 2     def __init__(self,name,age):    #構造函數，根據類建立對象時（實例化）自動執行
 3         self.name=name
 4         self.age=age
 5     
 6     def run():
 7         print("%s今年%s歲了。"%(self.name,self.age)
 8         
 9 
10 #實例化（就是將內容封裝到某處）
11 #實際上alex和22被封裝到了obj1中，x54256和21被封裝到了obj2中
12 
13 obj1=Foo('alex',22)
14 
15 obj2=Foo('x54256',21)
16 
17 
18 #若要調用必須從obj1，obj2中調用封裝的內容
19 
20 print(obj1.name)
21 print(obj2.name)
22 
23 #要從被封裝的地方調用類中的函數
24 
25 obj1.run()    
26 obj2.run()

封裝代碼

2、繼承

繼承，面向對象中的繼承和現實生活中的繼承相同，即：子能夠繼承父的內容。

例如：

　　貓能夠：喵喵叫、吃、喝、拉、撒

　　狗能夠：汪汪叫、吃、喝、拉、撒

若是咱們要分別爲貓和狗建立一個類，那麼就須要爲 貓 和 狗 實現他們全部的功能，以下所示：

 1 class 貓：
 2 
 3     def 喵喵叫(self):
 4         print '喵喵叫'
 5 
 6     def 吃(self):
 7         # do something
 8 
 9     def 喝(self):
10         # do something
11 
12     def 拉(self):
13         # do something
14 
15     def 撒(self):
16         # do something
17 
18 class 狗：
19 
20     def 汪汪叫(self):
21         print '喵喵叫'
22 
23     def 吃(self):
24         # do something
25 
26     def 喝(self):
27         # do something
28 
29     def 拉(self):
30         # do something
31 
32     def 撒(self):
33         # do something
34 
35 僞代碼

僞代碼

上述代碼不難看出，吃、喝、拉、撒是貓和狗都具備的功能，而咱們卻分別的貓和狗的類中編寫了兩次。若是使用 繼承 的思想，以下實現：

　　動物：吃、喝、拉、撒

　　   貓：喵喵叫（貓繼承動物的功能）

　　   狗：汪汪叫（狗繼承動物的功能）

 1 class 動物:
 2 
 3     def 吃(self):
 4         # do something
 5 
 6     def 喝(self):
 7         # do something
 8 
 9     def 拉(self):
10         # do something
11 
12     def 撒(self):
13         # do something
14 
15 # 在類後面括號中寫入另一個類名，表示當前類繼承另一個類
16 class 貓(動物)：
17 
18     def 喵喵叫(self):
19         print '喵喵叫'
20         
21 # 在類後面括號中寫入另一個類名，表示當前類繼承另一個類
22 class 狗(動物)：
23 
24     def 汪汪叫(self):
25         print '喵喵叫'
26 
27 僞代碼

僞代碼

 1 class Animal:
 2 
 3     def eat(self):
 4         print "%s 吃 " %self.name
 5 
 6     def drink(self):
 7         print "%s 喝 " %self.name
 8 
 9     def shit(self):
10         print "%s 拉 " %self.name
11 
12     def pee(self):
13         print "%s 撒 " %self.name
14 
15 
16 class Cat(Animal):
17 
18     def __init__(self, name):
19         self.name = name
20         self.breed ＝ '貓'
21 
22     def cry(self):
23         print '喵喵叫'
24 
25 class Dog(Animal):
26     
27     def __init__(self, name):
28         self.name = name
29         self.breed ＝ '狗'
30         
31     def cry(self):
32         print '汪汪叫'
33         
34 
35 # ######### 執行 #########
36 
37 c1 = Cat('小白家的小黑貓')
38 c1.eat()
39 
40 c2 = Cat('小黑的小白貓')
41 c2.drink()
42 
43 d1 = Dog('胖子家的小瘦狗')
44 d1.eat()

3、多態

多態性（polymorphisn）是容許你將父對象設置成爲和一個或更多的他的子對象相等的技術，賦值以後，父對象就能夠根據當前賦值給它的子對象的特性以不一樣的方式運做。簡單的說，就是一句話：容許將子類類型的指針賦值給父類類型的指針。

那麼，多態的做用是什麼呢？咱們知道，封裝能夠隱藏實現細節，使得代碼模塊化；繼承能夠擴展已存在的代碼模塊（類）；它們的目的都是爲了——代碼重用。而多態則是爲了實現另外一個目的—— 接口重用！多態的做用，就是爲了類在繼承和派生的時候，保證使用「家譜」中任一類的實例的某一屬性時的正確調用。

 1 class Animal(object):
 2 
 3     def __init__(self, name):  # Constructor of the class
 4 
 5         self.name = name
 6 
 7     def talk(self):              # Abstract method, defined by convention only
 8 
 9         raise NotImplementedError("Subclass must implement abstract method")
10 
11 class Cat(Animal):
12 
13     def talk(self):
14 
15         print('%s: 喵喵喵!' %self.name)
16 
17 
18 class Dog(Animal):
19 
20     def talk(self):
21 
22         print('%s: 汪！汪！汪！' %self.name)
23 
24 
25 def func(obj): #一個接口，多種形態
26 
27     obj.talk()
28 
29 
30 c1 = Cat('小晴')
31 
32 d1 = Dog('李磊')
33 
34 
35 func(c1)
36 
37 func(d1)

領域模型 

領域模型就是對需求所涉及的領域的一個建模,更通俗的講法是業務模型。 參考百度百科領域模型定義以下: (http://baike.baidu.cn/view/757895.htm )

從這個定義咱們能夠看出,領域模型有兩個主要的做用:

1. 發掘重要的業務領域概念
2. 創建業務領域概念之間的關係 

領域域建模的方法就是「從用例中找名詞」。 固然,找到名詞後,爲了可以更加符合面向對象的要求和特色,咱們還須要對這些名詞進一步完善,這就 是接下來的步驟:加屬性,連關係! 

1.找名詞

who : 學員、講師、管理員

用例：

1. 管理員 建立了 北京 和 上海 兩個校區

2. 管理員 建立了 Linux \ Python \ Go 3個課程 

3. 管理員 建立了 北京校區的Python 16期， Go開發第一期，和上海校區的Linux 36期 班級

4. 管理員 建立了 北京校區的 學員 小晴 ，並將其 分配 在了 班級  python 16期 

5. 管理員 建立了 講師 Alex , 並將其分配 給了 班級 python 16期 和全棧脫產5期

6. 講師 Alex 建立 了一條 python 16期的 上課紀錄 Day6 

7. 講師 Alex 爲Day6這節課 全部的學員 批了做業 ，小晴得了A, 李磊得了C-, 嚴帥得了B

8. 學員小晴 在 python 16 的 day6裏 提交了做業 

9. 學員李磊 查看了本身所報的全部課程 

10 學員 李磊  在 查看了 本身在 py16期 的 成績列表 ，而後自殺了

11. 學員小晴  跟 講師 Alex 表白了

名詞列表：

管理員、校區、課程、班級、上課紀錄、做業、成績、講師、學員

2.加屬性

3.連關係 

有了類,也有了屬性,接下來天然就是找出它們的關係了。

 

總結

以上就是本節對於面向對象初級知識的介紹，總結以下：

• 面向對象是一種編程方式，此編程方式的實現是基於對 類 和 對象 的使用
• 類 是一個模板，模板中包裝了多個「函數」供（對象）使用
• 對象，根據模板建立的實例（即：對象），實例用於調用被包裝在類中的函數
• 面向對象三大特性：封裝、繼承和多態

問答專區

問題一：什麼樣的代碼纔是面向對象？

答：從簡單來講，若是程序中的全部功能都是用 類 和 對象 來實現，那麼就是面向對象編程了。

問題二：函數式編程 和 面向對象 如何選擇？分別在什麼狀況下使用？

答：須知：對於 C# 和 Java 程序員來講不存在這個問題，由於該兩門語言只支持面向對象編程（不支持函數式編程）。而對於 Python 和 PHP 等語言卻同時支持兩種編程方式，且函數式編程能完成的操做，面向對象均可以實現；而面向對象的能完成的操做，函數式編程不行（函數式編程沒法實現面向對象的封裝功能）。

因此，通常在Python開發中，所有使用面向對象 或 面向對象和函數式混合使用

面向對象的應用場景:

 

1.多函數需使用共同的值，如：數據庫的增、刪、改、查操做都須要鏈接數據庫字符串、主機名、用戶名和密碼

 1 class SqlHelper:
 2 
 3     def __init__(self, host, user, pwd):
 4 
 5         self.host = host
 6         self.user = user
 7         self.pwd = pwd
 8 
 9     def 增(self):
10         # 使用主機名、用戶名、密碼（self.host 、self.user 、self.pwd）打開數據庫鏈接
11         # do something
12         # 關閉數據庫鏈接
13 
14     def 刪(self):
15         # 使用主機名、用戶名、密碼（self.host 、self.user 、self.pwd）打開數據庫鏈接
16         # do something
17         # 關閉數據庫鏈接
18 
19     def 改(self):
20         # 使用主機名、用戶名、密碼（self.host 、self.user 、self.pwd）打開數據庫鏈接
21         # do something
22         # 關閉數據庫鏈接
23 
24     def 查(self):
25     # 使用主機名、用戶名、密碼（self.host 、self.user 、self.pwd）打開數據庫鏈接
26         # do something
27         # 關閉數據庫鏈接# do something

僞代碼

2.須要建立多個事物，每一個事物屬性個數相同，可是值的需求
如：張3、李4、楊五，他們都有姓名、年齡、血型，但其都是不相同。即：屬性個數相同，但值不相同

 

 1 class Person:
 2 
 3     def __init__(self, name ,age ,blood_type):
 4 
 5         self.name = name
 6         self.age = age
 7         self.blood_type = blood_type
 8 
 9 
10     def detail(self):
11         temp = "i am %s, age %s , blood type %s " % (self.name, self.age, self.blood_type)
12         print temp
13 
14 zhangsan = Person('張三', 18, 'A')
15 lisi = Person('李四', 73, 'AB')
16 yangwu = Person('楊五', 84, 'A')

實例代碼

問題三：類和對象在內存中是如何保存？

答：類以及類中的方法在內存中只有一份，而根據類建立的每個對象都在內存中須要存一份，大體以下圖：