面向对象

面向对象

Yiuhang Chan
  2018-09-08 12:13:23 2018-09-08 12:13:23 创建   2024-02-28 18:49:07 2024-02-28 18:49:07 更新      7.2k 字  27 分钟  

核心概念

面向对象编程（Object-Oriented Programming, OOP）是一种编程范式，它使用“对象”来设计软件。这种方法不仅侧重于数据（即属性），还侧重于操作这些数据的代码（即方法）。面向对象编程基于几个核心概念，包括类、对象、继承、多态和封装。

  1. 类（Class）：类是创建对象的蓝图或模板。它定义了对象的属性和方法。属性是类中的变量，方法是类中的函数。类本身不占用内存空间，它只是定义了对象的结构。
  2. 对象（Object）：对象是类的实例。当类被实例化时，会创建一个对象。对象具有类定义的属性和方法。每个对象都有自己的属性值，但共享相同的方法。
  3. 继承（Inheritance）：继承允许一个类继承另一个类的属性和方法。这有助于代码重用，并实现多层次的分类。在继承关系中，有基类（父类）和派生类（子类）。
  4. 多态（Polymorphism）：多态是指即使不同类的对象可能有不同的实现，但它们可以通过相同的接口进行交互。这意味着，可以用统一的方式来处理不同类的对象，即使它们具有不同的内部结构。
  5. 封装（Encapsulation）：封装是隐藏对象内部实现细节的过程，仅公开必要的接口。这有助于防止外部代码随意更改对象内部状态，从而保护对象的完整性并简化接口。
  6. 抽象（Abstraction）：抽象是将复杂的现实世界问题简化为模型的过程。在面向对象编程中，这通常意味着创建类，这些类代表了现实世界中的实体或概念，但只包括与当前问题相关的部分。

优点

  • 模块化：OOP 促进了代码的模块化，使得不同模块可以独立开发和测试，提高了代码的可维护性和复用性。
  • 可扩展性：通过继承和多态，可以在现有代码的基础上添加新功能，而不必大幅修改现有代码。
  • 可维护性：封装提供了一种方式，使得代码更易于理解和维护。

缺点

  • 性能：相较于面向过程的编程，面向对象的程序可能在性能上稍微逊色，因为它需要额外的内存和处理。
  • 复杂性：面向对象的系统可能比简单的面向过程的系统更复杂。

应用

面向对象编程在软件工程中广泛应用，从桌面和移动应用程序到大型企业级系统。众多流行的编程语言，如 Java、C#、Python、Ruby 和 C++，都支持面向对象的编程范式。

类 (Class)

类（Class）是面向对象编程（OOP）中的一个核心概念。在很多现代编程语言中，类作为一种构造，提供了一种封装数据和行为（即代码）的方式。它们允许开发者创建复杂的数据结构

类的定义

首先，我们定义一个名为Car的类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Car:
    # 这些是成员属性
    brand = None
    color = None
    speed = 0

    # 这是一个成员方法
    def start(self):
        print(f"{self.brand}车启动了。")

    def accelerate(self, increase):
        self.speed += increase
        print(f"{self.brand}车加速到了{self.speed}公里/小时。")

    def brake(self):
        print(f"{self.brand}车正在刹车。")
        self.speed = 0

在这个Car类中：

  • 成员属性：brand（品牌）、color（颜色）和speed（速度）是类的属性。它们用来描述这个类的状态。
  • 成员方法：start、accelerate 和 brake 是类的方法。它们描述了Car可以执行的操作。

实例化类

接下来，我们创建几个Car类的实例：

1
2
3
4
5
6
7
8
9
10
11
first_car = Car()  # 实例化第一辆车
first_car.brand = 'Toyota'
first_car.color = '红色'
first_car.start()
first_car.accelerate(30)

second_car = Car() # 实例化第二辆车
second_car.brand = 'Ford'
second_car.color = '蓝色'
second_car.start()
second_car.accelerate(40)

每次调用Car()时，我们都创建了一个新的Car类的实例（即一个新的汽车对象）。通过为不同的实例分别设置属性（如brand和color），每辆车都有自己的特点。

