学生信息系统-优快云博客

本文链接：https://blog.youkuaiyun.com/jbbsubsi/article/details/131366155

该代码示例展示了一个基于Java实现的学生信息管理系统，包括School、Class和Student实体类，以及User类。系统提供了登录、注册、查询、删除和添加学院、班级、学生等功能。此外，还包括一个User类用于用户登录和密码修改。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

学生信息管理系统

实体类

School类

public class School {
    Integer SchoolId;   //学院编号
    String SchoolName;  //学院名称
    String SchoolClass;  //专业

    @Override
    public String toString() {
        return "\t\t学院编号：" + SchoolId +
                "\t\t学院名称：" + SchoolName +
                "\t\t专业：" + SchoolClass;

    }

    public School(Integer schoolId, String schoolName, String schoolClass) {
        SchoolId = schoolId;
        SchoolName = schoolName;
        SchoolClass = schoolClass;
    }

    public Integer getSchoolId() {
        return SchoolId;
    }

    public void setSchoolId(Integer schoolId) {
        SchoolId = schoolId;
    }

    public String getSchoolName() {
        return SchoolName;
    }

    public void setSchoolName(String schoolName) {
        SchoolName = schoolName;
    }

    public String getSchoolClass() {
        return SchoolClass;
    }

    public void setSchoolClass(String schoolClass) {
        SchoolClass = schoolClass;
    }
}

Class类

public class Class {
    int ClassId;  //班级编号
    String ClassName;  //班级名
    School school;  //学院对象

    public Class(int ClassId, String className,  School school) {
        this.ClassId = ClassId;
        ClassName = className;

        this.school = school;
    }

    public int getId() {
        return ClassId;
    }

    public void setId(int id) {
        this.ClassId = id;
    }

    public String getClassName() {
        return ClassName;
    }

    public void setClassName(String className) {
        ClassName = className;
    }



    public School getSchool() {
        return school;
    }

    public void setSchool(School school) {
        this.school = school;
    }

    @Override
    public String toString() {
        return
                "\t\t班级编号：" + ClassId +
                "\t\t班级名：" + ClassName +
                "\t\t" + school ;
    }
}

Student类

public class Student {

    int StudentId;//学生id
    String name;//学生姓名

    int age;//年龄


    Class aClass;//所属班级

    public Student(int id, String name, int age, Class aClass) {
        this.StudentId = id;
        this.name = name;
        this.age = age;
        this.aClass = aClass;
    }

    public int getId() {
        return StudentId;
    }

    public void setId(int id) {
        this.StudentId = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Class getaClass() {
        return aClass;
    }

    public void setaClass(Class aClass) {
        this.aClass = aClass;
    }

    @Override
    public String toString() {
        return
                "学生id：" + StudentId +
                        "\t\t姓名：" + name +
                        "\t\t年龄：" + age +
                        "\t\t" + aClass;
    }
}

User类

public class User {

    private  String name;
    private  String password;

    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }



    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

service

public class StudentService {
    //    用泛型定义一个list 保存User、school、class、students信息
    List<User> listUser = new ArrayList<>();
    List<School> ListSchools = new ArrayList<>();
    List<Class> ListClasses = new ArrayList<>();

    List<Student> ListStudents = new ArrayList<>();

    //保存姓名查找的学生信息

//    实例化三个类   用来存储每一个对象
    School school;
    Class aClass;
    Student student;
    //初始化列表信息
    User user;
    //定义整形数组保存下标



    //无参构造函数 初始化列表 及user 、school、class、student
    public StudentService() {
        user = new User("张三", "123456");
        school = new School(21, "数计", "计算机");
        aClass = new Class(221, "计算机2202", school);
        student = new Student(2201, "张三", 18, aClass);
        ListSchools.add(school);
        ListClasses.add(aClass);
        ListStudents.add(student);
        listUser.add(user);

    }


    //登录
    public User login(String name, String password) {
//        循环遍历存放user信息的集合 将每个user 赋给未初始化值的user
        for (User value : listUser) {
//            如果密码和用户名 相等 返回user
            user = value;
            if (name.equals(user.getName()) && password.equals(user.getPassword())) {
                return user;
            }
        }
//        如果没有返回空
        return null;
    }

    //注册
    public void register(User newUser) {
//        将返回的user对象加入到user集合中
        listUser.add(newUser);
    }

    //密码修改
    public void updatePassword(User newUser, String password) {
    //循环遍历存放user信息的集合 将每个user 赋给未初始化值的user
        for (User value : listUser) {
            user = value;
//            如果传过来的对象 和数组中对象想等 设置新密码
            if (user.equals(newUser)) {
                user.setPassword(password);
            }
        }
    }


    //根据id查找学院
    public School findBySchoolId(int id) {
//        for循环遍历school集合将集合中的对象依次赋给school对象
        for (School listSchool : ListSchools) {
            school = listSchool;
//            for循环遍历id 如果相等 返回school
            if (school.getSchoolId() == id) {
                return school;
            }
        }
        return null;
    }

    //根据id查找班级
    public Class findByClassId(int id) {
//        for循环遍历class集合 将数据赋给class 对象 并判断id是否相等
        for (Class listClass : ListClasses) {
            aClass = listClass;
            System.out.println("26752137"+aClass);
            if (aClass.getId() == id) {
//                相等返回class
                return aClass;
            }
        }
        return null;
    }

    //根据id查找学生
    public Student findByStudentId(int id) {
//        for 循环遍历集合 查找id对应的对象
        for (Student listStudent : ListStudents) {
            student = listStudent;
            if (student.getId() == id) {
                return student;
            }
        }
        return null;
    }

    //根据姓名查找学生
    public List<Student> findByStudentName(String name) {
        List<Student> findByName = new ArrayList<>();
        //清空集合
		findByName=new ArrayList<>();
        //        for 循环遍历集合 查找name对应的对象
        for (Student listStudent : ListStudents) {
            student = listStudent;
            if (student.getName().equals(name)) {
                findByName.add(student);
            }
        }
        return findByName;
    }

    //根据班级查找学生
    public List<Student> findByClass(Class aClasss) {
        //保存用班级查找的学生信息
        List<Student> findByClass = new ArrayList<>();
		findByClass=new ArrayList<>();
        //        for 循环遍历集合 查找class 对象对应的对象
        for (Student listStudent : ListStudents) {
            //将学生集合的每一个得到的班级对象 赋给aclass
            aClass = listStudent.getaClass();
            //如果aclass对象相等
            if (aClass == aClasss) {
                //将集合当前的数据添加到列表中
                findByClass.add(listStudent);
            }
        }
        return findByClass;
    }

    //根据学院查找学生
    public List<Student> findBySchool(School newSchool) {
        //保存学院查找的学生信息
        List<Student> findBySchool = new ArrayList<>();
		findBySchool=new ArrayList<>();
        for (Student listStudent : ListStudents) {
//            for 循环遍历集合 查找school 对象对应的对象
            school = listStudent.getaClass().getSchool();
            if (school == newSchool) {
                findBySchool.add(listStudent);
            }
        }
        return findBySchool;
    }

    //学院删除
    public void schoolDelete(int id) {
//        for 循环遍历集合 查找id对应的对象
        for (int i = 0; i < ListSchools.size(); i++) {
            school = ListSchools.get(i);
//            如果存在调用remove方法 删除 school内容
            if (school.getSchoolId() == id) {
                ListSchools.remove(i);
                i--;
            }
        }
        for (int i = 0; i < ListClasses.size(); i++) {
            aClass = ListClasses.get(i);
//            for 循环遍历集合 查找id对应的对象
            if (aClass.getSchool().getSchoolId() == id) {
                //            如果存在调用remove方法 删除class 内容
                ListClasses.remove(i);
                i--;
            }
        }

        for (int i = 0; i < ListStudents.size(); i++) {
            student = ListStudents.get(i);
            //            for 循环遍历集合 查找id对应的对象
            if (student.getaClass().getSchool().getSchoolId() == id) {
                //            如果存在调用remove方法 删除student 内容
                ListStudents.remove(i);
                i--;
            }
        }

    }

    //班级删除
    public void classDelete(int id) {
//        for 循环遍历集合 查找id对应的对象
        for (int i = 0; i < ListClasses.size(); i++) {
            aClass = ListClasses.get(i);
            if (aClass.getId() == id) {
                //            如果存在调用remove方法 删除class 内容
                ListClasses.remove(i);
                i--;
            }
        }

        for (int i = 0; i < ListStudents.size(); i++) {
            //            for 循环遍历集合 查找id对应的对象
            student = ListStudents.get(i);
            if (student.getaClass().getId() == id) {
                //            如果存在调用remove方法 删除student 内容
                ListStudents.remove(i);
                i--;
            }
        }

    }

    //学生删除
    public void deleteStudent(int id) {
        for (int i = 0; i < ListStudents.size(); i++) {
            //            for 循环遍历集合 查找id对应的对象
            student = ListStudents.get(i);
            if (student.getId() == id) {
                //            如果存在调用remove方法 删除student 内容
                ListStudents.remove(i);
                i--;
            }
        }
    }


    //添加学院方法
    public void addSchool(School school) {
//        调用集合add 添加对象
        ListSchools.add(school);
    }

    //添加班级方法
    public void addClass(Class aClass) {
        //        调用集合add 添加对象
        ListClasses.add(aClass);
    }


    //添加学生方法
    public void addStudent(Student student) {
        //        调用集合add 添加对象
        ListStudents.add(student);
    }


    //全查询学生
    public List<Student> findAllStudent() {
//        当调用方法时返回集合所有元素
        return ListStudents;
    }

    //全查询学院
    public List<School> findAllSchool() {
        //        当调用方法时返回集合所有元素
        return ListSchools;
    }

    //全查询班级
    public List<Class> findAllClass() {
        //        当调用方法时返回集合所有元素
        return ListClasses;
    }
}

view试图主菜单栏

public class StudentView {
    //    用来控制while循环
    boolean loop = true;


    //学校id
    int SchoolId = 22;
    //班级编号
    int ClassId = 222;
    //学生id
    int StudentId = 2202;

    StudentService studentService = new StudentService();

    //定义用户对象 用来保存登录后的信息
    User LoginUser;

    //登录
    public void login() {
        System.out.println("请输入用户名");
        String name = Utility.readString(20);
        System.out.println("请输入密码");
        String password = Utility.readString(20);
//        调用login方法 得到返回值
        User user = studentService.login(name, password);
//        如果返回值为空 提示密码或用户名错误
        if (user == null) {
            System.out.println("用户名或密码错误");
            return;
        }
        //如果登录成功 获取用户名密码 方便后续密码修改
        LoginUser = user;
        //调用登录成功后的主菜单栏
        mainEu2();
    }

    //注册
    public void register() {
        System.out.println("请输入用户名");
        String name = Utility.readString(20);
        String password = "";
//        循环判断两次密码是否一致
        while (true) {
            System.out.println("请输入密码");
            password = Utility.readString(20);
            System.out.println("请确认密码");
            String password1 = Utility.readString(20);
            if (password1.equals(password)) {
                break;
            }
            System.out.println("两次输入的密码不一致！请重新输入");
        }
//        将输入的数据赋给user
        User user = new User(name, password);
//        调用Service的注册
        studentService.register(user);
    }

    //修改密码
    public void updatePassword() {
        System.out.println("请输入新的密码");
        String password = Utility.readString(20);
//        调用方法
        studentService.updatePassword(LoginUser, password);
    }

    //查看学院
    public void findAllSchool() {
        //调用方法 获得集合
        List<School> list = studentService.findAllSchool();
//        循环遍历列表元素
        list.forEach(System.out::println);
    }

    //删除学院
    public void deleteSchool() {

        System.out.println("请输入你要删除的学院编号");
        int id = Utility.readInt();
//        调用iD查询方法 并赋给school对象
        School school = studentService.findBySchoolId(id);
        System.out.println(school);
//        调用删除方法
        studentService.schoolDelete(id);

    }

    //添加学院
    public void addSchool() {
        System.out.println("请输入学院名称");
        String name = Utility.readString(20);
        System.out.println("请输入学院专业");
        String classname = Utility.readString(20);
//        将输入的信息用全参构造器添加进去
        School school = new School(SchoolId, name, classname);
//        设置学校id自增长，无需手动输入
        SchoolId++;
        studentService.addSchool(school);
        System.out.println("********恭喜您 ，添加成功！********");
    }

    //修改学院
    public void updateSchool() {
        System.out.println("请输入要修改的学院编号");
        int id = Utility.readInt();
//        调用单查询获得学院信息
        School school = studentService.findBySchoolId(id);
        if (school == null) {
            System.out.println("很遗憾！目前还没有该学院");
            return;
        }
        System.out.println("请输入学院名称");
        String name = Utility.readString(20);
        school.setSchoolName(name);
        System.out.println("请输入学院专业");
        String className = Utility.readString(20);
//        调用类 的set方法 设置name 值
        school.setSchoolName(name);
        school.setSchoolClass(className);
        System.out.println("********修改成功********");


    }

    //查看班级
    public void findAllClass() {
//        调用全查询方法 将数据赋给集合
        List<Class> list = studentService.findAllClass();
        //输出
        for (Class list1 : list) {
            System.out.println(list1);
        }
//        list.forEach(System.out::println);
    }

    //添加班级
    public void addClass() {

        System.out.println("请输入你要将班级加入的学院编号");
        int id = Utility.readInt();
//        调用id查询 将返回的数据赋给school对象
        School school = studentService.findBySchoolId(id);
//        如果school为空 输出提示信息 结束方法
        if (school == null) {
            //        如果school为空 输出提示信息 结束方法
            System.out.println("很遗憾！还没有该学院");
            return;
        }
        System.out.println("请输入班级名");
        String name = Utility.readString(20);
        Class aclass = new Class(ClassId, name, school);
//        调用添加方法加进去
        studentService.addClass(aclass);
//        编号自增1
        ClassId++;
        System.out.println("********班级加入学院成功********");

    }

    //修改班级
    public void updateClass() {
        System.out.println("请输入你要修改的班级编号");
        int id = Utility.readInt();
//        调用id查询方法 将数据赋给class对象
        Class aClass = studentService.findByClassId(id);
        System.out.println(aClass);
        //        如果school为空 输出提示信息 结束方法
        if (aClass == null) {
            System.out.println("班级不存在");
            return;
        }
        System.out.println("请输入要修改的班级名");
        String name = Utility.readString(20);
//        调用Set方法 设置name
        aClass.setClassName(name);
        System.out.println("********修改班级成功********");
    }

    //删除班级
    public void deleteClass() {
        System.out.println("请输入要删除的班级编号");
        int id = Utility.readInt();
//        调用查询方法 显示出要删除的信息
        Class aclass = studentService.findByClassId(id);
        if (aclass == null) {
            System.out.println("班级不存在！");
            return;
        }
        System.out.println(aclass);
//        调用删除方法
        studentService.classDelete(id);
        System.out.println("********修改成功********");

    }

    //查看学生
    public void findAllStudent() {
//        调用全查询 获得数据并赋给集合
        List<Student> list = studentService.findAllStudent();

        for (Student student : list) {
            System.out.println(student);
        }
//        list.forEach(System.out::println);
    }

    //添加学生
    public void addStudent() {
        System.out.println("请输入你要将学生加入的班级号");
        int classId = Utility.readInt();
        //        调用id查询 将返回的数据赋给aClass对象
        Class aClass = studentService.findByClassId(classId);
        if (aClass == null) {
            //        如果aClass为空 输出提示信息 结束方法
            System.out.println("班级信息不存在");
            return;
        }

        System.out.println("请输入学生姓名");
        String name = Utility.readString(20);
        System.out.println("请输入学生年龄");
        int age = Utility.readInt();
        Student student = new Student(StudentId, name, age, aClass);
        //        调用添加方法加进去
        studentService.addStudent(student);
        //        编号自增1
        SchoolId++;
        System.out.println("*******添加成功********");
    }

