python 初識面向對象

1. 初識面向對象
面向過程:
一切以事務的發展流程為中心.
面向對象:
一切以對象為中心. 一切皆為對象. 具體的某一個事務就是對象

打比方:
大象進冰箱
步驟: 第一步, 開門, 第二步, 裝大象, 第三步, 關門

面向對象:大象, 你進冰箱.
此時主語是大象. 我操縱的是大象. 此時的大象就是對象

 1 class Car:  # 類名首字母大寫,嚴格蹲守駝峰命名規則
 2     pass
 3 
 4 
 5 # 造車
 6 c = Car()  # 類名()  # 創建對象
 7 
 8 #  出廠之後進行改裝
 9 c.color = '紅顏色'  # 對象.屬性    點:的  當屬性不存在的時候, 添加一個屬性
10 c.pai = '京A8888'  # 對象.屬性
11 c.pailiang = '555L'  # 排量
12 
13 print(c.color)  # 此車是紅顏色
14 print(c.pai)
15 print(c.pailiang)
16 
17 c.color = '綠顏色'  # 當屬性存在的時候是修改屬性信息
18 # 對象.屬性 =xxx 設置屬性信息
19 print(c.color)

2. 類. 對象
類: 就是圖紙. 創建對象的第一步. 先畫圖紙. 先寫類.
對象: 對象就是車. 通過圖紙造出來的具體的東西. 通過類來創建對象

類與對象的關係:
類是對xxx事物的歸類.
寫:
__init__(self, 參數) 參數一般作為屬性設置給對象. 對象就是self, 對屬性的封裝.

def 方法(self, 參數): 方法. 第一個參數一般是固定的self. 當前類的對象.
pass

對象是xx類型的一個具體
創建對象: 類名()

創建類:
class 類名:

def __init__(self): # 初始化方法. 又被成為構造方法
self.屬性 = 值
self.屬性 = 值
self.屬性 = 值

def fangfa(self):
方法體(函數體, return)

創建對象:
變數 = 類名() # 實例化 <-> 創建對象

變數.屬性 # 訪問對象的屬性信息
變數.方法() # 訪問類中的方法

 1 1.
 2 class Car:  # 類名首字母大寫,嚴格蹲守駝峰命名規則
 3     # __init__方法是一個特殊的方法. 初始化方法. (構造方法)
 4     # 在創建對象的時候會自動的調用__init__()
 5     # self就是你創建出來的那個對象
 6     def __init__(self):  # init初識方法. 在創建對象的時候. 預設執行這個函數
 7         print('我是init')
 8         print('self=', self)
 9 
10 
11 c = Car()  # 創建Car類型對象. 此時self參數不需要我們管
12 print('c=', c)
13 
14 2.
15 class Car:  # 類名首字母大寫,嚴格蹲守駝峰命名規則
16     def __init__(self, color, pai, pailiang):  # init初識方法. 在創建對象的時候. 預設執行這個函數
17         # self.color = '紅色' # 在出廠的時候都是紅色 靜態的
18         self.color = color  # 動態獲取 第一個color是設置 第二個color是獲取的參數
19         self.pai = pai
20         self.pailiang = pailiang
21 
22     # 跑: 動作, 功能 -> 函數
23     # 在類中寫的函數-> 方法
24     # self 當前類的對象
25     def pao(self):  # self是自動傳遞的. 不用管它
26         print('%s我的車能跑' % self.color)  #self.color
27     def jump(self):
28         print('you jump, I jump')
29 #
30 #
31 #
32 #
33 c = Car('紅色', '京A8888', '555L')  # 創建Car類型對象. 此時self參數不需要我們管
34 c2 = Car('藍色', '京B6666', '1.6T')
35 print(c.color)
36 print(c2.color)
37 #
38 #
39 c.pao()
40 c2.pao()
41 c.jump()

3. 面向對象和麵向過程的對比
如果寫一些比較小的程式用面向過程.
程式很複雜. 很龐大建議用面向對象.

4. 面向對象的三大特征
封裝:
1. 對屬性的封裝(__init__())
self.xxx = xxx
2. 對方法和功能的封裝

繼承
子類自動擁有父類中除了私有內容外的其他所有內容
class Bar(Foo): Bar對Foo進行了擴展
pass

當出現x是一種y的時候. 推薦使用繼承關係
python支持多繼承. 查找順序: 先找離他近的.

1 class Foo:
2     def getMoney(self):
3         print('拿錢')
4 
5 class Bar(Foo):
6     pass
7 
8 b = Bar()
9 b.getMoney()  # 此時調用的是父類中的方法

多態(python原生直接就是多態)
python更多的支持的是鴨子模型, 只要會嘎嘎叫就是好鴨子

 1 多態性: 用一個對象. 多種形態
 2 python 支持的是鴨子類型. 會嘎嘎叫的東西就是鴨子
 3 為了程式能夠正常執行. 本來需要傳遞進來一隻鴨子. 但是我只需要傳遞一個會嘎嘎叫的東西就可以了
 4 def func(yazi):
 5     yazi.gagajiao()
 6 
 7 class Animal:
 8     def chi(self):
 9         print("會吃")
10 
11 class GoldenMonkey(Animal):
12     def chi(self):
13         print("用手拿著吃, 五花八門")
14 
15 class Tiger(Animal):
16     def chi(self):
17         print("老虎吃肉")
18 
19 class Elephant(Animal):
20     def chi(self):
21         print("大象吃香蕉")
22 
23 class QiE(Animal):
24     def chi(self):
25         print("企鵝吃人民幣")
26 
27 # 以下代碼是飼養員
28 # 優點: 超強的可擴展行. 面向對象的核心就是多態
29 def wei_animal(ani):  # 傳進來的東西要會吃的就行
30     ani.chi()
31 
32 # 動物園
33 t = Tiger()
34 m = GoldenMonkey()
35 e = Elephant()
36 
37 wei_animal(t)
38 wei_animal(m)
39 wei_animal(e)
40 
41 a = 188
42 def cul(n):  # python中萬事萬物都是對象, object(對象)
43     print(n)
44 
45 cul(a)
46 cul('哈哈')