文章目录

Python 类和对象：详细讲解前言9. 方法重写（Method Overriding）9.1 为什么需要方法重写？9.2 方法重写的基本示例9.3 代码详解

10. 多继承（Multiple Inheritance）10.1 多继承的概念10.2 多继承的示例10.3 代码详解10.4 方法解析顺序（MRO）

11. 类的组合（Composition）11.1 什么是类的组合？11.2 类的组合的示例11.3 代码详解11.4 组合与继承的对比

12. 总结3

13.方法解析顺序（MRO）13.1 MRO 的基本概念13.2 查看 MRO13.3 复杂继承结构中的 MRO

14. 抽象类和接口14.1 什么是抽象类？14.2 Python 中的抽象类14.3 抽象类的用途

Python 类和对象：详细讲解

前言

接上篇：【Python篇】Python 类和对象：详细讲解（上篇）

在编程中，类和对象是面向对象编程（OOP）的核心概念。Python 是一门支持面向对象编程的语言，这意味着你可以使用类和对象来组织代码，使其更加模块化、可维护和可扩展。

9. 方法重写（Method Overriding）

方法重写是在子类中定义与父类中同名的方法，以覆盖或扩展父类的行为。通过方法重写，子类可以改变或定制从父类继承的方法的功能。

9.1 为什么需要方法重写？

在继承中，子类会继承父类的所有方法和属性。然而，有时你可能希望子类的某些方法与父类的方法表现不同。这时，你就可以在子类中重写这些方法。

9.2 方法重写的基本示例

我们来定义一个基本的 <code>Car 类，然后在子类 ElectricCar 中重写它的方法。

class Car:

def __init__(self, brand, color):

self.brand = brand

self.color = color

self.speed = 0

def start(self):

self.speed = 10

print(f"The { self.color} { self.brand} car is starting at { self.speed} km/h.")

def stop(self):

self.speed = 0

print(f"The { self.color} { self.brand} car is stopping.")

# 定义一个 ElectricCar 类，继承自 Car 类

class ElectricCar(Car):

def __init__(self, brand, color, battery_capacity):

super().__init__(brand, color) # 调用父类的构造函数初始化 brand 和 color

self.battery_capacity = battery_capacity

def start(self):

# 重写 start 方法，让电动汽车以不同的方式启动

self.speed = 20 # 电动汽车启动时速度更快

print(f"The { self.color} { self.brand} electric car is silently starting at { self.speed} km/h with { self.battery_capacity} kWh capacity.")

def charge(self):

print(f"The { self.color} { self.brand} electric car is charging with { self.battery_capacity} kWh capacity.")

# 创建 ElectricCar 对象并使用它

electric_car = ElectricCar("Tesla", "White", 85)

electric_car.start() # 输出: The White Tesla electric car is silently starting at 20 km/h with 85 kWh capacity.

electric_car.stop() # 输出: The White Tesla car is stopping.

electric_car.charge() # 输出: The White Tesla electric car is charging with 85 kWh capacity.

9.3 代码详解

父类 Car 的方法：Car 类定义了 start 和 stop 方法。start 方法设置初始速度为 10 km/h，stop 方法将速度设为 0。子类 ElectricCar 的方法重写：

ElectricCar 继承了 Car 的所有属性和方法。ElectricCar 重写了 start 方法，使其启动速度为 20 km/h，并增加了电池容量的输出。super().__init__(brand, color) 调用了父类的构造函数，以确保 brand 和 color 属性被正确初始化。

10. 多继承（Multiple Inheritance）

多继承是指一个类可以同时继承多个父类的特性。Python 支持多继承，但使用时需要注意可能的复杂性，尤其是在多个父类中有相同方法的情况下。

10.1 多继承的概念

多继承允许一个子类同时从多个父类中继承方法和属性。这种特性非常强大，但也可能带来复杂的依赖关系。

10.2 多继承的示例

创建两个父类 Vehicle 和 Electric，然后定义一个子类 ElectricCar，它同时继承自这两个父类。

class Vehicle:

def __init__(self, brand):

self.brand = brand

def start(self):

print(f"The { self.brand} vehicle is starting.")

class Electric:

def __init__(self, battery_capacity):

self.battery_capacity = battery_capacity

def charge(self):

print(f"Charging with { self.battery_capacity} kWh battery capacity.")

# ElectricCar 继承了 Vehicle 和 Electric

class ElectricCar(Vehicle, Electric):

def __init__(self, brand, color, battery_capacity):

Vehicle.__init__(self, brand) # 初始化 Vehicle 类的属性

Electric.__init__(self, battery_capacity) # 初始化 Electric 类的属性

self.color = color

def start(self):

print(f"The { self.color} { self.brand} electric car is silently starting with { self.battery_capacity} kWh battery.")

# 使用 ElectricCar 类

electric_car = ElectricCar("Tesla", "White", 85)

electric_car.start() # 输出: The White Tesla electric car is silently starting with 85 kWh battery.

electric_car.charge() # 输出: Charging with 85 kWh battery capacity.

10.3 代码详解

Vehicle 和 Electric 父类：这两个类分别提供 brand 和 battery_capacity 属性，并各自定义了 start 和 charge 方法。ElectricCar 的多继承：

ElectricCar 同时继承了 Vehicle 和 Electric 的属性和方法。通过在 __init__ 方法中分别调用 Vehicle.__init__(self, brand) 和 Electric.__init__(self, battery_capacity) 来初始化父类的属性。ElectricCar 中的 start 方法重写了 Vehicle 类的 start 方法，以自定义启动行为。

10.4 方法解析顺序（MRO）

当使用多继承时，Python 会根据方法解析顺序（MRO）来决定调用哪个父类的方法。MRO 是 Python 确定方法调用顺序的规则。

