学生成绩管理系统的模拟实现（java基础实战）

- 日理万妓 2024-04-23 15:37 5阅读 0赞

> ✅作者简介：大家好，我是小鱼儿，大家可以叫我鱼儿
> 
> 📒博客首页：[是小鱼儿哈][Link 1]
> 
> 🔥系列专栏：[JavaSE学习笔记][JavaSE]
> 
> 🌻每日一句：**尽管我们越来越现实，但是请不要忘记我们最初的梦想**
> 
> 💖博主也在学习阶段，如发现问题请告知，非常感谢💖

**目录**

一、效果展示

二、代码实现

🌻主函数（程序的入口）

🌻学生信息储存包

🌻学生对象操作包

--------------------

关于该系统的很多细节我们在之前的博客已经讲过，这里不再赘叙

> **传送门**：[图书管理系统的的实现（超详细）][Link 2]

**一起来看看这个系统的效果吧**！

## 一、效果展示 ##

**🌰新增学生信息**

![acb6bf8e8161475092ea9c325107e9ca.png][]

**🌰按姓名对学生的信息进行查找**

![ace54c44dd1f44a5b3bb4ccb99a72bd0.png][]

🌰**按学号修改某一学生的信息**

![b49f018d057648618f290bcbd06197e9.png][]

🌰**按学号删除某一学生的全部信息**

![e5663303b950442f8a2c2070c394ae53.png][]

🌰**按总成绩对学生对象进行排序**

![93a19c5b69d0481eb60231d9970ba124.png][]

🌰**输出不及格的学生对象信息**

![bb5659b93f0e439f87b4a51db6d933c6.png][]

**🌰退出系统**

![8608836c177e4d02a8af9538ec039e71.png][]

--------------------

## 二、代码实现 ##

### 🌻主函数（程序的入口） ###

import Operation.*;
    import Operation.studentChange;
    import student.StudentList;
    
    import java.util.Scanner;
    import Operation.ioOPerate;
    public class Main {
        public static void main(String[] args) {
            System.out.println("欢迎来到学生成绩管理系统");
            System.out.println("========================");
            System.out.println("0.添加学生信息");
            System.out.println("1.打印所有学生的信息");
            System.out.println("2.按姓名查找该学生的信息");
            System.out.println("3.按学号修改某一学生的成绩信息");
            System.out.println("4.按学号删除某一学生的全部信息");
            System.out.println("5.按学生总成绩进行进行升序排列");
            System.out.println("6.按科目输出不及格的学生信息");
            System.out.println("7.退出系统");
            System.out.println("=========================");
            StudentList studentList = new StudentList();
            // 这里相等于接口引用引用了不同的子类对象，发生了向上转型
            ioOPerate[] ioOperation = new ioOPerate[] {  // 对接口数组进行赋值，分别指向不同的实例化操作对象
                    new AddStudent(),                   // 这样我们就可以按下标对学生对象进行不同的操作
                    new printAll(),
                    new studentFind(),
                    new studentChange(),
                    new studentDelete(),
                    new studentSort(),
                    new flunkPrint(),
                    new exitOperation(),
            };
            while (true) {
                System.out.print("请输入你的操作：");
                Scanner sc  = new Scanner(System.in);
                int choice = sc.nextInt();
                // 体现了多态
                ioOperation[choice].work(studentList);  // work是一个被子类重写的方法，会根据当前接口对象ioOperation的不同引用来进行不同的操作
                // 接口就相等于是父类，子类实现接口就相当于是子类继承了父类
                // 多态的条件：1.有继承（实现）关系   2.父类引用（接口引用）引用子类对象（向上转型） 3.子类对象对父类（接口中的方法进行了重写）
            }
        }
    }

### **🌻学生信息储存包** ###

> **这个包有两个类，一个包含单个学生的所有属性的学生类，另一个是学生对象的集合类**

Student类

