Python 面向對象(創建類和對象，面向對象的三大特性是指：封裝、繼承和多態，多態性)

本文轉載自查看原文 2017-06-13 13:50 2307

概念：

面向過程：根據業務邏輯從上到下寫壘代碼
函數式：將某功能代碼封裝到函數中，日后便無需重復編寫，僅調用函數即可
面向對象：對函數進行分類和封裝，讓開發“更快更好更強...”

面向過程編程最易被初學者接受，其往往用一長段代碼來實現指定功能，開發過程中最常見的操作就是粘貼復制，即：將之前實現的代碼塊復制到現需功能處。

隨着時間的推移，開始使用了函數式編程，增強代碼的重用性和可讀性，就變成了這樣：

今天我們來學習一種新的編程方式：面向對象編程（Object Oriented Programming，OOP，面向對象程序設計）
注：Java和C#來說只支持面向對象編程，而python比較靈活即支持面向對象編程也支持函數式編程

創建類和對象

面向對象編程是一種編程方式，此編程方式的落地需要使用 “類” 和 “對象” 來實現，所以，面向對象編程其實就是對 “類” 和 “對象” 的使用。

類就是一個模板，模板里可以包含多個函數，函數里實現一些功能

　　對象則是根據模板創建的實例，通過實例對象可以執行類中的函數

class是關鍵字，表示類
創建對象，類名稱后加括號即可

ps：類中的函數第一個參數必須是self（詳細見：類的三大特性之封裝）
　　 類中定義的函數叫做 “方法”

 
                # 創建類 
               
                class  
                Foo: 
               
                def  
                Bar( 
                self 
                ): 
               
                print  
                'Bar' 
               
                def  
                Hello( 
                self 
                , name): 
               
                print  
                'i am %s'  
                % 
                name 
               
                # 根據類Foo創建對象obj 
               
                obj  
                =  
                Foo() 
               
                obj.Bar()             
                #執行Bar方法 
               
                obj.Hello( 
                'wupeiqi' 
                )  
                #執行Hello方法

你在這里是不是有疑問了？使用函數式編程和面向對象編程方式來執行一個“方法”時函數要比面向對象簡便

面向對象：【創建對象】【通過對象執行方法】
函數編程：【執行函數】

觀察上述對比答案則是肯定的，然后並非絕對，場景的不同適合其的編程方式也不同。

總結：函數式的應用場景 --> 各個函數之間是獨立且無共用的數據

面向對象三大特性

面向對象的三大特性是指：封裝、繼承和多態，多態性

一、封裝

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

所以，在使用面向對象的封裝特性時，需要：

將內容封裝到某處
從某處調用被封裝的內容

第一步：將內容封裝到某處

self 是一個形式參數，當執行 obj1 = Foo('wupeiqi', 18 ) 時，self 等於 obj1

當執行 obj2 = Foo('alex', 78 ) 時，self 等於 obj2

所以，內容其實被封裝到了對象 obj1 和 obj2 中，每個對象中都有 name 和 age 屬性，在內存里類似於下圖來保存。

第二步：從某處調用被封裝的內容

調用被封裝的內容時，有兩種情況：

通過對象直接調用
通過self間接調用

1、通過對象直接調用被封裝的內容

上圖展示了對象 obj1 和 obj2 在內存中保存的方式，根據保存格式可以如此調用被封裝的內容：對象.屬性名

 1 class Foo:
 2  
 3     def __init__(self, name, age):
 4         self.name = name
 5         self.age = age
 6  
 7 obj1 = Foo('wupeiqi', 18)
 8 print obj1.name    # 直接調用obj1對象的name屬性
 9 print obj1.age     # 直接調用obj1對象的age屬性
10  
11 obj2 = Foo('alex', 73)
12 print obj2.name    # 直接調用obj2對象的name屬性
13 print obj2.age     # 直接調用obj2對象的age屬性

對象.屬性名調用

2、通過self間接調用被封裝的內容

執行類中的方法時，需要通過self間接調用被封裝的內容

 1 class Foo:
 2 
 3     def __init__(self, name, age):
 4         self.name = name
 5         self.age = age
 6 
 7     def detail(self):
 8         print (self.name)
 9         print (self.age)
10 
11 obj1 = Foo('wupeiqi', 18)
12 obj1.detail()  # Python默認會將obj1傳給self參數，即：obj1.detail(obj1)，所以，此時方法內部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18
13 
14 obj2 = Foo('alex', 73)
15 obj2.detail()  # Python默認會將obj2傳給self參數，即：obj1.detail(obj2)，所以，此時方法內部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

self間接調用被封裝的內容

綜上所述，對於面向對象的封裝來說，其實就是使用構造方法將內容封裝到對象中，然后通過對象直接或者self間接獲取被封裝的內容。

 1 def kanchai(name, age, gender):
 2     print （"%s,%s歲,%s,上山去砍柴" %(name, age, gender)）
 3 
 4 
 5 def qudongbei(name, age, gender):
 6     print （"%s,%s歲,%s,開車去東北" %(name, age, gender)）
 7 
 8 
 9 def dabaojian(name, age, gender):
