python——類和類之間的關係（繼承多態）

一、類和類之間的關係有三種：is-a、has-a和use-a關係。

• is-a關係也叫繼承或泛化，好比學生和人的關係、手機和電子產品的關係都屬於繼承關係。
• has-a關係一般稱之爲關聯，好比部門和員工的關係，汽車和引擎的關係都屬於關聯關係；關聯關係若是是總體和部分的關聯，那麼咱們稱之爲聚合關係；若是總體進一步負責了部分的生命週期（總體和部分是不可分割的，同時同在也同時消亡），那麼這種就是最強的關聯關係，咱們稱之爲合成關係。
• use-a關係一般稱之爲依賴，好比司機有一個駕駛的行爲（方法），其中（的參數）使用到了汽車，那麼司機和汽車的關係就是依賴關係。

 

利用類之間的這些關係，咱們能夠在已有類的基礎上來完成某些操做，也能夠在已有類的基礎上建立新的類，

這些都是實現代碼複用的重要手段。

複用現有的代碼不只能夠減小開發的工做量，也有利於代碼的管理和維護，這是咱們在平常工做中都會使用到的技術手段。

 

class Person(object):
    """人"""

    def __init__(self, name, age):
        self._name = name
        self._age = age

    @property
    def name(self):
        return self._name

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age

    def play(self):
        print('%s正在愉快的玩耍.' % self._name)

    def watch_av(self):
        if self._age >= 18:
            print('%s正在觀看愛情動做片.' % self._name)
        else:
            print('%s只能觀看《熊出沒》.' % self._name)


class Student(Person):
    """學生"""

    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self._grade = grade

    @property
    def grade(self):
        return self._grade

    @grade.setter
    def grade(self, grade):
        self._grade = grade

    def study(self, course):
        print('%s的%s正在學習%s.' % (self._grade, self._name, course))


class Teacher(Person):
    """老師"""

    def __init__(self, name, age, title):
        super().__init__(name, age)
        self._title = title

    @property
    def title(self):
        return self._title

    @title.setter
    def title(self, title):
        self._title = title

    def teach(self, course):
        print('%s%s正在講%s.' % (self._name, self._title, course))


def main():
    stu = Student('王大錘', 15, '初三')
    stu.study('數學')
    stu.watch_av()
    


if __name__ == '__main__':
    main()

 

子類在繼承了父親的方法後，能夠對父類已有的方法給出新的實現版本，這個動做稱之爲重寫（override）.經過方法

重寫咱們可讓父類的同一個行爲在子類中擁有不一樣的實現版本，當咱們調用這個通過子類重寫的方法的，不一樣的子類

對象會表現出不一樣的行爲，這個就是多態（poly-morphism）

from abc import ABCMeta, abstractmethod

class Pet(object, metaclass=ABCMeta):
    """寵物"""
    def __init__(self, nickname):
        self._nickname = nickname

    @abstractmethod
    def make_voice(self):
        """發出聲音"""
        pass

class Dog(Pet):
    """狗"""

    def make_voice(self):
        print('%s:汪汪汪...' % self._nickname)

class Cat(Pet):
    """貓"""
    def make_voice(self):
        print('%s:喵喵' % self._nickname)

def main():
    pets = [Dog('旺財'), Cat('凱蒂'), Dog('大黃')]
    for pet in pets:
        pet.make_voice()

if __name__ == '__main__':
    main()

將Pet類處理成了一個抽象類，所謂抽象類就是不可以建立對象的類，這種類的存在就是專門爲了讓其餘類去繼承它。

Python從語法層面並無像Java或C#那樣提供對抽象類的支持，可是咱們能夠經過abc模塊的ABCMeta元類和abstractmethod包裝器來達到抽象類的效果，若是一個類中存在抽象方法那麼這個類就不可以實例化（建立對象）。

上面的代碼中，Dog和Cat兩個子類分別對Pet類中的make_voice抽象方法進行了重寫並給出了不一樣的實現版本，當咱們在main函數中調用該方法時，這個方法就表現出了多態行爲（一樣的方法作了不一樣的事情）。