    //删除学生
    public void deleteStudent() {
        System.out.println("请输入要删除的学生编号");
        int id = Utility.readInt();
        //        调用查询方法 显示出要删除的信息
        //        调用删除方法
        studentService.deleteStudent(id);
        System.out.println("********删除成功！********");
    }

    //修改学生
    public void updateStudent() {
        System.out.println("请输入你要修改的学生编号");
        int id = Utility.readInt();
        //        调用单查询获得学生信息
        Student student = studentService.findByStudentId(id);
//        Class aClass=studentService.findClassById(id);
        if (student == null) {
//            如果为空 输出提示信息
            System.out.println("没有对应的学生信息");
            return;
        }
        System.out.println("请输入学生姓名");
        String name = Utility.readString(20);
        System.out.println("请输入学生年龄");
        int age = Utility.readInt();
//        调用set设置信息
        student.setName(name);
        student.setAge(age);
        System.out.println("********修改成功********");
    }

    //根据姓名查看学生信息
    public void findByName() {
        System.out.println("请输入要查找的学生姓名");
        String name = Utility.readString(20);
        List<Student> list = studentService.findByStudentName(name);
        for (Student student : list) {
            System.out.println(student);
        }
    }

    //根据班级查看学生信息
    public void findByClass() {
        System.out.println("请输入要查找的学生的班级编号");
        int id = Utility.readInt();
//        调用单查询 获的班级信息
        Class aclass = studentService.findByClassId(id);
        if (aclass == null) {
            System.out.println("没有对应的信息");
            return;
        }
//        将班级对象 赋给查询方法 返回list 集合
        List<Student> list = studentService.findByClass(aclass);
        for (Student student : list) {
            System.out.println(student);
        }
    }

    //根据学院查看学生信息
    public void findBySchool() {
        System.out.println("请输入要查看的学生的学院id");
        int id = Utility.readInt();
//        调用单查询获得school对象
        School school = studentService.findBySchoolId(id);
//        将school对象赋给方法 并调用返回
        List<Student> list = studentService.findBySchool(school);
        for (Student student : list) {
            System.out.println(student);
        }
    }

    public void mainEu1() {
//        do while 循环执行菜单栏
        do {
            System.out.println("**************学生信息管理系统**************");
            System.out.println("\t\t\t1、登录");
            System.out.println("\t\t\t2、注册");
            System.out.println("\t\t\t3、退出系统");
            System.out.println("请输入你的选择(1、2、3)");
//            调用Utility来获取键盘输入  想当于Scanner语句
            int key = Utility.readInt();
            //switch进行输入判断 执行不同的方法
            switch (key) {
                case 1:
                    login();
                    break;
                case 2:
                    register();
                    break;
                case 3:
//                    设置控制变量loop为false
                    loop = false;
                    break;
                default:
                    System.out.println("输入有误 请重新输入");
                    break;
            }
        } while (loop);
        System.out.println("您退出了整个系统");
    }

    public void mainEu2() {
        boolean loop1 = true;
//        do while 循环执行菜单栏
        do {
            System.out.println("**************学生信息管理系统**************");
            System.out.println("\t\t\t1、学院管理");
            System.out.println("\t\t\t2、班级管理");
            System.out.println("\t\t\t3、学生管理");
            System.out.println("\t\t\t4、修改密码");
            System.out.println("\t\t\t5、退出系统");
            System.out.println("请输入你的选择(1、2、3、4、5)");
//            调用Utility来获取键盘输入  想当于Scanner语句
            int key = Utility.readInt();
            //switch进行输入判断 执行不同的方法
            switch (key) {
                case 1:
                    mainSchool();
                    break;
                case 2:
                    mainClass();
                    break;
                case 3:
                    mainStudent();
                    break;
                case 4:
                    updatePassword();
                    break;
                case 5:
//                    设置控制变量loop为false
                    loop1 = false;
                    break;
                default:
                    System.out.println("输入有误 请重新输入");
                    break;
            }
        } while (loop1);
        System.out.println("您退出了系统");
    }


    //学院管理
    public void mainSchool() {
        boolean loop2 = true;
        do {
            System.out.println("**************学生信息管理系统**************");
            System.out.println("\t\t\t1、查看学院信息");
            System.out.println("\t\t\t2、添加学院信息");
            System.out.println("\t\t\t3、删除学院信息");
            System.out.println("\t\t\t4、修改学院信息");
            System.out.println("\t\t\t5、退出学院管理");
            System.out.println("请输入你的选择(1、2、3、4、5)");
//            调用Utility来获取键盘输入  想当于Scanner语句
            int key = Utility.readInt();
            //switch进行输入判断 执行不同的方法
            switch (key) {
                case 1:
                    findAllSchool();
                    break;
                case 2:
                    addSchool();
                    break;
                case 3:
                    deleteSchool();
                    break;
                case 4:
                    updateSchool();
                    break;
                case 5:
//                    设置控制变量loop为false
                    loop2 = false;
                    break;
                default:
                    System.out.println("输入有误 请重新输入");
                    break;
            }
        } while (loop2);
        System.out.println("您退出了学院管理");
    }
    //班级管理

    public void mainClass() {
        boolean loop3 = true;

        do {
            System.out.println("**************学生信息管理系统**************");
            System.out.println("\t\t\t1、查看班级信息");
            System.out.println("\t\t\t2、添加班级信息");
            System.out.println("\t\t\t3、删除班级信息");
            System.out.println("\t\t\t4、修改班级信息");
            System.out.println("\t\t\t5、退出班级管理");
            System.out.println("请输入你的选择(1、2、3、4、5)");
//            调用Utility来获取键盘输入  想当于Scanner语句
            int key = Utility.readInt();
            //switch进行输入判断 执行不同的方法
            switch (key) {
                case 1:
                    findAllClass();
                    break;
                case 2:
                    addClass();
                    break;
                case 3:
                    deleteClass();
                    break;
                case 4:
                    updateClass();
                    break;
                case 5:
//                    设置控制变量loop为false
                    loop3 = false;
                    break;
                default:
                    System.out.println("输入有误 请重新输入");
                    break;
            }
        } while (loop3);
        System.out.println("您退出了班级管理");
    }

