Python面向对象之继承代码详解

本文将详细讲解Python面向对象编程中的继承（inheritance）概念及其相关语法，包括继承的基本语法、继承的作用、多层继承、继承的构造函数、覆盖/重写父类方法等内容。

继承的基本语法

Python中的继承基于类（class）来实现，用关键字class声明类名和类属性，用def声明类的方法，其中在继承中需要使用到的关键字为class 子类名(父类名):，表示子类继承了父类的所有属性和方法。具体实现如下：

class Animal:                          # 定义父类
   def __init__(self, name, color):
      self.name = name
      self.color = color

   def speak(self):                    # 父类方法
      pass

class Dog(Animal):                     # 定义子类，继承 Animal 类
   def speak(self):                    # 子类重写父类方法
      return "Woof"

class Cat(Animal):                     # 定义子类，继承 Animal 类
   def speak(self):                    # 子类重写父类方法
      return "Meow"

在上述代码中，我们定义了一个父类Animal以及两个子类Dog和Cat，子类都继承了父类的属性和方法。其中，对于父类的__init__方法，定义了两个属性name和color，分别表示动物的名字和颜色；对于父类的speak方法，定义了一个占位符pass，表示在父类中暂时不实现子类需要继承的方法，在子类中再进行重写（覆盖）操作。对于子类，我们定义了speak方法，分别返回了不同的结果。

继承的作用

继承是面向对象编程中的一大特色，主要的作用有以下几个方面：

1. 代码复用。通过继承，子类可以直接使用父类中的方法和属性，避免重复编写代码，提高了代码的重用性。

2. 提高代码的可维护性。由于继承具有层次性，当需求变更时，我们可以直接在父类中修改代码，而不用修改每一个子类中的代码，避免了大规模的修改工作。

3. 扩展和重写。在父类中定义的方法和属性，可以被子类继承和修改，达到了扩展和重写的目的。

多层继承

除了单一继承，Python中还提供了多层继承的概念，即一个子类可以继承自另一个子类。具体实现如下：

class Animal:                          # 定义父类
   def __init__(self, name, color):
      self.name = name
      self.color = color

   def speak(self):                    # 父类方法
      pass

class Pet(Animal):                      # 定义子类，继承 Animal 类
   def __init__(self, name, color, pet_type):
      super().__init__(name, color)    # 调用父类的构造函数
      self.pet_type = pet_type

   def play(self):                     # 子类独有方法
      pass

class Dog(Pet):                        # 定义子类，继承 Pet 类
   def speak(self):                    # 子类重写父类方法
      return "Woof"

class Cat(Pet):                        # 定义子类，继承 Pet 类
      def speak(self):                # 子类重写父类方法
        return "Meow"

在上述代码中，我们定义了一个父类Animal、一个中间类Pet以及两个子类Dog和Cat。其中，类Pet继承了类Animal的构造函数，并添加了一个独特的属性pet_type和方法play，同时作为子类的父类，通过子类Dog和Cat的继承，依次获得了父类和中间类的所有属性和方法。

继承的构造函数

在继承中，我们常常需要使用到父类的构造函数，来初始化子类的某些属性。在Python中，使用super()函数可以调用父类的构造函数。具体实现如下：

class Animal:
    def __init__(self, name, color):
        self.name = name
        self.color = color

class Dog(Animal):
    def __init__(self, name, color, breed):
        super().__init__(name, color)      # 初始化父类的构造函数
        self.breed = breed

在上述代码中，我们定义了一个父类Animal和一个子类Dog。子类通过super()函数调用父类的构造函数，用self.breed = breed初始化自己独有的属性breed。

覆盖/重写父类方法

当子类和父类拥有相同名字的方法时，子类就会对父类的方法进行覆盖或重写（override）。具体实现如下：

class Animal:
    def speak(self):
        return "Animal speaks"

class Dog(Animal):
    def speak(self):
        return "Dog barks"

在上述代码中，父类Animal和子类Dog都定义了speak方法，但内容不同，子类对父类的方法进行了覆盖或重写。当我们通过子类创建对象并调用speak方法时，会默认执行子类中的方法。

示例说明

下面我们通过一个小游戏来说明继承的用法。该游戏中，有一个动物类Animal和两个子类Dog和Cat，每个动物都有自己独特的名字和颜色，并可以通过speak方法发出声音。代码如下：

class Animal:
    def __init__(self, name, color):
        self.name = name
        self.color = color

    def speak(self):
        return "Animal speaks"

class Dog(Animal):
    def __init__(self, name, color, breed):
        super().__init__(name, color)
        self.breed = breed

    def speak(self):
        return "Woof! I am a {} and my name is {}".format(self.breed, self.name)

class Cat(Animal):
    def speak(self):
        return "Meow! My name is {}".format(self.name)

dog = Dog("Fido", "brown", "Shiba Inu")
cat = Cat("Kitty", "white")

print(dog.speak())      # 输出：Woof! I am a Shiba Inu and my name is Fido
print(cat.speak())      # 输出：Meow! My name is Kitty

在上述代码中，我们定义了一个动物类Animal和两个子类Dog和Cat。其中，子类Dog增加了一个独特的属性breed，并覆盖了speak方法，实现了狗的啸叫效果，子类Cat则直接重写了speak方法。接着，我们创建了一个Dog和一个Cat对象，并调用其speak方法输出不同的结果。

另外，如果我们需要增加新的动物，比如鸟类，只需要直接继承父类Animal，并在子类中重写speak方法即可实现。

总的来说，继承是Python面向对象编程中重要的一环，它可以帮助我们提高代码的复用性和可维护性，同时也为我们的代码扩展和重写提供了便利。