python面向对象（五）之多态

继承

​ 在讲多态之前我们再复习下继承，下面是一个例子。

​

Circle

和

Rectangle

继承自

Shape

，不同的图形，面积（

area

）计算方式不同。

# shape.py

class Shape:
def area(self):
return 0.0

class Circle(Shape):
def __init__(self, r=0.0):
self.r = r

def area(self):
return math.pi * self.r * self.r

class Rectangle(Shape):
def __init__(self, a, b):
self.a, self.b = a, b

def area(self):
return self.a * self.b

用法比较直接：

>>> from shape import *
>>> circle = Circle(3.0)
>>> circle.area()
28.274333882308138
>>> rectangle = Rectangle(2.0, 3.0)
>>> rectangle.area()
6.0

如果

Circle

没有定义自己的

area

：

class Circle(Shape):
pass

那么它将继承父类

Shape

的

area

：

>>> Shape.area is Circle.area
True

一旦

Circle

定义了自己的

area

，从

Shape

继承而来的那个

area

就被重写（

overwrite

）了：

>>> from shape import *
>>> Shape.area is Circle.area
False

通过类的字典更能明显地看清这一点：

>>> Shape.__dict__['area']
<function Shape.area at 0x0000000001FDB9D8>
>>> Circle.__dict__['area']
<function Circle.area at 0x0000000001FDBB70>

所以，子类重写父类的方法，其实只是把相同的属性名绑定到了不同的函数对象。可见 Python 是没有覆写（

override

）的概念的。

同理，即使

Shape

没有定义

area

也是可以的，

Shape

作为“接口”，并不能得到语法的保证。

甚至可以动态的添加方法：

class Circle(Shape):
...
#  def area(self):
#  return math.pi * self.r * self.r

# 为 Circle 添加 area 方法。
Circle.area = lambda self: math.pi * self.r * self.r

动态语言一般都是这么灵活，Python 也不例外。

Python 官方教程「9. Classes」第一句就是：


Python 以最少的新的语法和语义实现了类机制，这一点确实让人惊叹，但是也让 C++ / Java 程序员感到颇为不适。

多态

如前所述，Python 没有重写（

override

）的概念。严格来讲，Python 并不支持「多态」，也不用支持多态，python是一种多态语言，崇尚鸭子类型**。

以下是维基百科中对鸭子类型得论述：





－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－



为了解决继承结构中接口和实现的问题，或者说为了更好的用 Python 面向接口编程（设计模式所提倡的），我们需要人为的设一些规范。

请考虑

Shape.area()

除了简单的返回

0.0

，有没有更好的实现？

以内建模块

asyncio

为例，

AbstractEventLoop

原则上是一个接口，类似于 Java 中的接口或 C++ 中的纯虚类，但是 Python 并没有语法去保证这一点，为了尽量体现

AbstractEventLoop

是一个接口，首先在名字上标志它是抽象的（Abstract），然后让每个方法都抛出异常

NotImplementedError

。

class AbstractEventLoop:
def run_forever(self):
raise NotImplementedError
...

纵然如此，你是无法禁止用户实例化

AbstractEventLoop

的：

loop = asyncio.AbstractEventLoop()
try:
loop.run_forever()
except NotImplementedError:
pass

C++ 可以通过纯虚函数或设构造函数为

protected

来避免接口被实例化，Java 就更不用说了，接口就是接口，有完整的语法支持。

你也无法强制子类必须实现“接口”中定义的每一个方法，C++ 的纯虚函数可以强制这一点（Java 更不必说）。

就算子类「自以为」实现了“接口”中的方法，也不能保证方法的名字没有写错，C++ 的

override

关键字可以保证这一点（Java 更不必说）。

静态类型的缺失，让 Python 很难实现 C++ / Java 那样严格的多态检查机制。所以面向接口的编程，对 Python 来说，更多的要依靠程序员的素养。

回到

Shape

的例子，仿照

asyncio

，我们把“接口”改成这样：

class AbstractShape:
def area(self):
raise NotImplementedError

这样，它才更像一个接口。

super

有时候，需要在子类中调用父类的方法。

比如图形都有颜色这个属性，所以不妨加一个参数

color

到

__init__

：

class AbstractShape:
def __init__(self, color):
self.color = color

那么子类的

__init__()

势必也要跟着改动：

class Circle(AbstractShape):
def __init__(self, color, r=0.0):
super().__init__(color)
self.r = r

通过

super

把

color

传给父类的

__init__()

。其实不用

super

也行：

class Circle(AbstractShape):
def __init__(self, color, r=0.0):
AbstractShape.__init__(self, color)
self.r = r

但是

super

是推荐的做法，因为它避免了硬编码，也能处理多继承的情况。