在java中处理嵌套循环内复杂且关联的数据收集时，直接使用分散的数组往往导致数据管理和后续处理的困难。本文将详细介绍如何通过面向对象编程思想，定义自定义类来封装相关数据，从而实现更清晰、更易于维护和扩展的数据结构。通过实例代码，我们将演示如何创建学生对象、收集其各项成绩，并进行简单的输出处理，提升代码的可读性和功能性。
在软件开发中，尤其是在需要从用户处收集多组相关数据时，例如一个班级中每个学生的姓名、多门测验成绩、期中和期末成绩等，开发者经常会遇到如何高效、清晰地组织这些数据的问题。如果仅依赖于简单的字符串数组或基本数据类型，当数据结构变得复杂（如嵌套循环中收集不同类型的成绩）时，代码会迅速变得难以管理和维护，尤其是在后续需要对这些数据进行计算或展示时。
传统方法的局限性
考虑以下场景：我们需要为多名学生收集姓名、两次测验成绩、一次期中成绩和一次期末成绩。如果沿用原始代码中在每次外层循环（学生）内部创建新的局部数组来存储测验、期中和期末成绩，会遇到以下问题：
- 数据丢失： 每次外层循环迭代时，quiz、midterm 和 myfinal 数组都会被重新创建，并且在当前迭代结束后，这些数组所引用的数据就会丢失，无法在循环外部访问。这意味着我们无法收集所有学生的成绩。
- 数据分散： 学生的姓名和其对应的各项成绩被存储在不同的、不关联的数组中，使得在需要访问特定学生的完整信息时，需要进行复杂的索引匹配。
- 类型不一致： 原始代码中使用 String[] 来存储成绩，这在进行数学计算时需要额外的类型转换，增加了代码的复杂性和出错的可能性。
为了克服这些局限性，最佳实践是采用面向对象的方法来结构化数据。
面向对象的数据结构：定义 Student 类
面向对象编程（OOP）提供了一种优雅的解决方案，即通过定义一个自定义类来封装所有与一个“学生”相关的数据。这个类将作为学生信息的蓝图，每个学生都是这个类的一个实例。
立即学习“Java免费学习笔记（深入）”；
首先，我们定义一个 Student 类，包含学生的姓名以及各项成绩。为了便于后续的数值计算，成绩应使用 int 或 double 类型存储。
public class Student {
private String name;
private int[] quizzes; // 存储测验成绩
private int[] midterms; // 存储期中成绩
private int[] finals; // 存储期末成绩
// 构造函数：用于创建Student对象并初始化其属性
public Student(String name, int numberOfQuizzes, int numberOfMidterms, int numberOfFinals) {
this.name = name;
this.quizzes = new int[numberOfQuizzes];
this.midterms = new int[numberOfMidterms];
this.finals = new int[numberOfFinals];
}
// Getter 方法：允许外部访问私有属性
public String getName() {
return name;
}
public int[] getQuizzes() {
return quizzes;
}
public int[] getMidterms() {
return midterms;
}
public int[] getFinals() {
return finals;
}
// Setter 方法：允许外部修改私有属性（如果需要）
public void setQuizMark(int index, int mark) {
if (index >= 0 && index < quizzes.length) {
this.quizzes[index] = mark;
} else {
System.out.println("Invalid quiz index.");
}
}
public void setMidtermMark(int index, int mark) {
if (index >= 0 && index < midterms.length) {
this.midterms[index] = mark;
} else {
System.out.println("Invalid midterm index.");
}
}
public void setFinalMark(int index, int mark) {
if (index >= 0 && index < finals.length) {
this.finals[index] = mark;
} else {
System.out.println("Invalid final index.");
}
}
// 辅助方法：计算平均测验成绩
public double getAverageQuizScore() {
if (quizzes.length == 0) return 0.0;
int sum = 0;
for (int mark : quizzes) {
sum += mark;
}
return (double) sum / quizzes.length;
}
// 可以添加更多计算方法，例如总分、平均分等
}重构主程序：数据收集与处理
有了 Student 类，我们就可以重构主程序来高效地收集和处理数据。关键在于创建一个 Student 对象的数组，并在外层循环中为每个学生创建一个 Student 实例，然后将所有相关数据存储到该实例中。
import java.util.Scanner;
public class StudentManagement {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("How many students do you want to enter?");
int numberOfStudents = 0;
// 输入验证，确保用户输入的是一个整数
while (!input.hasNextInt()) {
System.out.println("Invalid input. Please enter a number.");
input.next(); // 消费掉无效输入
}
numberOfStudents = input.nextInt();
input.nextLine(); // 消费掉换行符，避免影响后续的nextLine()
// 定义每个学生需要输入的测验、期中、期末数量
final int NUM_QUIZZES = 2;
final int NUM_MIDTERMS = 1;
final int NUM_FINALS = 1;
// 创建Student对象数组来存储所有学生的信息
Student[] students = new Student[numberOfStudents];
for (int stIndex = 0; stIndex < numberOfStudents; stIndex++) {
System.out.println("\n--- Entering data for Student " + (stIndex + 1) + " ---");
System.out.println("Enter the name for student " + (stIndex + 1) + ":");
String studentName = input.nextLine(); // 读取整行姓名
// 创建新的Student对象
students[stIndex] = new Student(studentName, NUM_QUIZZES, NUM_MIDTERMS, NUM_FINALS);
// 收集测验成绩
for (int qzIndex = 0; qzIndex < NUM_QUIZZES; qzIndex++) {
System.out.println("Enter quiz mark " + (qzIndex + 1) + " for " + studentName + ":");
int quizMark = 0;
while (!input.hasNextInt()) {
System.out.println("Invalid input. Please enter an integer mark.");
input.next();
}
quizMark = input.nextInt();
students[stIndex].setQuizMark(qzIndex, quizMark);
}
input.nextLine(); // 消费掉数字输入后的换行符
// 收集期中成绩
for (int mtIndex = 0; mtIndex < NUM_MIDTERMS; mtIndex++) {
System.out.println("Enter midterm mark " + (mtIndex + 1) + " for " + studentName + ":");
int midtermMark = 0;
while (!input.hasNextInt()) {
System.out.println("Invalid input. Please enter an integer mark.");
input.next();
}
midtermMark = input.nextInt();
students[stIndex].setMidtermMark(mtIndex, midtermMark);
}
input.nextLine(); // 消费掉数字输入后的换行符
// 收集期末成绩
for (int fnIndex = 0; fnIndex < NUM_FINALS; fnIndex++) {
System.out.println("Enter final mark " + (fnIndex + 1) + " for " + studentName + ":");
int finalMark = 0;
while (!input.hasNextInt()) {
System.out.println("Invalid input. Please enter an integer mark.");
input.next();
}
finalMark = input.nextInt();
students[stIndex].setFinalMark(fnIndex, finalMark);
}
input.nextLine(); // 消费掉数字输入后的换行符
}
input.close();
// 数据收集完成后，进行处理和展示
System.out.println("\n--- All Students' Marks ---");
for (Student student : students) {
System.out.println("Student Name: " + student.getName());
System.out.print(" Quizzes: ");
for (int mark : student.getQuizzes()) {
System.out.print(mark + " ");
}
System.out.println(" (Average: " + String.format("%.2f", student.getAverageQuizScore()) + ")");
System.out.print(" Midterms: ");
for (int mark : student.getMidterms()) {
System.out.print(mark + " ");
}
System.out.println();
System.out.print(" Finals: ");
for (int mark : student.getFinals()) {
System.out.print(mark + " ");
}
System.out.println();
System.out.println("---------------------------");
}
}
}注意事项与最佳实践
- 数据类型选择： 对于分数等数值数据，应使用 int 或 double 类型，而不是 String。这不仅避免了不必要的类型转换，还确保了数据在存储时的语义正确性。
- 输入验证： 在从用户读取输入时，始终进行输入验证。例如，使用 Scanner.hasNextInt() 检查用户是否输入了整数，防止 InputMismatchException。
- 消费换行符： 当使用 Scanner.nextInt() 或 Scanner.nextDouble() 等方法读取数字后，Scanner 会将换行符留在输入缓冲区中。如果紧接着使用 Scanner.nextLine() 读取字符串，它会立即读取这个残留的换行符，导致跳过实际的字符串输入。因此，在数字输入后，通常需要调用 input.nextLine() 来消费掉这个换行符。
- 封装性： Student 类中的属性（如 name, quizzes）被声明为 private，并通过公共的 getter 和 setter 方法来访问和修改。这遵循了面向对象编程的封装原则，提高了代码的模块化和安全性。
-
灵活性： 构造函数允许我们为每个学生指定不同数量的测验、期中和期末成绩，这增加了程序的灵活性。如果需要更动态的数量（例如，学生可以有任意数量的测验），可以考虑使用 ArrayList
而不是固定大小的数组。 - 错误处理： 在 setQuizMark 等方法中添加索引边界检查，以防止 ArrayIndexOutOfBoundsException。
- 扩展性： 可以在 Student 类中添加更多的方法，例如计算总分、平均分、判断及格与否等，将与学生相关的业务逻辑集中管理，使主程序更简洁。
总结
通过采用面向对象的方法，定义一个 Student 类来封装学生的姓名和各项成绩，我们成功解决了在嵌套循环中收集和管理复杂相关数据的问题。这种方法不仅使数据结构更加清晰、易于理解，而且极大地提高了代码的可维护性、可读性和可扩展性。它将数据与操作数据的方法绑定在一起，是处理复杂数据场景的强大工具。
