• 编写类之三子类
    • 子类、父类和继承

    编写类之三子类

    关于类，看官想必已经有了感觉，看下面的代码，请仔细阅读，并看看是否能够发现点什么问题呢？

    1. #!/usr/bin/env python
    2. #coding:utf-8
    4. class Person:
    5.     def __init__(self, name, lang, email):
    6.         self.name = name
    7.         self.lang = lang
    8.         self.email = email
    10.     def author(self):
    11.         return self.name
    13. class Programmer:
    14.     def __init__(self, name, lang, email, system, website):
    15.         self.name = name
    16.         self.lang = lang
    17.         self.email = email
    18.         self.system = system
    19.         self.website = website
    21.     def pythoner(self):
    22.         pythoner_list = [ self.name, self.lang, self.email, self.system, self.website ]
    23.         return pythoner_list
    25. if __name__=="__main__":
    26.     writer = Person("qiwsir","Chinese","qiwsir@gmail.com")
    27.     python = Programmer("qiwsir","Python","qiwsir@gmail.com","Ubutun","qiwsir.github.io")
    28.     print "My name is:%s"%writer.author()
    29.     print "I write program by:%s"%python.pythoner()[1]

    上面这段代码，运行起来没有什么问题，但是，仔细看，发现有两个类，一个名字叫做Person，另外一个叫做Programmer，这还不是问题所在，问题所在是这两个类的构造函数中，存在这相同的地方：self.name=name,self.lang=lang,self.email=email，这对于追求代码质量的程序员，一般是不允许的。最好不要有重复代码或者冗余代码。可是，在两个类中都要有这些参数，应该怎么办呢？

    子类、父类和继承

    看下面的代码，里面有两个类A，B。这段程序能够正确运行，每个类的功能是仅仅打印指定的内容。

    1. #!/usr/bin/env python
    2. #coding:utf-8
    4. class A:
    5.     def __init__(self):
    6.         print "aaa"
    8. class B:
    9.     def __init__(self):
    10.         print "bbb"
    12. if __name__=="__main__":
    13.     a = A()
    14.     b = B()
    16. #运行结果
    17. aaa
    18. bbb

    上面的两个类彼此之间没有所谓的父子关系。现在稍加改变，将类B改写，注意观察与上面的差异。

    1. #!/usr/bin/env python
    2. #coding:utf-8
    4. class A:
    5.     def __init__(self):
    6.         print "aaa"
    8. class B(A):         #这里和上面程序不同。B继承了A
    9.     def __init__(self):
    10.         print "bbb"
    12. if __name__=="__main__":
    13.     a = A()
    14.     b = B()
    16. #运行结果
    17. aaa
    18. bbb

    这段程序中，类B跟前面的那段有一点不同，class B(A):,这样写就表明了B相对A的关系：B是A的子类，B从A继承A的所有东西（子承父业）。

    但是，看官发现了没有，运行结果一样。是的，那是以为在B中尽管继承了A，但是没有调用任何A的东西，就好比儿子从老爸那里继承了财富，但是儿子一个子也没动，外界看到的和没有继承一样。

    1. #!/usr/bin/env python
    2. #coding:utf-8
    4. class A:
    5.     def __init__(self):
    6.         print "aaa"
    8. class B(A):
    9.     def __init__(self):
    10.         #print "bbb"
    11.         A.__init__(self)    #运行继承的父类
    13. if __name__=="__main__":
    14.     a = A()
    15.     b = B()
    17. #运行结果
    18. aaa
    19. aaa

    这回运行结果有了变化，本来b=B()是运行类B，但是B继承了A，并且在初始化的构造函数中，引入A的构造函数，所以，就运行A的结果相应结果了。

    下面把最开头的那端程序用子类继承的方式重写，可以是这样的：

    1. #!/usr/bin/env python
    2. #coding:utf-8
    4. class Person:
    5.     def __init__(self, name, lang, email):
    6.         self.name = name
    7.         self.lang = lang
    8.         self.email = email
    10.     def author(self):
    11.         return self.name
    12. """
    13. class Programmer:
    14.     def __init__(self, name, lang, email, system, website):
    15.         self.name = name
    16.         self.lang = lang
    17.         self.email = email
    18.         self.system = system
    19.         self.website = website
    21.     def pythoner(self):
    22.         pythoner_list = [ self.name, self.lang, self.email, self.system, self.website ]
    23.         return pythoner_list
    24. """
    26. class Programmer(Person):       #继承父类Person
    27.     def __init__(self, name, lang, email, system, website):
    28.         Person.__init__(self,name,lang,email)   #将Person.__init__()的功能继承到这里
    29.         #self.name = name                       #这三句是Person中已经搞定的，就不用重复
    30.         #self.lang = lang                       #通过继承已经实现了这三句的功能
    31.         #self.email = email
    32.         self.system = system                    #子类中不同于Person父类部分
    33.         self.website = website
    35.     def pythoner(self):
    36.         pythoner_list = [ self.name, self.lang, self.email, self.system, self.website ]
    37.         return pythoner_list
    39. if __name__=="__main__":
    40.     writer = Person("qiwsir","Chinese","qiwsir@gmail.com")
    41.     python = Programmer("qiwsir","Python","qiwsir@gmail.com","Ubutun","qiwsir.github.io")
    42.     print "My name is:%s"%writer.author()
    43.     print "I write program by:%s"%python.pythoner()[1]

    代码运行结果与前面一样。

    列位是否理解了子类和父类、继承的特点。如果你有一个老爹，是一个高官或者富豪，那么你就官二代或者富二代了，你就从他们那里继承了很多财富，所以生活就不用太劳累了。这就是继承的作用。在代码中，也类似，继承能够让写代码的少劳累一些。

    需要提供注意的是，在子类中，如果要继承父类，必须用显明的方式将所继承的父类方法写出来，例如上面的Person.init(self,name,lang,email)，必须这样写，才能算是在子类中进行了继承。如果不写上，是没有继承的。用编程江湖的黑话（比较文雅地称为“行话”）说就是“显式调用父类方法”。

    对于为什么要用继承，好友@令狐虫 大侠给了以非常精彩的解释：

    从技术上说，OOP里，继承最主要的用途是实现多 态。对于多态而言，重要的是接口继承性，属性和行为是否存在继承性，这是不一定的。事实上，大量工程实践表明，重度的行为继承会导致系统过度复杂和臃肿， 反而会降低灵活性。因此现在比较提倡的是基于接口的轻度继承理念。这种模型里因为父类（接口类）完全没有代码，因此根本谈不上什么代码复用了。

    在Python里，因为存在Duck Type，接口定义的重要性大大的降低，继承的作用也进一步的被削弱了。

    另外，从逻辑上说，继承的目的也不是为了复用代码，而是为了理顺关系。

    我表示完全赞同上述解释。不过看官如果不理解，也没有关系，上述解释中的精神，的确需要在编程实践中感悟才能领会到的。