查看 MRO：

你可以通过 ClassName.mro() 方法查看一个类的 MRO。

例如：

print(ElectricCar.mro())

这将输出：

[<class '__main__.ElectricCar'>, <class '__main__.Vehicle'>, <class '__main__.Electric'>, <class 'object'>]

MRO 解析顺序：Python 会从左到右、从上到下地查找方法。在本例中，ElectricCar 先查找自身，然后是 Vehicle，接着是 Electric，最后是 Python 所有类的基类 object。

11. 类的组合（Composition）

类的组合是指一个类可以包含其他类的实例作为属性，从而创建更复杂的对象。与继承相比，组合更灵活，因为它不涉及继承链的复杂性。

11.1 什么是类的组合？

类的组合通过在一个类中包含另一个类的实例，来实现功能模块化。这种方法使得类的职责更加明确，也让代码更加易于维护。

11.2 类的组合的示例

让我们定义一个 Battery 类，并将其组合到 ElectricCar 中。

class Battery:

def __init__(self, capacity):

self.capacity = capacity

def charge(self):

print(f"Charging the battery with { self.capacity} kWh capacity.")

class ElectricCar:

def __init__(self, brand, color, battery_capacity):

self.brand = brand

self.color = color

self.battery = Battery(battery_capacity) # 组合 Battery 类

def start(self):

print(f"The { self.color} { self.brand} electric car is starting.")

def charge(self):

self.battery.charge() # 调用 Battery 类的 charge 方法

# 使用 ElectricCar 类

electric_car = ElectricCar("Tesla", "White", 85)

electric_car.start() # 输出: The White Tesla electric car is starting.

electric_car.charge() # 输出: Charging the battery with 85 kWh capacity.

11.3 代码详解

Battery 类：Battery 类代表电动汽车的电池。它有一个 charge 方法来模拟充电。ElectricCar 的组合：

ElectricCar 类拥有一个 Battery 类的实例，作为其 battery 属性。当调用 electric_car.charge() 时，实际是调用 Battery 类的 charge 方法。

11.4 组合与继承的对比

继承：用于创建一个“是一个”关系的类结构，例如 ElectricCar 是一个 Car。组合：用于创建一个“有一个”关系的类结构，例如 ElectricCar 有一个 Battery。

组合通常比继承更灵活，因为你可以在不改变类继承层次的情况下，动态地更改组合类的行为。

12. 总结3

在本次学习中，你已经掌握了以下关键概念：

方法重写：通过在子类中定义与父类同名的方法，你可以重写父类的方法，从而定制子类的行为。重写方法时，子类的方法会覆盖父类的同名方法，这是实现多态性的重要方式。多继承：Python 支持一个类同时继承多个父类的属性和方法。多继承虽然强大，但使用时需要注意方法解析顺序（MRO）和潜在的复杂性。通过多继承，你可以复用多个类的功能，从而创建功能更加丰富的子类。类的组合：通过在一个类中包含其他类的实例，你可以创建复杂的对象结构。这种方法比多继承更加灵活且易于维护，因为它不涉及复杂的继承关系。组合强调对象之间的协作，而不是继承层次中的耦合。

13.方法解析顺序（MRO）

在多继承中，方法解析顺序（MRO）是 Python 用来确定类层次结构中的方法调用顺序的机制。理解 MRO 对于有效使用多继承和调试复杂的类层次结构非常重要。

13.1 MRO 的基本概念

MRO 决定了当你调用一个方法时，Python 如何查找该方法的定义。MRO 是通过一种称为 C3 线性化的算法来计算的，该算法确保了类层次结构中的一致性和方法解析的确定性。

13.2 查看 MRO

你可以使用类的 mro() 方法或 __mro__ 属性来查看一个类的 MRO。

例如：

class A:

pass

class B(A):

pass

class C(A):

pass

class D(B, C):

pass

print(D.mro())

输出将显示 D 类的 MRO：

[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

13.3 复杂继承结构中的 MRO

当类层次结构变得复杂时，MRO 可以帮助你理解方法调用的顺序。例如，如果 D 类继承了 B 和 C，而 B 和 C 又都继承自 A，MRO 可以告诉你调用 D 的方法时，Python 是如何在 B、C 和 A 之间选择方法的。

通过了解 MRO，你可以避免潜在的方法冲突，并确保你的代码在多继承情况下能够按照预期工作。

14. 抽象类和接口

在面向对象编程中，抽象类和接口用于定义类的框架和通用行为，确保子类实现这些行为。

14.1 什么是抽象类？

抽象类是一种不能被实例化的类，它通常用于定义子类必须实现的方法。抽象类提供了一个模板，让你可以确保所有子类都具有某些共同的行为。

14.2 Python 中的抽象类

在 Python 中，你可以使用 abc 模块中的 ABC 和 abstractmethod 来定义抽象类和抽象方法。

例如：

from abc import ABC, abstractmethod

class Animal(ABC):

@abstractmethod

def sound(self):

pass

class Dog(Animal):

def sound(self):

return "Woof!"

class Cat(Animal):

def sound(self):

return "Meow!"

在这个例子中，Animal 是一个抽象类，它定义了一个抽象方法 sound。任何继承 Animal 的子类都必须实现 sound 方法，否则会引发错误。

14.3 抽象类的用途

统一接口：抽象类强制子类实现某些方法，从而确保所有子类有统一的接口。代码复用：抽象类可以包含具体的方法实现，这些方法可以被子类继承和复用。增强代码的可维护性：通过抽象类，你可以更容易地理解和维护子类之间的关系和行为。

以上就是关于【Python篇】Python 类和对象：详细讲解（中篇）的内容啦，各位大佬有什么问题欢迎在评论区指正，您的支持是我创作的最大动力！❤️