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函数中调用该方法时，这个方法就表现出了多态行为（一样的方法作了不一样的事情）。