QA

问：

通过类名()可以实例化一个对象吗？

答：

在Python中，你可以通过调用类名并传递所需的参数（如果有的话）来创建（实例化）一个类的实例。例如，如果有一个名为 MyClass 的类，可以通过 my_instance = MyClass() 来创建这个类的一个实例。

问：

类具有属性和方法吗？

答：

在Python中，类可以拥有属性（有时称为数据成员）和方法（类内定义的函数）。属性用于保存数据值，而方法用于定义对象可以执行的操作。

问：

一个类只能创建一个对象吗？

答：

这个说法是错误的。一个类可以用来创建任意数量的对象。每个对象都是类的实例，拥有自己的属性集和方法。例如，如果有一个 Dog 类，可以用它来创建许多 Dog 实例，每个实例代表一个不同的狗。

问：

对象是一个实体吗？

答：

在编程中，对象通常指的是一个具体的实例，它由类创建。对象是类定义的实体的具体表现。它拥有类中定义的属性和方法。

成员方法中的self

在Car类的成员方法中，self关键字是对当前对象实例的引用。它用于访问对象的属性和调用其他方法。例如，在accelerate方法中，self.speed += increase表示将当前车辆的速度增加increase单位。

_ _init_ _初始化方法(魔术方法/构造器)

__init__ 是一个在 Python 中特别重要的方法，它是类的一个特殊方法（有时被称为“魔术方法”或“构造器”）。当创建类的新实例时，__init__ 方法被自动调用，用于为新创建的对象初始化其属性或执行其他必要的设置。以下是关于 __init__ 方法的一些关键点：

  1. 构造器：__init__ 方法可以看作是类的“构造器”。它在对象创建时立即执行，允许类接受参数并据此初始化对象的属性。
  2. self 参数：__init__ 方法的第一个参数总是 self，它是对类实例本身的引用。通过 self，可以在方法内部访问类的属性和其他方法。
  3. 初始化属性：可以在 __init__ 方法中定义并初始化对象的属性。这样做的好处是，可以为不同的对象实例设置不同的初始状态。
  4. 接受参数：__init__ 方法可以接受参数（除了自身 self 参数外），这些参数在创建类实例时传递给它，用于设置对象的属性或进行其他操作。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Car:
    # 使用 __init__ 方法初始化成员属性
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color
        self.speed = 0

    # 成员方法
    def start(self):
        print(f"{self.brand}车启动了。")

    def accelerate(self, increase):
        self.speed += increase
        print(f"{self.brand}车加速到了{self.speed}公里/小时。")

    def brake(self):
        print(f"{self.brand}车正在刹车。")
        self.speed = 0

# 使用 __init__ 方法实例化第一辆车
first_car = Car('Toyota', '红色')
first_car.start()
first_car.accelerate(30)

# 使用 __init__ 方法实例化第二辆车
second_car = Car('Ford', '蓝色')
second_car.start()
second_car.accelerate(40)

在这个例子中， Car 类中添加了 __init__ 方法，它接受 brand 和 color 作为参数，并将它们分别赋值给实例的 brand 和 color 属性。现在，在创建 Car 类的实例时，我们需要提供品牌和颜色作为参数。这样一来，每个 Car 实例在创建时都会有自己的品牌和颜色属性。

QA

问：为什么accelerate不在car(brand, color)里直接写？

答：将 accelerate 方法放在 Car 类的构造方法 (__init__) 中与放在类的外部作为一个独立的方法有不同的含义和用途。理解这一点，需要对面向对象编程中的一些基本概念有所了解：

  1. 构造方法 (__init__): __init__ 方法用于初始化新创建的对象的状态。它通常用于设置对象的初始属性值。构造方法在对象被创建时自动调用一次，用于设置对象的初始状态。
  2. 成员方法: 类中定义的其他方法（如 accelerate）用于描述对象的行为。这些方法可以在对象的整个生命周期内被多次调用，并且通常用于执行特定的操作，比如修改对象的状态或者与其他对象进行交互。
  3. 职责分离: 在面向对象设计中，通常推荐遵循单一职责原则。这意味着每个部分（如方法）应该只负责一项功能。将 accelerate 方法放在类的外部作为一个独立的方法，而不是在 __init__ 中定义，可以使类的结构更加清晰，每个方法的职责更加明确。
  4. 灵活性与可重用性: 将 accelerate 作为独立的方法可以在任何时候调用以改变对象的速度属性。如果它被放在 __init__ 中，它只能在对象创建时执行，这限制了方法的用途。

总结来说，accelerate 不放在 __init__ 中是为了保持代码的清晰性和组织性，确保每个方法只负责一项特定的功能，并允许在对象的生命周期中多次调用 accelerate 方法。这是一种更灵活、可维护和符合面向对象设计原则的做法。

问：self.speed = 0 为什么在(__init__) 里？

答：将 self.speed = 0 放在 __init__ 方法中是为了初始化 Car 类的每个实例的速度属性。这是一种常见的做法，用于设定对象的初始状态。以下是放置这个语句在 __init__ 中的几个理由：

  1. 初始状态设定：在面向对象编程中，构造方法（如 Python 中的 __init__）用于设定对象的初始状态。对于汽车来说，初始速度设为 0 是合理的，因为当汽车被“创建”（或实例化）时，它通常是静止的。
  2. 统一属性管理：将所有属性的初始化集中在 __init__ 方法中可以使代码更加清晰和易于维护。这样，可以在一个地方看到对象所有属性的初始值。
  3. 确保属性存在：在 __init__ 方法中初始化 speed 确保了每个 Car 实例都具有 speed 属性，并且有一个明确的初始值。这避免了在其他方法（如 accelerate 或 brake）中使用 speed 属性之前需要检查其是否存在的情况。
  4. 避免未初始化的属性：如果不在 __init__ 中初始化 speed，那么在调用 accelerate 方法之前，尝试访问 speed 属性可能会导致错误，因为 Python 不会自动创建这个属性。

综上所述，将 self.speed = 0 放在 __init__ 方法中是为了初始化对象的速度属性，保证对象的完整性，并为后续的操作（如加速或刹车）提供一个明确和稳定的起点。

案例

类定义与初始化

首先，我们定义一个名为Car的类，并在其中使用__init__方法来初始化类的实例。__init__是一个特殊的方法，它在类的实例化时自动调用。我们可以通过它来设置初始的成员属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Car:
    # 使用 __init__ 方法初始化成员属性
    def __init__(self, brand, color, weight):
        # self.brand 创建了一个名为 brand 的属性
        # brand = None 的效果类似于此
        # self.brand = brand 用传入的参数 brand 初始化
        self.brand = brand
        # 同理，为 color 和 weight 属性赋值
        self.color = color
        self.weight = weight

    # 定义一个成员方法用于显示汽车的信息
    def display_info(self):
        print(f"这辆车是 {self.color}色的 {self.brand}，重 {self.weight}公斤。")
实例化类

当我们实例化这个类时，我们需要提供品牌、颜色和重量这三个参数。

1
2
3
4
# 实例化 Car 类
first_car = Car("Toyota", "红色", 1500)
# 调用方法显示信息
first_car.display_info()

这里，first_car 是 Car 类的一个实例，代表了一辆特定的汽车。我们给它赋予了“Toyota”品牌、“红色”颜色和1500公斤重量的属性，并通过display_info方法打印了这些信息。

总结

通过修改这个例子，我们可以看到如何在类中使用初始化方法（__init__）来设置对象的初始状态，并通过实例化这个类来创建具体的对象。每个对象都有自己的属性值，但它们共享相同的方法（如display_info）。

QA

问：以女娲造人为例子

  • 什么是类？
  • 什么是实例化类？
  • 什么是面向对象？

答：

什么是类？

在女娲造人的故事中，女娲的想法或设计可以被看作是一个“类”（Class）。这个类是一个抽象的概念，它定义了人类将拥有的特征（如眼睛、鼻子、嘴巴）和行为（如走路、说话）。类是面向对象编程中定义数据结构和行为的蓝图或模板。

什么是实例化类？

当女娲根据她的想法创造出一个具体的人时，这个过程就像是在面向对象编程中的“实例化”（Instantiation）。实例化类的过程就是根据类的定义创建一个具体的对象（在这个故事中就是一个具体的人）。每个人（对象）都有类定义的特征和行为，但每个人也有自己的个性（即对象的状态可以独立于其他对象）。

什么是面向对象？

面向对象编程（Object-Oriented Programming, OOP）是一种编程范式，它使用对象来模拟现实世界的实体。在女娲造人的故事中，整个造人过程（设计-创造-赋予行为）就类似于面向对象的过程。面向对象编程的核心是类和对象，以及它们之间的交互。

问：面向对象的好处是什么？我们以后开发代码需要怎么做？

答：

好处

  1. 封装：面向对象允许封装数据和方法，提高数据安全性。
  2. 继承：通过继承，新的类可以扩展现有类的功能。
  3. 多态：相同的接口可以用在不同的对象上，提高代码的灵活性和可重用性。
  4. 代码组织和可读性：OOP 提高了代码的组织性和可读性，使大型项目更易于管理。

开发时的做法

  • 使用类和对象来模拟现实世界的实体和概念。
  • 封装相关的属性和方法，确保数据安全性和减少外部干扰。
  • 通过继承和多态性来重用代码和提高代码的灵活性。
  • 关注对象之间的交互，而不仅仅是代码的执行流程。

问： self 在初始化__init__的作用是什么？ 在普通方法中的作用是什么？

答：

在 __init__ 方法中

  • self 在 __init__ 方法中代表新创建的对象本身。
  • 它用于初始化对象的属性。
  • 通过 self，可以将对象的属性与局部变量区分开来。

在普通方法中

  • self 在类的其他方法中也代表对象本身。
  • 它用于访问和修改对象的属性。
  • 同样，self 用于调用对象的其他方法。

简而言之，self 是类方法中的一个参数，它提供了对类实例本身的引用。这允许类的方法在操作对象时访问和修改对象的属性，以及调用其他方法。

问：请根据闹钟 来写一个类 并创造三个闹钟

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
from datetime import datetime
from playsound import playsound


# print(current_time) 测试格式
class Alarm:
    # 使用init方法初始化成员属性
    def __init__(self, time, music):
        self.time = time  # time 是字符串格式 'HH:MM:SS'
        self.music = music

    # 成员方法
    def sound(self):
        # 一些写音乐文件调用的逻辑
        playsound(self.music)  # 播放歌曲
        print(f"{self.music} has been played")

    def clock(self):
        # 调用当前当前时间
        current_time = datetime.now().strftime('%H:%M:%S')
        if self.time == current_time:
            Alarm.sound(self)
            print(f"{self.time}, time to wake up !")  # 起床
        else:
            print(f"Current time is {current_time}, wake up at {self.time}")  # 报时


# 实例化
first_alarm = Alarm('15:46:25', 'test1.mp3')
second_alarm = Alarm('22:06:50', 'test2.mp3')
third_alarm = Alarm('05:10:33', 'test3.mp3')

# 调用 clock 方法
first_alarm.clock()
second_alarm.clock()
third_alarm.clock()

面向对象的特点

封装 (Encapsulation)

封装是面向对象编程中的一个核心概念，它指的是将对象的数据（属性）和行为（方法）组合在一起，形成一个独立的单元。在封装过程中，可以对对象的成员进行访问限制。

  • 私有属性 (Private Attributes)

    属性名前加了两个下划线表示它是私有属性，只能在类的内部被访问。

    作用: 不能被外部直接访问

    • self.__资金 = 0 私有属性，代表车辆的资金

  • 私有方法 (Private Methods)

    方法名前加了两个下划线表示它是私有方法，只能在类的内部被调用。

    作用: 不能被外部直接访问

    1
    2
    def __start_engine(self):
        print('引擎启动，准备行驶')

以汽车为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Car:
    # 初始化
    def __init__(self, brand, engine, seats):
        # 公有属性
        self.brand = brand
        self.engine = engine
        self.seats = seats
        # 私有属性
        self.__资金 = 0

    # 公有方法
    def drive(self):
        print(f'{self.brand} 正在行驶')
        # 在公有方法中使用私有方法
        self.__start_engine()

    # 私有方法
    def __start_engine(self):
        print('引擎启动，准备行驶')

# 实例化类
my_car = Car('宝马', 'V6', 5)
my_car.drive()

在类中，成员属性和成员方法可以通过在名称前加上两个下划线 __ 来设为私有。这样做的好处是能够保证这些成员不会被外界直接访问，但它们仍然可以在类的内部通过 self 被访问。这种方式有助于隐藏数据和实现细节，提高了代码的安全性和健壮性。

QA

问：为什么class AdvancedCar(Car)不用super()

答：AdvancedCar 类继承自 Car 类。在这个特定的情况下，super() 没有被使用，原因如下：

  1. 不需要覆盖父类的方法： 在 AdvancedCar 类中，我们添加了新的方法（autopilot 和 advanced_navigation），而没有修改或覆盖任何继承自 Car 类的方法。因此，没有必要使用 super() 来调用父类 Car 的任何方法。
  2. 构造函数未被重写： 如果子类不重写父类的构造函数（__init__ 方法），则默认调用父类的构造函数。在例子中，AdvancedCar 没有定义自己的 __init__ 方法，因此它会自动使用父类 Car 的构造函数来初始化对象。如果在子类中重写了构造函数并且想要执行父类的构造函数，那么在子类的构造函数中使用 super().__init__() 是必要的。
  3. 独立的新方法： AdvancedCar 类中新增的方法（autopilot 和 advanced_navigation）是独立的，它们不依赖于 Car 类中定义的任何方法，因此没有必要使用 super()。

总结一下，super() 主要用于需要调用或扩展父类中定义的方法时。如果只是在子类中添加新的独立方法或属性，并且没有重写父类的构造函数，就不需要使用 super()。在例子中，由于这些条件都未满足，因此不使用 super() 是合理的。

继承 (Inheritance)

在面向对象编程中，继承允许我们从一个已存在的类（称为父类）派生出一个新的类（称为子类）。子类会继承父类的所有属性和方法，并可以添加新的属性和方法或重写某些方法。

以汽车为例，我们可以从一个基本的汽车类派生出一个具有更多功能的特殊汽车类。

首先是父类，表示基本的汽车：

1
2
3
4
5
6
7
8
9
10
11
class Car:
    def __init__(self, brand, engine, seats):
        self.brand = brand
        self.engine = engine
        self.seats = seats

    def start_engine(self):
        print(f'{self.brand} 的引擎启动了')

    def drive(self):
        print(f'{self.brand} 正在行驶')

然后是子类，这里我们假设有一个增强版的汽车，它除了有基本的汽车功能外，还增加了自动驾驶和先进的导航系统：

1
2
3
4
5
6
7
8
9
10
11
12
13
class AdvancedCar(Car):  # 继承自 Car 类
    def autopilot(self):
        print(f'{self.brand} 的自动驾驶系统已启动')

    def advanced_navigation(self):
        print(f'{self.brand} 正在使用先进的导航系统')

# 实例化一个增强版的汽车
my_advanced_car = AdvancedCar('特斯拉', '电动', 5)
my_advanced_car.start_engine()  # 继承自 Car 类的方法
my_advanced_car.drive()         # 继承自 Car 类的方法
my_advanced_car.autopilot()     # AdvancedCar 类的新增方法
my_advanced_car.advanced_navigation()  # AdvancedCar 类的新增方法

在这个例子中，AdvancedCar 类继承了 Car 类的所有属性和方法（如 start_engine 和 drive），并新增了 autopilot 和 advanced_navigation 方法。这表明 AdvancedCar 不仅保留了基本汽车的特性，还加入了新的功能，充分展示了继承的实用性和灵活性。

多态 (Polymorphism)

多态是面向对象编程中的一个重要概念，它允许不同类的对象对同一消息做出响应。即不同的对象可以通过相同的接口（方法或函数）执行不同的操作。这增加了程序的灵活性和可扩展性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Dog:
    def speak(self):
        return "汪汪！"

class Cat:
    def speak(self):
        return "喵喵！"

# 定义一个函数，接受不同的动物对象
def animal_sound(animal):
    # 无论传入的是什么动物，调用相同的speak方法
    print(animal.speak())

# 实例化Dog和Cat
dog = Dog()
cat = Cat()

# 调用animal_sound函数，展示多态
animal_sound(dog)  # 输出: 汪汪！
animal_sound(cat)  # 输出: 喵喵！

在这个例子中，Dog 和 Cat 类都实现了同一个方法 speak，但它们以不同的方式响应（狗叫声和猫叫声）。函数 animal_sound 接受任何有 speak 方法的对象作为参数，然后调用这个方法。这就是多态的核心：通过同一接口，不同的对象可以执行各自不同的操作。

总结来说，多态允许我们编写更通用和可重用的代码，因为我们可以设计函数或方法，它们可以与任何符合特定接口（即实现特定方法）的对象交互，而不关心对象的具体类型。这样可以提高代码的灵活性和可扩展性。

学生管理系统案例

这个学员管理系统示例演示了面向对象编程的几个关键概念，如类的定义、初始化、封装、私有属性和方法的使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
# 定义一个名为StudentManagementSystem的类
class StudentManagementSystem:
    # 类的构造函数，用于初始化对象的属性
    def __init__(self, name, gender, age):
        # 公有属性，可以被外部访问
        self.name = name
        self.gender = gender
        self.age = age
        # 私有属性，前面有两个下划线，仅在类内部可访问
        self.__balance = 1000  # 设置初始余额为1000

    # 私有方法，用于扣除费用，仅在类内部可调用
    def __deduct_fee(self, amount):
        # 检查余额是否足够
        if self.__balance >= amount:
            self.__balance -= amount
            print(f'扣除{amount}元成功。')
        else:
            print('余额不足，无法扣款。')

    # 公有方法，用于展示学员信息
    def show_info(self):
        # 打印学员信息，包括私有属性余额
        print(f"姓名: {self.name}, 性别: {self.gender}, 年龄: {self.age}, 余额: {self.__balance}")

    # 公有方法，用于购买课程
    def purchase_course(self):
        try:
            # 输入价格，并尝试转换为整数
            price = int(input('请输入购买的价格:'))
            # 调用私有方法扣款
            self.__deduct_fee(price)
        except ValueError:
            print("请输入有效的价格。")

    # 新增的公有方法，用于为学员账户充值
    def recharge(self, amount):
        # 增加学员余额
        self.__balance += amount
        print(f'已成功充值{amount}元。')

    # 新增的公有方法，用于学员对课程进行评价
    def rate_course(self, course, rating):
        # 打印学员对课程的评分
        print(f'学员{self.name}给课程{course}的评分是: {rating}')

# 实例化一个StudentManagementSystem类的对象
user = StudentManagementSystem('用户', '男', '18')
user.purchase_course()  # 调用方法购买课程
user.purchase_course()  # 再次调用方法购买课程
user.show_info()        # 展示学员信息
user.recharge(500)      # 调用方法充值500元
user.rate_course("Python编程基础", 5)  # 对课程进行评分

为了在现有的 StudentManagementSystem 类中引入继承和多态的特点，我们可以创建一个基类来表示一般的用户，然后让 StudentManagementSystem 类成为这个基类的子类。此外，我们可以定义一个接口（一个具有共同方法但没有具体实现的基类），来展示多态。

首先是基类和接口的定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 基类 User，表示一般的用户
class User:
    def __init__(self, name, gender, age):
        self.name = name
        self.gender = gender
        self.age = age

    def show_info(self):
        print(f"姓名: {self.name}, 性别: {self.gender}, 年龄: {self.age}")

# 接口类 CourseConsumer，定义了一个没有具体实现的方法 purchase_course
class CourseConsumer:
    def purchase_course(self):
        raise NotImplementedError("Subclass must implement this method")

