学习计划：第一阶段（第二周）

标签：班级 对象 self 学生 学习 第二周 student 属性 第一阶段

目录

第一阶段第二周

内容细化

第一天 - 第二天：丰富学生类的属性和方法

属性扩展：

方法添加：

第三天 - 第四天：对象间的交互与关联（以班级和学生为例）

创建班级类：

建立关联：

第五天：代码整合与优化

整合代码：

代码优化：

第一天：丰富学生类的属性和方法

第二天：丰富学生类的属性和方法

第三天：对象间的交互与关联（以班级和学生为例）

第四天：对象间的交互与关联（以班级和学生为例）

第五天：代码整合与优化

类的知识延申

一、类的属性扩展

二、类的方法添加

三、类的交互与关联

注意事项

属性扩展

属性的合理性与必要性

符合业务逻辑：

避免冗余属性：

属性的数据类型选择

合适的数据类型匹配属性意义：

考虑数据类型的兼容性和可扩展性：

属性的初始化和默认值设置

正确初始化属性：

合理设置默认值：

属性的可见性和访问控制（适用于支持访问控制的编程语言）

合理控制访问权限：

遵循访问控制规则：

对现有代码的影响和兼容性

检查方法对新属性的适应性：

考虑继承关系和多态性：

方法添加

方法的功能单一性和内聚性

功能单一：

内聚性：

参数传递和合法性检查

参数的必要性和合理性：

参数合法性检查：

方法的返回值设计

明确返回值类型和意义：

返回值的一致性和准确性：

方法与对象状态的一致性维护

对对象属性的合理修改：

方法之间的协作和对象状态的整体维护：

方法的可见性和访问控制（适用于支持访问控制的编程语言）

合理设置访问权限：

遵循访问控制原则：

交互与关联

关系的语义明确性

清晰定义关联关系：

避免模糊或错误的关联解释：

关联的强度和生命周期管理

区分不同关联强度：

正确处理对象的生命周期关联：

交互的接口设计和协议遵守

设计良好的交互接口：

遵守交互协议：

数据一致性和并发访问问题（在多线程或分布式环境下）

确保数据一致性：

处理并发访问冲突：

循环依赖问题

识别和避免循环依赖：

解耦循环依赖（如果存在）：

第一阶段第二周

内容细化

第一天 - 第二天：丰富学生类的属性和方法

• 属性扩展：

  • 给 “学生” 类添加 “成绩列表” 属性，用于存储学生多门课程的成绩。可以使用列表数据类型来实现，例如self.scores = []。
  • 增加 “班级” 属性，用于表示学生所属的班级信息，数据类型可以是字符串。

• 方法添加：

  • 定义 “添加成绩” 方法add_score(self, score)，该方法接受一个成绩参数score，并将其添加到成绩列表self.scores中。
  • 创建 “计算总分” 方法calculate_total_score(self)，在方法内部遍历成绩列表，计算所有成绩的总和并返回。
  • 编写 “显示所有信息” 方法display_all_info(self)，该方法不仅输出学生的姓名、年龄、学号，还会打印出成绩列表和班级信息。

第三天 - 第四天：对象间的交互与关联（以班级和学生为例）

• 创建班级类：

  • 定义 “班级” 类，具有 “班级名称” 属性和 “学生列表” 属性，用于存储班级中的所有学生对象。例如：

class Class:
    def __init__(self, class_name):
        self.class_name = class_name
        self.student_list = []

• 在班级类中添加 “添加学生” 方法add_student(self, student)，该方法接受一个学生对象作为参数，并将其添加到学生列表self.student_list中。
• 设计 “显示班级学生信息” 方法display_student_info(self)，遍历学生列表，调用每个学生对象的 “显示所有信息” 方法，展示班级中所有学生的详细信息。

• 建立关联：

  • 在学生类的构造函数中，添加一个参数用于接收所属班级对象，并将其赋值给学生对象的 “班级” 属性。例如：

class Student:
    def __init__(self, name, age, student_id, class_obj):
        self.name = name
        self.age = age
        self.student_id = student_id
        self.class_obj = class_obj
        self.scores = []

• 通过这种方式，建立起学生对象与班级对象之间的关联，体现对象之间的关系在面向对象编程中的应用。

第五天：代码整合与优化

• 整合代码：

  • 在主程序中，先创建班级对象，如class1 = Class("Class 1")。
  • 然后创建多个学生对象，并在创建学生对象时将班级对象作为参数传入，例如student1 = Student("Alice", 20, "1001", class1)。
  • 将学生对象添加到班级对象中，class1.add_student(student1)。
  • 最后调用班级对象的 “显示班级学生信息” 方法，展示整个班级的学生信息情况。

• 代码优化：

  • 对学生类和班级类中的方法进行错误处理优化。例如，在添加成绩时，检查传入的成绩是否为合法的数值；在添加学生到班级时，确保传入的是有效的学生对象等。
  • 考虑代码的可扩展性，思考如果后续需要添加更多的学生属性或班级功能，如何能够方便地进行扩展而不影响现有代码结构。

