Python 面向对象编程与异常处理指南

2.2.3 类方法与静态方法

2.2.3.1 类方法

类方法使用 @classmethod 装饰器，第一个参数为 cls（代表类本身）：

class Person:
    species = "人类"
    
    @classmethod
    def get_species(cls):
        return cls.species

print(Person.get_species())  # 输出：人类

2.2.3.2 静态方法

静态方法使用 @staticmethod 装饰器，无需传入类或实例参数：

class Person:
    @staticmethod
    def say_hello():
        print("你好！")

Person.say_hello()  # 输出：你好！

2.3 封装与访问控制

2.3.1 封装的实现

在 Python 中，通过以下方式实现封装：

• 公共属性/方法：默认情况下，所有属性和方法都是公共的，可以被外部访问。
• 私有属性/方法：在属性或方法名前添加两个下划线 __，使其成为私有属性/方法，外部无法直接访问。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.__age = age  # 私有属性
    
    def get_age(self):  # 公共方法，用于访问私有属性
        return self.__age
    
    def set_age(self, age):  # 公共方法，用于修改私有属性
        if age > 0 and age < 150:
            self.__age = age
        else:
            print("年龄输入无效")

person = Person("张三", 25)
print(person.name)       # 输出：张三
print(person.get_age())  # 输出：25
person.set_age(30)
print(person.get_age())  # 输出：30

2.4 继承与重写

2.4.1 继承的实现

在 Python 中，使用 class 子类名 (父类名) 语法实现继承：

class Animal:
    def __init__(self, name):
        self.name = name
    
    def make_sound(self):
        print("动物发出声音")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
    
    def make_sound(self):
        print("汪汪汪")

class Cat(Animal):
    def __init__(self, name, color):
        super().__init__(name)
        self.color = color
    
    def make_sound(self):
        print("喵喵喵")

dog = Dog("旺财", "金毛")
cat = Cat("咪咪", "白色")

print(dog.name)     # 输出：旺财
print(dog.breed)    # 输出：金毛
dog.make_sound()    # 输出：汪汪汪

print(cat.name)     # 输出：咪咪
print(cat.color)    # 输出：白色
cat.make_sound()    # 输出：喵喵喵

💡 super() 函数用于调用父类的方法。

2.4.2 方法重写

子类可以重写父类的方法，实现自己的行为：

class Animal:
    def make_sound(self):
        print("动物发出声音")

class Dog(Animal):
    def make_sound(self):
        print("汪汪汪")

2.5 多态

2.5.1 多态的实现

在 Python 中，多态通过子类重写父类的方法实现：

def make_animal_sound(animal):
    animal.make_sound()

dog = Dog("旺财", "金毛")
cat = Cat("咪咪", "白色")
make_animal_sound(dog)  # 输出：汪汪汪
make_animal_sound(cat)  # 输出：喵喵喵

2.6 异常处理

2.6.1 异常的概念

异常是程序运行过程中发生的错误，如语法错误、逻辑错误、资源不足等。当程序出现异常时，会终止执行并抛出异常信息。

2.6.2 异常类型

Python 支持多种异常类型，常见的包括：

• SyntaxError：语法错误。
• NameError：未定义变量。
• TypeError：类型错误。
• ValueError：值错误。
• IndexError：索引越界。
• KeyError：字典键不存在。
• FileNotFoundError：文件未找到。
• ZeroDivisionError：除数为 0。

2.6.3 异常处理方法

2.6.3.1 try-except 语句

使用 try-except 语句捕获并处理异常：

try:
    # 可能会抛出异常的代码
    num1 = int(input("请输入第一个数字："))
    num2 = int(input("请输入第二个数字："))
    result = num1 / num2
    print("结果：", result)
except ZeroDivisionError:
    print("除数不能为 0")
except ValueError:
    print("请输入有效的整数")
except Exception as e:
    print("发生了未知错误：", e)

2.6.3.2 try-except-else 语句

如果 try 块中的代码没有抛出异常，则执行 else 块：

try:
    num1 = int(input("请输入第一个数字："))
    num2 = int(input("请输入第二个数字："))
    result = num1 / num2
except ZeroDivisionError:
    print("除数不能为 0")
except ValueError:
    print("请输入有效的整数")
else:
    print("结果：", result)

2.6.3.3 try-except-finally 语句

无论 try 块中的代码是否抛出异常，都会执行 finally 块：

try:
    file = open("test.txt", "r")
    content = file.read()
    print(content)
except FileNotFoundError:
    print("文件未找到")
finally:
    if "file" in locals():
        file.close()

2.6.4 自定义异常

通过继承 Exception 类可以创建自定义异常：

class InvalidAgeException(Exception):
    def __init__(self, age):
        self.age = age
    
    def __str__(self):
        return f"无效的年龄：{self.age}"

def check_age(age):
    if age < 0 or age > 150:
        raise InvalidAgeException(age)

try:
    check_age(200)
except InvalidAgeException as e:
    print(e)  # 输出：无效的年龄：200

2.7 实战案例：学生管理系统

2.7.1 需求分析

设计一个学生管理系统，支持以下功能：

• 添加学生信息（姓名、年龄、学号）。
• 删除学生信息（学号）。
• 修改学生信息（学号）。
• 查询学生信息（学号）。
• 显示所有学生信息。

2.7.2 代码实现

class Student:
    def __init__(self, name, age, student_id):
        self.name = name
        self.age = age
        self.student_id = student_id
    
    def __str__(self):
        return f"姓名：{self.name}，年龄：{self.age}，学号：{self.student_id}"

class StudentManagementSystem:
    def __init__(self):
        self.students = []
    
    def add_student(self, name, age, student_id):
        # 检查学号是否已存在
        for student in self.students:
            if student.student_id == student_id:
                print("该学号已存在")
                return
        student = Student(name, age, student_id)
        self.students.append(student)
        print("学生信息添加成功")
    
    def delete_student(self, student_id):
        for student in self.students:
            if student.student_id == student_id:
                self.students.remove(student)
                print("学生信息删除成功")
                return
        print("未找到该学号的学生")
    
    def modify_student(self, student_id, name, age):
        for student in self.students:
            if student.student_id == student_id:
                student.name = name
                student.age = age
                print("学生信息修改成功")
                return
        print("未找到该学号的学生")
    
    def query_student(self, student_id):
        for student in self.students:
            if student.student_id == student_id:
                print(student)
                return
        print("未找到该学号的学生")
    
    def display_all_students(self):
        if not self.students:
            print("没有学生信息")
            return
        for student in self.students:
            print(student)

def main():
    sms = StudentManagementSystem()
    while True:
        print("\n学生管理系统")
        print("1. 添加学生信息")
        print("2. 删除学生信息")
        print("3. 修改学生信息")
        print("4. 查询学生信息")
        print("5. 显示所有学生信息")
        print("6. 退出系统")
        choice = input("请输入你的选择（1/2/3/4/5/6）：")
        if choice == "1":
            name = input("请输入姓名：")
            age = int(input("请输入年龄："))
            student_id = input("请输入学号：")
            sms.add_student(name, age, student_id)
        elif choice == "2":
            student_id = input("请输入学号：")
            sms.delete_student(student_id)
        elif choice == "3":
            student_id = input("请输入学号：")
            name = input("请输入新姓名：")
            age = int(input("请输入新年龄："))
            sms.modify_student(student_id, name, age)
        elif choice == "4":
            student_id = input("请输入学号：")
            sms.query_student(student_id)
        elif choice == "5":
            sms.display_all_students()
        elif choice == "6":
            print("感谢使用学生管理系统")
            break
        else:
            print("无效的选择")

if __name__ == "__main__":
    main()

2.7.3 实施过程

1. 定义 Student 类，用于存储学生的姓名、年龄和学号。
2. 定义 StudentManagementSystem 类，用于管理学生信息，实现添加、删除、修改、查询和显示所有学生信息的功能。
3. 定义 main() 函数，负责用户交互和系统调用。
4. 在 main() 函数中，通过循环显示菜单，获取用户输入，并调用相应的功能方法。

2.7.4 最终效果

运行程序后，用户可以根据菜单选择功能，输入相应的信息完成学生管理操作。程序会对无效输入和重复学号进行处理，并给出相应的提示。

2.8 常见问题与解决方案

2.8.1 类属性与实例属性混淆

问题：在类中定义的属性被所有实例共享，导致修改实例属性时影响其他实例。 解决方案：将属性定义在 __init__ 方法中，使其成为实例属性。

2.8.2 继承时初始化方法未调用父类

问题：子类继承父类时，未在 __init__ 方法中调用父类的 __init__ 方法，导致父类属性未初始化。 解决方案：使用 super().__init__() 调用父类的初始化方法。

2.8.3 异常捕获不完整

问题：只捕获了部分异常，导致程序在出现未捕获的异常时终止。 解决方案：使用 Exception 类捕获所有异常，并在 except 块中处理。

总结

✅ 本文详细介绍了面向对象编程的核心思想，包括类与对象的定义、继承、封装、多态等特性，以及异常处理机制。 ✅ 通过学生管理系统的实战案例，读者可以理解面向对象编程在实际开发中的应用。 ✅ 建议读者在学习过程中多练习，通过编写代码加深对知识点的理解。