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

    编写类之三子类

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

    1. #!/usr/bin/env python
    2. #coding:utf-8
    3. class Person:
    4. def __init__(self, name, lang, email):
    5. self.name = name
    6. self.lang = lang
    7. self.email = email
    8. def author(self):
    9. return self.name
    10. class Programmer:
    11. def __init__(self, name, lang, email, system, website):
    12. self.name = name
    13. self.lang = lang
    14. self.email = email
    15. self.system = system
    16. self.website = website
    17. def pythoner(self):
    18. pythoner_list = [ self.name, self.lang, self.email, self.system, self.website ]
    19. return pythoner_list
    20. if __name__=="__main__":
    21. writer = Person("qiwsir","Chinese","qiwsir@gmail.com")
    22. python = Programmer("qiwsir","Python","qiwsir@gmail.com","Ubutun","qiwsir.github.io")
    23. print "My name is:%s"%writer.author()
    24. 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
    3. class A:
    4. def __init__(self):
    5. print "aaa"
    6. class B:
    7. def __init__(self):
    8. print "bbb"
    9. if __name__=="__main__":
    10. a = A()
    11. b = B()
    12. #运行结果
    13. aaa
    14. bbb

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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