第一天：丰富学生类的属性和方法

上午：

• 回顾第一周学习的关于类、对象、属性和方法的基本概念，重点复习类的构造函数（__init__方法）的作用和使用方式。
• 确定要给 “学生” 类添加的新属性：“成绩列表” 和 “班级”。思考如何在类的构造函数中初始化这些新属性，“成绩列表” 初始化为空列表，“班级” 属性在创建学生对象时通过参数传入并赋值。

以下是修改后的学生类代码框架：

class Student:
    def __init__(self, name, age, student_id, class_obj):
        self.name = name
        self.age = age
        self.student_id = student_id
        self.class_obj = class_obj
        self.scores = []  # 成绩列表，初始化为空列表

下午：

• 编写 “添加成绩” 方法add_score。首先确定方法的参数为要添加的成绩score，在方法内部，使用isinstance函数判断传入的score是否为合法的数值类型（int或float），如果是，则将其添加到 “成绩列表” 属性中；如果不是，则打印错误提示信息 “无效的成绩输入。”

代码如下：

def add_score(self, score):
    # 检查成绩是否为合法数值
    if isinstance(score, (int, float)):
        self.scores.append(score)
    else:
        print("无效的成绩输入。")

• 开始编写 “计算总分” 方法calculate_total_score。在这个方法中，初始化一个变量total为 0，然后使用for循环遍历 “成绩列表” 中的每个成绩，将其累加到total变量中，最后返回total作为总分。

代码如下：

def calculate_total_score(self):
    total = 0
    for score in self.scores:
        total += score
    return total

晚上：

• 对当天编写的代码进行简单测试。创建一个学生对象，尝试调用add_score方法添加一些合法和非法的成绩，观察是否正确执行。然后调用calculate_total_score方法，查看计算出的总分是否正确，对出现的问题及时进行调试和修正。

测试代码如下：

# 创建一个班级对象，用于传入学生类构造函数
class1 = Class("Class 1")
student1 = Student("Alice", 20, "1001", class1)
student1.add_score(90)
student1.add_score("invalid")  # 故意传入非法成绩
print(student1.calculate_total_score())

第二天：丰富学生类的属性和方法

上午：

• 继续完善 “计算总分” 方法calculate_total_score，考虑可能出现的特殊情况，如成绩列表为空时的处理，可以返回 0 或者抛出一个自定义的异常，这里暂时返回 0，并添加相应的注释说明处理逻辑。

修改后的代码如下：

def calculate_total_score(self):
    total = 0
    if self.scores:  # 如果成绩列表不为空
        for score in self.scores:
            total += score
    return total

• 着手编写 “显示所有信息” 方法display_all_info。在这个方法中，依次打印出学生的姓名、年龄、学号、班级以及成绩列表信息。对于成绩列表，可以使用str函数将其转换为字符串格式以便打印输出。

代码如下：

def display_all_info(self):
    print(f"姓名: {self.name}")
    print(f"年龄: {self.age}")
    print(f"学号: {self.student_id}")
    print(f"班级: {self.class_obj.class_name}")
    print(f"成绩列表: {str(self.scores)}")

下午：

• 对 “显示所有信息” 方法display_all_info进行优化。可以考虑使用格式化字符串的方式使输出信息更加整齐美观，例如设置固定的字段宽度和对齐方式。同时，检查打印信息的准确性和完整性，确保所有属性信息都能正确显示。

优化后的代码如下：

def display_all_info(self):
    print(f"姓名: {self.name:<10}年龄: {self.age:<5}学号: {self.student_id:<8}班级: {self.class_obj.class_name:<10}成绩列表: {str(self.scores)}")

• 整体回顾和整理学生类的代码结构，检查各个方法之间的参数传递和属性访问是否正确，对代码进行适当的重构和优化，提高代码的可读性，比如将一些重复的代码块提取成独立的函数或者调整代码的缩进和空行，使代码布局更加清晰。

晚上：

• 再次进行测试，创建多个具有不同属性值的学生对象，调用add_score方法添加不同的成绩，然后分别调用calculate_total_score方法和display_all_info方法，验证总分计算的正确性和信息显示的完整性与美观性。记录测试过程中发现的问题，如显示格式不理想、总分计算错误等，并进行针对性的修改。

测试代码如下：

# 创建班级对象
class1 = Class("Class 1")
# 创建学生对象并测试
student1 = Student("Alice", 20, "1001", class1)
student1.add_score(90)
student1.add_score(85)
student1.calculate_total_score()
student1.display_all_info()

student2 = Student("Bob", 21, "1002", class1)
student2.add_score(78)
student2.add_score(88)
student2.calculate_total_score()
student2.display_all_info()

第三天：对象间的交互与关联（以班级和学生为例）

上午：

• 开始设计 “班级” 类。确定 “班级” 类的属性，包括 “班级名称” 和 “学生列表”，在类的构造函数中初始化这两个属性，“班级名称” 通过参数传入并赋值，“学生列表” 初始化为空列表。

代码如下：

class Class:
    def __init__(self, class_name):
        self.class_name = class_name
        self.student_list = []

• 编写 “班级” 类的 “添加学生” 方法add_student。该方法接受一个学生对象作为参数，首先使用isinstance函数判断传入的是否为学生对象，如果是，则将其添加到 “学生列表” 属性中；如果不是，则打印错误提示信息 “无效的学生对象。”

代码如下：

def add_student(self, student):
    # 检查传入的是否为学生对象
    if isinstance(student, Student):
        self.student_list.append(student)
    else:
        print("无效的学生对象。")

下午：

• 设计 “班级” 类的 “显示班级学生信息” 方法display_student_info。在这个方法中，先打印出班级的名称，然后使用for循环遍历 “学生列表” 中的每个学生对象，调用每个学生对象的 “显示所有信息” 方法，从而展示班级中所有学生的详细信息。

代码如下：

def display_student_info(self):
    print(f"班级名称: {self.class_name}")
    for student in self.student_list:
        student.display_all_info()

• 思考如何在学生类和班级类之间建立关联。确定在学生类的构造函数中添加一个参数用于接收所属班级对象，并将其赋值给学生对象的 “班级” 属性，这样就可以在学生对象中访问到所属班级的信息，实现对象间的关联。

晚上：

• 进行初步的集成测试。创建一个班级对象和几个学生对象，将学生对象添加到班级对象中，然后调用班级对象的 “显示班级学生信息” 方法，检查是否能够正确显示班级名称以及每个学生的详细信息。如果出现问题，检查班级类和学生类之间的关联建立是否正确，以及方法的调用逻辑是否有误，对发现的问题进行调试和修复。

测试代码如下：

# 创建班级对象
class1 = Class("Class 1")
# 创建学生对象
student1 = Student("Alice", 20, "1001", class1)
student2 = Student("Bob", 21, "1002", class1)
# 将学生添加到班级
class1.add_student(student1)
class1.add_student(student2)
# 显示班级学生信息
class1.display_student_info()

第四天：对象间的交互与关联（以班级和学生为例）

上午：

• 进一步优化班级类和学生类之间的关联代码。检查在学生对象创建时传入班级对象的过程是否稳定，以及在班级类中操作学生对象时是否能够正确地访问和修改学生对象的相关属性。例如，在班级类的 “添加学生” 方法中，除了将学生对象添加到列表中，还可以考虑一些额外的操作，如更新班级的学生数量统计信息（如果有需要的话）。

这里假设添加一个班级学生数量统计属性student_count，并在add_student方法中更新：

class Class:
    def __init__(self, class_name):
        self.class_name = class_name
        self.student_list = []
        self.student_count = 0  # 初始化学生数量为 0

    def add_student(self, student):
        # 检查传入的是否为学生对象
        if isinstance(student, Student):
            self.student_list.append(student)
            self.student_count += 1  # 添加学生时更新数量
        else:
            print("无效的学生对象。")

• 思考如何在班级类中提供更多与学生相关的操作方法，比如根据学生的学号查找学生对象、统计班级学生的平均成绩等。开始设计这些方法的框架，确定方法的参数和返回值类型。

以下是 “根据学号查找学生对象” 方法find_student_by_id的框架设计：

def find_student_by_id(self, student_id):
    for student in self.student_list:
        if student.student_id == student_id:
            return student
    return None

下午：

• 实现上午设计的部分方法，如 “根据学号查找学生对象” 方法find_student_by_id。该方法接受一个学号参数，在班级的 “学生列表” 中遍历查找匹配学号的学生对象，如果找到则返回该学生对象；如果未找到，则返回None或者抛出一个合适的异常。

代码如下：

def find_student_by_id(self, student_id):
    for student in self.student_list:
        if student.student_id == student_id:
            return student
    print(f"未找到学号为 {student_id} 的学生。")
    return None

• 对已实现的班级类新方法进行测试。创建班级对象并添加多个学生对象，调用 “根据学号查找学生对象” 方法，传入不同的学号进行测试，检查是否能够正确返回对应的学生对象或者处理未找到的情况，根据测试结果进行调试和优化。

测试代码如下：

# 创建班级对象并添加学生
class1 = Class("Class 1")
student1 = Student("Alice", 20, "1001", class1)
student2 = Student("Bob", 21, "1002", class1)
class1.add_student(student1)
class1.add_student(student2)

# 测试查找学生方法
found_student = class1.find_student_by_id("1001")
if found_student:
    found_student.display_all_info()

晚上：

• 回顾当天编写的代码，检查班级类和学生类之间的交互是否符合面向对象设计的原则，例如是否存在过度耦合或者不合理的依赖关系。对代码进行必要的调整和优化，确保代码的可维护性和扩展性。同时，整理代码文档，记录班级类和学生类的新功能、方法的参数和返回值以及代码的整体逻辑结构，方便后续的维护和开发。

第五天：代码整合与优化

上午：

