python oop 继承_Python 进阶_OOP 面向对象编程_组合与继承

zhu hao

于 2021-03-01 04:53:05 发布

阅读量91

点赞数

文章标签： python oop 继承

本文链接：https://blog.csdn.net/weixin_35019131/article/details/114911854

版权

#目录

前言

我们定义一个类是希望能够把类当成模块来使用，并把类嵌入到我们的应用代码中，与其他的数据类型、逻辑执行流结合使用。一般来说我们可以使用两种方法在代码中利用类，那就是组合和派生。

组合

组合: 就是将不同的类混合并加入到其他类中，来增加类的功能 / 提高代码的重用性 / 易于维护(对类的修改会直接反应到整个应用中) 。我们可以实例化一个更大的对象，同时还可以添加一些实例属性和实例方法的实现来丰富实例对象的功能。

In [1]: class NewAddrBookEntry(object): # 定义一个类

...: """New address book entry class."""

...: def __init__(self, name, phone): # 定义构造器

...: self.name = Name(name) # 创建 Name 对象

...: self.phone = Phone(phone) # 创建 Phone 对象

...: print "Created the instance for ", self.name

上述的 class NewAddrBookEntry 有它自身和其他类 Name/Phone 组合而成, 可以实现一些更为复杂的功能。

派生

当我们希望较小的类是较大的类的组件时，组合是一个很好的处理方式。但当我们希望相同的类却具有一些不同的功能时派生就是最好的处理方式。这也是面向对象编程最强大的功能之一 —— 使用一个已经定义好的类，扩展它的功能或者对其进行修改生成一个新的类，但却不会对原来的类造成影响。

子类会从基类继承他们的任何属性(数据和方法)，这种派生是可以继承多代的，且可以同时继承多个基类。

语法：

class SubClassName(ParentClass1[, ParentClass2, ...]):

class_suite

EXAMPLE：

In [8]: class Parent(object):

...: def __init__(self):

...: print "created an instance of: ", self.__class__.__name__

...:

In [9]: class Child(Parent):

...: pass

...:

In [10]: c = Child()

created an instance of: Child

In [14]: p = Parent()

created an instance of: Parent

类 Child 的实例对象 c 并没有定义 __init__() 构造器，但仍然执行了 print 语句，这是因为 Child 从 Parent 继承了其构造器。

通过继承来覆盖(重载)方法

当我们派生一个子类，但同时希望相同的方法能在子类实现不同的功能，这时我们需要使用方法的重载。使子类的方法能够覆盖父类的同名方法。

In [17]: class Parent(object):

...: def func(self):

...: print "This is Parent."

...:

In [18]: class Child(Parent):

...: def func(self):

...: print "This is Child."

...:

In [19]: p = Parent()

In [20]: p.func()

This is Parent.

In [21]: c = Child()

In [22]: c.func()

This is Child.

这里子类 Child 重载了父类 Parent 的 func() 方法，实现了不同的功能。

但仍然有些场合需要我们即能使用子类的重载方法的同时，也要求我们重现父类方法的功能。那么我们可以调用那个被我们覆盖的父类方法吗？

答案是肯定的。

In [23]: Parent.func(c)

This is Parent.

我们可以通过 ParentClassName.functionName(object) 的方式来重现父类所被覆盖的方法。当然我们还有其他的方式可以实现这个效果，EG. 在子类的重载方法里显式的调用父类的同名方法：

In [24]: class Child(Parent):

...: def func(self):

...: print "This is Child."

...: Parent.func(self)

In [25]: c = Child()

In [26]: c.func()

This is Child.

This is Parent.

两种方式本质上是相同的，都是通过父类名结合句点表达式来实现对父类方法的调用，而且需要注意的是，在调用的时候必须传递一个实例对象给 func()，否则会触发参数不匹配的语法错误。

还有一个更好的实现方式就是子类使用 super() 内置函数：

In [27]: class Child(Parent):

...: def func(self):

...: print "This is Child."

...: super(Child, self).func()

...:

In [28]: c = Child()

In [29]: c.func()

This is Child.

This is Parent.

super() 内置函数不仅能自动的找到父类方法，并且还是自动的为父类方法传入 self 参数来实现实例方法的绑定。

最常用的重载场景(实例方法的重载)

最常用的重载场景莫过于重载父类的构造器了。

在上述的例子可以看出，当我们在子类中没有重载构造器的时候，会自动的调用父类的构造器。这很明显是不符合我们的需求的，因为我们常常需要在子类中定义一些新的成员属性。但是问题是：当我们为了初始化子类中新的成员属性时，不可避免的需要重复的编写初始化从父类中继承而来的属性的代码。这也不符合代码重用的原则，所以我们一般会采用重载构造器(init()) + 重现父类构造器(super()) 的方式来解决这个问题。

In [32]: class Parent(object):

...: def __init__(self, name, age):

...: self.name = name

...: self.age = age

...: print "This is Parent."

...:

In [33]: class Child(Parent):

...: def __init__(self, name, age, sex): # 初始化子类实例对象的属性

...: super(Child, self).__init__(name, age) # 初始化父类实例对象的属性

...: self.sex = sex

...: print "This is Child."

...: