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

✅作者简介：大家好，我是小鱼儿，大家可以叫我鱼儿

📒博客首页：是小鱼儿哈

🔥系列专栏：JavaSE学习笔记

🌻每日一句：尽管我们越来越现实，但是请不要忘记我们最初的梦想

💖博主也在学习阶段，如发现问题请告知，非常感谢💖

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

传送门：图书管理系统的的实现（超详细）

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

一、效果展示

** 🌰新增学生信息**

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

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

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

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

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

** 🌰退出系统**

二、代码实现

🌻主函数（程序的入口）

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代码地址：学生管理小系统练习https://gitee.com/shen-xiao-yu/java104/tree/master/20220503/src** 结尾絮絮念：**

在实践的时候才发现自己对很多知识只是表面上懂了，并不是真正理解了。

大家一定要多实践，把知识尝试着用起来呀！！！