    public void mainStudent() {
        boolean loop4 = true;
        do {
            System.out.println("**************学生信息管理系统**************");
            System.out.println("\t\t\t1、查看学生信息");
            System.out.println("\t\t\t2、添加学生信息");
            System.out.println("\t\t\t3、删除学生信息");
            System.out.println("\t\t\t4、修改学生信息");
            System.out.println("\t\t\t5、根据姓名查找学生");
            System.out.println("\t\t\t6、查看班级的学生");
            System.out.println("\t\t\t7、查看学院的学生");
            System.out.println("\t\t\t8、退出学生管理");
            System.out.println("请输入你的选择(1、2、3、4、5、6、7、8)");
//            调用Utility来获取键盘输入  想当于Scanner语句
            int key = Utility.readInt();
            //switch进行输入判断 执行不同的方法
            switch (key) {
                case 1:
                    findAllStudent();
                    break;
                case 2:
                    addStudent();
                    break;
                case 3:
                    deleteStudent();
                    break;
                case 4:
                    updateStudent();
                    break;
                case 5:
                    findByName();
                    break;
                case 6:
                    findByClass();
                    break;
                case 7:
                    findBySchool();
                    break;
                case 8:
//                    设置控制变量loop为false
                    loop4 = false;
                    break;
                default:
                    System.out.println("输入有误 请重新输入");
                    break;
            }
        } while (loop4);
        System.out.println("您退出了学生管理");
    }
}

接收键盘输入类

package 学生信息管理系统.Util;

import java.util.Scanner;

/**
 工具类的作用:
 处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
 */
public class Utility {
    //静态属性
    private static Scanner scanner = new Scanner(System.in);
    /**
     * 功能：读取键盘输入的一个菜单选项，值：1——5的范围
     * @return 1——5
     */
    public static char readMenuSelection(){
        char c ;
        for (; ;){
            String str = readKeyBoard(1,false);//包含一个字符的字符串
            c = str.charAt(0);
            if (c!='1'&&c!='2'&&c!='3'&c!='4'&c!='5'){
                System.out.println("选择错误，请重新输入：");
            }
            else break;
        }
        return c;
    }
    /**
     * 功能：读取键盘输入的一个字符
     * @return 一个字符
     */
    public static char readChar(){
        String str =  readKeyBoard(1,false);//读取字符
        return  str.charAt(0);
    }
    /**
     * 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
     * @param defaultValue 指定的默认值
     * @return 默认值或输入的字符
     */
    public static  char readChar(char defaultValue){
        String str = readKeyBoard(1,true);//读取结果不是字符就是一个空的字符串
        return (str.length()==0)?defaultValue:str.charAt(0);
    }
    /**
     * 功能：读取键盘输入的整型，长度小于2位
     * @return 整数
     */
    public static int readInt(){
        int n;
        for(; ;){
            String str = readKeyBoard(10,true);//读取一个整数，长度<=10位
            try {
                n=Integer.parseInt(str);//进行转型，字符转换成整数
                break;
            }catch (NumberFormatException e){
                System.out.println("数字输入的有错误，请重新输入！");
            }
        }return n;
    }
    /**
     * 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
     *
     * @param defaultValue 指定的默认值
     * @return 整数或默认值
     *
     */
    public static int readInt(int defaultValue){
        int n;
        for(; ;){
            String str = readKeyBoard(10,true);
            if (str.equals("")){
                return defaultValue;
            }
            //异常处理
            try {
                n = Integer.parseInt(str);
                break;
            }catch (NumberFormatException e){
                System.out.println("数字输入的有错误，请重新输入！");
            }
        }
        return n;
    }
    /**
     * 功能：读取键盘输入的指定长度的字符串
     * @param limit 限制的长度
     * @return 指定长度的字符串
     */
    public  static  String readString(int limit){
        return readKeyBoard(limit,false);
    }
    /**
     * 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
     * @param limit 限制的长度
     * @param defaultValue 指定的默认值
     * @return 指定长度的字符串
     */
    public static String readString(int limit,String defaultValue){
        String str = readKeyBoard(limit, true);
        return str.equals("")? defaultValue : str;
    }
    /**
     * 功能：读取键盘输入的确认选项，Y或N
     * 将小的功能，封装到一个方法中.
     * @return Y或N
     */
    public static char readConfirmSelection(){
        System.out.println("请输入你的选择（Y/N）");
        char c ;
        for(; ; ){
            //将接受的字符转换成大写字母
            String str = readKeyBoard(1,false).toUpperCase();
            c = str.charAt(0);
            if (c=='Y'||c=='N'){
                break;
            }else {
                System.out.println("选择有错误，请重新输入！");
            }
        }
        return c;
    }
    /**
     * 功能： 读取一个字符串
     * @param limit 读取的长度
     * @param blankReturn 如果为true ,表示 可以读空字符串。
     * 					  如果为false表示 不能读空字符串。
     *
     *	如果输入为空，或者输入大于limit的长度，就会提示重新输入。
     * @return
     */
    public static  String readKeyBoard(int limit,boolean blankReturn){
        //定义一个字符串
        String line = "";
        while (scanner.hasNextLine()){//判断是否有下一行
            line = scanner.nextLine();
            //如果line.length=0, 即用户没有输入任何内容，直接回车
            if (line.length()==0){
                if (blankReturn)return line;//如果blankReturn=true,可以返回空串
                else continue; //如果blankReturn=false,不接受空串，必须输入内容
            }
            //如果用户输入的内容大于了 limit，就提示重写输入
            //如果用户如的内容 >0 <= limit ,我就接受
            if (line.length()<1||line.length()>limit){
                System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }
        return line;
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        StudentView studentView=new StudentView();
//        studentView.mainEu1();
        studentView.mainEu2();
    }
}