Python 入門 —— Python 面向對象的三大特點：封裝、繼承、多態

Python 面向對象的三大特點：封裝、繼承、多態

• 面向對象的三大特點：
  
  • 封裝：將有一定功能的代碼封裝起來，使用時調用即可
  • 繼承：將公共的屬性和方法放在父類中，自己自考慮特有的屬性和方法。
  • 多態：程序運行過程中，根據執行條件的不同，動態執行不同的操作代碼的過程稱爲運行時多態。

1 封裝

• 封裝
  1.封裝是面向對象編程的一大特點
  2.面向對象編程的第一步將屬性和方法封裝到一抽象的類中
  3.外界使用類創建對象，然後讓對象調用方法
  4.對象方法的細節都被封裝在類的內部

示例一：
要求：
XX愛跑步
1. XX體重75.0公斤
2. XX每次跑步會減肥0.5公斤
3. XX每次吃東西體重會增加1公斤

 class Person():      # 定義類
     def __init__(self,name,weight):
         self.name = name
         self.weight = weight
         print "%s like to run,and %s's weight is %.2f kg" \ 
         % (self.name,self.name,self.weight)

     def run(self,lose_weight):   # 定義方法
         self.weight -= lose_weight
         print "When %s run,weight will be lost %.2f kg ,and the finall weight is %.2f" \
         % (self.name,lose_weight,self.weight)

     def eat(self,get_weight):    # 定義方法
         self.weight += get_weight
         print "When %s eat,weight will be put on %.2f kg ,and the finall weight is %.2f" \
         % (self.name,get_weight, self.weight)

 Tom = Person('Tom',75)    # 定義對象
 Tom.run(0.5)              # 調用方法，加上參數，意味，Tom 每跑一次步，就減重0.5
 Jarry = Person('Jarry',60)# 可以定義第二個對象，再調用方法
 Jarry.eat(1)               # 調用方法，加上參數，意味，Tom 每吃一次，就增重1

執行如下：

控制檯顯示如下：

這就是封裝，定義不同對象，只需要對類中的方法進行調用，然後讓其完成對應的效果
示例二：
擺放傢俱
需求:
1.房子有戶型，總面積和傢俱名稱列表
新房子沒有任何的傢俱
2.傢俱有名字和戰地面積，其中
牀:佔4平米
衣櫃:佔2平面
餐桌:佔1.5平米
3.將以上三件傢俱添加到房子中
4.打印房子時,要求輸出:戶型，總面積，剩餘面積，傢俱名稱列表

 class Furniture(object):        # 建立類 Furniture
     def __init__(self,name,area):
         self.name = name
         self.area = area


 class House(object):            # 建立類 House
     def __init__(self,model,areas):
         self.model = model
         self.areas = areas
         self.free_area = areas
         self.furniture_list = []

     def __str__(self):
         return '房子戶型：%s\n房子大小：%.2f\n剩餘空間：%.2f\n傢俱列表:%s' \
              % (self.model,self.areas,self.free_area,self.furniture_list)

     def add(self,furniture):   # 創建方法 add 進行傢俱的添加
         if furniture.area > self.areas:
             print '%s 面積太大，無法添加' % furniture.name
             return
         self.furniture_list.append(furniture.name)
         print '%s 添加成功' % furniture.name
         self.free_area -= furniture.area

 bed = Furniture('bed',400)          # 建立傢俱類的對象 bed，給bed面積爲100
 wardrobe = Furniture('wardrobe',2)  # 建立傢俱類的對象 wardrobe
 table = Furniture('table',1.5)      # 建立傢俱類的對象 table

 my_house = House('三室一廳',100)    # 創建對象my_house，給他的面積爲100
 my_house.add(bed)                  # 調用方法添加及傢俱
 my_house.add(wardrobe)
 my_house.add(table)

 print my_house

控制檯顯示如下：

由於bed面積大於房子的面積100，所以無法被添加