• 在主程序中进行代码整合。首先创建班级对象，例如class1 = Class("Class 1")。然后创建多个学生对象，并在创建学生对象时将班级对象作为参数传入，如student1 = Student("Alice", 20, "1001", class1)。接着将学生对象添加到班级对象中，class1.add_student(student1)。

主程序代码如下：

# 创建班级对象
class1 = Class("Class 1")

# 创建学生对象并添加到班级
student1 = Student("Alice", 20, "1001", class1)
student1.add_score(90)
student1.add_score(85)
class1.add_student(student1)

student2 = Student("Bob", 21, "1002", class1)
student2.add_score(78)
student2.add_score(88)
class1.add_student(student2)

• 检查主程序中的代码逻辑是否正确，确保班级对象和学生对象的创建、关联以及操作都能按预期执行。可以在关键代码行添加一些打印语句，输出相关的变量值或者操作结果，以便在调试过程中更好地理解程序的执行流程。

下午：

• 对学生类和班级类中的方法进行全面的错误处理优化。除了之前在 “添加成绩” 和 “添加学生” 方法中已有的错误检查，进一步检查其他可能出现错误的地方。例如，在班级类的 “显示班级学生信息” 方法中，如果 “学生列表” 为空，添加相应的提示信息；在学生类的 “计算总分” 方法中，如果成绩列表中的成绩数据类型不合法，抛出一个更详细的异常信息，以便在调试时能更快地定位问题。

修改后的 “显示班级学生信息” 方法如下：

def display_student_info(self):
    print(f"班级名称: {self.class_name}")
    if self.student_list:
        for student in self.student_list:
            student.display_all_info()
    else:
        print("班级暂无学生信息。")

修改后的 “计算总分” 方法如下：

def calculate_total_score(self):
    total = 0
    if self.scores:  # 如果成绩列表不为空
        for score in self.scores:
            if isinstance(score, (int, float)):
                total += score
            else:
                raise ValueError("成绩列表中存在非法数据类型。")
    return total

• 考虑代码的可扩展性，思考如果后续需要添加更多的学生属性（如家庭住址、联系方式等）或班级功能（如班级课程表管理等），如何对现有代码结构进行调整和扩展。可以对代码进行一些简单的重构尝试，比如将一些与学生属性操作相关的代码封装成独立的模块或者类，以便在添加新属性时能够更方便地进行修改和扩展。

晚上：

• 进行最后的综合测试。模拟各种正常和异常的使用场景，对整个程序进行全面测试，包括创建不同数量和属性的学生对象、对学生成绩的各种操作、班级对象对学生的管理和信息显示等功能。检查程序在各种情况下的稳定性和正确性，对测试中发现的任何问题进行最后的修改和完善。整理代码文件，添加必要的注释和文档说明，使代码更易于他人理解和维护，同时也方便自己在后续学习或项目开发中回顾和使用。

完整的代码示例：

# 学生类
class Student:
    def __init__(self, name, age, student_id, class_obj):
        self.name = name
        self.age = age
        self.student_id = student_id
        self.class_obj = class_obj
        self.scores = []  # 成绩列表，初始化为空列表

    def add_score(self, score):
        # 检查成绩是否为合法数值
        if isinstance(score, (int, float)):
            self.scores.append(score)
        else:
            print("无效的成绩输入。")

    def calculate_total_score(self):
        total = 0
        if self.scores:  # 如果成绩列表不为空
            for score in self.scores:
                if isinstance(score, (int, float)):
                    total += score
                else:
                    raise ValueError("成绩列表中存在非法数据类型。")
        return total

    def display_all_info(self):
        print(f"姓名: {self.name:<10}年龄: {self.age:<5}学号: {self.student_id:<8}班级: {self.class_obj.class_name:<10}成绩列表: {str(self.scores)}")