然后是修改后的 StudentManagementSystem 类，它继承自 User 并实现了 CourseConsumer 接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# StudentManagementSystem 类继承自 User 类并实现了 CourseConsumer 接口
class StudentManagementSystem(User, CourseConsumer):
    def __init__(self, name, gender, age):
        super().__init__(name, gender, age)  # 调用父类的构造函数
        self.__balance = 1000  # 私有属性

    def __deduct_fee(self, amount):
        if self.__balance >= amount:
            self.__balance -= amount
            print(f'扣除{amount}元成功。')
        else:
            print('余额不足，无法扣款。')

    # 重写父类的 show_info 方法
    def show_info(self):
        super().show_info()  # 调用父类方法
        print(f"余额: {self.__balance}")

    # 实现接口中定义的方法
    def purchase_course(self):
        try:
            price = int(input('请输入购买的价格:'))
            self.__deduct_fee(price)
        except ValueError:
            print("请输入有效的价格。")

    def recharge(self, amount):
        self.__balance += amount
        print(f'已成功充值{amount}元。')

    def rate_course(self, course, rating):
        print(f'学员{self.name}给课程{course}的评分是: {rating}')

在这个修改后的版本中，StudentManagementSystem 类继承了 User 类，并且实现了 CourseConsumer 接口的 purchase_course 方法。这样的设计不仅引入了继承，还通过实现接口展示了多态。继承允许 StudentManagementSystem 类重用 User 类的代码，而多态则体现在 StudentManagementSystem 类能够以不同方式实现 CourseConsumer 接口中定义的方法。这样的设计使得代码更加灵活和可扩展。

信息

在面向对象编程中，super() 函数的使用通常出现在继承体系中，尤其是在子类需要调用父类的方法或构造函数时。以下是一些使用 super() 的典型情况：

  1. 在子类的构造函数中调用父类的构造函数： 当创建一个子类时，可能需要在子类中初始化一些继承自父类的属性。使用 super() 调用父类的构造函数可以确保这些属性被适当地初始化。
1
2
3
4
5
6
7
8
class Parent:
    def __init__(self):
        print("Parent init")

class Child(Parent):
    def __init__(self):
        super().__init__()  # 调用父类的 __init__ 方法
        print("Child init")
  1. 在子类中覆盖父类的方法时调用父类的实现： 如果在子类中重写了父类的方法，并且还想保留父类方法的行为，可以在子类方法中使用 super() 调用父类的方法。
1
2
3
4
5
6
7
8
class Parent:
    def say_hello(self):
        print("Hello from Parent")

class Child(Parent):
    def say_hello(self):
        super().say_hello()  # 调用父类的 say_hello 方法
        print("Hello from Child")
  1. 多重继承中解决方法解析顺序（Method Resolution Order, MRO）问题： 在使用多重继承时，super() 被用来确保每个父类都被适当地初始化或调用相应的方法。它按照方法解析顺序遍历所有的基类。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Base:
    def __init__(self):
        print("Base init")

class A(Base):
    def __init__(self):
        super().__init__()
        print("A init")

class B(Base):
    def __init__(self):
        super().__init__()
        print("B init")

class Child(A, B):
    def __init__(self):
        super().__init__()
        print("Child init")

总之，super() 的使用有助于确保父类的适当初始化和方法调用，尤其是在有继承关系的类之间。这有助于减少代码重复，并确保继承体系中的逻辑一致性。

  • 标题: 面向对象
  • 作者: Yiuhang Chan
  • 创建于 : 2018-09-08 12:13:23
  • 更新于 : 2024-02-28 18:49:07
  • 链接: https://www.yiuhangblog.com/2018/09/08/20180908面向对象/
  • 版权声明: 本文章采用 CC BY-NC-SA 4.0 进行许可。
评论
此页目录
面向对象
  1. 核心概念
    1. 优点
    2. 缺点
    3. 应用
  2. 类 (Class)
    1. 类的定义
    2. 实例化类
    3. 成员方法中的self
    4. _ _init_ _初始化方法(魔术方法/构造器)
      1. 案例
        1. 类定义与初始化
        2. 实例化类
        3. 总结
  3. 面向对象的特点
    1. 封装 (Encapsulation)
    2. 继承 (Inheritance)
    3. 多态 (Polymorphism)
  4. 学生管理系统案例