python面向對象之繼承/多態/封裝

老師說，按繼承/多態/封裝這個順序來講。

子類使用父類的方法：

#!/usr/bin/env python
# coding:utf-8

class Vehicle:
    def __init__(self,name,speed,load,power):
        self.name = name
        self.speed = speed
        self.load = load
        self.power = power

    def run(self):
        print("開動啦。")


class Benz(Vehicle):
    def __init__(self,name,speed,load,power,color):
        # Vehicle.__init__(self,name,speed,load,power) # 使用指定類名方式調用了父類方法
        # super(__class__.self).__init__(name,speed,load,power) # 使用super(__class__.self)方式
        super().__init__(name,speed,load,power) # 採用super()不傳參數的方法
        self.color=color

    def show_info(self):
        print(self.name,self.speed,self.load,self.power,self.color)

    def run(self):
        # Vehicle.run(self) # 使用指定類名稱的方式，調用了父類方法
        super().run()
        print("%s %s 出發啦." % (self.color,self.name))


car1 = Benz("GLK 300","120","5人","2.4T","black")
car1.show_info()
car1.run()

繼承的例子：

#!/usr/bin/env python
# coding:utf-8

'''
組合與繼承都是有效地利用已有類的資源的重要方式。但是二者的概念和使用場景皆不同，

1.繼承的方式

通過繼承建立了派生類與基類之間的關係，它是一種'是'的關係，比如白馬是馬，人是動物。

當類之間有很多相同的功能，提取這些共同的功能做成基類，用繼承比較好，比如老師是人，學生是人

2.組合的方式

用組合的方式建立了類與組合的類之間的關係，它是一種‘有’的關係,比如教授有生日，教授教python和linux課程，教授有學生s1、s2、s3...

當類之間有顯著不同，並且較小的類是較大的類所需要的組件時，用組合比較好
'''

class Dad:
    '這個是爸爸類'
    money=10
    def __init__(self,name):
        print('父類')
        self.name=name
    def hit_son(self):
        print('%s 正在打兒子' %self.name)


# class Son(Dad):
#     pass
#
# # print(Son.money)
# # Son.hit_son()  # 繼承了父類的數據屬性和函數屬性
# s1=Son('alex')
# s1.hit_son()
# print(s1.name)
# print(Dad.__dict__)
# print(Son.__dict__)


class Son(Dad):
    money = 1000000009
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def hit_son(self):
        print('來自子類')

s1 = Son('Jerry',12)
print(s1.money)
print(Dad.money) # 子類在自己裡面定義了與父類同名的屬性，並沒有覆蓋父類的屬性
s1.hit_son()

print(s1.__dict__)

繼承順序：

#!/usr/bin/env python
# coding:utf-8

## 繼承的順序

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

class B(A): # 單繼承
    # def test(self):
    #     print("B")
    pass

class C(A):
    def test(self):
        print("C")
    pass

class D(B):
    # def test(self):
    #     print("D")
    pass

class E(C):
    # def test(self):
    #     print("E")
    pass

class F(D,E): # 多繼承
    # def test(self):
    #     print("F")
    pass

f1 = F()
f1.test()
# 新式類查找順序 F >> D >> B >> E >> C >> A
# 經典類查找順序 F >> D >> B >> A >> E >> C

print(F.__mro__) # python2中經典類沒有 __mro__

## 如果繼承關係為菱形結構，那麼屬性的查找方式有兩種，分別是：深度優先和廣度優先
## 經典類時，要查找的屬性不存在時，多繼承會按照深度優先的方式查找
## 新式類時，要查找的屬性不存在時，多繼承會按照廣度優先的方式查找，最後找到object

多態的例子：

#!/usr/bin/env python
# coding:utf-8

## 多態
## python本身就是多態的.
# 由不同的類實例化得到的對象，調用同一個方法，執行的邏輯不同
# 指出了對象如何通過他們共同的屬性和動作來操作及訪問，而不需要考慮它們具體的類。
# 表明瞭動態綁定的存在，允許重載及運行時類型確定和驗證。
# 體現在調用不同對象的共同方法時，才能展現出來。

class H2O:
    def __init__(self,name,temperature):
        self.name=name
        self.temperature=temperature
    def turn_ice(self):
        if self.temperature < 0:
            print('[%s]溫度太低結冰了' %self.name)
        elif self.temperature > 0 and self.temperature < 100:
            print('[%s]液化成水' %self.name)
        elif self.temperature > 100:
            print('[%s]溫度太高變成了水蒸氣' %self.name)

class Water(H2O):
    pass
class Ice(H2O):
    pass
class Steam(H2O):
    pass

w1=Water('水',25)
i1=Ice('冰',-20)
s1=Steam('蒸汽',3000)

# 下麵三個對象調用了相同的方法，但是得到的結果卻不一樣。
w1.turn_ice()
i1.turn_ice()
s1.turn_ice()