# 班级类
class Class:
    def __init__(self, class_name):
        self.class_name = class_name
        self.student_list = []
        self.student_count = 0  # 初始化学生数量为 0

    def add_student(self, student):
        # 检查传入的是否为学生对象
        if isinstance(student, Student):
            self.student_list.append(student)
            self.student_count += 1  # 添加学生时更新数量
        else:
            print("无效的学生对象。")

    def find_student_by_id(self, student_id):
        for student in self.student_list:
            if student.student_id == student_id:
                return student
        print(f"未找到学号为 {student_id}

类的知识延申

一、类的属性扩展

概念：

类的属性扩展是指在已有的类定义基础上，添加新的属性来丰富类所描述对象的特征信息。这些新属性可以是各种数据类型，根据具体需求来确定，以便更全面地刻画对象的状态。

代码示例（以学生类为例）：

假设我们最初有一个简单的学生类，只包含基本信息如姓名和年龄：

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

现在我们要对其进行属性扩展，添加 “学号”“成绩列表” 和 “所属班级” 等属性：

class Student:
    def __init__(self, name, age, student_id, class_name):
        self.name = name
        self.age = age
        self.student_id = student_id
        self.scores = []  # 成绩列表，初始化为空列表
        self.class_name = class_name

在上述代码中，我们通过在__init__构造函数中添加新的参数，并将其赋值给相应的实例属性，实现了类的属性扩展。这样，创建出来的学生对象就可以携带更多关于学生的详细信息了。

二、类的方法添加

概念：

方法添加是为了赋予类的对象更多的行为能力，即让对象能够执行特定的操作。这些操作可以是对对象自身属性的处理、与其他对象的交互等，通过定义方法来实现具体的功能逻辑。

代码示例（继续以扩展后的学生类为例）：

我们为学生类添加一些方法，比如 “添加成绩” 方法、“计算平均成绩” 方法和 “显示学生信息” 方法：

class Student:
    def __init__(self, name, age, student_id, class_name):
        self.name = name
        self.age = age
        self.student_id = student_id
        self.scores = []
        self.class_name = class_name

    def add_score(self, score):
        """
        添加成绩到成绩列表的方法
        :param score: 要添加的成绩，应为数值类型
        """
        if isinstance(score, (int, float)):
            self.scores.append(score)
        else:
            print("无效的成绩输入，请输入数值类型的成绩。")

    def calculate_average_score(self):
        """
        计算平均成绩的方法
        :return: 平均成绩，如果成绩列表为空则返回0
        """
        if not self.scores:
            return 0
        total = sum(self.scores)
        average = total / len(self.scores)
        return average

    def display_student_info(self):
        """
        显示学生所有信息的方法
        """
        print(f"姓名: {self.name}")
        print(f"年龄: {self.age}")
        print(f"学号: {self.student_id}")
        print(f"所属班级: {self.class_name}")
        print(f"成绩列表: {self.scores}")

在上述代码中：

• add_score方法用于向学生的成绩列表中添加成绩，在添加前会检查输入的成绩是否为合法的数值类型。
• calculate_average_score方法通过计算成绩列表中所有成绩的总和并除以成绩数量，得到平均成绩，若成绩列表为空则返回 0。
• display_student_info方法将学生的所有属性信息以清晰的格式打印出来，方便查看学生的详细情况。

三、类的交互与关联

概念：

类之间的交互与关联描述了不同类的对象之间如何进行协作以及它们之间存在的关系。常见的关系包括关联、聚合、组合等。通过建立这些关系，可以构建出更复杂、更符合实际业务场景的对象模型。

代码示例（引入班级类与学生类建立关联）：

首先定义班级类：

class Class:
    def __init__(self, class_name):
        self.class_name = class_name
        self.student_list = []

    def add_student(self, student):
        """
        将学生添加到班级的学生列表中的方法
        :param student: 要添加的学生对象
        """
        if isinstance(student, Student):
            self.student_list.append(student)
        else:
            print("无效的学生对象，请确认传入的是Student类的对象。")

    def display_class_info(self):
        """
        显示班级所有信息的方法，包括班级名称和班级内所有学生的信息
        """
        print(f"班级名称: {self.class_name}")
        for student in self.student_list:
            student.display_student_info()

在上述班级类中：

• __init__方法初始化班级的名称属性和一个空的学生列表属性，用于存储该班级的所有学生对象。
• add_student方法用于将学生对象添加到班级的学生列表中，添加前会检查传入的对象是否为学生类的对象。
• display_class_info方法先打印出班级名称，然后遍历学生列表，调用每个学生对象的display_student_info方法，显示班级内所有学生的信息。

现在我们来建立学生类和班级类之间的关联。在学生类的构造函数中，我们可以添加一个参数用于接收所属班级对象，并将其赋值给学生对象的一个属性，以便学生对象能够知道自己所属的班级：

class Student:
    def __init__(self, name, age, student_id, class_obj):
        self.name = name
        self.age = age
        self.student_id = student_id
        self.scores = []
        self.class_obj = class_obj  # 关联班级对象

    # 其他方法（add_score、calculate_average_score、display_student_info）保持不变

在主程序中，我们可以创建班级对象和学生对象，并建立它们之间的关联：

# 创建班级对象
class1 = Class("一班")

# 创建学生对象并关联到班级
student1 = Student("张三", 18, "001", class1)
student1.add_score(85)
student1.add_score(90)

student2 = Student("李四", 19, "002", class1)
student2.add_score(78)
student2.add_score(82)

# 将学生添加到班级
class1.add_student(student1)
class1.add_student(student2)

# 显示班级信息
class1.display_class_info()

在上述主程序中：

• 首先创建了一个班级对象class1。
• 然后创建了两个学生对象student1和student2，并在创建时将class1作为参数传入，建立了学生对象与班级对象的关联。
• 接着分别为学生对象添加成绩。
• 之后将学生对象添加到班级对象的学生列表中。
• 最后通过调用班级对象的display_class_info方法，展示了班级的名称以及班级内所有学生的详细信息，体现了学生类和班级类之间通过关联实现的交互与协作。

通过以上对类的属性扩展、方法添加以及交互与关联的详细介绍和代码示例，希望能让你更深入地理解这些面向对象编程中的重要概念及其应用。

注意事项

属性扩展

属性的合理性与必要性

• 符合业务逻辑：

  • 添加的属性应该与类所代表的对象在业务场景中的实际特征相符合。例如，在 “学生” 类中，添加 “成绩”“学号”“班级” 等属性是合理的，因为这些属性能够准确地描述学生在学校环境中的相关信息。而添加一些与学生概念无关的属性，如 “商品价格”，就不符合业务逻辑。

• 避免冗余属性：

  • 要确保新添加的属性不是对已有属性的重复描述。例如，如果已经有了 “出生日期” 属性，就可能不需要再添加一个通过出生日期计算出来的 “年龄” 属性（除非有特殊的业务需求，如频繁使用年龄进行查询或比较，为了提高性能而单独存储），否则会导致数据冗余，增加存储成本和维护难度。

属性的数据类型选择

• 合适的数据类型匹配属性意义：

  • 根据属性所表示的概念选择合适的数据类型。例如，“学生学号” 属性通常可以选择字符串类型，因为学号可能包含字母和数字等多种字符组合；“学生年龄” 属性则适合用整数类型来表示。如果数据类型选择不当，可能会导致数据存储和操作上的问题。
  • 对于一些复杂的属性，可能需要选择更高级的数据结构。比如，“学生成绩” 属性如果要记录多门课程的成绩，使用列表或字典等数据结构会比单个变量更合适。使用列表可以方便地存储成绩序列，使用字典则可以将课程名称和成绩关联起来。

• 考虑数据类型的兼容性和可扩展性：

  • 在选择数据类型时，要考虑到与其他方法或属性的兼容性。例如，如果一个方法需要对属性进行数学运算，那么该属性的数据类型应该支持相应的运算。同时，要考虑未来可能的扩展需求。如果预计将来可能需要对属性进行更复杂的操作，如对学生成绩进行排序和统计分析，选择能够方便地支持这些操作的数据类型（如numpy数组或pandas数据框）会更好。

属性的初始化和默认值设置

• 正确初始化属性：

  • 在类的构造函数（如__init__方法）中，要正确地初始化新添加的属性。对于简单的数据类型属性，可以直接赋值初始值。例如，在 “学生” 类中添加 “是否是班干部” 属性，可以在构造函数中初始化为False。对于复杂的数据结构属性，如列表或字典，要注意初始化的方式，避免出现意外的错误。例如，初始化成绩列表为一个空列表，以方便后续添加成绩操作。

• 合理设置默认值：

  • 根据属性的实际意义和业务场景，合理设置默认值。默认值应该是在大多数情况下合理且不会引起错误的值。例如，在 “学生” 类中添加 “所属社团” 属性，如果大部分学生都没有加入社团，那么可以将默认值设置为None或者一个空字符串，表示未加入社团。但如果默认值设置不合理，可能会导致后续的操作出现问题。比如，将 “成绩” 属性的默认值设置为一个不符合实际成绩范围的值（如 - 1），可能会在计算平均成绩等操作中引发错误。

属性的可见性和访问控制（适用于支持访问控制的编程语言）

• 合理控制访问权限：

  • 像在 Java、C++ 等编程语言中，通过访问控制修饰符（如public、private、protected）来决定属性的可见性。对于不希望被外部类直接访问和修改的属性，应该设置为private或protected，并提供公共的方法（如getter和setter方法）来间接访问和修改属性。这样可以保护属性的完整性和一致性，防止外部类随意修改属性值导致对象状态混乱。
  • 对于一些需要被外部类广泛访问的属性，如 “学生姓名”“班级名称” 等，可以设置为public，但要谨慎考虑这种做法对封装性的影响。

• 遵循访问控制规则：

  • 在访问和修改其他类的属性时，要遵守其访问控制规则。如果试图访问一个private属性，会导致编译错误（在强类型语言中）或者不期望的运行时错误。在继承关系中，要理解protected属性的访问规则，确保子类能够正确地访问和使用这些属性，同时不破坏封装性原则。

对现有代码的影响和兼容性

• 检查方法对新属性的适应性：

  • 在添加新属性后，要检查类中的现有方法是否能够正确地处理这些属性。例如，在 “学生” 类中添加了 “成绩” 属性后，“显示学生信息” 方法可能需要更新，以包含成绩信息的显示；“计算平均成绩” 方法需要能够正确地读取和处理新的成绩属性。如果现有方法不能适应新属性，可能会导致程序出现错误或者逻辑不一致。

• 考虑继承关系和多态性：

  • 如果类存在继承关系，添加属性时要考虑对子类的影响。子类可能继承了父类的方法，这些方法可能需要适应新添加的属性。同时，要考虑多态性，确保在使用父类引用指向子类对象时，新属性能够正确地工作。例如，在一个继承体系中，“学生” 类是父类，“大学生” 类是子类，添加 “专业” 属性到 “学生” 类后，要检查 “大学生” 类的方法是否能够正确地处理这个新属性，以及在多态场景下（如将 “大学生” 对象作为 “学生” 对象使用），属性的访问和操作是否符合预期。

方法添加

方法的功能单一性和内聚性

• 功能单一：

  • 每个方法应该专注于执行一个明确的、相对独立的功能。例如，在学生类中，“添加成绩” 方法就只负责将成绩添加到成绩列表中，而不应该同时进行成绩的排序或其他复杂操作。这样可以使方法易于理解、维护和测试。
  • 如果一个方法承担了过多不相关的功能，会导致代码的可读性变差，也不利于后续的修改和扩展。比如，一个 “计算学生成绩相关信息” 的方法，如果既计算平均分又输出成绩分布图表，当需要修改其中一个功能（如改变图表的样式）时，可能会影响到另一个功能（平均分计算）。

• 内聚性：

  • 方法内部的代码应该紧密围绕其功能展开，各个操作之间应该有较强的关联性。例如，在 “计算平均成绩” 方法中，代码的主要操作应该是对成绩列表进行求和并计算平均值，所有代码都与成绩的计算有关。避免在方法内部出现与功能无关的代码，如在这个方法中不应该出现修改学生姓名等操作。

参数传递和合法性检查

• 参数的必要性和合理性：

  • 在定义方法时，要仔细考虑需要哪些参数来完成功能。参数应该是方法执行过程中必不可少的数据。例如，“添加成绩” 方法需要一个成绩参数来确定要添加的具体成绩。
  • 同时，参数的数量和类型应该合理。过多或不必要的参数会使方法的调用变得复杂，容易出错。如果一个方法的参数数量过多，可以考虑将部分参数封装成一个对象来传递，或者重新审视方法的功能是否过于复杂需要拆分。

• 参数合法性检查：

  • 对于方法接收的参数，应该进行合法性检查。例如，在学生类的 “添加成绩” 方法中，需要检查传入的成绩是否为数值类型（如整数或浮点数），如果不是，应该采取适当的措施，如打印错误提示信息或者抛出异常。这样可以避免方法在处理非法参数时出现不可预测的错误，增强程序的健壮性。

方法的返回值设计

• 明确返回值类型和意义：

  • 方法的返回值应该有明确的类型和清晰的意义。例如，“计算平均成绩” 方法返回一个浮点数，表示学生成绩的平均值；“查找学生” 方法可以返回找到的学生对象或者在未找到时返回None，这样调用者能够清楚地知道返回结果的含义并进行相应的处理。
  • 如果方法的返回值类型不明确或者含义模糊，会给调用者带来困惑。例如，一个方法返回一个整数，但这个整数在不同情况下可能代表不同的含义（如有时代表数量，有时代表状态码），这是一种不好的设计。

• 返回值的一致性和准确性：

  • 方法应该在所有可能的执行路径下都返回符合预期的值。例如，在计算平均成绩时，如果成绩列表为空，应该返回一个合理的值（如 0），而不是返回一个未定义的值或者引发错误。并且，返回值的计算和处理应该是准确的，避免出现逻辑错误导致返回错误的结果。

方法与对象状态的一致性维护

• 对对象属性的合理修改：

  • 方法在执行过程中可能会修改对象的属性，这种修改应该是合理的、符合业务逻辑的。例如，在 “添加成绩” 方法中，修改学生的成绩列表是合理的，因为这与方法的功能一致。但如果一个方法随意修改对象的其他无关属性（如在 “添加成绩” 方法中修改学生的姓名），会破坏对象状态的一致性，导致程序出现难以理解的错误。
  • 在修改属性时，要考虑到对其他方法和对象行为的影响。例如，如果修改了成绩列表的存储结构（如从列表改为字典），那么所有涉及成绩列表操作的方法（如计算平均成绩、显示成绩等）都可能需要进行相应的修改，以确保程序的正常运行。

• 方法之间的协作和对象状态的整体维护：

  • 不同方法之间应该协作维护对象的状态。例如，在学生类中，“添加成绩” 方法和 “计算平均成绩” 方法应该相互配合，确保在添加成绩后，平均成绩能够正确计算。如果方法之间的协作出现问题，可能会导致对象状态的不一致，比如添加成绩后平均成绩没有正确更新。

方法的可见性和访问控制（适用于支持访问控制的编程语言）

• 合理设置访问权限：

  • 在一些编程语言（如 Java、C++）中，有访问控制修饰符（如public、private、protected）来控制方法的可见性。应该根据方法的功能和安全性要求合理设置访问权限。例如，对于一些只是在类内部辅助其他方法使用的工具方法，可以设置为private，防止外部类误调用。
  • 对于需要被外部类访问的方法，如提供给其他类获取学生信息或者执行特定操作的方法，可以设置为public。合理的访问控制可以保护对象的内部状态，提高代码的安全性和可维护性。

• 遵循访问控制原则：

  • 当调用其他类的方法时，要遵守其访问控制规则。如果一个方法是private的，就不应该在其他类中尝试直接调用，否则会破坏封装性。同时，在继承关系中，要注意protected方法的使用范围和规则，避免不恰当的访问导致的错误。

交互与关联

关系的语义明确性

• 清晰定义关联关系：

  • 在建立类之间的交互和关联时，要明确关系的语义。例如，在 “学生” 类和 “班级” 类的关联中，应该明确是 “一个学生属于一个班级” 的关系。这种语义要在代码的命名和结构中体现出来，比如在学生类的属性中，可以有一个名为class_obj（代表所属班级对象）的属性，并且在方法和文档注释中清楚地说明这种所属关系。

• 避免模糊或错误的关联解释：

  • 不能让关联关系存在多种可能的解释。比如，不能让一个属性或方法让人误解为学生和班级是一种其他的关系（如 “班级包含学生信息备份” 之类模糊的关系）。如果关联关系不明确，会导致代码的理解和维护困难，特别是在复杂的系统中，多个开发人员协作时更容易产生混淆。

关联的强度和生命周期管理

• 区分不同关联强度：

  • 理解关联关系的强度，如关联、聚合和组合。关联是一种比较松散的关系，比如学生和学校图书馆之间的关系（学生可以使用图书馆资源，但没有强依赖）；聚合关系稍强，如班级和学生的关系（班级由学生组成，但学生可以独立于班级存在）；组合关系是最强的，例如学生和学生的身份证信息（身份证信息不能脱离学生对象单独存在）。在设计类之间的交互时，要根据实际业务需求选择合适的关联强度，并在代码中正确体现。
  • 对于强关联关系（如组合），要注意对象生命周期的管理。例如，在组合关系中，当主对象（如包含身份证信息的学生对象）被销毁时，附属对象（身份证信息）也应该被销毁或者失去意义。如果生命周期管理不当，可能会导致资源泄漏或数据不一致等问题。

• 正确处理对象的生命周期关联：

  • 在建立和解除关联时，要考虑对象的状态变化。例如，当一个学生从一个班级转到另一个班级时，需要正确地更新学生对象和两个班级对象之间的关联关系，包括从原班级的学生列表中移除该学生，以及将其添加到新班级的学生列表中。如果没有正确处理这些关联的变更，会导致数据的错误表示，如班级学生人数统计错误等。

交互的接口设计和协议遵守

• 设计良好的交互接口：

  • 当类之间需要交互时，要设计清晰、简单且功能明确的接口方法。例如，在班级类中，如果要实现添加学生的功能，设计一个add_student方法，这个方法的参数应该明确是一个学生对象，返回值可以是添加成功或失败的标志。接口方法的参数和返回值的设计要考虑到调用者的方便性和可理解性。
  • 接口方法的命名应该符合其功能语义。避免使用模糊或容易误解的命名，如一个用于获取班级学生平均成绩的方法，不能命名为get_something，而应该明确命名为get_average_score_of_students之类的名称，这样其他开发人员可以很容易地理解其功能并正确使用。

• 遵守交互协议：

  • 类之间的交互应该遵守一定的协议。例如，在调用另一个类的方法时，要按照方法的要求传递正确的参数，并且正确处理返回值。如果一个方法要求在特定状态下才能调用，那么调用者应该确保满足这个条件。比如，班级类的remove_student方法可能要求班级中存在要移除的学生，调用者不能在不符合这个条件的情况下随意调用该方法，否则会导致程序出错。

数据一致性和并发访问问题（在多线程或分布式环境下）

• 确保数据一致性：

  • 在类之间交互过程中，要确保数据的一致性。例如，学生对象的成绩信息存储在学生类中，当班级类需要获取学生的平均成绩来更新班级的成绩统计信息时，要确保获取的成绩数据是最新的、准确的。如果在交互过程中数据发生不一致，可能会导致错误的业务决策，如错误地评估班级的学习情况。

• 处理并发访问冲突：

  • 在多线程或分布式环境下，多个线程或进程可能同时访问和修改关联的类对象。例如，多个线程同时对一个班级的学生成绩进行更新操作。要考虑使用适当的并发控制机制（如锁、事务等）来避免数据冲突和不一致。如果不处理并发访问问题，可能会出现数据丢失、数据错误更新等严重问题。

循环依赖问题

• 识别和避免循环依赖：

  • 要注意避免类之间的循环依赖。例如，学生类依赖班级类来获取班级信息，同时班级类又依赖学生类来获取学生信息，如果这种依赖关系形成一个闭环，会导致代码的编译和运行出现问题。在设计类的交互和关联时，要梳理清楚依赖关系，尽量采用单向依赖或者通过合理的接口设计来打破循环依赖。

• 解耦循环依赖（如果存在）：

  • 如果不可避免地出现了循环依赖，可以采用一些解耦策略。比如，提取公共接口或者使用中介者模式等设计模式来降低类之间的直接依赖程度，使代码结构更加清晰和易于维护。但解耦过程要谨慎，确保不会破坏原有的业务逻辑和功能。

标签：班级,对象,self,学生,学习,第二周,student,属性,第一阶段
From： https://blog.csdn.net/shangzhiqi/article/details/144016433