JAVA学生信息管理系统（项目概述、分析设计、代码实现）
使用JAVA设计学生信息管理系统，完成学生信息的增删改查功能。
一、项目信息
1.1 名称
学生信息管理系统
1.2 项目描述
- 请使用Java语言设计并实现一个“学生信息管理系统”。该系统能够管理多个学生的基本信息、课程成绩、以及提供简单的统计功能。通过这个系统可以：
- 添加新的学生信息；
- 查询学生的详细信息（包括基本信息和成绩）；
- 修改学生信息和课程成绩；
- 统计并显示所有学生的平均成绩；
- 显示指定课程的最高分和最低分；
- 列出所有学生及其成绩；
- 删除学生信息。
1.3 功能需求
- 学生信息管理功能：
- 使用Arraylist数组来存储多个学生的信息。
- 每个学生的信息包括：学号、姓名、性别、年龄、所修课程及对应的成绩（支持多门课程）。
- 实现增、删、改、查等功能，具体包括：
- 增加新学生信息
- 修改指定学生的基本信息或成绩
- 删除指定学生
- 根据学号或姓名查询学生详细信息
- 成绩统计功能：
- 计算并显示所有学生的平均成绩。
- 显示指定课程的最高分和最低分。
1.4 类的设计要求
- 类设计：
- 创建一个
Student类，包含学生的基本信息（如学号、姓名、性别、年龄）以及课程成绩。 - 使用封装来保护类的属性，提供
getter和setter方法。- 实例中public方法是外部类访问该类成员变量的入口。通常情况下，这些方法被称为getter和setter方法。因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。
- 参考文章：菜鸟教程
- 为学生类实现一个
toString()方法，用于格式化输出学生信息。
- 创建一个
- 继承与多态：
- 设计一个抽象类
Person，其中包含基础的个人信息（如姓名、性别、年龄）和基本的行为（如displayInfo()方法）。让Student类继承自Person类，并实现具体的行为。
- 设计一个抽象类
- 组合：
- 学生类中的课程成绩可以设计为一个组合类，如
Course类，其中包含课程名称和成绩。
- 学生类中的课程成绩可以设计为一个组合类，如
1.5 程序结构要求
- 面向对象的设计：运用类、继承、封装、多态和组合的概念。
- 数组的应用：用数组或ArrayList来管理学生对象。
- 流程控制：程序中需要包含用户交互界面（命令行），如通过菜单操作实现添加、查询、删除、统计功能。
- 数据类型与类型转换：注意数据类型的合理使用，如年龄为整数，成绩为浮点数。并在适当场景下实现类型转换。
1.6 次要功能
- 提供课程成绩的排序功能，按指定课程的成绩从高到低排序输出学生信息。
- 使用异常处理来应对用户输入错误（如输入无效的学号、年龄或成绩）。
二、JAVA设计前置基础知识
2.1 JAVA对象、类
2.1.1 JAVA中的类
- 类可以看成是创建 Java 对象的模板
- 一个类可以包含以下类型变量
- 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
- 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
- 类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。
2.1.2 JAVA中的对象
- 软件对象的状态就是属性，行为通过方法体现。
- 对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下三步：
- 声明：声明一个对象，包括对象名称和对象类型。
- 实例化：使用关键字 new 来创建一个对象。
- 初始化：使用 new 创建对象时，会调用构造方法初始化对象。
2.1.3 源文件声明规则
- 一个源文件中只能有一个 public 类
- 一个源文件可以有多个非 public 类
- 源文件的名称应该和 public 类的类名保持一致。例如：源文件中 public 类的类名是 Employee，那么文件应该命名为Employee.java。
- 如果一个类定义在某个包中，那么 package 语句应该在源文件的首行。
- 如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。
- import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。
2.2 JAVA变量类型
- 静态变量或类变量（Class Variables）：
- 类变量是在类中用 static 关键字声明的变量，它们属于类而不是实例，所有该类的实例共享同一个类变量的值，类变量在类加载时被初始化，而且只初始化一次。由于静态变量是与类相关的，因此可以通过类名来访问静态变量，也可以通过实例名来访问静态变量。
- 静态变量（也称为类变量）的命名规范通常遵循驼峰命名法，并且通常使用全大写字母，单词之间用下划线分隔，并且要用 static 关键字明确标识。
- 使用驼峰命名法：静态变量的命名应该使用驼峰命名法，即首字母小写，后续每个单词的首字母大写。例如：myStaticVariable。
- Java String 类
- 字符串广泛应用在 Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。
2.3 JAVA修饰符
修饰符用来定义类、方法或者变量，通常放在语句的最前端。
- 访问控制修饰符
- Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限
- private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
- public : 对所有类可见。使用对象：类、接口、变量、方法
- protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
- Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限
- 非访问控制修饰符
- static 修饰符，用来修饰类方法和类变量。
- final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
- abstract 修饰符，用来创建抽象类和抽象方法。
2.4 JAVA循环结构
- Java 增强 for 循环
- Java5 引入了一种主要用于数组的增强型 for 循环
for(声明语句 : 表达式)
{
//代码句子
}
- 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
- 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
2.5 JAVA方法
- System.out.println()
- println() 是一个方法
- System 是系统类
- out 是标准输出对象
- 因此，这句话的用法是：调用系统类 System 中的标准输出对象 out 中的方法 println()。
- 方法（函数）的命名规则
- 方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson
- 方法重载
- 在同一个类中，创建另一个有相同名字但参数不同的方法即为方法的重载，即一个类的两个方法拥有相同的名字，但是有不同的参数列表。
- 重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法
- 构造方法
- 当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
- 每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
2.5.1 JAVA toString方法
2.6 Java获取用户输入与输出
2.6.1 Java Scanner 类
- java.util.Scanner 是 Java5 的新特征，我们可以通过 Scanner 类来获取用户的输入。
- 参考资料
2.6.2 JAVA输出
- 浮点输出保留位数处理
double d=3.1415926;
double e=3.465;
System.out.println(String.format("%.2f", d));
System.out.println(String.format("%.2f", e));
System.out.printf("%.2f%n",d);- 输出：3.14、3.47(保留两位小数)
2.6.3 JAVA的函数参数传递
2.7 JAVA异常处理
2.8 JAVA继承
2.8.1 继承的概念
- 继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
- 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。继承需要符合的关系是：父类更通用，子类更具体。
2.8.2 类的继承格式
- 在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：
class 父类 {
}
class 子类 extends 父类 {
}
2.8.3 继承的特性
- 子类拥有父类非 private 的属性、方法。
- 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
- 子类可以用自己的方式实现父类的方法。
- Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
- 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。
2.8.3 super 与 this 关键字
- super 关键字：我们可以通过 super 关键字来实现对父类成员的访问，用来引用当前对象的父类。
- this 关键字：指向自己的引用，引用当前对象，即它所在的方法或构造函数所属的对象实例。
class Animal {
void eat() {
System.out.println("animal : eat");
}
}
class Dog extends Animal {
void eat() {
System.out.println("dog : eat");
}
void eatTest() {
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.eatTest();
}
}
2.8.4 JAVA object类
- Java Object类是所有类的父类，也就是说 Java 的所有类都继承了 Object，子类可以使用 Object 的所有方法。
- Object类位于 java.lang 包中，编译时会自动导入，我们创建一个类时，如果没有明确继承一个父类，那么它就会自动继承Object，成为Object的子类。
- Object类部分方法如下
- 参考资料
2.9 Java 重写(Override)与重载(Overload)
2.9.1 重写(Override)
- 重写（Override）是指子类定义了一个与其父类中具有相同名称、参数列表和返回类型的方法，并且子类方法的实现覆盖了父类方法的实现。 即外壳不变，核心重写！
- 重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。这样，在使用子类对象调用该方法时，将执行子类中的方法而不是父类中的方法。
2.9.2 重载(Overload)
- 重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
- 每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
2.9.3 总结
- 方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
- 方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
2.10 JAVA多态
- 多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作。
- 多态存在的三个必要条件：继承、重写、父类引用指向子类对象：Parent p = new Child();
- 当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
2.11 JAVA封装
- 在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
2.11.1 实现封装的步骤
- 修改属性的可见性来限制对属性的访问（一般限制为private）
- 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，通常情况下，这些方法被称为getter和setter方法。因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。
2.12 JAVA Arraylist
2.12.1 Arraylist介绍
- ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。
- ArrayList 类位于 java.util 包中，使用前需要引入它。
- ArrayList 是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
- 语法格式如下：
import java.util.ArrayList; // 引入 ArrayList 类
ArrayList<E> objectName =new ArrayList<>(); // 初始化，E: 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。
- 参考资料
2.12.2 将Arraylist写入纯文本文件
后面再说
2.13 JAVA组合类
2.14 JAVA疑惑
- main函数中的传入参数是什么？为什么会有传入参数？
三、项目构思流程
3.1 思维导图绘制
3.1.1 需求思维导图
3.1.2 模拟运作流程图
3.1.3 体系架构图
四、JAVA编程错误处理
4.1 输入输出流
- Exception in thread “main“ java.util.NoSuchElementException
- 只要确保关闭流之后不会再调用输入流读取方法就可以了,通常把close()方法放在程序末尾.
- 参考文章
五、项目设计说明
5.1 类的设计思路
本项目目前设计了四大类
- Person类
- 抽象类
Person其中包含基础的个人信息（如姓名、性别、年龄）和基本的行为（如displayInfo()方法）。 - Person类是Student类的父类。
- 抽象类
- Student类
Student类包含学生的基本信息（如学号、姓名、性别、年龄）以及课程成绩。Student类继承自Person类。Student类使用封装来保护类的属性，提供getter和setter方法。Student类中实现toString()方法，用于格式化输出学生信息。Student类中实例化Course类，用于存储该学生课程信息（类的组合）。
- Course类
- 包含课程名称和成绩
- Main类
- Main类用于命令行交互，并提供学生信息增删改查的选项。
- 由ArryList存储Student类。
5.2 面向对象编程特性应用
package Students_Information_Management;
class Student extends Person{
private String ID; //ID为子类属性，父类属性使用super访问,子类属性使用this引用。
public void setName(String name) { //定义getter和setter方法，访问父类属性
super.name = name;
}
public String getName() {
return super.name;
}
public void setSex(String sex) {
super.sex = sex;
}
public String getSex() {
return super.sex;
}
public void setAge(int age) {
super.age = age;
}
public int getAge() {
return super.age;
}
public void setID(String ID) { //定义getter和setter方法，访问子类属性
this.ID = ID;
}
public String getID() {
return this.ID;
}
private Course course = new Course();
public void setOperateSystemGrades(int operateSystemGrades) { //定义getter和setter方法，访问Course类属性operateSystemGrades
course.operateSystemGrades = operateSystemGrades;
}
public float getOperateSystemGrades() {
return course.operateSystemGrades;
}
public void setComputerNetworkGrades(int computerNetworkGrades) { //定义getter和setter方法，访问Course类属性computerNetworkGrades
course.computerNetworkGrades = computerNetworkGrades;
}
public float getComputerNetworkGrades() {
return course.computerNetworkGrades;
}
public void setDataStructureGrades(int dataStructureGrades) { //定义getter和setter方法，访问Course类属性dataStructureGrades
course.dataStructureGrades = dataStructureGrades;
}
public float getDataStructureGrades() {
return course.dataStructureGrades;
}
public void setDataBaseGrades(int dataBaseGrades) { //定义getter和setter方法，访问Course类属性dataBaseGrades
course.dataBaseGrades = dataBaseGrades;
}
public float getDataBaseGrades() {
return course.dataBaseGrades;
}
@Override
public String toString() { //重写toString()函数
return "Student:name=" + super.name + " ID=" + this.ID + " sex=" + this.sex + " age=" + this.age + " operateSystemGrades=" + course.operateSystemGrades + "分 computerNetworkGrades=" + course.computerNetworkGrades + "分 dataStructureGrades=" + course.dataStructureGrades + "分 dataBaseGrades=" + course.dataBaseGrades + "分";
}
}
- 封装
- 使用private关键词封装Student类属性，提供提供
getter和setter方法访问Student类属性。
- 使用private关键词封装Student类属性，提供提供
- 继承
class Student extends Person表示Student类继承自Person类。
- 重写
@Override
public String toString() { //重写toString()函数
return "Student:name=" + super.name + " ID=" + this.ID + " sex=" + this.sex + " age=" + this.age + " operateSystemGrades=" + course.operateSystemGrades + "分 computerNetworkGrades=" + course.computerNetworkGrades + "分 dataStructureGrades=" + course.dataStructureGrades + "分 dataBaseGrades=" + course.dataBaseGrades + "分";
}
- 重写tostring()函数
- 组合
private Course course = new Course();在Student类中实例化一个Course类，用于保存学生的课程成绩。
5.3 数组的使用情况
- 使用ArryList
保存Student类。 - 选择ArryList
是因为其具有线性结构，且增删查找操作简易，有高度集成接口。
5.4 测试用例
提供若干测试用例，展示系统的增、删、改、查功能及统计功能的测试情况
- 输入规范
- 姓名：String
- 学号：String
- 年龄：int
- 性别：String
- 课程成绩：float
- 系统增、删、改、查功能请具体操作。
六、提升与改进
6.1 本项目目前存在的问题
- Main类中的代码块有多段重复，模块化程度不高。
- 对学生信息的输入异常处理不完备（如学号位数、年龄区间等）
6.2 本项目可提升的空间
- 当前我们利用ArrayList存储创建的Student类，一旦程序停止运行，存储在内存中的信息会全部被清除。为了能够保留创建的包含Student类的ArrayList，我们可以将ArrayList写入到本地硬盘中，下次加载时将ArrayList读入程序即可实现数据的保留。或者可结合数据库做相应实现。
- 命令行界面有些简陋，可做适当的UI设计。
七、提交项目的完整代码清单
/*
Person类
*/
package Students_Information_Management;
class Person {
protected String name;
protected String sex;
protected int age;
protected void displayInfo() {
}
}
/*
Student类（继承自Person类）
*/
package Students_Information_Management;
class Student extends Person{
private String ID; //ID为子类属性，父类属性使用super访问,子类属性使用this引用。
public void setName(String name) { //定义getter和setter方法，访问父类属性
super.name = name;
}
public String getName() {
return super.name;
}
public void setSex(String sex) {
super.sex = sex;
}
public String getSex() {
return super.sex;
}
public void setAge(int age) {
super.age = age;
}
public int getAge() {
return super.age;
}
public void setID(String ID) { //定义getter和setter方法，访问子类属性
this.ID = ID;
}
public String getID() {
return this.ID;
}
private Course course = new Course();
public void setOperateSystemGrades(int operateSystemGrades) { //定义getter和setter方法，访问Course类属性operateSystemGrades
course.operateSystemGrades = operateSystemGrades;
}
public float getOperateSystemGrades() {
return course.operateSystemGrades;
}
public void setComputerNetworkGrades(int computerNetworkGrades) { //定义getter和setter方法，访问Course类属性computerNetworkGrades
course.computerNetworkGrades = computerNetworkGrades;
}
public float getComputerNetworkGrades() {
return course.computerNetworkGrades;
}
public void setDataStructureGrades(int dataStructureGrades) { //定义getter和setter方法，访问Course类属性dataStructureGrades
course.dataStructureGrades = dataStructureGrades;
}
public float getDataStructureGrades() {
return course.dataStructureGrades;
}
public void setDataBaseGrades(int dataBaseGrades) { //定义getter和setter方法，访问Course类属性dataBaseGrades
course.dataBaseGrades = dataBaseGrades;
}
public float getDataBaseGrades() {
return course.dataBaseGrades;
}
@Override
public String toString() { //重写toString()函数
return "Student:name=" + super.name + " ID=" + this.ID + " sex=" + this.sex + " age=" + this.age + " operateSystemGrades=" + course.operateSystemGrades + "分 computerNetworkGrades=" + course.computerNetworkGrades + "分 dataStructureGrades=" + course.dataStructureGrades + "分 dataBaseGrades=" + course.dataBaseGrades + "分";
}
}
/*
Course类：用于Student内的组合设计
*/
package Students_Information_Management;
class Course {
protected String operateSystem = "操作系统";
protected float operateSystemGrades = 0;
protected String computerNetwork = "计算机网络";
protected float computerNetworkGrades = 0;
protected String dataStructure = "数据结构";
protected float dataStructureGrades = 0;
protected String dataBase = "数据库";
protected float dataBaseGrades = 0;
}
/*
Statistics类：用于统计函数的汇总
*/
package Students_Information_Management;
import java.util.ArrayList;
class Statistics {
public static void averageGrades(ArrayList<Student> arrayList, int course) {
int len = arrayList.size();
float average = 0;
switch (course) {
case 1:
for(Student student : arrayList)
average += student.getOperateSystemGrades();
average = average / len;
System.out.println("OperateSystemGrades所有学生平均分为" + average);
break;
case 2:
for(Student student : arrayList)
average += student.getComputerNetworkGrades();
average = average / len;
System.out.println("ComputerNetworkGrades所有学生平均分为" + average);
break;
case 3:
for(Student student : arrayList)
average += student.getDataStructureGrades();
average = average / len;
System.out.println("DataStructureGrades所有学生平均分为" + average);
break;
case 4:
for(Student student : arrayList)
average += student.getDataBaseGrades();
average = average / len;
System.out.println("DataBaseGrades所有学生平均分为" + average);
break;
}
}
public static void maxAndMinGrades(ArrayList<Student> arrayList, int course) {
float max = 0, min = 0;
switch (course) {
case 1:
min = arrayList.getFirst().getOperateSystemGrades();
for(Student student : arrayList) {
if(student.getOperateSystemGrades() > max)
max = student.getOperateSystemGrades();
if (student.getOperateSystemGrades() < min)
min = student.getOperateSystemGrades();
}
System.out.println("OperateSystemGrades的最高分为：" + max + " ，最低分为：" + min + "。");
break;
case 2:
min = arrayList.getFirst().getComputerNetworkGrades();
for(Student student : arrayList) {
if(student.getComputerNetworkGrades() > max)
max = student.getComputerNetworkGrades();
if (student.getComputerNetworkGrades() < min)
min = student.getComputerNetworkGrades();
}
System.out.println("ComputerNetworkGrades的最高分为：" + max + " ，最低分为：" + min + "。");
break;
case 3:
min = arrayList.getFirst().getDataStructureGrades();
for(Student student : arrayList) {
if(student.getDataStructureGrades() > max)
max = student.getDataStructureGrades();
if (student.getDataStructureGrades() < min)
min = student.getDataStructureGrades();
}
System.out.println("DataStructureGrades的最高分为：" + max + " ，最低分为：" + min + "。");
break;
case 4:
min = arrayList.getFirst().getDataBaseGrades();
for(Student student : arrayList) {
if(student.getDataBaseGrades() > max)
max = student.getDataBaseGrades();
if (student.getDataBaseGrades() < min)
min = student.getDataBaseGrades();
}
System.out.println("DataBaseGrades的最高分为：" + max + " ，最低分为：" + min + "。");
break;
}
}
public static void printNameAndGrades(ArrayList<Student> arrayList) {
System.out.println("姓名 OperateSystemGrades ComputerNetworkGrades DataStructureGrades DataBaseGrades");
for (Student student : arrayList)
System.out.println(student.getName() + " " + student.getOperateSystemGrades() + " " + student.getComputerNetworkGrades() + " " + student.getDataStructureGrades() + " " + student.getDataBaseGrades());
}
}
/*
Main类：命令行控制，实现学生信息管理系统
*/
package Students_Information_Management;
import java.util.Objects;
import java.util.Scanner;
import java.io.IOException;
import java.util.ArrayList;
public class Main {
public static void main(String[] args) throws InterruptedException {
ArrayList<Student> studentManager = new ArrayList<Student>();
while(true) {
int select = 0;
System.out.println("（1）添加学生信息\n（2）查询学生信息\n（3）删除学生信息\n（4）修改学生信息\n（5）统计成绩信息\n（6）退出程序\n请输入您的操作选项：");
Scanner scan = new Scanner(System.in); //利用scanner读取用户输入
if(scan.hasNextInt()) { //判断输入是否是一个合法整数,**属于异常处理**
select = scan.nextInt();
}
else {
System.err.println("输入错误，请重新选择！");
continue;
}
if(select == 1) {
Student newstudent = new Student();
System.out.println("请输入待添加的学生姓名：");
Scanner scan11 = new Scanner(System.in);
String info11 = scan11.next();
newstudent.setName(info11);
System.out.println("请输入" + newstudent.getName() + "的学号：");
Scanner scan12 = new Scanner(System.in);
String info12 = scan12.next();
newstudent.setID(info12);
System.out.println("请输入" + newstudent.getName() + "的性别：");
Scanner scan13 = new Scanner(System.in);
String info13 = scan13.next();
newstudent.setSex(info13);
System.out.println("请输入" + newstudent.getName() + "的年龄：");
Scanner scan14 = new Scanner(System.in);
if(scan14.hasNextInt()) { //判断输入是否是一个合法整数,**属于异常处理**
int info14 = scan14.nextInt();
newstudent.setAge(info14);
}
else {
System.err.println("输入错误，请重新选择！");
continue;
}
System.out.println("是否需要添加学生成绩信息？（请输入T/F）");
char scan15 = '0';
try {
scan15 = (char)System.in.read();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(scan15 == 'T') { //输入学生成绩信息
System.out.println("请输入" + newstudent.getName() + "的operateSystemGrades：");
Scanner scan16 = new Scanner(System.in);
int info16 = scan16.nextInt();
newstudent.setOperateSystemGrades(info16);
System.out.println("请输入" + newstudent.getName() + "的computerNetworkGrades：");
Scanner scan17 = new Scanner(System.in);
int info17 = scan17.nextInt();
newstudent.setComputerNetworkGrades(info17);
System.out.println("请输入" + newstudent.getName() + "的dataStructureGrades：");
Scanner scan18 = new Scanner(System.in);
int info18 = scan18.nextInt();
newstudent.setDataStructureGrades(info18);
System.out.println("请输入" + newstudent.getName() + "的dataBaseGrades：");
Scanner scan19 = new Scanner(System.in);
int info19 = scan19.nextInt();
newstudent.setDataBaseGrades(info19);
studentManager.add(newstudent);
}
else {
studentManager.add(newstudent);
continue;
}
}
else if(select == 2) {
System.out.println("请输入待查询学生姓名：");
Scanner scan21 = new Scanner(System.in);
String info21 = scan21.next();
int flag1 = 0; //做个标记
for(Student student : studentManager) {
if(Objects.equals(student.getName(), info21)) {
flag1++; //遍历后如果找到了就给个标记
System.out.println(student.toString());
Thread.sleep(2000); //输出信息后延迟两秒再进入下一循环
break;
}
}
if(flag1 == 0) //证明没找到
System.out.println("学生"+ info21 + "信息不存在。");
}
else if(select == 3) {
System.out.println("请输入待删除学生的姓名：");
Scanner scan31 = new Scanner(System.in);
String info31 = scan31.next();
int flag2 = 0;
for(Student student : studentManager) {
if(Objects.equals(student.getName(), info31)) {
flag2++;
studentManager.remove(student);
System.out.println(info31 + "信息已被删除！");
}
}
if(flag2 == 0)
System.out.println("学生不存在！");
}
else if(select == 4) {
System.out.println("请输入待修改学生的姓名：");
Scanner scan41 = new Scanner(System.in);
String info41 = scan41.next();
int flag3 = 0;
for(Student student : studentManager) {
if(Objects.equals(student.getName(), info41)) {
flag3++;
while(true){
int flag4 = 0;
System.out.println("请选择您想修改的" + info41 + "的信息");
System.out.println("（1）姓名\n（2）学号\n（3）性别\n（4）年龄\n（5）OperateSystemGrades\n（6）ComputerNetworkGrades\n（7）DataStructureGrades\n（8）DataBaseGrades\n（9）退出");
Scanner scan42 = new Scanner(System.in);
int info42 = scan42.nextInt();
switch (info42) {
case 1:
String temp1 = student.getName();
System.out.println("请输入修改后学生的姓名：");
Scanner scan43 = new Scanner(System.in);
String info43 = scan43.next();
student.setName(info43);
System.out.println(temp1 + "的姓名已改为" + student.getName());
info41 = info43;
break;
case 2:
String temp2 = student.getID();
System.out.println("请输入修改后学生的学号：");
Scanner scan44 = new Scanner(System.in);
String info44 = scan44.next();
student.setID(info44);
System.out.println(info41 + "的学号已由" + temp2 + "改为" + student.getID());
break;
case 3:
String temp3 = student.getSex();
System.out.println("请输入修改后学生的性别：");
Scanner scan45 = new Scanner(System.in);
String info45 = scan45.next();
student.setID(info45);
System.out.println(info41 + "的性别已由" + temp3 + "改为" + student.getSex());
break;
case 4:
int temp4 = student.getAge();
System.out.println("请输入修改后学生的年龄：");
Scanner scan46 = new Scanner(System.in);
int info46 = scan46.nextInt();
student.setAge(info46);
System.out.println(info41 + "的年龄已由" + temp4 + "改为" + student.getAge());
break;
case 5:
float temp5 = student.getOperateSystemGrades();
System.out.println("请输入修改后学生的OperateSystemGrades：");
Scanner scan47 = new Scanner(System.in);
int info47 = scan47.nextInt();
student.setOperateSystemGrades(info47);
System.out.println(info41 + "的OperateSystemGrades已由" + temp5 + "改为" + student.getOperateSystemGrades());
break;
case 6:
float temp6 = student.getComputerNetworkGrades();
System.out.println("请输入修改后学生的ComputerNetworkGrades：");
Scanner scan48 = new Scanner(System.in);
int info48 = scan48.nextInt();
student.setComputerNetworkGrades(info48);
System.out.println(info41 + "的ComputerNetworkGrades已由" + temp6 + "改为" + student.getComputerNetworkGrades());
break;
case 7:
float temp7 = student.getDataStructureGrades();
System.out.println("请输入修改后学生的DataStructureGrades：");
Scanner scan49 = new Scanner(System.in);
int info49 = scan49.nextInt();
student.setDataStructureGrades(info49);
System.out.println(info41 + "的DataStructureGrades已由" + temp7 + "改为" + student.getDataStructureGrades());
break;
case 8:
float temp8 = student.getDataBaseGrades();
System.out.println("请输入修改后学生的DataBaseGrades：");
Scanner scan410 = new Scanner(System.in);
int info410 = scan410.nextInt();
student.setDataStructureGrades(info410);
System.out.println(info41 + "的DataBaseGrades已由" + temp8 + "改为" + student.getDataBaseGrades());
break;
case 9:
flag4++;
break;
default:
System.out.println("输入选择错误，请重新输入！");
break;
}
if(flag4 == 1)
break;
}
}
}
if (flag3 == 0)
System.out.println("学生不存在！");
}
else if(select == 5) {
while (true) {
int flag5 = 0;
System.out.println("请选择您将统计的信息：");
System.out.println("（1）平均分\n（2）最高/最低分\n（3）所有学生的各门课程成绩汇总\n（4）退出");
Scanner scan51 = new Scanner(System.in);
if (scan51.hasNextInt()) {
int info51 = scan51.nextInt();
switch (info51) {
case 1: //计算平均分
while(true) {
System.out.println("请选择您想查询平均分的课程：");
System.out.println("（1）OperateSystemGrades\n（2）ComputerNetworkGrades\n（3）DataStructureGrades\n（4）DataBaseGrades\n（5）退出查询");
Scanner scan52 = new Scanner(System.in);
if (scan52.hasNextInt()) {
int info52 = scan52.nextInt();
if (info52 < 1 || info52 > 5) {
System.out.println("输入选择错误，请重新选择！");
continue;
}
if(info52 == 5)
break;
if (studentManager.isEmpty() || studentManager == null) {
System.out.println("表中暂无学生信息！");
break;
}
Statistics.averageGrades(studentManager, info52); //调用计算均值函数
}
else {
System.err.println("输入选择错误，请重新选择！");
}
}
break;
case 2: // 每门课的最高/最低分
while(true) {
System.out.println("请选择您想查询最高/最低分的课程：");
System.out.println("（1）OperateSystemGrades\n（2）ComputerNetworkGrades\n（3）DataStructureGrades\n（4）DataBaseGrades\n（5）退出查询");
Scanner scan53 = new Scanner(System.in);
if (scan53.hasNextInt()) {
int info53 = scan53.nextInt();
if (info53 < 1 || info53 > 5) {
System.out.println("输入选择错误，请重新选择！");
continue;
}
if(info53 == 5)
break;
if (studentManager.isEmpty() || studentManager == null) {
System.out.println("表中暂无学生信息！");
break;
}
Statistics.maxAndMinGrades(studentManager, info53); //调用计算最高/最低分函数
}
else {
System.err.println("输入选择错误，请重新选择！");
}
}
break;
case 3: //成绩汇总打印
Statistics.printNameAndGrades(studentManager);
case 4:
flag5++;
break;
default:
System.out.println("输入选择错误，请重新输入！");
break;
}
if(flag5 == 1)
break;
}
else {
System.err.println("输入选择错误，请重新选择！");
continue;
}
}
}
else if(select == 6) {
System.exit(0);
}
}
}
}
浙公网安备 33010602011771号