文章目录
- 一、实战概述
- 二、知识贮备
- （一） 类与对象设计
- （二）文件读写操作
- （三）集合类应用
- 三、思路分析
- （一）系统架构设计
- （二）功能模块划分
- 四、实现步骤
- （一）创建Java项目
- （二）创建学生实体类
- （三）创建学生管理器类
- 1、声明变量
- 2、将学生列表写入文件
- 3、从文件读出学生列表
- 4、添加学生信息
- 5、查询学生信息
- （1）查询全部学生
- （2）按学号查询学生
- （3）按姓名查询学生
- 6、修改学生信息
- 7、删除学生信息
- 8、构建菜单系统
- （1）构建一级菜单系统
- （2）构建二级菜单系统
- （四）运行程序，查看效果
- 五、实战总结
一、实战概述
-
本实战项目基于Java语言，设计并实现了一个学生信息管理系统。系统通过精心设计的
Student类和StudentManager类，实现了对学生信息的封装、管理与操作。其中，Student类包含了学生的各项基本信息如姓名、学号和年龄等，并提供getter/setter方法进行数据访问控制。而StudentManager类作为核心管理者，利用集合类（如ArrayList）高效存储并实现了添加、删除、查询和修改学生信息的功能模块。 -
在文件读写操作方面，项目采用Java I/O流中的
FileReader、FileWriter以及BufferedReader来完成学生信息的持久化存储与读取。为了确保资源安全关闭和异常处理，使用了try-catch语句。 -
系统设计上遵循面向对象编程原则，功能模块划分清晰，包括新增学生记录、根据学号或姓名检索特定学生、更新学生信息以及删除学生记录。此外，还构建了一个菜单驱动的交互界面，方便用户直观操作。
-
整个实现过程分为创建Java项目、定义
Student实体类、实现StudentManager管理类及其实现各种功能方法四个步骤，通过实际编程实践，帮助学习者深入理解面向对象设计、文件读写操作和集合类应用等重要知识点。
二、知识贮备
（一） 类与对象设计
-
在编程的王国里，我们首先构思了一位名叫
Student的角色。这位角色拥有独一无二的三大属性：姓名（name）、学号（id）和年龄（age），它们构成了每位学生的身份标识。为了保证这些信息的安全性和可控性，我们为每个属性精心设计了getter和setter方法——get方法如同一把钥匙，允许外界获取学生的信息；而set方法则像一个保险箱，确保只有合法的数据才能更新学生的属性。 -
接着，为了统御这片由众多
Student构成的知识海洋，我们构建了一个名为StudentManager的管理者类。它掌握着所有学生的生命周期管理，负责执行诸如新增（add）、删除（delete）、修改（update）以及查询（find）等核心操作。通过这个管理者，我们可以高效有序地维护整个学生群体的信息系统，使得无论是查询特定学生的信息，还是进行大规模的学生数据管理，都能轻松自如、游刃有余。
（二）文件读写操作
-
在Java中，
FileReader和FileWriter是基础的文件读写类，分别用于从文件读取字符流和向文件写出字符流。若要按行进行读取操作，通常会配合使用BufferedReader以提高效率和提供便捷的行读取功能。 -
例如，使用
FileReader结合BufferedReader来逐行读取文本文件
try (FileReader fr = new FileReader("input.txt");
BufferedReader br = new BufferedReader(fr)) {
String line;
while ((line = br.readLine()) != null) {
// 处理每一行内容
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
- 同样，使用
FileWriter可以将数据一行一行写入文件
try (FileWriter fw = new FileWriter("output.txt")) {
for (String content : dataList) {
fw.write(content + "\n"); // 每个内容后添加换行符以便分隔各条记录
}
} catch (IOException e) {
e.printStackTrace();
}
- 注意：在处理文件时务必使用try-with-resources语句或显式关闭资源，避免资源泄露。同时，在实际应用中应考虑异常处理、编码问题以及文件路径的有效性。
（三）集合类应用
- 在高效管理众多
Student对象的过程中，我们充分利用了Java集合框架的强大功能。比如，采用ArrayList这一动态数组作为存储容器，它可以轻松容纳数量不定的学生信息，并通过索引快速定位和访问学生对象，实现数据的随机存取。而当需要根据学号或姓名等特定属性查找学生时，我们则会切换到灵活高效的HashMap。它利用键值对的形式将学生信息进行组织，使得查找、添加和删除操作的时间复杂度降为近乎常量级别，极大地提升了数据处理效率，使大规模学生信息的管理变得轻而易举。
三、思路分析
（一）系统架构设计
-
在系统架构设计阶段，我们首要任务是规划清晰的模块结构。首先，精心雕琢
Student类，它作为整个学生信息系统的基本单元，封装了学生的姓名、学号和年龄等核心属性，并通过getter/setter方法确保数据的安全访问与修改。这样一来，每个Student对象就如同一张详尽的学生信息卡片，具有良好的内聚性和低耦合度。 -
其次，为了实现对众多
Student对象的有效管理和控制，我们创建了一个名为StudentManager的核心管理类。该类负责统筹所有的学生信息操作，如添加新学生、删除已注册学生、更新学生信息以及检索特定学生等。通过将这些操作逻辑集中在一个专门的类中，不仅使功能模块划分得更加清晰明了，而且便于后续维护与扩展，充分体现了面向对象设计原则中的单一职责原则与高内聚、低耦合的设计思想，为构建稳定、高效的教育信息化系统奠定了坚实基础。
（二）功能模块划分
-
在功能模块划分中，我们详细规划了学生信息管理的各项核心操作。
-
添加学生信息：设计
StudentManager类中的addStudent()方法，用于添加学生信息，通过用户输入创建并初始化一个Student对象，然后将其添加到从文件读取的学生列表中，并将更新后的学生列表重新写入文件。全程提供交互式提示，确保新学生记录成功添加。 -
删除学生信息：实现
deleteStudentById(String id)方法，用于根据学号删除学生记录。首先检查学号是否存在，然后读取存储学生信息的文件。在学生列表中找到匹配学号的学生并移除，最后将更新后的学生列表写回文件，全程提供交互式提示，确保选定学生记录成功删除。 -
查询学生信息：提供多种查询接口，例如
findStudentById(String id)、findStudentsByName(String name)以及findAllStudents()。这些方法分别用于根据学号、姓名获取单个学生信息，或者返回所有学生信息列表。查询逻辑基于底层集合的数据结构特性，实现高效的检索服务。 -
修改学生信息：设计
updateStudent(String id)方法，用于根据学号修改学生信息。首先检查学号是否存在，然后读取存储学生信息的文件。通过用户输入更新选定学生的各项属性，并将修改后的学生列表重新写入文件。全程提供交互式提示，确保数据安全、准确地更新。
-
-
综上所述，各个功能模块的实现思路既独立又协同，共同构建了一个完整且灵活的学生信息系统，满足日常教务工作的多样化需求。
四、实现步骤
（一）创建Java项目
- 创建Java项目 -
Project02 - StudentManagement
- 单击【Create】按钮，得到初始化项目
（二）创建学生实体类
- 创建
net.huawei.project02包，在包里创建Student类
- 该类定义了一个学生实体，包含学号、姓名、性别、年龄、班级、专业、学院和电话号码属性，并提供了对应的getter/setter方法。通过toString()方法可以将学生信息转化为易于阅读的字符串形式。
package net.huawei.project02;
/**
* 功能：学生实体类
* 作者：华卫
* 日期：2024年01月29日
*/
public class Student {
private String id;
private String name;
private String gender;
private int age;
private String clazz;
private String major;
private String school;
private String telephone;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getClazz() {
return clazz;
}
public void setClazz(String clazz) {
this.clazz = clazz;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
public String getTelephone() {
return telephone;
}
public void setTelephone(String telephone) {
this.telephone = telephone;
}
@Override
public String toString() {
return "Student{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", gender='" + gender + '\'' +
", age=" + age +
", clazz='" + clazz + '\'' +
", major='" + major + '\'' +
", school='" + school + '\'' +
", telephone='" + telephone + '\'' +
'}';
}
}
（三）创建学生管理器类
- 在
net.huawei.project02包里创建StudentManager类
1、声明变量
- 声明静态学生列表，用于存储多个学生对象
package net.huawei.project02;
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
* 功能：学生管理器类
* 作者：华卫
* 日期：2024年01月29日
*/
public class StudentManager {
private static List<Student> students = new ArrayList<>();
}
2、将学生列表写入文件
- 创建
writeStudentsToFile方法
/**
* 将学生列表写入文件
*
* @param students
* @param filePath
*/
public static void writeStudentsToFile(List<Student> students, String filePath) {
try {
// 创建文件字符输出流
FileWriter fw = new FileWriter(filePath);
// 遍历学生列表
for (Student student : students) {
// 拼接学生信息
String studentInfo = student.getId() + " "
+ student.getName() + " "
+ student.getGender() + " "
+ student.getAge() + " "
+ student.getClazz() + " "
+ student.getMajor() + " "
+ student.getSchool() + " "
+ student.getTelephone();
// 将学生信息写入指定文件
fw.write(studentInfo + "\n");
}
// 关闭文件字符输出流
fw.close();
} catch (IOException e) {
System.err.println(e.getMessage());
}
}
- 该方法用于将学生列表写入指定文件。通过遍历学生列表，拼接每位学生的各项属性为一行文本，逐行写入文件中，并在每行末尾添加换行符。最后确保关闭输出流，若发生IO异常则打印错误信息。
3、从文件读出学生列表
- 创建
readStudentsFromFile方法
/**
* 从文件读出学生列表
*
* @param filePath
* @return 学生列表
*/
public static List<Student> readStudentsFromFile(String filePath) {
// 创建学生列表
List<Student> students = new ArrayList<>();
// 判断文件是否存在
File file = new File(filePath);
if (file.exists()) {
try {
// 创建文件字符输入流
FileReader fr = new FileReader(filePath);
// 创建缓冲字符输入流
BufferedReader br = new BufferedReader(fr);
// 定义行字符串
String nextLine = "";
// 读取文件
while ((nextLine = br.readLine()) != null) {
// 拆分行内容
String[] fields = nextLine.split(" ");
// 创建学生对象
Student student = new Student();
// 设置对象属性
student.setId(fields[0]); // 学号
student.setName(fields[1]); // 姓名
student.setGender(fields[2]); // 性别
student.setAge(Integer.parseInt(fields[3])); // 年龄
student.setClazz(fields[4]); // 班级
student.setMajor(fields[5]); // 专业
student.setSchool(fields[6]); // 学院
student.setTelephone(fields[7]); // 电话
// 将学生对象添加到学生列表
students.add(student);
}
} catch (IOException e) {
System.err.println(e.getMessage());
}
} else {
System.out.println("温馨提示：学生文件不存在~");
}
// 返回学生列表
return students;
}
- 该方法用于从文件读取并构建学生列表。首先判断文件是否存在，存在则创建输入流逐行读取内容，按空格拆分每一行数据并初始化
Student对象，将各属性分别设置后添加到学生列表中。若文件不存在或读取过程中出现异常，则输出提示信息。最后返回构建好的学生列表。
4、添加学生信息
- 在
StudentManager类里创建静态方法 -addStudent()
/**
* 添加学生信息
*/
public static void addStudent() {
// 声明变量
Scanner sc = new Scanner(System.in);
String id;
String name;
String gender;
int age;
String clazz;
String major;
String school;
String telephone;
// 输入学生信息
System.out.print("学号：");
id = sc.next();
System.out.print("姓名：");
name = sc.next();
System.out.print("性别：");
gender = sc.next();
System.out.print("年龄：");
age = sc.nextInt();
System.out.print("班级：");
clazz = sc.next();
System.out.print("专业：");
major = sc.next();
System.out.print("学院：");
school = sc.next();
System.out.print("电话：");
telephone = sc.next();
// 创建学生对象
Student student = new Student();
// 设置对象属性
student.setId(id);
student.setName(name);
student.setGender(gender);
student.setAge(age);
student.setClazz(clazz);
student.setMajor(major);
student.setSchool(school);
student.setTelephone(telephone);
// 获取项目根目录
String projectRoot = System.getProperty("user.dir");
// 从文件读出学生列表
students = readStudentsFromFile(projectRoot + "/students.txt");
// 将学生对象添加到学生列表
students.add(student);
// 将学生列表写入文件
writeStudentsToFile(students, projectRoot + "/students.txt");
// 提示用户
System.out.println("学生记录添加成功~");
}
- 该方法用于添加学生信息，通过控制台交互式获取用户输入的学生各项属性，并创建、初始化一个
Student对象。随后读取文件中已存在的学生列表，将新学生对象添加到列表，再将更新后的学生列表写回文件，最后输出添加成功的提示信息。 - 添加主方法，在主方法里调用
addStudent()方法，看能否添加学生记录，并写入文件
- 运行程序，输入学生信息，提示“学生记录添加成功~”
- 查看学生文件 -
students.txt
- 多运行几次程序，添加几条学生记录
5、查询学生信息
（1）查询全部学生
- 创建
findAllStudents()方法
/**
* 查询全部学生
*/
public static List<Student> findAllStudents() {
// 获取项目根目录
String projectRoot = System.getProperty("user.dir");
// 判断文件是否存在
File file = new File(projectRoot + "/students.txt");
if (file.exists()) {
// 从文件读出学生列表
students = readStudentsFromFile(projectRoot + "/students.txt");
} else {
System.out.println("温馨提示：学生文件不存在~");
}
// 返回学生列表
return students;
}
- 该方法查询并返回所有学生信息。首先检查文件是否存在，存在则从指定路径读取学生列表；若文件不存在，则提示信息。最后返回获取到的学生列表。
- 修改主方法，测试
findAllStudents()方法
- 运行程序，查看结果
（2）按学号查询学生
- 创建
findStudentById()方法
/**
* 按学号查询学生
*
* @param id
* @return 学生对象
*/
public static Student findStudentById(String id) {
// 获取项目根目录
String projectRoot = System.getProperty("user.dir");
// 判断文件是否存在
File file = new File(projectRoot + "/students.txt");
if (file.exists()) {
// 从文件读出学生列表
students = readStudentsFromFile(projectRoot + "/students.txt");
for (Student student : students) {
if (student.getId().equals(id)) { // 找到学生记录
return student;
}
}
} else {
System.out.println("温馨提示：学生文件不存在~");
}
return null;
}
- 该方法按学号精确查找学生信息。首先判断文件是否存在，存在则从文件读取所有学生记录，遍历查找与输入id相匹配的学生对象，并返回；若未找到匹配项，则返回null。如果文件不存在，则提示。
- 修改主方法，测试
findStudentById()方法
public static void main(String[] args) {
String id = "2023001";
Student student = findStudentById(id);
if (student != null) {
System.out.println(student);
} else {
System.out.println("学号[" + id + "]的学生未找到~");
}
}
- 运行程序，查看结果
- 修改学号，再运行程序，查看结果
（3）按姓名查询学生
- 创建
findStudentsByName()方法
/**
* 按姓名查询学生（支持模糊查询）
*
* @param name
* @return 学生列表
*/
public static List<Student> findStudentsByName(String name) {
// 创建满足条件的学生列表
List<Student> foundStudents = new ArrayList<>();
// 获取项目根目录
String projectRoot = System.getProperty("user.dir");
// 判断文件是否存在
File file = new File(projectRoot + "/students.txt");
if (file.exists()) {
// 从文件读出学生列表
students = readStudentsFromFile(projectRoot + "/students.txt");
for (Student student : students) {
if (student.getName().startsWith(name)) { // 找到学生记录
foundStudents.add(student);
}
}
} else {
System.out.println("温馨提示：学生文件不存在~");
}
// 返回满足条件的学生列表
return foundStudents;
}
- 该方法根据姓名（支持模糊查询）查找学生信息。首先创建一个存储匹配结果的学生列表，然后从文件读取所有学生记录，逐条判断姓名是否以输入的name开头，若是则添加到结果列表中。若文件不存在，则提示。最后返回查找到的学生列表。
- 修改主方法，测试
findStudentsByName()方法
public static void main(String[] args) {
String name = "陈明真";
List<Student> students = findStudentsByName(name);
if (students.size() > 0) {
students.stream().forEach(student -> System.out.println(student));
} else {
System.out.println("姓名[" + name + "]的学生未找到~");
}
}
- 运行程序，查看结果
- 查询姓“陈”的学生
- 查询“李晓彤”，提示找不到
6、修改学生信息
- 创建
updateStudentById()方法
/**
* 修改学生
*
* @param id
*/
public static void updateStudentById(String id) {
// 判断学号是否存在
if (findStudentById(id) == null) {
System.out.println("学号[" + id + "]的学生不存在~");
return;
}
// 获取项目根目录
String projectRoot = System.getProperty("user.dir");
// 判断文件是否存在
File file = new File(projectRoot + "/students.txt");
if (file.exists()) {
// 从文件读出学生列表
students = readStudentsFromFile(projectRoot + "/students.txt");
for (int i = 0; i < students.size(); i++) {
if (students.get(i).getId().equals(id)) { // 找到学生记录
// 声明变量
Scanner sc = new Scanner(System.in);
String name;
String gender;
String age;
String clazz;
String major;
String school;
String telephone;
System.out.println("温馨提示：直接敲回车，不作修改~");
System.out.println("学号：" + id);
// 输入学生信息
System.out.print("姓名：");
name = sc.nextLine();
System.out.print("性别：");
gender = sc.nextLine();
System.out.print("年龄：");
age = sc.nextLine();
System.out.print("班级：");
clazz = sc.nextLine();
System.out.print("专业：");
major = sc.nextLine();
System.out.print("学院：");
school = sc.nextLine();
System.out.print("电话：");
telephone = sc.nextLine();
// 修改列表中学生信息
if (!name.equals("")) {
students.get(i).setName(name);
}
if (!gender.equals("")) {
students.get(i).setGender(gender);
}
if (!age.equals("")) {
students.get(i).setAge(Integer.parseInt(age));
}
if (!clazz.equals("")) {
students.get(i).setClazz(clazz);
}
if (!major.equals("")) {
students.get(i).setMajor(major);
}
if (!school.equals("")) {
students.get(i).setSchool(school);
}
if (!telephone.equals("")) {
students.get(i).setTelephone(telephone);
}
// 将学生列表写入文件
writeStudentsToFile(students, projectRoot + "/students.txt");
// 提示用户
System.out.println("学生记录修改成功~");
// 跳出循环
break;
}
}
} else {
System.out.println("温馨提示：学生文件不存在~");
}
}
- 该方法根据学号修改学生信息。首先检查学号是否存在，若不存在则提示。存在时从文件读取学生列表，找到对应ID的学生记录并交互式获取用户要更新的信息，对非空输入进行相应属性更新。完成后将更新后的学生列表写回文件，并输出修改成功提示。如果文件不存在，则提示文件不存在。
- 修改主方法，测试
updateStudent()方法
public static void main(String[] args) {
String id = "2023001";
updateStudentById(id);
}
- 运行程序，修改学生信息
- 查看学生文件，看看学号
2023001的记录是否修改成功
7、删除学生信息
- 创建
deleteStudentById()方法
/**
* 删除学生
*
* @param id
*/
public static void deleteStudentById(String id) {
// 判断学号是否存在
if (findStudentById(id) == null) {
System.out.println("学号[" + id + "]的学生不存在~");
return;
}
// 获取项目根目录
String projectRoot = System.getProperty("user.dir");
// 判断文件是否存在
File file = new File(projectRoot + "/students.txt");
if (file.exists()) {
// 从文件读出学生列表
students = readStudentsFromFile(projectRoot + "/students.txt");
for (Student student : students) {
if (student.getId().equals(id)) { // 找到学生记录
// 删除该元素
students.remove(student);
// 将学生列表写入文件
writeStudentsToFile(students, projectRoot + "/students.txt");
// 提示用户
System.out.println("学号[" + id + "]的学生删除成功~");
// 跳出循环
break;
}
}
} else {
System.out.println("温馨提示：学生文件不存在~");
}
}
-
该方法根据学号删除学生记录。首先检查学号是否存在，若不存在则提示。存在时，从项目根目录下的"students.txt"文件读取学生列表，找到匹配ID的学生记录并从列表中移除，然后将更新后的学生列表写回文件，并输出删除成功的提示。如果文件不存在，则提示文件不存在。
-
修改主方法，测试
deleteStudentById()方法
public static void main(String[] args) {
String id = "2023006";
deleteStudentById(id);
}
- 运行程序，查看结果
- 查看学生文件，看学号[2023006]的学生是否被删除
8、构建菜单系统
-
我们要实现一个基于控制台的学生管理系统，包含了一级和二级菜单。一级菜单提供五个选项：添加、修改、查询、删除学生以及退出系统。当用户选择查询功能时，进入查询学生的二级菜单，提供按全部、学号或姓名查询的子选项。
-
在每次循环中，根据用户输入的菜单编号执行对应的操作，如调用
addStudent、updateStudentById、deleteStudentById等方法处理学生数据，并通过findAllStudents、findStudentById和findStudentsByName方法进行查询操作。整个设计采用命令行交互形式，结构清晰，易于扩展和维护，实现了对学生信息的增删改查全功能管理。
（1）构建一级菜单系统
- 在主方法里构建一级菜单系统
public static void main(String[] args) {
int mc1;
Scanner sc = new Scanner(System.in);
boolean isRunning = true; // 循环控制变量
while (isRunning) {
// 绘制二级菜单
System.out.println("======学生管理系统======");
System.out.println(" 1. 添加学生");
System.out.println(" 2. 修改学生");
System.out.println(" 3. 查询学生");
System.out.println(" 4. 删除学生");
System.out.println(" 5. 退出系统");
System.out.println("=======================");
System.out.print("输入菜单编号[1,2,3,4,5]：");
mc1 = sc.nextInt();
switch (mc1) {
case 1:
System.out.println("执行添加学生功能~");
addStudent(); // 调用添加学生方法
break;
case 2:
System.out.println("执行修改学生功能~");
System.out.print("输入学号：");
String updateId = sc.next();
updateStudentById(updateId); // 调用修改学生方法
break;
case 3:
findStudent(); // 调用查询学生二级菜单系统
break;
case 4:
System.out.println("执行删除学生功能~");
System.out.print("输入学号：");
String deleteId = sc.next();
deleteStudentById(deleteId); // 调用删除学生方法
break;
case 5:
isRunning = false; // 结束一级菜单循环
System.out.println("谢谢使用，再见~");
break;
default:
System.out.println("输入的菜单编号有误！");
}
}
}
（2）构建二级菜单系统
- 针对查询学生，构建二级菜单系统
/**
* 查询学生
*/
private static void findStudent() {
int mc2;
Scanner sc = new Scanner(System.in);
boolean isRunning = true; // 循环控制变量
while (isRunning) {
// 绘制二级菜单
System.out.println("=======查询学生========");
System.out.println(" 1. 查询全部学生");
System.out.println(" 2. 按学号查询学生");
System.out.println(" 3. 按姓名查询学生");
System.out.println(" 4. 返回上级");
System.out.println("=======================");
System.out.print("输入菜单编号[1,2,3,4]：");
mc2 = sc.nextInt();
switch (mc2) {
case 1:
System.out.println("执行查询全部学生功能~");
List<Student> students1 = findAllStudents();
students1.stream().forEach(student1 -> System.out.println(student1));
break;
case 2:
System.out.println("执行按学号查询学生功能~");
System.out.print("输入学号：");
String id = sc.next();
Student student = findStudentById(id);
if (student != null) {
System.out.println(student);
} else {
System.out.println("学号[" + id + "]的学生未找到~");
}
break;
case 3:
System.out.println("执行按姓名查询学生功能~");
System.out.print("输入姓名：");
String name = sc.next();
List<Student> students2 = findStudentsByName(name);
if (students2.size() > 0) {
students2.stream().forEach(student2 -> System.out.println(student2));
} else {
System.out.println("姓名[" + name + "]的学生未找到~");
}
break;
case 4:
isRunning = false; // 结束二级菜单循环
break;
default:
System.out.println("输入的菜单编号有误！");
}
}
}
（四）运行程序，查看效果
- 运行程序，首先看到一级菜单系统
- 输入菜单编号有误的情况
- 输入菜单编号[3]，进入二级菜单
- 输入菜单编号[1]，查询全部学生
- 输入菜单编号[2]，按学号查询学生
- 输入菜单编号[3]，按姓名查询，查询姓“张”的学生
- 输入菜单编号[4]，返回上级菜单
- 输入菜单编号[1]，添加学生记录
- 可以查看学生文件，看刚添加的学生
- 输入菜单编号[2]，修改学生记录
- 查看学生文件，看刚修改的学生
- 输入菜单编号[4]，删除学生记录
- 输入菜单编号[5]，退出系统
五、实战总结
- 本实战项目运用Java语言，设计并实现了学生信息管理系统。通过精心构建
Student类与StudentManager类，完成了对学生信息的封装、增删改查等核心功能模块开发。利用集合类实现数据高效存储，并结合文件读写操作实现信息持久化。项目涵盖了面向对象设计原则、文件I/O处理以及集合类应用等多个关键知识点，提供菜单式交互界面，有效提升了用户体验和系统实用性。通过实际编程实践，使学习者充分理解并掌握了Java编程中的重要概念和技术点。
扫一扫
416
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