/**
     * 学生类，里面一个学生的所有属性
     */
    package student;
    // 因为要比较Student类型的引用变量，所以要实现Comparable接口
    public class Student implements Comparable<Student> {
        private long studentId;
        private String name;
        private double cGrade;
        private double dataStructureGrade;
        // 构造方法对学生的各个属性进行初始化
        public Student(long studentId, String name, double cGrade, double dataStructureGrade) {
            this.studentId = studentId;
            this.name = name;
            this.cGrade = cGrade;
            this.dataStructureGrade = dataStructureGrade;
        }
        // 对父类Object的toString方法进行重写，以便接下来对Arrays.toString(students)可以直接打印出数组中各个引用对象的值
        @Override
        public String toString() {
            return "Student{" +
                    "studentId=" + studentId +
                    ", name='" + name + '\'' +
                    ", cGrade=" + cGrade +
                    ", dataStructureGrade=" + dataStructureGrade +
                    '}';
        }
        // 重写Comparable接口中的compareTo方法，按总成绩进行比较
        @Override
        public int compareTo(Student o) {
            return (int)((this.cGrade + this.dataStructureGrade) - (o.cGrade + o.dataStructureGrade));
        }
    
        // 修改指定学生的信息
        public void studentChange(long studentId, String name, double cGrade, double dataStructureGrade) {
            System.out.println("将学生" + this.name + "的姓名修改为：" + name);
            this.name = name;
            System.out.println("学号从" + this.studentId + "修改为：" + studentId);
            this.studentId = studentId;
            System.out.println("c语言成绩从" + this.cGrade + "修改为：" + cGrade);
            this.cGrade = cGrade;
            System.out.println("数据结构成绩从" + this.dataStructureGrade + "修改为：" + dataStructureGrade);
            this.dataStructureGrade = dataStructureGrade;
            System.out.println("恭喜，修改成功！");
        }
    
        public long getStudentId() {
            return studentId;
        }
    
        public void setStudentId(long studentId) {
            this.studentId = studentId;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getcGrade() {
            return cGrade;
        }
    
        public void setcGrade(double cGrade) {
            this.cGrade = cGrade;
        }
    
        public double getDataStructureGrade() {
            return dataStructureGrade;
        }
    
        public void setDataStructureGrade(double dataStructureGrade) {
            this.dataStructureGrade = dataStructureGrade;
        }
    }

StudentList类

/**
     * 里面存放了一群学生的信息，是学生对象的一个集合，我们对学生系统的操作主要围绕这个StudentList类来展开
     */
    package student;
    // 进行导包操作
    import java.util.Scanner;
    
    public class StudentList {
        private int usedSize;
    
        public int getUsedSize() {
            return usedSize;
        }
    
        public void setUsedSize(int usedSize) {
            this.usedSize = usedSize;
        }
    
        public Student[] getStudents() {
            return students;
        }
        // 打印指定下标的学生对象
        public void printStudent(int pos) {
            System.out.println(students[pos]);
        }
        // 获取指定下标的图书
        public Student getStudent(int pos) {
            return students[pos];
        }
        // 在数组的指定位置放置图书
        public void setStudent(int pos, Student student) {
            students[pos] = student;
        }
    
        // 初始化学生数组
        private Student[] students = new Student[10];
        public StudentList() {
            students[0] = new Student(12345, "张三", 76, 92);
            students[1] = new Student(12346, "李四", 86, 67);
            students[2] = new Student(12347, "王五", 64, 99);
            usedSize = 3;
        }
    
        // 删除数组中的某一个元素
        public void delete() {
            // 删除学生信息
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入你要删除的学生的学号：");
            long id = sc.nextLong();
            if (students[usedSize - 1].getStudentId() == id) {
                --usedSize;  // 当删除的是数组结尾的值时，要特殊处理
                System.out.println("恭喜，删除成功！！！");
                return;
            }
            for (int i = 0; i < usedSize; i++) {
                if (students[i].getStudentId() == id) {
                    for (int j = i + 1; j < usedSize; j++) {
                        students[j - 1] = students[j];
                    }
                    --usedSize;
                    System.out.println("恭喜，删除成功！！！");
                    return;
                }
            }
            System.out.println("删除失败，没有找到该学生！！！");
        }
    
    }

### 🌻学生对象操作包 ###

>   
> **这个包里主要是对一些具体的各种操作**

ioOperation接口

>     package Operation;
>     
>     import student.Student;
>     import student.StudentList;
>     // 这是一个接口，其中的work抽象方法被实现该接口的不同子类所重写，实现了多态
>     // 接口就相等于是父类，子类实现接口就相当于是子类继承了父类
>     // 多态的条件：1.有继承（实现）关系   2.父类引用（接口引用）引用子类对象（向上转型） 3.子类对象对父类（接口中的方法进行了重写）
>     public abstract interface ioOPerate {
>         public abstract void work(StudentList studentList);
>     }

添加学生信息

>     package Operation;
>     
>     import student.Student;
>     import student.StudentList;
>     
>     import java.util.Scanner;
>     
>     public class AddStudent implements ioOPerate{ // 实现ioOperation接口
>         @Override // 对接口中的抽象方法 work 进行重写
>         public void work(StudentList studentList) {
>             if (studentList.getUsedSize() > 10) {
>                 System.out.println("添加失败，系统中无法再添加学生了，需要扩容！！！");
>                 return;
>             }
>             Scanner sc = new Scanner(System.in);
>             System.out.println("请输入你要增加的学生的学号");
>             long studentId = sc.nextLong();
>             System.out.println("请输入你要增加的学生的姓名");
>             String name = sc.next();
>             System.out.println("请输入你要增加的学生的c语言成绩");
>             double cGrade = sc.nextDouble();
>             System.out.println("请输入你要增加的学生的数据结构的成绩");
>             double dataStructureGrade = sc.nextDouble();
>     
>             Student student = new Student(studentId, name, cGrade, dataStructureGrade);
>             studentList.setStudent(studentList.getUsedSize(), student); // 默认在数组的最后新增图书
>             studentList.setUsedSize(studentList.getUsedSize() + 1);
>             System.out.println("恭喜，添加成功！！！");
>         }
>     }

显示所有学生的信息

>     package Operation;
>     
>     import student.Student;
>     import student.StudentList;
>     
>     import java.util.Arrays;
>     
>     // 将所以学生的信息打印出来
>     public class printAll implements ioOPerate{
>     
>         @Override
>         public void work(StudentList studentList) {
>             // 打印所有学生的信息
>             System.out.println("此时的的学生信息为：");
>             for (int i = 0; i < studentList.getUsedSize(); i++) {
>                 studentList.printStudent(i);
>             }
>         }
>     }

按姓名查找指定学生的信息

>     package Operation;
>     
>     import student.Student;
>     import student.StudentList;
>     
>     import java.util.Scanner;
>     
>     public class studentFind implements ioOPerate{
>         @Override
>         public void work(StudentList studentList) {
>             // 打印指定学生的信息
>     
>             // 根据学生姓名进行打印
>             Scanner sc = new Scanner(System.in);
>             System.out.println("请输入你要查找的学生的姓名：");
>             String nameFind = sc.nextLine();
>     
>             for (int i = 0; i < studentList.getUsedSize(); i++) {
>                 if (studentList.getStudents()[i].getName().equals(nameFind)) {
>                     System.out.println("学号：" + studentList.getStudents()[i].getStudentId() + "  姓名：" + studentList.getStudents()[i].getName());
>                     System.out.println("c语言成绩：" + studentList.getStudents()[i].getcGrade() + "  数据结构成绩：" + studentList.getStudents()[i].getDataStructureGrade());
>                     return;
>                 }
>             }
>             System.out.println("没有找到该学生！！！");
>         }
>     }

按学号修改指定的学生信息

>     package Operation;
>     
>     import student.Student;
>     import student.StudentList;
>     
>     import java.util.Scanner;
>     
>     // 修改学生信息
>     public class studentChange implements ioOPerate{
>         @Override
>         public void work(StudentList studentList) {
>             // 按学号修改学生信息
>             Scanner sc = new Scanner(System.in);
>             System.out.println("请输入你要修改的学生的学号：");
>             long id = sc.nextLong();
>             for (int i = 0; i < studentList.getUsedSize(); i++) {
>                 if (studentList.getStudents()[i].getStudentId() == id) {
>                     System.out.println("请输入修改后的姓名：");
>                     String name = sc.next();
>                     System.out.println("请输入修改后的学号：");
>                     long studentId = sc.nextLong();
>                     System.out.println("请输入修改后的c语言分数：");
>                     double cGrade = sc.nextDouble();
>                     System.out.println("请输入修改后的数据结构的分数：");
>                     double dateStructureGrade = sc.nextDouble();
>                     studentList.getStudents()[i].studentChange(studentId, name, cGrade, dateStructureGrade);
>                     return;
>                 }
>             }
>             System.out.println("修改失败，系统里没有该学生！！！");
>         }
>     }

按学号删除指定学生的信息

>     package Operation;
>     
>     import student.Student;
>     import student.StudentList;
>     
>     import java.util.Scanner;
>     
>     public class studentDelete implements ioOPerate{
>         @Override
>         public void work(StudentList studentList) {
>             // 删除学生信息
>             Scanner sc = new Scanner(System.in);
>             System.out.println("请输入你要删除的学生的学号：");
>             long id = sc.nextLong();
>             if (studentList.getStudents()[studentList.getUsedSize() - 1].getStudentId() == id) {
>                 studentList.setStudent(studentList.getUsedSize(), null);  // 当删除的是数组结尾的值时，要特殊处理
>                 studentList.setUsedSize(studentList.getUsedSize() - 1);
>                 System.out.println("恭喜，删除成功！！！");
>                 return;
>             }
>             for (int i = 0; i < studentList.getUsedSize(); i++) {
>                 if (studentList.getStudents()[i].getStudentId() == id) {
>                     for (int j = i + 1; j < studentList.getUsedSize(); j++) {
>                         Student student = studentList.getStudent(j);
>                         studentList.setStudent(j - 1, student);
>                     }
>                     studentList.setUsedSize(studentList.getUsedSize() - 1);
>                     System.out.println("恭喜，删除成功！！！");
>                     return;
>                 }
>             }
>             System.out.println("删除失败，没有找到该学生！！！");
>         }
>     }

按学生总成绩进行对学生进行升序排序

>     package Operation;
>     
>     import student.Student;
>     import student.StudentList;
>     
>     import java.util.Arrays;
>     
>     public class studentSort implements ioOPerate{
>         @Override
>         public void work(StudentList studentList) {
>             System.out.println("正在按总成绩对学生进行排序~~~");
>             Arrays.sort(studentList.getStudents(), 0, studentList.getUsedSize());
>             System.out.println("恭喜，排序成功！！！");
>         }
>     }

输出不及格的学生信息

>     package Operation;
>     
>     import student.Student;
>     import student.StudentList;
>     
>     import java.util.Arrays;
>     
>     // 对不及格学生的打印
>     public class flunkPrint implements ioOPerate{
>         @Override
>         public void work(StudentList studentList) {
>             for (int i = 0; i < studentList.getUsedSize(); i++) {
>                 if (studentList.getStudents()[i].getcGrade() < 60 || studentList.getStudents()[i].getDataStructureGrade() < 60) {
>                     studentList.printStudent(i);
>                 }
>             }
>         }
>     }

退出系统

>     package Operation;
>     
>     import student.Student;
>     import student.StudentList;
>     
>     public class exitOperation implements ioOPerate{
>         @Override
>         public void work(StudentList studentList) {
>             System.out.println("正在退出系统");
>             for (int i = 0; i < studentList.getUsedSize(); i++) {
>                 studentList.setStudent(i, null);
>             }
>             System.out.println("退出成功！");
>             System.exit(0);
>         }
>     }

**gitee代码地址：**[学生管理小系统练习![icon-default.png_t_M3K6][]https://gitee.com/shen-xiao-yu/java104/tree/master/20220503/src][icon-default.png_t_M3K6_https_gitee.com_shen-xiao-yu_java104_tree_master_20220503_src] **结尾絮絮念：**

> **在实践的时候才发现自己对很多知识只是表面上懂了，并不是真正理解了。**
> 
> **大家一定要多实践，把知识尝试着用起来呀！！！**

![138c1ebdd74e4f3b90ff7414ab1cac04.png][]

[Link 1]: https://blog.csdn.net/weixin_61061381?type=blog
[JavaSE]: https://blog.csdn.net/weixin_61061381/category_11724948.html?spm=1001.2014.3001.5482
[Link 2]: https://blog.csdn.net/weixin_61061381/article/details/124170383
[acb6bf8e8161475092ea9c325107e9ca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/378cdf9fb7c948b98abb19f36440a908.png
[ace54c44dd1f44a5b3bb4ccb99a72bd0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/cbb0679a063242a9bc500e32aba1bf1e.png
[b49f018d057648618f290bcbd06197e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/c2c34bb29d2c495a975fbcd06ad4686c.png
[e5663303b950442f8a2c2070c394ae53.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/eafbd509e4f640949dc42d6cbfb8325a.png
[93a19c5b69d0481eb60231d9970ba124.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/8afaf8a3ab634f4eade747f566ef3356.png
[bb5659b93f0e439f87b4a51db6d933c6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/5ab0f08d1b5a48ecb8bef04ecc8b814b.png
[8608836c177e4d02a8af9538ec039e71.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/89356207372d4f8db58536411c0a6eca.png
[icon-default.png_t_M3K6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/577f031b46c84ef082e4e516514339b6.png
[icon-default.png_t_M3K6_https_gitee.com_shen-xiao-yu_java104_tree_master_20220503_src]: https://gitee.com/shen-xiao-yu/java104/tree/master/20220503/src
[138c1ebdd74e4f3b90ff7414ab1cac04.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/9396d7af592048be9fc7b21509444da9.png