2 繼承：

• Python 類的繼承
  在OOP（Object Oriented Programming）程序設計中，當我們定義一個c lass的時候，可以從某個現有的class 繼承，新的class稱爲子類（Subclass），而被繼承的class稱爲基類、父類或超類（Base class、Super class）。
• 子類擁有父類的所有屬性和方法
  子類繼承父類，可以直接享受父類已經封裝好的方法
  子類中應該根據自己的職責，封裝子類特有的屬性和方法

示例：

 class Animal():              # 定義父類 Animal 類
     def eat(self):           # 定義父類中的方法
         print 'eat'
     def drink(self):
         print 'drink'
     def run(self):
         print 'run'
     def sleep(self):
         print 'sleep'

 class Cat(Animal):
     # 子類擁有父類的所有屬性和方法
     # 子類根據自己的職責，封裝子類特有的屬性和方法
     def scream(self):
         print 'miao~~' 

 tom = Cat()
 tom.eat()       # 子類的示例直接可以調用父類中的方法
 tom.drink()
 tom.run()
 tom.sleep()
 tom.scream()

執行如下：

控制檯顯示如下：

繼承的傳遞性：（爺爺，父親，兒子）

1.C類從B類繼承，B類又從A類繼承
2.那麼C類就具有B類和A類的所有屬性和方法
子類擁有父類以及父類的父類中封裝的所有屬性和方法

示例：

 class Animal():
     def eat(self):
         print 'eat'
     def drink(self):
         print 'drink'
     def run(self):
         print 'run'
     def sleep(self):
         print 'sleep'

 class Cat(Animal):
     # 子類擁有父類的所有屬性和方法
     # 子類根據自己的職責，封裝子類特有的屬性和方法
     def scream(self):
         print 'miao~~'

 class BlueCat(Cat):         # 定義子類的子類
     def speak(self):
         print 'I can spea Chinese'

 bluecat = BlueCat()

 bluecat.eat()
 bluecat.drink()
 bluecat.run()
 bluecat.sleep()
 bluecat.scream()
 bluecat.speak() 

執行如下：

控制檯顯示如下：

繼承——重寫父類

• 重寫父類方法有兩種情況：
  1.覆蓋父類的方法
  2.對父類方法進行擴展

1.覆蓋父類的方法

如果在開發中，父類的方法的實現和子類方法的實現，
完全不同，就可以使用覆蓋的方式，
在子類中重新編寫父類的方法
具體實現方法，相當於在子類中定義了一個父類同名的方法並且實現
重寫之後，在運行時，只會調用子類的重寫方法
而不會調用父類的封裝的方法

示例：

class Animal():
    def eat(self):
        print 'eat'
    def drink(self):
        print 'drink'
    def run(self):
        print 'run'
    def sleep(self):
        print 'sleep'

class Cat(Animal):
    # 子類擁有父類的所有屬性和方法
    def scream(self):
        print 'miao~~'
# 子類繼承父類，可以直接享受父類已經封裝好的方法
# 子類中應該根據自己的職責，封裝子類特有的屬性和方法

class BlueCat(Cat):
    def speak(self):
        print 'I can speak Chinese'
    def scream(self):        # 子類中定義與父類相同的方法，進行覆蓋
        print 'Come here beat me!'
 bluecat = BlueCat()    # 定義對象

 bluecat.eat()          # 調用父類的方法
 bluecat.drink()
 bluecat.run()
 bluecat.sleep()
 bluecat.scream()       # 調用重新定義過的與父類中方法相同的方法
 bluecat.speak()

執行如下：

控制檯顯示如下：

2.對父類的方法進行擴展

如果在開發中，子類的方法實現包含有父類的方法實現
（父類原本封裝的方法實現是子類方法的一部分就可以使用擴展方法）
1.在子類中重寫父類的方法
2.在需要的位置使用父類名.方法（self）來調用父類方法的執行（使用父類名稱調用父類方法）
3.代碼其他位置針對子類的需求，編寫子類特有的代碼實現

