JAVA（十二）学生、班级、年级管理系统

分层思想

DAO层：主要做数据持久层的工作，负责与数据库进行联络的一些任务都封装在此
Service层：主要负责业务模块的应用逻辑设计，设计接口、实现类等，Service层的业务层具体要调用已经定义的DAO层接口
Controller层：负责具体的业务模块流程的控制，要调用Service层的接口来控制业务流程

具体步骤

1、设置MySQL数据库
2、创建Java项目并配置MySQL JDBC
3、分层设计Java类
4、实现Console输入与数据库操作

设置MySQL数据库

一、数据表设计

1、E-R图：实体-联系图，提供了表示实体类型、属性和联系的方法，用来描述现实世界和概念模型。
（1）实体类型：具有相同属性的实体必然具有共同的特征和性质。用实体名及描述它的各属性名，可以刻画出全部同质实体的共同特征和性质，称为实体类型。例如，学生（学号，姓名，性别，出生年月，所在院系，入学时间）就是一个实体型。在E-R图中用矩形表示，矩形框内写明实体名
（2）属性：实体所具有的某一特性，一个实体可由若干个属性来刻画。属性不能脱离实体，属性是相对实体而言的。在E-R图中用椭圆形表示，并用无向边将其与相应的实体连接起来
（3）联系：也称关系，信息世界中反映实体内部或实体之间的关联。实体内部的联系通常是指组成实体的各属性之间的联系；实体之间的联系通常是指不同实体集之间的联系。在E-R图中用菱形表示，菱形框内写明联系名，并用无向边分别与有关实体连接起来，同时在无向边旁标上联系的类型（1:1，1:n或m:n）

一对多的关系怎么标1和n：先假想是其中的的一个实体，把描述的关系放联系名对面的边，我是一个班级，那么我有n个学生，所以n放对边，我是一个学生是吧，我只有一个班级，所以1放我对边。然后就完成了。

2、数据表设计
（1）学生表t_student

字段名	字段类型	备注
id	bigint	学生id，学生的唯一标识符
class_id	bigint	班级id，外键，关联到班级表的id
grade_id	bigint	年级id，外键，关联到年级表的id
name	varchar	姓名
gender	tinyint	性别，1代表男性，2代表女性
age	int	年龄
update_time	datetime	修改时间
create_time	datetime	创建时间
delete_flag	tinyint	删除标记，1代表正常，2代表已删除

（2）班级表t_class

字段名	字段类型	备注
id	bigint	班级id，班级的唯一标识符
grade_id	bigint	年级id，外键，关联到年级表的id
name	varchar	班级名称
update_time	datetime	修改时间
create_time	datetime	创建时间
delete_flag	tinyint	删除标记，1代表正常，2代表已删除

（3）年级表t_grade

字段名	字段类型	备注
id	bigint	年级id，年级的唯一标识符
name	varchar	年级名称
update_time	datetime	修改时间
create_time	datetime	创建时间
delete_flag	tinyint	删除标记，1代表正常，2代表已删除

3、MySQL建表语句
（1）年级表

CREATE TABLE `studentmanagement`.`t_grade` (
  `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '年级id',
  `name` VARCHAR(255) NOT NULL,
  `update_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
  `create_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `delete_flag` TINYINT NOT NULL DEFAULT 1 COMMENT '删除标记',
  PRIMARY KEY (`id`))
COMMENT = '年级表';

AUTO_INCREMENT属性用于自动增长主键。
DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP用于自动设置update_time和create_time字段的值。
FOREIGN KEY用于定义外键约束，确保数据的完整性。
ON DELETE CASCADE确保当被引用的记录被删除时，相关联的记录也会被删除。

（2）班级表

CREATE TABLE `studentmanagement`.`t_class` (
  `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '班级id',
  `grade_id` BIGINT NOT NULL,
  `name` VARCHAR(255) NOT NULL COMMENT '班级名称',
  `update_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
  `create_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `delete_flag` TINYINT NOT NULL DEFAULT 1 COMMENT '删除标记',
  PRIMARY KEY (`id`),
  INDEX `grade_id_idx` (`grade_id` ASC) VISIBLE,
  CONSTRAINT `grade_id`
    FOREIGN KEY (`grade_id`)
    REFERENCES `studentmanagement`.`t_grade` (`id`)
    ON DELETE CASCADE
    ON UPDATE NO ACTION)