10     print （"%s,%s歲,%s,最愛大保健" %(name, age, gender)）
11 
12 
13 kanchai('小明', 10, '男')
14 qudongbei('小明', 10, '男')
15 dabaojian('小明', 10, '男')
16 
17 
18 kanchai('老李', 90, '男')
19 qudongbei('老李', 90, '男')
20 dabaojian('老李', 90, '男')

函數

 1 class Foo:
 2     
 3     def __init__(self, name, age ,gender):
 4         self.name = name
 5         self.age = age
 6         self.gender = gender
 7 
 8     def kanchai(self):
 9         print （"%s,%s歲,%s,上山去砍柴" %(self.name, self.age, self.gender)）
10 
11     def qudongbei(self):
12         print （"%s,%s歲,%s,開車去東北" %(self.name, self.age, self.gender)）
13 
14     def dabaojian(self):
15         print （"%s,%s歲,%s,最愛大保健" %(self.name, self.age, self.gender)）
16 
17 
18 xiaoming = Foo('小明', 10, '男')
19 xiaoming.kanchai()
20 xiaoming.qudongbei()
21 xiaoming.dabaojian()
22 
23 laoli = Foo('老李', 90, '男')
24 laoli.kanchai()
25 laoli.qudongbei()
26 laoli.dabaojian()

面向對象

上述對比可以看出，如果使用函數式編程，需要在每次執行函數時傳入相同的參數，如果參數多的話，又需要粘貼復制了... ；而對於面向對象只需要在創建對象時，將所有需要的參數封裝到當前對象中，之后再次使用時，通過self間接去當前對象中取值即可。

二、繼承

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

例如：

　　貓可以：喵喵叫、吃、喝、拉、撒

　　狗可以：汪汪叫、吃、喝、拉、撒

如果我們要分別為貓和狗創建一個類，那么就需要為貓和狗實現他們所有的功能，如下所示：

 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 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()
45 
46 代碼實例

繼承動物

所以，對於面向對象的繼承來說，其實就是將多個類共有的方法提取到父類中，子類僅需繼承父類而不必一一實現每個方法。

注：除了子類和父類的稱謂，你可能看到過派生類和基類，他們與子類和父類只是叫法不同而已。

多繼承

是否可以繼承多個類
如果繼承的多個類每個類中都定了相同的函數，那么那一個會被使用呢？

1、Python的類可以繼承多個類，Java和C#中則只能繼承一個類

2、Python的類如果繼承了多個類，那么其尋找方法的方式有兩種，分別是：深度優先和廣度優先

當類是經典類時，多繼承情況下，會按照深度優先方式查找
當類是新式類時，多繼承情況下，會按照廣度優先方式查找

經典類和新式類，從字面上可以看出一個老一個新，新的必然包含了跟多的功能，也是之后推薦的寫法，從寫法上區分的話，如果 當前類或者父類繼承了object類，那么該類便是新式類，否則便是經典類。

三、多態和多態性

多態指的是一類事物有多種形態，（一個抽象類有多個子類，因而多態的概念依賴於繼承）

一什么是多態性（請務必注意注意注意：多態與多態性是兩種概念。）

多態性是指具有不同功能的函數可以使用相同的函數名，這樣就可以用一個函數名調用不同功能的函數。

在面向對象方法中一般是這樣表述多態性：向不同的對象發送同一條消息（！！！obj.func():是調用了obj的方法func，又稱為向obj發送了一條消息func），不同的對象在接收時會產生不同的行為（即方法）。也就是說，每個對象可以用自己的方式去響應共同的消息。所謂消息，就是調用函數，不同的行為就是指不同的實現，即執行不同的函數。

比如：老師.下課鈴響了（），學生.下課鈴響了()，老師執行的是下班操作，學生執行的是放學操作，雖然二者消息一樣，但是執行的效果不同

多態性分為靜態多態性和動態多態性

靜態多態性：如任何類型都可以用運算符+進行運算

動態多態性：如下

#多態是同一種事物的多種形態
class Animal:
    def talk(self):
            print('正在叫')


class People(Animal):
    def talk(self):
        print('say hello')

class Pig(Animal):
    def talk(self):
        print('哼哼哼')

class Dog(Animal):
    def talk(self):
        print('汪汪汪')


class Cat(Animal):
    def talk(self):
        print('喵喵喵')
peo1=People()
pig1=Pig()
dog1=Dog()
cat1=Cat()


#多態性

peo1.talk()
dog1.talk()
pig1.talk()


def func(x):
    x.talk()


func(peo1)
func(pig1)
func(dog1)
func(cat1)


#輸出結果：
# say hello
# 汪汪汪
# 哼哼哼

# say hello
# 哼哼哼
# 汪汪汪
# 喵喵喵

View Code

免責聲明！

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

猜您在找 Javascript面向對象三大特性（封裝性、繼承性、多態性）詳解及創建對象的各種方法面向對象的三大特性 - 繼承、多態、封裝面向對象三大特性-----封裝、繼承、多態面向對象的三大特性 - 繼承、多態、封裝面向對象的三大特征之一：多態性 python的面向對象的特性（繼承、封裝、多態） python面向對象三大特性之繼承、多態、封裝面向對象三大特性之多態性面向對象三大特性:封裝,繼承,多態(一,封裝和繼承) 面向對象之多態、多態性