本教程旨在解决在java嵌套循环中收集和处理复杂、关联性数据时遇到的挑战。我们将通过引入自定义类（如`student`类）来封装相关数据，从而实现更结构化、可维护的数据存储和操作。教程将涵盖类定义、数据收集逻辑重构、以及如何有效地进行数据计算与展示，避免使用零散数组导致的数据管理混乱。
1. 挑战与问题背景
在处理多组关联数据时，例如收集多个学生的姓名、多次测验成绩、期中和期末成绩，开发者常常会遇到数据管理上的困惑。当数据收集逻辑涉及多层嵌套循环时，如果简单地使用多个独立的数组来存储这些数据（例如一个数组存姓名，一个数组存测验成绩，另一个数组存期中成绩），会导致以下问题：
- 数据关联性弱： 很难直观地看出某个测验成绩属于哪个学生。
- 代码复杂性高： 需要通过索引在多个数组之间进行同步，容易出错。
- 数据处理困难： 对特定学生进行总分计算或信息展示时，需要手动组合来自不同数组的数据。
- 可维护性差： 增加新的数据类型（如实验成绩）时，需要修改大量代码。
原始代码示例中，尝试使用多个独立的String[]数组来存储学生的姓名、测验、期中和期末成绩，这种方式在后续的数据处理（如计算、打印）时会非常不便，因为不同数组之间缺乏明确的关联。
2. 解决方案：采用面向对象封装数据
为了解决上述问题，最有效的方法是采用面向对象编程（OOP）的思想，创建一个自定义类来封装所有与特定实体（例如“学生”）相关的数据。这样，每个学生实例都将包含自己的姓名、测验成绩、期中成绩和期末成绩，形成一个内聚的数据单元。
2.1 定义学生类 (Student Class)
首先，我们定义一个Student类，它将包含学生的所有属性。为了便于后续的计算，成绩数据类型应选择int或double而非String。
立即学习“Java免费学习笔记（深入）”；
import java.util.Arrays; // 导入Arrays工具类用于打印数组
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.err.println("Error: Quiz index out of bounds.");
}
}
public void setMidtermMark(int index, int mark) {
if (index >= 0 && index < midterms.length) {
this.midterms[index] = mark;
} else {
System.err.println("Error: Midterm index out of bounds.");
}
}
public void setFinalMark(int index, int mark) {
if (index >= 0 && index < finals.length) {
this.finals[index] = mark;
} else {
System.err.println("Error: Final index out of bounds.");
}
}
// 计算总分的方法示例
public int calculateTotalScore() {
int total = 0;
for (int mark : quizzes) {
total += mark;
}
for (int mark : midterms) {
total += mark;
}
for (int mark : finals) {
total += mark;
}
return total;
}
// 打印学生信息的方法示例
@Override
public String toString() {
return "Student Name: " + name +
"\n Quizzes: " + Arrays.toString(quizzes) +
"\n Midterms: " + Arrays.toString(midterms) +
"\n Finals: " + Arrays.toString(finals) +
"\n Total Score: " + calculateTotalScore();
}
}2.2 在主方法中收集数据
有了Student类后，我们可以重构主方法中的数据收集逻辑。现在，我们将创建一个Student对象数组来存储所有学生的信息。
import java.util.InputMismatchException;
import java.util.Scanner;
public class GradeCollector {
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;
try {
numberOfStudents = input.nextInt();
} catch (InputMismatchException e) {
System.err.println("Invalid input. Please enter a number for students.");
input.close();
return;
}
input.nextLine(); // 消耗掉nextInt()留下的换行符
// 定义每个学生需要输入的测验、期中、期末数量
final int NUM_QUIZZES = 2;
final int NUM_MIDTERMS = 1;
final int NUM_FINALS = 1;
// 创建Student对象数组来存储所有学生的信息
Student[] students = new Student[numberOfStudents];
// 外层循环：遍历每个学生
for (int stNumber = 0; stNumber < numberOfStudents; stNumber++) {
System.out.println("\n--- Entering data for Student " + (stNumber + 1) + " ---");
System.out.println("Enter the name for student " + (stNumber + 1) + ":");
String studentName = input.nextLine();
// 创建一个新的Student对象，并初始化其内部的成绩数组
Student currentStudent = new Student(studentName, NUM_QUIZZES, NUM_MIDTERMS, NUM_FINALS);
// 嵌套循环：收集测验成绩
for (int qzNumber = 0; qzNumber < NUM_QUIZZES; qzNumber++) {
System.out.println("Enter quiz mark " + (qzNumber + 1) + " for " + studentName + ":");
try {
currentStudent.setQuizMark(qzNumber, input.nextInt());
} catch (InputMismatchException e) {
System.err.println("Invalid input. Please enter a number for quiz mark.");
input.nextLine(); // 清除错误输入
qzNumber--; // 重新输入当前测验成绩
}
}
input.nextLine(); // 消耗掉nextInt()留下的换行符
// 嵌套循环：收集期中成绩
for (int mtNumber = 0; mtNumber < NUM_MIDTERMS; mtNumber++) {
System.out.println("Enter midterm mark " + (mtNumber + 1) + " for " + studentName + ":");
try {
currentStudent.setMidtermMark(mtNumber, input.nextInt());
} catch (InputMismatchException e) {
System.err.println("Invalid input. Please enter a number for midterm mark.");
input.nextLine(); // 清除错误输入
mtNumber--; // 重新输入当前期中成绩
}
}
input.nextLine(); // 消耗掉nextInt()留下的换行符
// 嵌套循环：收集期末成绩
for (int fnNumber = 0; fnNumber < NUM_FINALS; fnNumber++) {
System.out.println("Enter final mark " + (fnNumber + 1) + " for " + studentName + ":");
try {
currentStudent.setFinalMark(fnNumber, input.nextInt());
} catch (InputMismatchException e) {
System.err.println("Invalid input. Please enter a number for final mark.");
input.nextLine(); // 清除错误输入
fnNumber--; // 重新输入当前期末成绩
}
}
input.nextLine(); // 消耗掉nextInt()留下的换行符
// 将当前学生对象存储到学生数组中
students[stNumber] = currentStudent;
}
input.close(); // 关闭Scanner
System.out.println("\n--- All Student Marks Collected ---");
// 遍历并打印所有学生的信息
for (Student student : students) {
if (student != null) { // 确保学生对象不为空
System.out.println(student.toString());
System.out.println("------------------------------------");
}
}
}
}3. 数据处理与展示
通过上述方法，所有学生的数据都以结构化的方式存储在Student对象数组中。现在，我们可以轻松地对这些数据进行处理和展示。
在GradeCollector的main方法末尾，我们已经展示了如何遍历students数组并打印每个学生的信息。由于Student类中已经定义了calculateTotalScore()方法和toString()方法，我们可以直接调用它们来获取格式化的输出和计算结果。
例如，如果你想计算所有学生的平均总分：
// ... (接GradeCollector的main方法)
int totalOverallScore = 0;
for (Student student : students) {
if (student != null) {
totalOverallScore += student.calculateTotalScore();
}
}
double averageOverallScore = (double) totalOverallScore / numberOfStudents;
System.out.println("\nAverage total score for all students: " + averageOverallScore);4. 注意事项与最佳实践
- 数据类型选择： 对于需要进行数值计算的数据（如分数），务必使用int、double或float等数值类型，而不是String。在从用户输入读取时，使用Scanner的nextInt()或nextDouble()方法。
- 输入验证与异常处理： 用户输入可能不符合预期（例如输入字母而不是数字）。在读取数值输入时，使用try-catch块捕获InputMismatchException，并提示用户重新输入，提高程序的健壮性。同时，input.nextLine()在nextInt()之后的使用非常重要，用于消耗掉行尾的换行符，防止影响后续的nextLine()调用。
- 封装性： 在Student类中，将属性声明为private，并通过public的getter和setter方法来访问和修改这些属性，这是良好的面向对象设计实践，可以更好地控制数据的访问。
-
动态数组： 如果学生数量或测验数量在程序运行前不确定，可以考虑使用java.util.ArrayList
代替固定大小的Student[]数组，以实现更灵活的数据存储。 - 代码可读性： 使用有意义的变量名和常量（如NUM_QUIZZES），添加注释，可以大大提高代码的可读性和可维护性。
- 方法复用： 将计算逻辑（如calculateTotalScore()）封装在Student类内部，使得每个Student对象都能独立完成自己的计算，符合“单一职责原则”。
5. 总结
通过本教程，我们学习了如何利用Java的面向对象特性，通过自定义类来优雅地管理嵌套循环中收集的复杂关联数据。这种方法不仅解决了数据关联性弱、代码复杂性高的问题，还显著提升了代码的可读性、可维护性和可扩展性。在处理任何结构化数据时，将相关属性封装到对象中，是Java编程中一个非常重要的设计模式。