COMMENT = '班级表';

（3）学生表

CREATE TABLE `studentmanagement`.`t_student` (
  `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '学生id',
  `class_id` BIGINT NOT NULL COMMENT '班级id',
  `grade_id` BIGINT NOT NULL COMMENT '年级id',
  `name` VARCHAR(255) NOT NULL COMMENT '学生姓名',
  `gender` TINYINT NOT NULL COMMENT '性别',
  `age` INT NOT NULL COMMENT '年龄',
  `update_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '修改时间',
  `create_time` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `delete_flag` TINYINT NOT NULL DEFAULT 1 COMMENT '删除标记',
  PRIMARY KEY (`id`),
  INDEX `grade_id_idx_2` (`grade_id` ASC) VISIBLE,
  INDEX `class_id_idx` (`class_id` ASC) VISIBLE,
  CONSTRAINT `class_id`
    FOREIGN KEY (`class_id`)
    REFERENCES `studentmanagement`.`t_class` (`id`)
    ON DELETE CASCADE
    ON UPDATE NO ACTION,
  CONSTRAINT `grade_id_2`
    FOREIGN KEY (`grade_id`)
    REFERENCES `studentmanagement`.`t_grade` (`id`)
    ON DELETE CASCADE
    ON UPDATE NO ACTION)
COMMENT = '学生表';

遇到的问题：Error 1826: Duplicate foreign key constraint 错误，在一个数据库中建了若干张表，其中的外键索引重复了
解决方法：设置新的索引名和外键名

DAO层

MySQLConnection类

package com.studentmanagement.dao;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
 * @author shi.hongpin
 */
public class MysqlConnection {
    /**
     * 数据库连接URL，用户名和密码需要根据实际情况替换 获取数据库连接
     * 
     * @return Connection 数据库连接对象，如果连接失败则返回null
     */
    public static Connection getConnection() {
        Connection conn = null;
        try {
            // 加载MySQL JDBC驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
            // 建立连接
            conn = DriverManager.getConnection("jdbc:url", "user", "password");
        } catch (ClassNotFoundException e) {
            System.err.println("找不到JDBC驱动类: " + e.getMessage());
        } catch (SQLException e) {
            System.err.println("数据库连接失败: " + e.getMessage());
        }
        return conn;
    }

    /**
     * 关闭数据库连接
     * 
     * @param conn 数据库连接对象
     */
    public static void closeConnection(Connection conn) {
        if (conn != null) {
            try {
                // 关闭连接
                conn.close();
            } catch (SQLException e) {
                System.err.println("关闭数据库连接时发生错误: " + e.getMessage());
            }
        }
    }
}

遇到的问题：找不到JDBC驱动类
解决方法：新建的项目需要将驱动mysql-connector-java.jar包导入IDEA。在项目下新建文件夹lib，将jar粘贴到该目录下，右击该目录，点击Add as Library，导入成功。

DaoGrade类

package com.studentmanagement.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

/**
 * @author shi.hongpin
 */
public class DaoGrade {
    /** 私有构造函数，防止实例化 */
    private DaoGrade() {}

