从零开始学Python-Day40-继承和多态

文章目录[隐藏]

多态
静态语言 vs 动态语言
小结

面向对象编程过程中，我们可以从已有class继承，定义一个新的类class，这个类被称作子类Subclass，被继承者的类被称为基类、父类或者超类（Base class、Super class）。
例如我们编写了一个名为Animal的类：

>>> class Animal(object):
	def run(self):
		print('Animals are running...')
>>> animal = Animal()
>>> animal.run()
Animals are running...

当我们定义新的类Dog和Cat时，可以直接从Animal继承：

>>> class Dog(Animal):
	pass

>>> class Cat(Animal):
	pass

>>> dog = Dog()
>>> dog.run()
Animals are running...
>>> cat = Cat()
>>> cat.run()
Animals are running...

对于Dog和Cat，Animal就是它们的父类，它俩就是Animal的子类，都继承了Animal的run方法
当然可以对子类增加方法：

>>> class Dog(Animal):
	def run(self):
		print('Dog is running...')
	def eat(self):
		print('Dog is eating...')

相比直接从Animal继承的run，显然修改后的Dog类的run方法更符合逻辑。当子类和父类都存在相同方法run()时，子类的run覆盖了父类的run。

多态

当我们定义一个class时，实际上就是定义了一种数据类型，接下来我们看下面这组判断：

>>>a = list() 
>>>b = Animal() 
>>>c = Dog()
>>> isinstance(a, list)
True
>>> isinstance(b, Animal)
True
>>> isinstance(c, Dog)
True
>>> isinstance(c, Animal)
True

isinstance用来判断一个变量是否为某个类型，我们看到a，b，c都符合对应的类型；但是c除了对应Dog类型，同时也是Animal类型。
如上，在继承关系中，如果一个实例的数据类型是一个子类，它的数据类型也可以看做父类，但反过来是不行的：

>>> b = Animal()
>>> isinstance(b, Dog)
False

要理解多态的好处，我们还需要再编写一个函数，这个函数接受一个Animal类型的变量：

>>> def run_twice(animal):
	animal.run()
	animal.run()

>>> run_twice(Animal())
Animals are running...
Animals are running...
>>> run_twice(Dog())
Dog is running...
Dog is running...

我们再定义一个Animal的子类Mouse：

>>> class Mouse(Animal):
	def run(self):
		print('Mouse is so small...')

		
>>> run_twice(Mouse())
Mouse is so small...
Mouse is so small...

可以看到对于新增的子类Mouse，不必修改run_twice，依赖父类Animal作为参数的函数或方法都可以不加修正的正常使用，原因就是多态！
多态的好处就在于此，我们要传入子类时，只要接收父类就可以，例如Dog、Cat都是Animal类型。
对于一个变量，我们只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心地调用run()方法，而具体调用的run()方法是作用在Animal、Dog、Cat对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：

1、对扩展开放：允许新增Animal子类；
2、对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

继承还可以一级一级地继承下来，就好比从爷爷到爸爸、再到儿子这样的关系。而任何类，最终都可以追溯到根类object，这些继承关系看上去就像一颗倒着的树。比如如下的继承树：

                ┌───────────────┐
                │    object     │
                └───────────────┘
                        │
           ┌────────────┴────────────┐
           │                         │
           ▼                         ▼
    ┌─────────────┐           ┌─────────────┐
    │   Animal    │           │    Plant    │
    └─────────────┘           └─────────────┘
           │                         │
     ┌─────┴──────┐            ┌─────┴──────┐
     │            │            │            │
     ▼            ▼            ▼            ▼
┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐
│   Dog   │  │   Cat   │  │  Tree   │  │ Flower  │
└─────────┘  └─────────┘  └─────────┘  └─────────┘

静态语言 vs 动态语言

对于静态语言（如Java）来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。
对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了：

class Timer(object):
    def run(self):
        print('Start...')

这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。
Python的“file-like object“就是一种鸭子类型。对真正的文件对象，它有一个read()方法，返回其内容。但是，许多对象，只要有read()方法，都被视为“file-like object“。
许多函数接收的参数就是“file-like object“，你不一定要传入真正的文件对象，完全可以传入任何实现了read()方法的对象。