面向对象(4)--继承和多态

一、继承

继承的类称为子类，被继承的类称为基类，父类，或超类。

继承的优点：

简化了代码
提高了代码的健壮性
提高了代码的安全性
多态的前提

缺点：耦合与内聚。耦合性越低，内聚性越高，代码越好。

比如，有一个Animal类，有个run方法：

In [1]: class Animal:
   ...:     def run(self):
   ...:         print('我正在跑步！！！')
   ...:

当我们需要创建Dog和Cat类时，可以直接继承Animal：

In [3]: class Dog(Animal):
   ...:     pass
   ...:

In [4]: class Cat(Animal):
   ...:     pass

由于Animal有run方法，通过继承，Dog和Cat也自动拥有了run方法。

In [5]: dog=Dog()
In [6]: dog.run()
我正在跑步！！！

In [7]: xjm=Cat()
In [8]: xjm.run()
我正在跑步！！！

在·此时你有没有想过，每个动物的run方法都不一样，有飞的，有游的。有跳的，有爬的。

所以我们可以对子类的方法进行重写，而重写后，子类的run方法会覆盖父类的run方法。这样就体现了继承的一个好处：多态。继承正是多态的前提。

In [9]: class Cat(Animal):
   ...:     def run(self):
   ...:         print('xjm正在爬呀爬呀！！！')
   ...:

In [10]: xjm=Cat()

In [11]: xjm.run()
xjm正在爬呀爬呀！！！

二、多继承

每个孩子都有自己爸爸妈妈，类是否一样呢？多继承：

首先创建一个Father类：

In [18]: class Father():
    ...:     def __init__(self,money):
    ...:         self.money=money
    ...:     def play(self):
    ...:         print('我很皮')
    ...:     def func(self):
    ...:         print('父亲的方法')

再创建一个Mother类：

In [19]: class Mother():
    ...:     def __init__(self,faceValue):
    ...:         self.faceValue=faceValue
    ...:     def eat(self):
    ...:         print('我是吃货')
    ...:     def func(self):
    ...:         print('母亲的方法')

先来满足这样一个需求，孩子继承Father的钱money。继承Mother的颜值faceValue

再来创建子类来继承Father和Mother：

In [21]: class Child(Father,Mother):
    ...:     def __init__(self,money,faceValue):
    ...:         Father.__init__(self,money)
    ...:         Mother.__init__(self,faceValue)

最后来实现一下：

In [23]: c=Child(30000,99)

In [24]: c.money
Out[24]: 30000

In [25]: c.faceValue
Out[25]: 99

In [26]: c.play()
我很皮

In [27]: c.eat()
我是吃货

In [28]: c.func()
父亲的方法

说明：父类中方法名相同，默认调用的是括号中排前面的父类中的方法。

三、多态

概念：一种事物的多种形态

要理解什么是多态，我们首先要对数据类型再作一点说明。当我们定义一个class的时候，我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型，比如str、list、dict没什么两样：

In [12]: a=list()

In [13]: b=Animal()

In [14]: c=Cat()

In [15]: isinstance(a,list)
Out[15]: True

In [16]: isinstance(c,Cat)
Out[16]: True

In [17]: isinstance(c,Animal)
Out[17]: True

从上面代码可以看出，c对象既属于Cat类，又属于Animal类。

那么多态有什么好处呢？通过一下一个事例来一一说明：

class Person():
    def __init__(self,name,gender):
        self.name=name
        self.gender=gender
    def who(self):
        print('我是一个人，我的名字是%s'%self.name)

class Student(Person):
    def __init__(self,name,gender,score):
        super(Student,self).__init__(name,gender)
        self.score=score
    def who(self):
        print('我是一名学生，我的名字是%s'%self.name)
class Teacher(Person):
    def __init__(self,name,gender,course):
        super(Teacher,self).__init__(name,gender)
        self.course=course
    def who(self):
        print('我是一名老师，我的名字是%s'%self.name)
def who(x):
    x.who()
a=Person('小狗','女')
b=Student('小猫','男',99)
c=Teacher('小鸡','不男不女','python')
who(a)
who(b)
who(c)

我是一个人，我的名字是小狗
我是一名学生，我的名字是小猫
我是一名老师，我的名字是小鸡

面向对象(4)--继承和多态

猜你喜欢