类的继承

  #面向对象编程带来的好处之一是代码的重用，实现代码重用的方法之一是通过继承机制。继承完全可以理解成类之间类型和子类型的关系。

        #在面向对象程序设计中，当我们定义一个class时，可以从某个现有的class继承，定义的新class称为子类（Subclass），而被继承的class称为基类、父类或者超类（Base class、Super class）。

        #继承定义如下：

class DerivedClassName(BaseClassName):
         <statement-1>
         .
         .
         .
         <statement-N>

#需要注意的是：继承语法class子类名（基类名）时，//基类名写在括号里，基本类时在定义类时，在元组中指明的。

        #在Python中，继承有以下特点：

        （1）、在继承中，基类的构造方法（__init__()方法）不会被调用，需要在子类的构造方法中专门调用。

        （2）、在调用基类的方法时需要加上基类的类名前缀，并带上self参数变量。区别于在类中调用普通函数时不需要带self参数。

        （3）、在Python中，首先查找对应类型的方法，如果在子类中找不到对应的方法，才到基类中逐个查找。

        #例如：

#! /usr/bin/python3
#-*-coding:UTF-8-*-
#继承

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

  #上面定义了一个名为Animal的类，类中定义了一个run()方法直接输出（没有显式定义__init__()方法，会调用默认的构造方法）。在编写Dog和Cat类时，可以直接从Animal类继承，定义如下：

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

class Dog(Animal):
    pass

class Cat(Animal):
    pass

  #在这段代码中，对于Dog来说，Animal就是他的父类；对于Animal来说，Dog就是他的子类。Cat和Dog类似。

        #继承最大的好处时子类获得了父类全部非私有的功能。由于在Animal中定义了非私有的run()方法，因此作为Animal的子类，Dog和Cat什么方法都没有定义，自动拥有父类中的run()方法，执行以下代码：

#! /usr/bin/python3
#-*-coding:UTF-8-*-
#继承

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

class Dog(Animal):
    pass

class Cat(Animal):
    pass

dog=Dog()
dog.run()

cat=Cat()
cat.run()

#程序执行结果如下：

D:Pythonworkspace>python 继承.py
Animal is running.
Animal is running.    

#由执行结果看到，子类中没有定义任何方法，但都成功执行了run()方法。

        #当然，子类可以拥有一些自己的方法，比如在Dog类中增加一个eat方法：

class Dog(Animal):
    def eat(self):
        print('Eating.')

    pass

    #程序执行结果如下：

D:Pythonworkspace>python 继承.py
Animal is running.
Eating.

   #由执行结果看到，既执行了父类的方法，又执行了dog自己定义的方法。

        #子类不能继承父类中的私有方法，也不能调用父类的私有方法，父类定义如下：

#! /usr/bin/python3
#-*-coding:UTF-8-*-
#继承

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

    def __run(self):
        print('this is a private method.')

  #子类定义不变，执行如下调用语句：

dog=Dog()
dog.run()
dog.__run()

   #程序执行结果如下：

D:Pythonworkspace>python 继承.py
Animal is running.
Traceback (most recent call last):
  File "继承.py", line 18, in <module>
    dog.__run()
AttributeError: 'Dog' object has no attribute '__run'

  #由执行结果看到，子类不能调用父类的私有方法，子类虽然继承了父类，但是调用父类的私有方法相当于从外部调用类中的方法，因而不能调用成功。

        #对于父类中扩展的非私有方法，子类可以拿来即用，如在父类Animal中增加一个jump方法：

#! /usr/bin/python3
#-*-coding:UTF-8-*-
#继承

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

    def jump(sel):
        print('Animal is jumpping.')

    def __run(self):
        print('I am a private method.')

     #上面我们增加了一个非私有的jump()方法，子类Dog和Cat保持原样，执行如下调用：

dog=Dog()
dog.run()
dog.jump()
#dog.__run()

cat=Cat()
cat.run()
cat.jump()
cat.__run()

   #程序执行结果如下：

D:Pythonworkspace>python 继承.py
Animal is running.
Animal is jumpping.
Animal is running.
Animal is jumpping.
Traceback (most recent call last):
  File "继承.py", line 29, in <module>
    cat.__run()
AttributeError: 'Cat' object has no attribute '__run'

#由执行结果看到，子类可以立即获取父类增加的非私有方法。

        #继承可以一级一级继承下来，就好比爷爷到爸爸再到儿子的关系。所有类最终都可以追溯到根类object，这些继承关系看上去就像一颗倒着的树，如下图所示：

   #例如如下：

#! /usr/bin/python3
#-*-coding:UTF-8-*-
#class的继承

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

    def eat(self):
        print('this is good food.')

class BigDog(Animal):
    pass

class BigCat(Animal):
    pass

class SmallDog(BigDog):
    pass

class SmallCat(BigCat):
    pass


dog=BigDog()
dog.run()

cat=BigCat()
cat.run()


bigdog=BigDog()
bigdog.eat()

bigcat=BigCat()
bigcat.eat()

#程序执行结果如下：

D:Pythonworkspacedatatime20171129>python class的继承.py
Animal is running.
Animal is running.
this is good food.
this is good food.

    #由输出结果看到，SmallDog和SmallCat虽然和Animal没有直接的联系，但是也通过BigDog和BigCat继承了Animal的eat()方法