python类的继承

        在程序设计中，定义一个class的时候，可以从某个现有的class继承，新的class成为子类（subcclass），而被继承的class称为基类、父类或超类（Base class、Super class）。

        编写一个名为Animal的class，有一个run()方法可以直接打印

1
2
3
class Animal(object):
    def run(self):
        print 'Animal is running...'

        需要编写B和C类时，就可以直接从Animal类继承

1
2
3
4
5
class B(Animal):
    pass
class C(Animal):
    pass

        对于B来说，Animal就是它的父类，对于Animal来说，B就是它的子类。C和B类似。

        继承最大的好处就是子类获得了父类的全部功能。由于Animal实现了run()方法，因此，B和C作为它的子类，就自动用友了run()方法

1
2
3
4
5
b = B()
b.run()
c = C()
c.run()

        运行结果如下

1
2
Animal is running...
Animal is running...

        当然，也可以对子类增加一些方法

1
2
3
4
5
class B(Animal):
    def run(self):
        print 'B is running...'
    def eat(self):
        print 'Eating meat...'

        继承的第二个好处需要对代码做一点改进。无论是B还是C，它们run()的时候，显示的都是Animal is running...，符合逻辑的做法是分别显示B is running...和C is running...，因此，对B和C类改进如下

1
2
3
4
5
6
7
class B(Animal):
    def run(self):
        print 'B is running...'
class C(Animal):
    def run(self):
        print 'C is running...'

        再次运行

1
2
B is running...
C is running...

        当子类和父类都存在相同的run()方法是，子类的run()覆盖了父类的run()，在代码运行的时候，总是会调用子类的run()。这样，就获得了继承的另一个好处：多态。

        什么是多态，首先要对数据类型作一点说明。当定义一个class的时候，实际上就定义了一中数据类型。定义的数据类型和python自带的数据类型没什么两样

1
2
3
a = list() # a是list类型
b = Animal() # b是Animal类型
c = B() # c是B类型

        判断一个变量是否是某个类型可以用isinstance()判断

1
2
3
4
5
6
>>> isinstance(a, list)
True
>>> isinstance(b, Animal)
True
>>> isinstance(c, B)
True

        看来a、b、c对应着list、Animal、B这3个类型。

1
2
>>> isinstance(c, Animal)
True

        B不仅仅是B，还是Animal。

        这是有道理的，因为B是从Animal继承下来的，当创建了一个B的实例c时，认为c的数据类型是B没错，但c同时也是Animal也没错，B本来就是Animal的一种。

        所以，在继承关系中，如果一个实例的数据类型是某个子类，那它的数据类型也可以被看做是父类。但是，反过来就不行

1
2
3
>>> b = Animal()
>>> isinstance(b, B)
False

        B可以看成Animal，但Animal不可以看成B。

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

1
2
3
def run_twice(animal):
    animal.run()
    animal.run()

        当传入Animal的实例时，run_twice()就打印出

1
2
3
>>> run_twice(Animal())
Animal is running...
Animal is running...

        当传入B的实例时，run_twice()就打印出

1
2
3
>>> run_twice(Dog())
B is running...
B is running...

        当传入C的实例时，run_twice()就打印出

1
2
3
>>> run_twice(Cat())
C is running...
C is running...

        看上去没啥意思，但再定义个一个Tortoise类型，也从Animal派生

1
2
3
class Tortoise(Animal):
    def run(self):
        print 'Tortoise is running slowly...'

        当调用run_twice()时，传入Tortoise的实例

1
2
3
>>> run_twice(Tortoise())
Tortoise is running slowly...
Tortoise is running slowly...

        发现，新增一个Animal的子类，不必对run_twice()做任何修改，实际上，任何依赖Animal作为参数的函数或者方法都可以不加修改的正常运行，原因就在于多态。

        多态的好处就是，当需要传入B、C、Tortoise…时，只需要接收Animal类型就可以了，因为B、C、Tortoise…都是Animal类型，然后，按照Animal类型进行操作即可。由于Animal类型有run()方法，因此，传入的任务类型，只要是Animal类或者子类，就会自动调用实际类型的run()方法，这就是多态的意思。

        对于一个变量，只需要知道它是Animal类型，无需确切地知道它的子类型，就可以放心的调用run()方法，而具体调用的run()方法是左右能够在Animal、B、C还是Tortoise对象上，由运行时该对象的确切类型决定，折旧是多态真正的魏丽：调用方只管调用，不管细节，而放新增一种Animal的子类时，只要去报run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则：

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

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

        继承可以把父类的所有功能都直接拿过来，这样就不必重零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写；

        有了继承，才能有多态。在调用类实例方法的矢耦，尽量把变量视作父类类型，这样所有子类类型都可以正常被接收。