    /** 实现插入数据 */
    public static boolean insertGrade(long gradeId, String name, int deleteFlag) {
        String sql =
            "INSERT INTO t_grade (id, name, update_time, create_time, delete_flag) VALUES (?, ?, NOW(), NOW(), ?)";
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = MysqlConnection.getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setLong(1, gradeId);
            pstmt.setString(2, name);
            pstmt.setInt(3, deleteFlag);
            int affectedRows = pstmt.executeUpdate();
            return affectedRows > 0;
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("插入失败");
            return false;
        } finally {
            // 关闭PreparedStatement和Connection
            try {
                if (pstmt != null) {
                    pstmt.close();
                }
                if (conn != null) {
                    MysqlConnection.closeConnection(conn);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * public static void main(String[] args) { InsertGrade(5,"五年级",1); }
     */

    /** 实现逻辑删除，即不从表中删除行，而是更新一个字段来表示行已删除 */
    public static boolean logicDeleteGrade(long gradeId) {
        String sql = "UPDATE t_grade SET delete_flag = 2 WHERE id = ?";
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = MysqlConnection.getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setLong(1, gradeId);
            int affectedRows = pstmt.executeUpdate();
            return affectedRows > 0;
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("删除失败");
            return false;
        } finally {
            // 关闭PreparedStatement和Connection
            try {
                if (pstmt != null) {
                    pstmt.close();
                }
                if (conn != null) {
                    MysqlConnection.closeConnection(conn);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * public static void main(String[] args) { LogicDeleteGrade(3); }
     */

    /** 实现年级表数据更新 */
    public static boolean updateGrade(String name, long gradeId, int deleteFlag) {
        String sql = "UPDATE t_grade SET name = ?, delete_flag = ?, update_time = NOW() WHERE id = ?";
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = MysqlConnection.getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, name);
            pstmt.setInt(2, deleteFlag);
            pstmt.setLong(3, gradeId);
            int affectedRows = pstmt.executeUpdate();
            return affectedRows > 0;
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("更新失败");
            return false;
        } finally {
            // 关闭PreparedStatement和Connection
            try {
                if (pstmt != null) {
                    pstmt.close();
                }
                if (conn != null) {
                    MysqlConnection.closeConnection(conn);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * public static void main(String[] args) { UpdateGrade("高二年级",2); }
     */

    /**
     * 实现年级表数据查询 查询所有数据
     */
    public static boolean searchAllGrade() {
        String sql = "SELECT * FROM t_grade";
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = MysqlConnection.getConnection();
            pstmt = conn.prepareStatement(sql);
            ResultSet affectedRows = pstmt.executeQuery();
            System.out.println("ID\t年级名称\t更新时间\t创建时间\t删除标记");
            while (affectedRows.next()) {
                System.out.println(affectedRows.getLong("id") + "\t" + affectedRows.getString("name") + "\t"
                    + affectedRows.getTimestamp("update_time") + "\t" + affectedRows.getTimestamp("create_time") + "\t"
                    + affectedRows.getInt("delete_flag"));
            }
            return affectedRows != null;
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("查询失败");
            return false;
        } finally {
            // 关闭PreparedStatement和Connection
            try {
                if (pstmt != null) {
                    pstmt.close();
                }
                if (conn != null) {
                    MysqlConnection.closeConnection(conn);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * public static void main(String[] args) { SearchAllGrade(); }
     */

    /** 按照id查询 */
    public static boolean searchGradeById(long gradeId) {
        String sql = "SELECT * FROM t_grade WHERE id = ?";
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = MysqlConnection.getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setLong(1, gradeId);
            ResultSet affectedRows = pstmt.executeQuery();
            System.out.println("ID\t年级名称\t更新时间\t创建时间\t删除标记");
            while (affectedRows.next()) {
                System.out.println(affectedRows.getLong("id") + "\t" + affectedRows.getString("name") + "\t"
                    + affectedRows.getTimestamp("update_time") + "\t" + affectedRows.getTimestamp("create_time") + "\t"
                    + affectedRows.getInt("delete_flag"));
            }
            return affectedRows != null;
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("查询失败");
            return false;
        } finally {
            // 关闭PreparedStatement和Connection
            try {
                if (pstmt != null) {
                    pstmt.close();
                }
                if (conn != null) {
                    MysqlConnection.closeConnection(conn);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /** 按照年级名称查询 */
    public static boolean searchGradeByName(String name) {
        String sql = "SELECT * FROM t_grade WHERE name = ?";
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = MysqlConnection.getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, name);
            ResultSet affectedRows = pstmt.executeQuery();
            System.out.println("ID\t年级名称\t更新时间\t创建时间\t删除标记");
            while (affectedRows.next()) {
                System.out.println(affectedRows.getLong("id") + "\t" + affectedRows.getString("name") + "\t"
                    + affectedRows.getTimestamp("update_time") + "\t" + affectedRows.getTimestamp("create_time") + "\t"
                    + affectedRows.getInt("delete_flag"));
            }
            return affectedRows != null;
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("查询失败");
            return false;
        } finally {
            // 关闭PreparedStatement和Connection
            try {
                if (pstmt != null) {
                    pstmt.close();
                }
                if (conn != null) {
                    MysqlConnection.closeConnection(conn);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * public static void main(String[] args) { SearchGradeByName("高二年级"); }
     */

    /** 判断年级id是否被逻辑删除 */
    public static boolean logDeleteGradeById(long gradeId) {
        String sql = "SELECT COUNT(*) FROM t_grade WHERE id = ? AND delete_flag = 2";
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = MysqlConnection.getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setLong(1, gradeId);
            ResultSet affectedRows = pstmt.executeQuery();
            // 检查结果集中的计数是否大于0
            if (affectedRows.next()) {
                long count = affectedRows.getLong(1);
                return count > 0;
            }
            return false;
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("查询失败");
            return false;
        } finally {
            // 关闭PreparedStatement和Connection
            try {
                if (pstmt != null) {
                    pstmt.close();
                }
                if (conn != null) {
                    MysqlConnection.closeConnection(conn);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * public static void main(String[] args) { boolean result = ExistsGradeById(1); System.out.print(result); }
     */

    /** 判断年级id是否存在 */
    public static boolean existsGradeById(long gradeId) {
        String sql = "SELECT COUNT(*) FROM t_grade WHERE id = ? AND delete_flag = 1";
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = MysqlConnection.getConnection();
            pstmt = conn.prepareStatement(sql);
            pstmt.setLong(1, gradeId);
            ResultSet affectedRows = pstmt.executeQuery();
            // 检查结果集中的计数是否大于0
            if (affectedRows.next()) {
                long count = affectedRows.getLong(1);
                return count > 0;
            }
            return false;
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("查询失败");
            return false;
        } finally {
            // 关闭PreparedStatement和Connection
            try {
                if (pstmt != null) {
                    pstmt.close();
                }
                if (conn != null) {
                    MysqlConnection.closeConnection(conn);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

DaoClass类和DaoStudent类代码类似

Service层

ServGrade类

package com.studentmanagement.service;

import java.util.Scanner;

import com.studentmanagement.dao.DaoClass;
import com.studentmanagement.dao.DaoGrade;
import com.studentmanagement.dao.DaoStudent;

/**
 * @author shi.hongpin
 */
public class ServGrade {
    private ServGrade() {}

    /** 增加或修改年级信息 */
    public static void addOrUpdateGrade(long gradeId, String name, int deleteFlag) {
        // 检查年级ID是否已存在（包括逻辑删除的记录）
        if (DaoGrade.logDeleteGradeById(gradeId)) {
            System.out.println("该年级id存在但已被逻辑删除");
            DaoGrade.updateGrade(name, gradeId, deleteFlag);
        } else if (DaoGrade.existsGradeById(gradeId)) {
            System.out.println("该年级id已存在且未被逻辑删除");
            DaoGrade.updateGrade(name, gradeId, deleteFlag);
        } else {
            DaoGrade.insertGrade(gradeId, name, deleteFlag);
        }
        System.out.println("数据更新结束！");
    }

    /** 删除年级信息 */
    public static void deleteGrade(long gradeId) {
        // 检查年级ID是否存在
        if (DaoGrade.logDeleteGradeById(gradeId)) {
            System.out.println("该年级id已被删除！请勿重复操作！");
        } else if (DaoGrade.existsGradeById(gradeId)) {
            DaoGrade.logicDeleteGrade(gradeId);
            DaoClass.logicDeleteClassByGradeId(gradeId);
            DaoStudent.logicDeleteStudentByGradeId(gradeId);
            System.out.println("删除成功！");
        } else {
            System.out.println("该年级id不存在！");
        }
    }

    /** 查询年级信息 */
    public static void searchGrade(int flag) {
        Scanner scanner = new Scanner(System.in);

        if (flag == 1) {
            DaoGrade.searchAllGrade();
        } else if (flag == 2) {
            System.out.println("请输入年级id：");
            long gradeId = scanner.nextLong();
            DaoGrade.searchGradeById(gradeId);
        } else if (flag == 3) {
            System.out.println("请输入年级名称：");
            String name = scanner.nextLine();
            DaoGrade.searchGradeByName(name);
        } else {
            System.out.println("无效操作！");
        }
        System.out.println("查询结束！");
    }
    /**
     * public static void main(String[] args) { SearchGrade(3); }
     */
}

**ServClass类和ServStudent类代码类似

Control层

StuManagement类

package com.studentmanagement.control;

import java.util.Scanner;

import com.studentmanagement.service.ServGrade;
import com.studentmanagement.service.Serv_Class;
import com.studentmanagement.service.Serv_Student;

/**
 * @author shi.hongpin
 */
public class StuManagement {
    /** 学生表操作页面视图 */
    public static void viewStudent() {
        System.out.println("    欢迎使用学生管理系统    ");
        System.out.println("------------------------");
        System.out.println("  请选择操作序号：         ");
        System.out.println("  1、更新学生信息         ");
        System.out.println("  2、删除学生信息         ");
        System.out.println("  3、查询学生信息         ");
        System.out.println("  4、返回               ");
    }

    public static void viewStudentNext() {
        Scanner scan1 = new Scanner(System.in);
        boolean exitStudent = false;
        while (!exitStudent) {
            int choose1 = scan1.nextInt();
            switch (choose1) {
                case 1:
                    System.out.println("请输入学生id(七位数，前四位为班级id)：");
                    long studentId1 = scan1.nextLong();
                    System.out.println("请输入学生所属班级的班级id(四位数，第二位为年级id)：");
                    long classId = scan1.nextLong();
                    System.out.println("请输入学生所属年级的年级id(一位数)：");
                    long gradeId = scan1.nextLong();
                    scan1.nextLine();
                    System.out.println("请输入学生姓名：");
                    String name = scan1.nextLine();
                    System.out.println("请输入学生性别(1-男生，2-女生)：");
                    int gender = scan1.nextInt();
                    System.out.println("请输入学生年龄：");
                    int age = scan1.nextInt();
                    System.out.println("请设置是否删除标签(1-数据存在，2-数据删除)");
                    int deleteFlag = scan1.nextInt();
                    Serv_Student.AddorUpdateStudent(studentId1, classId, gradeId, name, gender, age, deleteFlag);
                    viewStudent();
                    break;
                case 2:
                    System.out.println("请输入要删除学生的学生id：");
                    long studentId2 = scan1.nextLong();
                    Serv_Student.DeleteStudent(studentId2);
                    viewStudent();
                    break;
                case 3:
                    System.out.println("    欢迎使用学生管理系统    ");
                    System.out.println("------------------------");
                    System.out.println("  请选择查询条件序号：      ");
                    System.out.println("  1、查询全部             ");
                    System.out.println("  2、根据学生姓名查询       ");
                    System.out.println("  3、根据年级id查询        ");
                    System.out.println("  4、根据班级id查询        ");
                    System.out.println("  5、根据学生性别查询       ");
                    System.out.println("  6、根据学生年龄查询       ");
                    System.out.println("  7、根据学生id查询        ");
                    System.out.println("  8、返回        ");
                    int choose2 = scan1.nextInt();
                    if (choose2 == 8) {
                        viewStudent();
                    } else {
                        Serv_Student.SearchStudent(choose2);
                    }
                    viewStudent();
                    break;
                case 4:
                    viewAll();
                    exitStudent = true;
                    break;
                default:
                    // 日志记录或抛出异常
                    System.out.println("Unhandled case");
                    break;
            }
        }
    }

    /** 班级表操作页面视图 */
    public static void viewClass() {
        System.out.println("    欢迎使用班级表管理系统   ");
        System.out.println("------------------------");
        System.out.println("  请选择操作序号：         ");
        System.out.println("  1、更新班级信息         ");
        System.out.println("  2、删除班级信息         ");
        System.out.println("  3、查询班级信息         ");
        System.out.println("  4、返回         ");
    }

    public static void viewClassNext() {
        Scanner scan2 = new Scanner(System.in);
        boolean exitClass = false;
        while (!exitClass) {
            int choose1 = scan2.nextInt();
            switch (choose1) {
                case 1:
                    System.out.println("请输入班级id(四位数，第二位为年级id)：");
                    long classId1 = scan2.nextLong();
                    System.out.println("请输入班级所属年级的年级id(一位数)：");
                    long gradeId = scan2.nextLong();
                    System.out.println("请输入班级姓名：");
                    String name = scan2.nextLine();
                    System.out.println("请设置是否删除标签(1-数据存在，2-数据删除)");
                    int deleteFlag = scan2.nextInt();
                    Serv_Class.AddorUpdateClass(classId1, gradeId, name, deleteFlag);
                    viewClass();
                    break;
                case 2:
                    System.out.println("请输入要删除班级的班级id：");
                    long classId2 = scan2.nextLong();
                    Serv_Class.DeleteClass(classId2);
                    viewClass();
                    break;
                case 3:
                    System.out.println("    欢迎使用班级表管理系统   ");
                    System.out.println("------------------------");
                    System.out.println("  请选择查询条件序号：      ");
                    System.out.println("  1、查询全部             ");
                    System.out.println("  2、根据班级id查询       ");
                    System.out.println("  3、根据班级名称查询        ");
                    System.out.println("  4、根据年级id查询        ");
                    System.out.println("  5、退出        ");
                    int choose2 = scan2.nextInt();
                    if (choose2 == 5) {
                        viewClass();
                    } else {
                        Serv_Class.SearchClass(choose2);
                    }
                    viewClass();
                    break;
                case 4:
                    viewAll();
                    exitClass = true;
                    break;
                default:
                    // 日志记录或抛出异常
                    System.out.println("Unhandled case");
                    break;
            }
        }
    }

    /** 年级表操作页面视图 */
    public static void viewGrade() {
        System.out.println("    欢迎使用年级表管理系统    ");
        System.out.println("------------------------");
        System.out.println("  请选择操作序号：         ");
        System.out.println("  1、更新年级信息         ");
        System.out.println("  2、删除年级信息         ");
        System.out.println("  3、查询年级信息         ");
        System.out.println("  4、返回         ");
    }

    public static void viewGradeNext() {
        Scanner scan3 = new Scanner(System.in);
        boolean exitGrade = false;
        while (!exitGrade) {
            int choose1 = scan3.nextInt();
            switch (choose1) {
                case 1:
                    System.out.println("请输入年级id(一位数)：");
                    long gradeId1 = scan3.nextLong();
                    System.out.println("请输入年级名称：");
                    String name = scan3.nextLine();
                    System.out.println("请设置是否删除标签(1-数据存在，2-数据删除)");
                    int deleteFlag = scan3.nextInt();
                    ServGrade.addOrUpdateGrade(gradeId1, name, deleteFlag);
                    viewGrade();
                    break;
                case 2:
                    System.out.println("请输入要删除年级的年级id：");
                    long gradeId2 = scan3.nextLong();
                    ServGrade.deleteGrade(gradeId2);
                    viewGrade();
                    break;
                case 3:
                    System.out.println("    欢迎使用年级表管理系统   ");
                    System.out.println("------------------------");
                    System.out.println("  请选择查询条件序号：      ");
                    System.out.println("  1、查询全部             ");
                    System.out.println("  2、根据年级id查询        ");
                    System.out.println("  3、根据年级名称查询       ");
                    System.out.println("  4、退出                ");
                    int choose2 = scan3.nextInt();
                    if (choose2 == 4) {
                        viewGrade();
                    } else {
                        ServGrade.searchGrade(choose2);
                    }
                    viewGrade();
                    break;
                case 4:
                    viewAll();
                    exitGrade = true;
                    break;
                default:
                    // 日志记录或抛出异常
                    System.out.println("Unhandled case:");
                    break;
            }
        }
    }

    /** 主页面操作视图 */
    public static void viewAll() {
        System.out.println("    欢迎使用学生、班级、年级管理系统    ");
        System.out.println("----------------------------------");
        System.out.println("       请选择操作以下哪张表：         ");
        System.out.println("       1、学生表         ");
        System.out.println("       2、班级表         ");
        System.out.println("       3、年级表         ");
        System.out.println("       4、退出          ");
    }

    public static void main(String[] args) {
        viewAll();
        Scanner scanner = new Scanner(System.in);
        boolean exitAll = false;
        while (!exitAll) {
            int choose = scanner.nextInt();
            switch (choose) {
                case 1:
                    viewStudent();
                    viewStudentNext();
                    break;
                case 2:
                    viewClass();
                    viewClassNext();
                    break;
                case 3:
                    viewGrade();
                    viewGradeNext();
                    break;
                case 4:
                    System.out.println("感谢使用学生、班级、年级管理系统！再见！");
                    exitAll = true;
                    break;
                default:
                    // 日志记录或抛出异常
                    System.out.println("Unhandled case");
                    break;
            }
        }
    }
}

报错及解决方法

报错

Column count doesn‘t match value count at row 1 存储的数据与数据库表的字段类型定义不相匹配
代码没有报错，执行 UPDATE t_grade SET id = ?, name = ?, update_time = NOW() WHERE id = ? 没有显示更新成功的提示
Can not issue executeUpdate() or executeLargeUpdate() with statements that produce result sets
尝试使用 executeUpdate() 或 executeLargeUpdate() 方法来执行一个 SQL 语句，但是这个语句产生了一个结果集（ResultSet）
函数缺少return语句
无法实现一个统一的、可循环的用户菜单界面，期望目标是用户在选择退出子菜单时显示主菜单，在主菜单中选择退出才会真正退出系统

System.out.println("请输入学生姓名：");
String name = scan_1.nextLine();
System.out.println("请输入学生性别(1-男生，2-女生)：");
int gender = scan_1.nextInt();

这段代码输出结果是

请输入学生姓名：
请输入学生性别(1-男生，2-女生)：

即直接跳过了键盘键入学生姓名的操作

解决方法

INSERT语句中要写出全部列
INSERT INTO t_grade (id, name, update_time, create_time, delete_flag) VALUES (?, ?, NOW(), NOW(), ?)
UPDATE 语句通常不能用来修改表的主键（Primary Key）的值
SQL语句产生了结果集，比如一个SELECT查询，应该使用executeQuery()方法来执行它。
try块中返回了一个布尔值，但是在catch块中并没有返回值，可以直接在catch块中return false
在main方法和ViewStudentNext等方法中都添加while循环，分别设置一个exit标志，exit被设置为true，循环终止
nextInt() 方法之后没有调用 nextLine() 或 .nextLine() 来消费掉行尾的换行符。当用户输入学生性别并按下回车键后，换行符被留在了输入缓冲区中。接下来的 nextLine() 调用立即读取了这个换行符，导致看起来好像没有接收到任何输入。在第一行代码前面添加scan_1.nextLine()。

posted @ 2024-08-28 17:40 一年都在冬眠阅读(83) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· JAVA（六）JDBC连接MySQL实现增删改查

· JAVA（四）IO、异常处理

· MySQL实现JDBC-简单案例演示

· Java中的一些思想

· JDBC(JAVA DATABASE CONNECTITVITY)

阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· winform 绘制太阳，地球，月球运作规律
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人

公告

昵称：一年都在冬眠
园龄： 7个月
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

shihongpin