示例：

 class Animal():
     def eat(self):
         print 'eat'
     def drink(self):
         print 'drink'
     def run(self):
         print 'run'
     def sleep(self):
         print 'sleep'

 class Cat(Animal):
     # 子類擁有父類的所有屬性和方法
     def scream(self):
         print 'miao~~'
 # 子類繼承父類，可以直接享受父類已經封裝好的方法
 # 子類中應該根據自己的職責，封裝子類特有的屬性和方法 

 class BlueCat(Cat):
     def speak(self):
         print 'I can speak Chinese'
     def scream(self):
         print 'Come here beat me!'
         Cat.scream(self)      # 調用父類的同名方法

 bluecat = BlueCat()

 bluecat.eat()
 bluecat.drink()
 bluecat.run()
 bluecat.sleep()
 bluecat.scream()
 bluecat.speak()

執行如下：

控制檯顯示如下：

多繼承

子類擁有一個父類叫做單繼承
子類可以擁有多個父類，並且具有所有父類的屬性和方法

示例：

 class A():           # 定義父類 A
     def test(self):
         print 'A'

 class B():           # 定義父類 B
     def demo(self):
         print 'B'

 class C(B,A):        # 定義子類C，繼承父類 A，B 的特性
     pass

 c = C()
 c.test()
 c.demo()

執行如下：

控制檯顯示如下：

若是父類的方法中有相同名稱的，子類會繼承在前方的屬性

示例：定義父類A，B，A，B中有相同的方法，子類會繼在前方的父類的方法

 class A():              # 定義父類 A
     def test(self):
         print 'A'

 class B():              # 定義父類 B
     def test(self):
         print 'B'

 class C(A,B):           # 定義子類C，繼承父類 A，B 的特性
     pass

 c = C()
 c.test()

執行如下：

控制檯顯示如下：

若是調換順序：

class A():
    def test(self):
        print 'A'

class B():
    def test(self):
        print 'B'

class C(B,A):
    pass

c = C()
c.test()

控制檯顯示如下：

3 多態

面向對象程序設計最有趣的特性是多態，它是是讓大多數人犯暈的特性。
多態：（Polymorphism） 按字面的意思就是“多種狀態”
在面嚮對象語言中，接口的多種不同的實現方式即爲多態。
多態意味着就算不知道變量所引用的對象類是什麼，還是能對它進行操作，而它也會根據對象（或類）類型的不同而表現出不同的行爲。

示例一：

class Animal(object):
    def __init__(self,name):
        self.name = name
    def scream(self):
        print '沒有動物叫'
class Cat(Animal):
    def scream(self):
        print '喵喵喵喵喵'
class Dog(Animal):
    def scream(self):
        print '汪汪汪汪汪'

a = Animal('')
a.scream()

c = Cat('Tom')
c.scream()

d = Dog('Senven')
d.scream()

代碼中有Cat和Dog 兩個子類，都繼承了類Animal，它們都有scream（）方法，輸入不同的動物名稱，會得到相應的結果，這就是多態的應用
執行如下：

控制檯顯示：

示例二：此例子能更清晰點

 class Dog(object):
     def __init__(self,name):
         self.name = name
     def scream(self):
         print '%s wang,wang,wang' % self.name
     def game(self):
         print '%s 玩耍，玩飛盤' % self.name

 class GodDog(Dog):
     def game(self):
         print '%s fly and scream' % self.name

 class Person(object):
     def __init__(self,name):
         self.name = name
       def game(self,dog):
         print '%s play with %s' % (self.name,dog.name)
         dog.game()
 wangcai = Dog('wangcai')

 goddog = GodDog('xiaotian')

 yangjian = Person('yangjain')
 yangjian.game(wangcai)

執行如下：

控制檯顯示：