(09)-Python3之--類的三大特性（封裝、繼承、多態）

1、封裝

封裝，就是只能在類的內部訪問，外部訪問屬性或方法會報異常，python中的封裝很簡單，只要在屬性前或者方法名前加上兩個下划線就可以，如self.__name，def __eat(self)這樣就完成了屬性和方法的私有化，也就是封裝。

class hj:
    _arg = 'world'  # 封裝
    __kws = 'kws'   # 封裝
    def __init__(self):
        print(self._arg)   # 內部調用一個下划線的封裝
        print(self.__kws)  # 內部調用兩個下划線的封裝

    # 提供封裝訪問函數讓外部可以使用
    def get(self):
        print(self.__kws)

h = hj()
print(h._arg)   # 一個下划線的封裝 外部是可以調用的
#print(h.__kws)  # 兩個下划線的封裝 外部是無法調用的(其實是可以調用的,只不過python給你做個一個重名的操作(_hj__kws))
h.get()    # 通過封裝的方法來調用

2、繼承

官方解釋：所謂繼承指提供了同一類對象共性的處理方法，子類繼承父類共性的東西。 這樣有利於代碼的復用性，即子類擁有父類的方法。通過繼承創建的新類稱為“子類”或“派生類”，被繼承的類稱為“基類”、“父類”或“超類”。

通俗講就是：父類的是子類的，子類的還是子類的。

python中繼承也非常簡單，定義一個Animal類，下面有一個eat()方法，再定義一個Dog類，Dog類中什么都不寫，用pass代替。然后實例化一個dog，讓dog繼承Animal類,dog可以使用eat()方法。

class Animal(object):
    def __init__(self,name):
        self.name = name
    def eat(self):
        print(self.name,"吃飯")

class Dog(Animal):
    pass
dog=Dog("旺財")
dog.eat()

結果：
旺財 吃飯

重寫：和父類的方法名稱一樣。但是在子類里面，重新實現。

　　1、完全覆蓋

class Animal:

    def __init__(self,name,private_v1):
        self.name = name
        self._private_v1 = private_v1
        self.__private_v2 = "private_really"　　# 私有化，不對子類開放

    def run(self):
        print("跑！！")

class Dog(Animal): # 繼承父類（Animal）

    def __init__(self,name,kind):
        self.name = name
        self.kind = kind

    def eat(self):
        print("一只名叫 {} 的 {} 在啃骨頭！！".format(self.name,self.kind))

    def run(self): # 重寫父類的run（）方法
        print("我是一條狗，我有四條腿跑！！")

# 實例化
dog = Dog("二狗","哈士奇")
dog.run()
dog.eat()

結果：
我是一條狗，我有四條腿跑！！
一只名叫 二狗 的 哈士奇 在啃骨頭！！

　　2、保留父類的做法，在它的基礎上再擴展其它的內容。（擴展方式：super()）

　　　　super()的2種表達：

　　　　　　super().方法(參數列表)

　　　　　　super(子類名，self).方法(參數列表)

class Animal:

    def __init__(self, name, private_v1):
        self.name = name
        self._private_v1 = private_v1
        self.__private_v2 = "private_really" 

    def run(self):
        print("跑！！")


class Dog(Animal):  # 繼承父類Animal

    def __init__(self, name, kind, private_v1):
        # 方法一
        super().__init__(name, private_v1)  # 調用父類現成的方法
        # 方法二
        # super(Dog,self).__init__(name)
        self.kind = kind  # 擴展子類自己的特性

    def eat(self):
        print("一只名叫 {} 的 {} 在啃骨頭！！".format(self.name, self.kind))

    def gogo(self):  # 完全顛覆父類的做法
        super().run()   # 父類做法
        print("我是一條狗，我有四條腿跑！！") # 我的做法

# 實例化
dog = Dog("小白","二哈","private_v1")
dog.eat()
dog.gogo()

結果：
一只名叫 小白 的 二哈 在啃骨頭！！
跑！！
我是一條狗，我有四條腿跑！！

多繼承：

在python中是可以多繼承的，繼承的先后順序是有區別的，當我們調用方法的時候，如果第一個繼承的找不到，才會去第二個中找，但是只要在第一個類中找到調用的那個方法，即使參數個數不匹配也不會調用第二個父類中的，此時會報錯。

class Student:
    def study(self):
        print("我是學生，我愛學習，我愛班級！")

class Employee:
    def work(self):
        print("我要賺錢，我要工作，我愛工作！！")

class People(Student,Employee): # 繼承Student類,Employee類

    def do_something(self):
        self.work()
        self.study()

p = People()
p.do_something()

結果：
我要賺錢，我要工作，我愛工作！！
我是學生，我愛學習，我愛班級！

3.多態

python中本質上是沒有真正多態這種思路，只是形式上有這樣一個多態的思路。

class Animal(object):
    def __init__(self,color):
        self.color=color
    def eat(self):
        print("吃飯")

class Cat(Animal):
    def eat(self):
        print("貓吃魚")

class Dog(Animal):
    def __init__(self,name,age,color):
        super(Dog,self).__init__(color)
        self.name=name
        self.age=age
    def eat(self):
        print("狗吃肉")
def feed(obj):
        obj.eat()

an=Animal("白色")#實例化Animal
cat=Cat("棕色")#實例化Cat
dog=Dog("小黃",2,"黃色")#實例化Dog

feed(an)
feed(cat)
feed(dog)

結果：
吃飯
貓吃魚
狗吃肉

定義了一個Animal父類，兩個子類Cat和Dog里面都有eat()方法，最后再定義一個feed()喂養方法，

傳入一個obj對象，調用obj.eat()，然后實例化Animal，Cat和Dog，分別在feed中傳入實例化對象an，cat和dog會分別打印出不同的語句，這個就是python中的多態。