代码12345

最新推荐文章于 2024-09-15 19:46:31 发布

wuxiguala

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量383

点赞数 11

文章标签： java

本文链接：https://blog.csdn.net/qq_73121793/article/details/135446760

版权

文章目录

GUImain

package gui; // 包声明

import java.awt.*; // 导入必要的类库
import java.awt.event.*;
import javax.swing.SwingUtilities;

public class GUImain extends Frame implements ActionListener { // 类声明，继承自 Frame 并实现 ActionListener 接口

    private static final long serialVersionUID = 1L; // 声明一个私有静态常量 serialVersionUID
    private Button[] buttons; // 按钮组件
    private Label a1, a2; // 标签组件
    private GridBagLayout gb; // 网格布局管理器
    private GridBagConstraints gbc; // 网格包容器

    // 构造方法
    public GUImain() { // 构造方法
        // 用户登录
        GUIUserLogin userLogin = new GUIUserLogin(); // 创建 GUIUserLogin 实例
        userLogin.setLocationRelativeTo(null); // 设置登录窗口相对于屏幕居中显示
        userLogin.setVisible(true); // 显示登录窗口

        // 在登录成功后才显示主界面
        userLogin.setLoginListener(new LoginListener() { // 设置登录监听器
            public void onLoginSuccess() { // 登录成功后的回调方法
                loadMainGUI(); // 加载主界面
            }
        });
    }

    // 加载主界面
    private void loadMainGUI() {
        a1 = new Label("     欢迎使用学生成绩管理系统"); // 创建标签，显示欢迎信息
        a1.setFont(new Font(null, Font.LAYOUT_RIGHT_TO_LEFT, 20)); // 设置字体
        a2 = new Label("                     "); // 创建标签
        gb = new GridBagLayout(); // 创建网格布局管理器
        setLayout(gb); // 设置布局为网格布局
        gbc = new GridBagConstraints(); // 创建网格包容器
        createButtons(); // 创建并添加按钮
        setupLayout(); // 设置布局

        // 获得屏幕尺寸
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); // 获取屏幕尺寸
        int screenWidth = screenSize.width; // 屏幕宽度
        int screenHeight = screenSize.height; // 屏幕高度

        // 计算窗口左上角坐标
        int windowWidth = 400; // 窗口宽度
        int windowHeight = 300; // 窗口高度
        int x = (screenWidth - windowWidth) / 2; // 计算窗口左上角 x 坐标
        int y = (screenHeight - windowHeight) / 2; // 计算窗口左上角 y 坐标
        setLocation(x, y); // 设置窗口位置
        setSize(windowWidth, windowHeight); // 设置窗口大小
        setVisible(true); // 显示窗口
    }

    // 创建并添加按钮
    private void createButtons() {
        buttons = new Button[5]; // 创建按钮数组
        buttons[0] = new Button("输入信息"); // 创建按钮
        buttons[1] = new Button("查询成绩");
        buttons[2] = new Button("输出成绩");
        buttons[3] = new Button("编辑或删除学生信息");
        buttons[4] = new Button("退出系统");
        for (Button button : buttons) { // 为按钮数组中的每个按钮添加事件监听器
            button.addActionListener(this);
        }
    }

    // 设置布局
    private void setupLayout() {
        gbc.fill = GridBagConstraints.HORIZONTAL; // 设置网格包容器的填充方式
        addComponent(a1, 0, 2, 1, 4); // 添加组件
        addComponent(a2, 4, 2, 1, 2);
        addComponent(buttons[0], 6, 2, 1, 2);
        addComponent(buttons[1], 8, 2, 1, 2);
        addComponent(buttons[2], 10, 2, 1, 2);
        addComponent(buttons[3], 12, 2, 1, 2);
        addComponent(buttons[4], 14, 2, 1, 2);
    }

    // 按钮监听器
    public void actionPerformed(ActionEvent e) {
        for (Button button : buttons) { // 遍历按钮数组
            if (e.getActionCommand().equals(button.getLabel())) { // 如果点击的按钮命令与按钮标签相同
                handleButtonClick(button.getLabel()); // 处理按钮点击
                break;
            }
        }
    }

    // 处理按钮点击
    private void handleButtonClick(String buttonLabel) {
        switch (buttonLabel) { // 根据按钮标签进行分支处理
            case "输入信息": // 如果是输入信息按钮
                GUIInput inputFrame = new GUIInput(); // 创建 GUIInput 实例
                setupFrame(inputFrame, 600, 400); // 设置窗口大小并显示
                break;
            case "查询成绩": // 如果是查询成绩按钮
                GUISeeknum seeknumFrame = new GUISeeknum(); // 创建 GUISeeknum 实例
                setupFrame(seeknumFrame, 600, 400); // 设置窗口大小并显示
                break;
            case "输出成绩": // 如果是输出成绩按钮
                GUIOutnum outnumFrame = new GUIOutnum(); // 创建 GUIOutnum 实例
                setupFrame(outnumFrame, 700, 500); // 设置窗口大小并显示
                break;
            case "编辑或删除学生信息": // 如果是编辑或删除学生信息按钮
                GUIEditDelete editStudentFrame = new GUIEditDelete(); // 创建 GUIEditDelete 实例
                setupFrame(editStudentFrame, 600, 400); // 设置窗口大小并显示
                break;
            case "退出系统": // 如果是退出系统按钮
                setVisible(false); // 隐藏窗口
                dispose(); // 释放资源
                System.exit(0); // 退出程序
                break;
            default: // 默认情况
                break;
        }
    }

    // 设置窗口大小和显示
    private void setupFrame(Frame frame, int width, int height) {
        frame.setSize(width, height); // 设置窗口大小
        frame.setVisible(true); // 显示窗口
    }

    // 添加组件方法
    public void addComponent(Component c, int row, int col, int nrow, int ncol) {
        gbc.gridx = col; // 设置组件的列索引
        gbc.gridy = row; // 设置组件的行索引
        gbc.gridheight = ncol; // 设置组件的行跨度
        gbc.gridwidth = nrow; // 设置组件的列跨度
        gb.setConstraints(c, gbc); // 使用网格包容器设置组件所在的位置和跨度
        add(c); // 添加组件
    }

    public static void main(String[] args) { // 主方法
        SwingUtilities.invokeLater(() -> { // 使用SwingUtilities的invokeLater方法在事件分发线程上创建和显示GUI
            GUImain mainGUI = new GUImain(); // 创建 GUImain 实例
            mainGUI.setVisible(false); // 初始不显示主界面
        });
    }
}

GUIInput

package gui; // 包声明

import java.awt.*; // 导入必要的类库
import java.awt.event.*;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import utils.JDBCUtil;

public class GUIInput extends Frame implements ActionListener {  // 类声明，继承自 Frame 并实现 ActionListener 接口

	private static final long serialVersionUID = 1L;  // 声明一个私有静态常量 serialVersionUID
	private TextField nameField, genderField, birthdayField, mathField, englishField, javaField, computerField;  // 声明文本字段
    private Button submitButton, exitButton;  // 声明按钮

    public GUIInput() {  // 构造函数
        // 初始化文本框、按钮等组件
        nameField = new TextField(20);
        genderField = new TextField(20);
        birthdayField = new TextField(20);
        mathField = new TextField(20);
        englishField = new TextField(20);
        javaField = new TextField(20);
        computerField = new TextField(20);
        submitButton = new Button("提交");
        exitButton = new Button("退出");

        setLayout(new GridLayout(9, 2));  // 使用网格布局管理器
        add(new Label("姓名"));  // 添加标签和文本字段到窗口
        add(nameField);
        add(new Label("性别"));
        add(genderField);
        add(new Label("生日"));
        add(birthdayField);
        add(new Label("应用数学"));
        add(mathField);
        add(new Label("大学英语"));
        add(englishField);
        add(new Label("Java程序设计"));
        add(javaField);
        add(new Label("计算机应用基础"));
        add(computerField);
        add(submitButton);
        add(exitButton);

        submitButton.addActionListener(this);  // 为提交按钮添加事件监听器
        exitButton.addActionListener(this);  // 为退出按钮添加事件监听器

        addWindowListener(new WindowAdapter() {  // 窗口关闭事件监听器
            public void windowClosing(WindowEvent e) {
                setVisible(false);  // 隐藏窗口
                dispose();  // 释放窗口资源
                System.exit(0);  // 退出程序
            }
        });
    }

    public void actionPerformed(ActionEvent e) {  // 实现 ActionListener 接口的方法
        if (e.getSource() == submitButton) {  // 当点击提交按钮时
            // 获取用户输入
            String name = nameField.getText();
            String gender = genderField.getText();
            String birthday = birthdayField.getText();
            double mathScore = Double.parseDouble(mathField.getText());
            double englishScore = Double.parseDouble(englishField.getText());
            double javaScore = Double.parseDouble(javaField.getText());
            double computerScore = Double.parseDouble(computerField.getText());
            // 计算总分和平均分
            double totalScore = mathScore + englishScore + javaScore + computerScore;
            double averageScore = totalScore / 4;
            // 保存学生信息
            try {
				saveStudentInfo(name, gender, birthday, mathScore, englishScore, javaScore, computerScore, totalScore, averageScore);  // 调用保存学生信息的方法
			} catch (Exception e1) {
				e1.printStackTrace();  // 打印异常信息
			}
        } else if (e.getSource() == exitButton) {  // 当点击退出按钮时
            setVisible(false);  // 隐藏窗口
            dispose();  // 释放窗口资源
        }
    }

    private void saveStudentInfo(String name, String gender, String birthday, double mathScore, double englishScore, double javaScore, double computerScore, double totalScore, double averageScore) throws Exception {
        try (JDBCUtil db = new JDBCUtil()) {  // 使用 try-with-resources 语句创建 JDBCUtil 实例
            Connection conn = db.getConn();  // 获取数据库连接
            String sql = "INSERT INTO students (name, gender, birthdate, math, English, Java, computer, score, average) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)";  // 定义插入学生信息的 SQL 语句
            PreparedStatement pst = conn.prepareStatement(sql);  // 创建 PreparedStatement 对象
            pst.setString(1, name);  // 设置参数
            pst.setString(2, gender);
            pst.setString(3, birthday);
            pst.setDouble(4, mathScore);
            pst.setDouble(5, englishScore);
            pst.setDouble(6, javaScore);
            pst.setDouble(7, computerScore);
            pst.setDouble(8, totalScore);
            pst.setDouble(9, averageScore);
            pst.executeUpdate();  // 执行插入操作
        } catch (SQLException e) {  // 捕获异常
            e.printStackTrace();  // 打印异常信息
        }
        displayResult();  // 调用显示结果的方法
    }

    private void displayResult() {  // 显示结果的方法
        Frame resultFrame = new Frame();  // 创建结果窗口
        resultFrame.setBounds(300, 300, 350, 100);
        resultFrame.setLayout(null);
        resultFrame.setVisible(true);

        Button returnButton = new Button("返回");
        returnButton.setBounds(230, 40, 80, 30);
        returnButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                resultFrame.setVisible(false);
                resultFrame.dispose();
            }
        });

        Label resultLabel = new Label("添加成功!");  // 创建结果标签
        resultLabel.setBounds(140, 20, 100, 40);
        resultFrame.add(resultLabel);
        resultFrame.add(returnButton);

        resultFrame.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent evt) {
                resultFrame.setVisible(false);
                resultFrame.dispose();
            }
        });
    }

    public static void main(String[] args) {  // 主方法
        GUIInput gui = new GUIInput();  // 创建 GUIInput 实例
        gui.setSize(600, 400);  // 设置窗口大小
        gui.setVisible(true);  // 显示窗口
    }
}

GUIoutnum

package gui; // 包声明

import java.awt.*; // 导入必要的类库
import java.awt.event.*;
import java.sql.*;
import javax.swing.*;
import javax.swing.table.DefaultTableModel; // 导入表格模型类
import org.jfree.chart.ChartFactory; // 导入 JFreeChart 类库
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.data.category.DefaultCategoryDataset;
import utils.JDBCUtil; // 导入 JDBCUtil 类

public class GUIOutnum extends JFrame implements ActionListener {  // 类声明，继承自 JFrame 并实现 ActionListener 接口

	private static final long serialVersionUID = 1L;  // 声明一个私有静态常量 serialVersionUID
	private JButton overallRankButton, subjectScoresButton, backButton;  // 声明按钮
    private JPanel chartPanel;  // 声明面板
    private GridBagConstraints gridBagConstraints;  // 声明网格包容器

    public GUIOutnum() {  // 构造函数
        setLayout(new GridBagLayout());  // 使用网格布局管理器
        gridBagConstraints = new GridBagConstraints();  // 创建网格包容器

        overallRankButton = new JButton("总体排名");  // 创建按钮
        overallRankButton.addActionListener(this);  // 添加事件监听器
        subjectScoresButton = new JButton("科目成绩");
        subjectScoresButton.addActionListener(this);
        backButton = new JButton("返回");
        backButton.addActionListener(this);

        addWindowListener(new WindowAdapter() {  // 窗口关闭事件监听器
            public void windowClosing(WindowEvent e) {
                setVisible(false);  // 隐藏窗口
                dispose();  // 释放窗口资源
                System.exit(0);  // 退出程序
            }
        });

        addComponent(overallRankButton, 0, 2, 1, 2);  // 添加组件
        addComponent(subjectScoresButton, 2, 2, 1, 2);
        addComponent(backButton, 4, 2, 1, 2);
        
    }

    public void addComponent(Component component, int row, int col, int nrow, int ncol) {  // 添加组件方法
        gridBagConstraints.gridx = col;  // 设置组件的列索引
        gridBagConstraints.gridy = row;  // 设置组件的行索引
        gridBagConstraints.gridheight = ncol;  // 设置组件的行跨度
        gridBagConstraints.gridwidth = nrow;  // 设置组件的列跨度
        gridBagConstraints.insets = new Insets(5, 5, 5, 5);  // 设置组件的内边距
        gridBagConstraints.fill = GridBagConstraints.HORIZONTAL;  // 设置网格包容器的填充方式
        add(component, gridBagConstraints);  // 添加组件
    }

    public void actionPerformed(ActionEvent e) {  // 处理按钮点击的方法
        if (e.getSource() == overallRankButton) {  // 当点击总体排名按钮时
            JFrame frame = new JFrame();  // 创建新的窗口
            frame.setBounds(600, 130, 500, 750);  // 设置窗口位置和大小
            frame.setLayout(new BorderLayout());  // 使用边界布局管理器
            frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);  // 设置关闭操作

            backButton.setBounds(380, 690, 80, 30);  // 设置按钮位置
            backButton.addActionListener(this);  // 添加事件监听器

            try (JDBCUtil db = new JDBCUtil()) {  // 使用 try-with-resources 语句创建 JDBCUtil 实例
                Connection conn = db.getConn();  // 获取数据库连接
                int rank = 1;  // 初始化排名为1
                try {
                    Statement stmt = conn.createStatement();  // 创建 Statement 对象
                    String sql = "SELECT name, id, math, English, Java, computer, (math + English + Java + computer) AS total " +
                                 "FROM students ORDER BY total DESC";  // 定义查询总体排名的 SQL 语句
                    ResultSet rs = stmt.executeQuery(sql);  // 执行查询语句

                    DefaultTableModel tableModel = new DefaultTableModel();  // 创建默认表格模型
                    tableModel.addColumn("排名");  // 添加列
                    tableModel.addColumn("姓名");
                    tableModel.addColumn("学号");
                    tableModel.addColumn("数学成绩");
                    tableModel.addColumn("英语成绩");
                    tableModel.addColumn("Java成绩");
                    tableModel.addColumn("计算机成绩");
                    tableModel.addColumn("总成绩");
                    tableModel.addColumn("平均成绩");

                    while (rs.next()) {  // 遍历结果集
                        double math = rs.getDouble("math");  // 获取数学成绩
                        double english = rs.getDouble("English");  // 获取英语成绩
                        double java = rs.getDouble("Java");  // 获取Java成绩
                        double computer = rs.getDouble("computer");  // 获取计算机成绩

                        double total = math + english + java + computer;  // 计算总成绩
                        double average = total / 4;  // 计算平均成绩
                        
                        // 将数据添加到表格模型中
                        String[] row = {String.valueOf(rank), rs.getString("name"), rs.getString("id"),
                                String.valueOf(math), String.valueOf(english),
                                String.valueOf(java), String.valueOf(computer),
                                String.valueOf(total), // 总成绩
                                String.valueOf(average)}; // 平均成绩
                        tableModel.addRow(row);  // 添加行
                        rank++;  // 排名加1
                    }

                    // 创建表格并添加到滚动面板中
                    JTable table = new JTable(tableModel);  // 创建表格
                    JScrollPane scrollPane = new JScrollPane(table);  // 创建滚动面板
                    frame.add(scrollPane, BorderLayout.CENTER);  // 添加到窗口中
                    frame.add(backButton, BorderLayout.SOUTH);  // 添加返回按钮到窗口底部

                    rs.close();  // 关闭结果集
                    stmt.close();  // 关闭 Statement
                    conn.close();  // 关闭连接
                } catch (Exception e1) {
                    e1.printStackTrace();  // 打印异常信息
                }
            } catch (Exception e1) {
                e1.printStackTrace();  // 打印异常信息
            }
            frame.setVisible(true);  // 显示窗口

        } else if (e.getSource() == subjectScoresButton) {  // 当点击科目成绩按钮时
            JFrame frame = new JFrame();  // 创建新的窗口
            frame.setBounds(300, 300, 450, 450);  // 设置窗口位置和大小
            frame.setLayout(new BorderLayout());  // 使用边界布局管理器
            frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);  // 设置关闭操作

            DefaultCategoryDataset dataset = new DefaultCategoryDataset();  // 创建默认分类数据集
            try (JDBCUtil db = new JDBCUtil()) {  // 使用 try-with-resources 语句创建 JDBCUtil 实例
                Connection conn = db.getConn();  // 获取数据库连接
                Statement stmt = conn.createStatement();  // 创建 Statement 对象

                String query = "SELECT math, English, Java, computer FROM students";  // 定义查询学生各科目成绩的 SQL 语句
                ResultSet rs = stmt.executeQuery(query);  // 执行查询语句

                while (rs.next()) {  // 遍历结果集
                    // 将各科目成绩添加到数据集中
                    dataset.addValue(rs.getDouble("math"), "Math", "Student");
                    dataset.addValue(rs.getDouble("English"), "English", "Student");
                    dataset.addValue(rs.getDouble("Java"), "Java", "Student");
                    dataset.addValue(rs.getDouble("computer"), "Computer", "Student");
                }

                JFreeChart barChart = ChartFactory.createBarChart("Student's subject grades", "Subject", "Grades", dataset);  // 创建柱状图

                chartPanel = new ChartPanel(barChart);  // 创建图表面板
                frame.add(chartPanel, BorderLayout.CENTER);  // 添加图表面板到窗口中

                rs.close();  // 关闭结果集
                stmt.close();  // 关闭 Statement
                conn.close();  // 关闭连接
            } catch (Exception ex) {
                ex.printStackTrace();  // 打印异常信息
            }

            frame.setVisible(true);  // 显示窗口
        } else if (e.getSource() == backButton) {  // 当点击返回按钮时
        	setVisible(false);  // 隐藏窗口
            dispose();  // 释放资源
        }
    }
    


    public static void main(String[] args) {  // 主方法
        SwingUtilities.invokeLater(() -> {  // 使用SwingUtilities的invokeLater方法在事件分发线程上创建和显示GUI
            GUIOutnum gui = new GUIOutnum();  // 创建 GUIOutnum 实例
            gui.setSize(700, 500);  // 设置窗口大小
            gui.setVisible(true);  // 显示窗口
        });
    }
   
}

GUIseeknum


package gui;  // 包声明

import java.awt.*;  // 导入必要的类库
import java.awt.event.*;
import java.sql.*;
import javax.swing.JOptionPane;  // 导入 JOptionPane 类
import utils.JDBCUtil;  // 导入 JDBCUtil 类

public class GUISeeknum extends Frame implements ActionListener {  // 类声明，继承自 Frame 并实现 ActionListener 接口
	
	private static final long serialVersionUID = 1L;  // 声明一个私有静态常量 serialVersionUID
	private Label a1;  // 标签组件
	private Button b1, b2, b3;  // 按钮组件
	private TextField c1;  // 文本框组件

	public GUISeeknum() {  // 构造方法
		a1 = new Label("请输入学生学号或姓名：");  // 创建标签实例
		c1 = new TextField(20);  // 创建文本框实例
		setLayout(new FlowLayout());  // 设置布局为流式布局
		add(a1);  // 添加标签
		add(c1);  // 添加文本框
		b1 = new Button("根据姓名查询");  // 创建按钮
		b2 = new Button("根据学号查询");
		b3 = new Button("退出");
		b1.addActionListener(this);  // 添加事件监听器
		b2.addActionListener(this);
		b3.addActionListener(this);
		add(b1);  // 添加按钮
		add(b2);
		add(b3);

		addWindowListener(new WindowAdapter() {  // 窗口关闭事件监听器
			public void windowClosing(WindowEvent e) {  // 当窗口关闭时
				System.exit(0);  // 退出程序
			}
		});
	}

	public void actionPerformed(ActionEvent e) {  // 处理按钮点击的方法
		String input = c1.getText().trim();  // 获取输入的文本并去除两端空白
		if (e.getSource() == b1) {  // 当点击“根据姓名查询”按钮时
			if (input.isEmpty()) {  // 如果输入为空
				JOptionPane.showMessageDialog(this, "请输入姓名", "提醒", JOptionPane.INFORMATION_MESSAGE);  // 显示消息对话框
			} else {
				try {
					searchByName(input);  // 调用根据姓名查询的方法
				} catch (Exception e1) {  // 处理异常
					e1.printStackTrace();  // 打印异常信息
				}
			}
		} else if (e.getSource() == b2) {  // 当点击“根据学号查询”按钮时
			if (input.isEmpty()) {  // 如果输入为空
				JOptionPane.showMessageDialog(this, "请输入学号", "提醒", JOptionPane.INFORMATION_MESSAGE);  // 显示消息对话框
			} else {
				try {
					searchById(input);  // 调用根据学号查询的方法
				} catch (Exception e1) {  // 处理异常
					e1.printStackTrace();  // 打印异常信息
				}
			}
		} else if (e.getSource() == b3) {  // 当点击“退出”按钮时
			setVisible(false);  // 隐藏窗口
            dispose();  // 释放资源
		}
	}

	private void searchByName(String name) throws Exception {  // 根据姓名查询的方法
	    String sql = "select * from students where name like ?";  // 使用占位符的 SQL 语句
	    try (JDBCUtil db = new JDBCUtil(); 
	         Connection conn = db.getConn();
	         PreparedStatement preparedStatement = conn.prepareStatement(sql)) {
	        preparedStatement.setString(1, "%" + name + "%");  // 设置占位符的值
	        try (ResultSet rs = preparedStatement.executeQuery()) {  // 执行查询并获取结果集
	            int count = 0;  // 计数器
	            while (rs.next()) {  // 遍历结果集
	                showStudentInfo(rs);  // 显示学生信息
	                count++;
	            }
	            if (count == 0) {  // 如果没有找到学生信息
	                JOptionPane.showMessageDialog(this, "没有找到学生信息", "提醒", JOptionPane.INFORMATION_MESSAGE);  // 显示消息对话框
	            }
	        }
	    } catch (SQLException ex) {  // 处理异常
	        ex.printStackTrace();  // 打印异常信息
	    }
	}

	private void searchById(String id) throws Exception {  // 根据学号查询的方法
		try {
	        int studentId = Integer.parseInt(id);  // 将学号转换为整数
	        String sql = "select * from students where id=" + studentId;  // 构造查询的 SQL 语句
	        executeQuery(sql);  // 执行查询
	    } catch (NumberFormatException e) {  // 处理格式转换异常
	        JOptionPane.showMessageDialog(this, "学号必须是数字", "错误", JOptionPane.ERROR_MESSAGE);  // 显示错误消息对话框
	    }
	}

	private void executeQuery(String sql) throws Exception {  // 执行查询的方法
	    try (JDBCUtil db = new JDBCUtil(); 
	            Connection conn = db.getConn();
	            Statement stmt = conn.createStatement();
	            ResultSet rs = stmt.executeQuery(sql)) {
	           int count = 0;  // 计数器
	           while (rs.next()) {  // 遍历结果集
	               showStudentInfo(rs);  // 显示学生信息
	               count++;
	           }
	           if (count == 0) {  // 如果没有找到学生信息
	               JOptionPane.showMessageDialog(this, "没有找到学生信息", "提醒", JOptionPane.INFORMATION_MESSAGE);  // 显示消息对话框
	           }
	       } catch (SQLException ex) {  // 处理异常
	           ex.printStackTrace();  // 打印异常信息
	       }
	}

	private void showStudentInfo(ResultSet rs) throws SQLException {  // 显示学生信息的方法
		String studentInfo = "学号: " + rs.getString("id") + "\n姓名: " + rs.getString("name") + "\n性别: "
				+ rs.getString("gender") + "\n生日: " + rs.getDate("birthdate") + "\n应用数学: " + rs.getFloat("math")
				+ "\n大学英语: " + rs.getFloat("English") + "\nJava程序设计: " + rs.getFloat("Java") + "\n计算机应用基础: "
				+ rs.getFloat("computer") + "\n总分: " + rs.getFloat("score") + "\n平均分: " + rs.getFloat("average");  // 构建学生信息字符串
		JOptionPane.showMessageDialog(this, studentInfo, "学生信息", JOptionPane.INFORMATION_MESSAGE);  // 显示消息对话框
	}

	public static void main(String[] args) {  // 主方法
		GUISeeknum mygb = new GUISeeknum();  // 创建 GUISeeknum 实例
		mygb.setSize(300, 200);  // 设置窗口大小
		mygb.setVisible(true);  // 显示窗口
	}
}

userloin

package gui;  // 包声明

import javax.swing.*;  // 导入必要的类库
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class GUIUserLogin extends JFrame {  // 类声明，继承自 JFrame

    private static final long serialVersionUID = 1L;  // 声明一个私有静态常量 serialVersionUID
    private JTextField usernameField;  // 用户名文本框
    private JPasswordField passwordField;  // 密码文本框
    private LoginListener loginListener;  // 登录监听器

    public void setLoginListener(LoginListener loginListener) {  // 设置登录监听器的方法
        this.loginListener = loginListener;
    }

    public GUIUserLogin() {  // 构造方法
        setTitle("用户登录");  // 设置窗口标题
        setSize(400, 250);  // 设置窗口大小
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  // 设置默认关闭操作

        JPanel panel = new JPanel(new GridBagLayout());  // 创建面板并使用网格包布局管理器
        GridBagConstraints gbc = new GridBagConstraints();  // 创建网格包容器

        JLabel usernameLabel = new JLabel("用户名:");  // 创建用户名标签
        usernameField = new JTextField(15);  // 创建用户名文本框并设置长度
        JLabel passwordLabel = new JLabel("密码:");  // 创建密码标签
        passwordField = new JPasswordField(15);  // 创建密码文本框并设置长度
        JButton loginButton = new JButton("登录");  // 创建登录按钮

        gbc.fill = GridBagConstraints.HORIZONTAL;  // 设置组件填充方式
        gbc.insets = new Insets(20, 20, 20, 20);  // 设置组件之间的间距

        gbc.gridx = 0;
        gbc.gridy = 0;
        panel.add(usernameLabel, gbc);  // 添加用户名标签到面板

        gbc.gridx = 1;
        gbc.gridy = 0;
        panel.add(usernameField, gbc);  // 添加用户名文本框到面板

        gbc.gridx = 0;
        gbc.gridy = 1;
        panel.add(passwordLabel, gbc);  // 添加密码标签到面板

        gbc.gridx = 1;
        gbc.gridy = 1;
        panel.add(passwordField, gbc);  // 添加密码文本框到面板

        gbc.gridwidth = 1;  // 设置按钮跨两列
        gbc.gridx = 1;
        gbc.gridy = 2;
        panel.add(loginButton, gbc);  // 添加登录按钮到面板

        add(panel);  // 将面板添加到窗口
        setLocationRelativeTo(null);  // 将窗口位置设置为屏幕中央

        loginButton.addActionListener(new ActionListener() {  // 登录按钮的点击事件监听器
            @Override
            public void actionPerformed(ActionEvent e) {
                String username = usernameField.getText();  // 获取用户名文本框的值
                String password = new String(passwordField.getPassword());  // 获取密码文本框的值

                // 实现验证逻辑，这里使用假的用户名和密码做示例
                if (username.equals("咕噜咕噜") && password.equals("123")) {  // 如果用户名和密码匹配
                    // 登录成功
                    JOptionPane.showMessageDialog(GUIUserLogin.this, "登录成功");  // 显示登录成功的消息
                    if (loginListener != null) {
                        loginListener.onLoginSuccess();  // 调用登录监听器的登录成功方法
                    }
                    dispose();  // 销毁窗口
                }
                else {
                    // 登录失败
                    JOptionPane.showMessageDialog(GUIUserLogin.this, "账号或密码错误，请重新输入");  // 显示登录失败的消息
                    // 清空文本框
                    usernameField.setText("");  // 清空用户名文本框
                    passwordField.setText("");  // 清空密码文本框
                }
            }
        });
    }

    public static void main(String[] args) {  // 主方法
        SwingUtilities.invokeLater(new Runnable() {  // 使用SwingUtilities的invokeLater方法在事件分发线程上创建和显示GUI
            @Override
            public void run() {
                GUIUserLogin loginGUI = new GUIUserLogin();  // 创建 GUIUserLogin 实例
                loginGUI.setVisible(true);  // 显示窗口
            }
        });
    }
}

interface LoginListener

package gui;  // 包声明

public interface LoginListener {  // 定义一个登录监听器接口
    // 定义一个登录成功的方法，用于通知实现该接口的类
    void onLoginSuccess();
}

generate

package gui;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.util.Random;

public class StudentDataGenerator {
    private static final String[] surnameList = {
        "赵", "钱", "孙", "李", "周", "吴", "郑", "王", "冯", "陈", "褚", "卫", "蒋", "沈", "韩",
        "杨", "朱", "秦", "尤", "许", "何", "吕", "施", "张", "孔", "曹", "严", "华", "金", "魏",
        "陶", "姜", "戚", "谢", "邹", "喻", "柏", "水", "窦", "章", "云", "苏", "潘", "葛",
        "奚", "范", "彭", "郎", "鲁", "韦", "昌", "马", "苗", "凤", "花", "方", "俞", "任", "袁",
        "柳", "酆", "鲍", "史", "唐", "费", "廉", "岑", "薛", "雷", "贺", "倪", "汤", "滕", "殷",
        "罗", "毕", "郝", "邬", "安", "常", "乐", "于", "时", "傅", "皮", "卞", "齐", "康", "伍",
        "余", "元", "卜", "顾", "孟", "平", "黄", "和", "穆", "萧", "尹", "欧阳", "慕容"
    };

    private static final String[] givenNameList = {
        "白", "羽", "斯", "年", "念", "瑀", "云", "飞", "宸", "悦", "华", "坦", "玄", "染", "生", "阳",
        "太", "极", "素", "宁", "凝", "礼", "瑞", "简", "钧", "珩", "安", "烟", "雾", "彤", "清", "辞",
        "檀", "桃", "莓", "夏", "愿", "华", "焜", "彤", "霭", "桐", "璃", "韵", "婉", "静", "娅", "娴"
    };

    public static void main(String[] args) {  // 主方法
        try {
            // 连接数据库
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "20041015");
            // 准备SQL插入语句
            String insertSQL = "INSERT INTO students (name, gender, math, English, Java, computer, score, average) VALUES (?, ?, ?, ?, ?, ?, ?, ?)";
            PreparedStatement pstmt = conn.prepareStatement(insertSQL);

            Random random = new Random();  // 创建随机数生成器

            // 循环生成学生数据
            for (int i = 1; i <= 100; i++) {
                // 随机生成中文姓名
                String name = getRandomChineseName();  // 生成中文姓名
                // 随机生成性别
                String gender = i % 2 == 0 ? "女" : "男";  // 根据序号奇偶确定性别
                // 生成随机数学成绩
                float mathScore = generateRandomScore(80, 20, random);  // 生成随机数学成绩
                // 生成随机英语成绩
                float englishScore = generateRandomScore(80, 20, random);  // 生成随机英语成绩
                // 生成随机Java成绩
                float javaScore = generateRandomScore(80, 20, random);  // 生成随机Java成绩
                // 生成随机计算机科学成绩
                float computerScore = generateRandomScore(80, 20, random);  // 生成随机计算机科学成绩

                // 将生成的数据插入数据库
                pstmt.setString(1, name);  // 设置姓名
                pstmt.setString(2, gender);  // 设置性别
                pstmt.setFloat(3, mathScore);  // 设置数学成绩
                pstmt.setFloat(4, englishScore);  // 设置英语成绩
                pstmt.setFloat(5, javaScore);  // 设置Java成绩
                pstmt.setFloat(6, computerScore);  // 设置计算机科学成绩
                pstmt.setFloat(7, (mathScore + englishScore + javaScore + computerScore));  // 设置总分
                pstmt.setFloat(8, (mathScore + englishScore + javaScore + computerScore) / 4);  // 设置平均分

                pstmt.executeUpdate();  // 执行插入操作
            }

            // 关闭连接和预编译语句
            pstmt.close();  // 关闭预编译语句
            conn.close();  // 关闭连接
        } catch (Exception e) {
            e.printStackTrace();  // 打印异常信息
        }
    }

    /**
     * 生成符合指定平均值和标准差的正态分布随机数
     * @param average 平均值
     * @param standardDeviation 标准差
     * @param random 随机数生成器
     * @return 生成的随机数
     */
    private static float generateRandomScore(float average, float standardDeviation, Random random) {  // 生成随机成绩的方法
        float score = (float) (random.nextGaussian() * standardDeviation + average);  // 使用正态分布生成随机数
        if (score < 0) {  // 如果成绩小于0
            return 0;  // 返回0
        } else if (score > 100) {  // 如果成绩大于100
            return 100;  // 返回100
        } else {
            return score;  // 返回生成的随机数
        }
    }

    private static String getRandomChineseName() {  // 生成随机中文名字的方法
        Random random = new Random();  // 创建随机数生成器
        int indexSurname = random.nextInt(surnameList.length);  // 随机获取一个姓氏
        int indexGivenName = random.nextInt(givenNameList.length);  // 随机获取一个名字
        return surnameList[indexSurname] + givenNameList[indexGivenName];  // 拼接姓氏和名字，并返回
    }
}

editform

package gui; // 包声明

import javax.swing.*; // 导入必要的类库
import java.awt.*;
import java.awt.event.*;
import java.sql.*;
import utils.JDBCUtil;

public class GUIEditForm extends JFrame implements ActionListener { // 类声明，继承自 JFrame 并实现 ActionListener 接口
	
	private static final long serialVersionUID = 1L; // 声明一个私有静态常量 serialVersionUID
	private JTextField nameField, genderField, birthdayField, mathField, englishField, javaField, computerField; // 声明文本字段
    private JButton saveButton, backButton; // 声明按钮
    private int studentId; // 声明学生编号变量

    public GUIEditForm(int id, String name) { // 构造函数，传入学生编号和姓名
        studentId = id; // 初始化学生编号
        setTitle("编辑学生信息"); // 设置窗口标题
        setLayout(new GridLayout(9, 2)); // 设置布局为网格布局，9行2列

        new JLabel("学号： " + id); // 创建标签，显示学生编号
        nameField = new JTextField(name); // 创建文本字段，显示学生姓名
        genderField = new JTextField(); // 创建文本字段，用于性别
        birthdayField = new JTextField(); // 创建文本字段，用于生日
        mathField = new JTextField(); // 创建文本字段，用于数学成绩
        englishField = new JTextField(); // 创建文本字段，用于英语成绩
        javaField = new JTextField(); // 创建文本字段，用于Java成绩
        computerField = new JTextField(); // 创建文本字段，用于计算机成绩
        saveButton = new JButton("保存"); // 创建保存按钮
        backButton = new JButton("返回"); // 创建返回按钮

        add(new Label("姓名")); // 将标签和文本字段添加到窗口中
        add(nameField);
        add(new Label("性别"));
        add(genderField);
        add(new Label("生日"));
        add(birthdayField);
        add(new Label("应用数学"));
        add(mathField);
        add(new Label("大学英语"));
        add(englishField);
        add(new Label("Java程序设计"));
        add(javaField);
        add(new Label("计算机应用基础"));
        add(computerField);
        add(saveButton);
        add(backButton);
        
        saveButton.addActionListener(this); // 为保存按钮添加事件监听器
        backButton.addActionListener(this); // 为返回按钮添加事件监听器

        addWindowListener(new WindowAdapter() { // 添加窗口关闭事件监听器
            public void windowClosing(WindowEvent e) {
                setVisible(false); // 隐藏窗口
                dispose(); // 释放窗口资源
            }
        });

        setLocationRelativeTo(null); // 设置窗口相对于屏幕居中显示
        setSize(600, 400); // 设置窗口大小
    }

    public void actionPerformed(ActionEvent e) { // 实现 ActionListener 接口的方法
        if (e.getSource() == saveButton) { // 当点击保存按钮时
            String name = nameField.getText(); // 获取输入的姓名
            String gender = genderField.getText(); // 获取输入的性别
            String birthday = birthdayField.getText(); // 获取输入的生日
            double mathScore = Double.parseDouble(mathField.getText()); // 获取输入的数学成绩
            double englishScore = Double.parseDouble(englishField.getText()); // 获取输入的英语成绩
            double javaScore = Double.parseDouble(javaField.getText()); // 获取输入的Java成绩
            double computerScore = Double.parseDouble(computerField.getText()); // 获取输入的计算机成绩

            try (JDBCUtil db = new JDBCUtil()) { // 使用 try-with-resources 语句创建 JDBCUtil 实例
                Connection conn = db.getConn(); // 获取数据库连接
                String sql = "UPDATE students SET name=?, gender=?, birthdate=?, math=?, English=?, Java=?, computer=? WHERE id=?"; // 定义更新学生信息的 SQL 语句
                PreparedStatement pst = conn.prepareStatement(sql); // 创建 PreparedStatement 对象
                pst.setString(1, name); // 设置参数
                pst.setString(2, gender);
                pst.setString(3, birthday);
                pst.setDouble(4, mathScore);
                pst.setDouble(5, englishScore);
                pst.setDouble(6, javaScore);
                pst.setDouble(7, computerScore);
                pst.setInt(8, studentId);
                pst.executeUpdate(); // 执行更新操作
                JOptionPane.showMessageDialog(null, "学生信息更新成功", "提示", JOptionPane.INFORMATION_MESSAGE); // 显示更新成功的提示框
            } catch (Exception ex) { // 捕获异常
                ex.printStackTrace(); // 打印异常信息
                JOptionPane.showMessageDialog(null, "保存失败，请检查输入", "错误", JOptionPane.ERROR_MESSAGE); // 弹出保存失败的提示框
            }
        } else if (e.getSource() == backButton) { // 当点击返回按钮时
            setVisible(false); // 隐藏窗口
            dispose(); // 释放窗口资源
        }
    }
}

editdelete

package gui; // 声明了包名为 gui

import javax.swing.*; // 导入 javax.swing 包
import java.awt.*; // 导入 java.awt 包
import java.awt.event.*; // 导入 java.awt.event 包
import java.sql.*; // 导入 java.sql 包，用于数据库操作
import javax.swing.table.DefaultTableModel; // 导入用于创建表格的 DefaultTableModel 类
import utils.JDBCUtil; // 导入自定义的 JDBCUtil 类，用于数据库连接

public class GUIEditDelete extends JFrame implements ActionListener { // 声明 GUIEditDelete 类，继承自 JFrame 类并实现 ActionListener 接口

    private static final long serialVersionUID = 1L; // 声明一个私有静态常量 serialVersionUID

    private JButton editButton, deleteButton, backButton; // 声明三个按钮变量
    private JTable table; // 声明一个表格变量
    private JScrollPane scrollPane; // 声明一个滚动面板变量

    public GUIEditDelete() { // 声明类的构造函数
        setLayout(new BorderLayout()); // 设置布局为 BorderLayout

        // 创建按钮
        JPanel buttonPanel = new JPanel(); // 创建一个面板
        editButton = new JButton("编辑"); // 创建编辑按钮
        deleteButton = new JButton("删除"); // 创建删除按钮
        backButton = new JButton("返回"); // 创建返回按钮
        editButton.addActionListener(this); // 为编辑按钮添加事件监听器
        deleteButton.addActionListener(this); // 为删除按钮添加事件监听器
        backButton.addActionListener(this); // 为返回按钮添加事件监听器
        buttonPanel.add(editButton); // 将编辑按钮添加到面板
        buttonPanel.add(deleteButton); // 将删除按钮添加到面板
        buttonPanel.add(backButton); // 将返回按钮添加到面板

        // 创建表格
        String[] columnNames = {"学号", "姓名", "性别", "生日", "数学", "英语", "Java", "计算机", "总成绩", "平均成绩"}; // 定义表格列的标题
        DefaultTableModel tableModel = new DefaultTableModel(columnNames, 0); // 创建一个表格模型
        table = new JTable(tableModel); // 创建表格对象
        scrollPane = new JScrollPane(table); // 创建滚动面板，并将表格添加到滚动面板中

        // 将按钮和表格加到容器中
        add(buttonPanel, BorderLayout.NORTH); // 将按钮面板添加到窗口顶部
        add(scrollPane, BorderLayout.CENTER); // 将表格添加到窗口中间

        // 查询数据库，并填充表格数据
        fillTableData(); // 调用 fillTableData 方法从数据库中获取数据并填充到表格中
    }

    public void fillTableData() { // 声明 fillTableData 方法，用于填充表格数据
        try (JDBCUtil jdbc = new JDBCUtil()) { // 使用 try-with-resources 语句创建 JDBCUtil 实例
            Connection conn = jdbc.getConn(); // 获取数据库连接
            String sql = "SELECT id, name, gender, birthdate, math, English, Java, computer, (math + English + Java + computer) AS total, (math + English + Java + computer) / 4 AS average FROM students"; // 定义 SQL 查询语句
            Statement stmt = conn.createStatement(); // 创建 Statement 对象
            ResultSet rs = stmt.executeQuery(sql); // 执行查询，返回结果集

            DefaultTableModel tableModel = (DefaultTableModel) table.getModel(); // 获取表格的模型
            tableModel.setRowCount(0); // 清空表格数据

            while (rs.next()) { // 循环遍历结果集
                Object[] row = { // 定义一行数据
                    rs.getInt("id"),
                    rs.getString("name"),
                    rs.getString("gender"),
                    rs.getString("birthdate"),
                    rs.getDouble("math"),
                    rs.getDouble("English"),
                    rs.getDouble("Java"),
                    rs.getDouble("computer"),
                    rs.getDouble("total"),
                    rs.getDouble("average")
                };
                tableModel.addRow(row); // 将一行数据添加到表格模型中
            }

            rs.close(); // 关闭结果集
            stmt.close(); // 关闭 Statement
        } catch (Exception e) { // 捕获异常
            e.printStackTrace(); // 打印异常信息
        }
    }

    public void actionPerformed(ActionEvent e) { // 实现 ActionListener 接口的方法
        if (e.getSource() == editButton) { // 当点击编辑按钮时
            int selectedRow = table.getSelectedRow(); // 获取用户选中的行
            if (selectedRow == -1) { // 如果没有选中行
                JOptionPane.showMessageDialog(null, "请选择一行数据进行编辑", "提示", JOptionPane.INFORMATION_MESSAGE); // 显示提示消息框
            } else { // 如果选中了行
                int studentId = (Integer) table.getValueAt(selectedRow, 0); // 获取学生学号
                String studentName = (String) table.getValueAt(selectedRow, 1); // 获取学生姓名
                GUIEditForm editForm = new GUIEditForm(studentId, studentName); // 创建编辑界面实例
                editForm.setVisible(true); // 显示编辑界面
                this.dispose(); // 关闭当前界面
            }
        } else if (e.getSource() == deleteButton) { // 当点击删除按钮时
            int selectedRow = table.getSelectedRow(); // 获取用户选中的行
            if (selectedRow == -1) { // 如果没有选中行
                JOptionPane.showMessageDialog(null, "请选择一行数据进行删除", "提示", JOptionPane.INFORMATION_MESSAGE); // 显示提示消息框
            } else { // 如果选中了行
                int studentId = (Integer) table.getValueAt(selectedRow, 0); // 获取学生学号
                deleteStudent(studentId); // 调用 deleteStudent 方法删除学生信息
            }
        } else if (e.getSource() == backButton) { // 当点击返回按钮时
            setVisible(false); // 隐藏当前窗口
            dispose(); // 释放当前窗口资源
        }
    }

    public void deleteStudent(int studentId) { // 声明 deleteStudent 方法，用于删除学生信息
        int result = JOptionPane.showConfirmDialog(null, "是否确认删除该学生信息？", "确认", JOptionPane.YES_NO_OPTION); // 显示确认对话框
        if (result == JOptionPane.YES_OPTION) { // 如果确认删除
            try (JDBCUtil db = new JDBCUtil()) { // 使用 try-with-resources 语句创建 JDBCUtil 实例
                Connection conn = db.getConn(); // 获取数据库连接
                String sql = "DELETE FROM students WHERE id = ?"; // 定义 SQL 删除语句
                PreparedStatement pst = conn.prepareStatement(sql); // 创建 PreparedStatement 对象
                pst.setInt(1, studentId); // 设置参数
                pst.executeUpdate(); // 执行删除操作
                fillTableData(); // 删除后刷新表格数据
            } catch (Exception e) { // 捕获异常
                e.printStackTrace(); // 打印异常信息
            }
        }
    }

    public static void main(String[] args) { // 主方法
        SwingUtilities.invokeLater(() -> { // 使用 invokeLater 方法在事件分派线程中创建和显示 GUI
            GUIEditDelete gui = new GUIEditDelete(); // 创建 GUIEditDelete 实例
            gui.setSize(800, 400); // 设置窗口尺寸
            gui.setVisible(true); // 显示窗口
        });
    }
}

studentDAO

package dao;  // 包声明

import model.Student;  // 导入学生类

import java.util.List;  // 导入所需的类库

public interface StudentDAO {  // 接口声明
    List<Student> getAllStudents();  // 获取所有学生信息的抽象方法
    void addStudent(Student student);  // 添加学生的抽象方法
    void updateStudent(Student student);  // 更新学生信息的抽象方法
    void deleteStudent(int id);  // 删除学生的抽象方法
}

studentDAOJDBCimpl

package dao;  // 包声明

import java.sql.Connection;  // 导入所需的类库
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import model.Student;  // 导入学生类

public class StudentDAOJDBCImpl implements StudentDAO {  // 类声明并实现 StudentDAO 接口
    private Connection conn;  // 数据库连接对象

    public StudentDAOJDBCImpl(Connection conn) {  // 构造函数
        this.conn = conn;
    }

    public List<Student> getAllStudents() {  // 获取所有学生信息的方法
        List<Student> students = new ArrayList<>();  // 创建学生列表

        try (PreparedStatement stmt = conn.prepareStatement("SELECT * FROM students");  // 准备查询学生信息的 SQL 语句
                ResultSet rs = stmt.executeQuery()) {  // 执行查询并获取结果集
            while (rs.next()) {  // 遍历结果集
                // 注意：根据实际表结构修改列名及数据类型
                Student student = new Student(rs.getInt("id"), rs.getString("name"), rs.getString("gender").charAt(0),
                        rs.getDate("birthdate"), rs.getDouble("math"), rs.getDouble("English"), rs.getDouble("Java"),
                        rs.getDouble("computer"), rs.getDouble("score"), rs.getDouble("average"));  // 根据查询结果构建学生对象
                students.add(student);  // 将学生对象添加到列表中
            }
        } catch (SQLException ex) {
            ex.printStackTrace();  // 打印异常信息
        }
        return students;  // 返回学生列表
    }

    public void addStudent(Student student) {  // 添加学生的方法
        try (PreparedStatement stmt = conn.prepareStatement(
                "INSERT INTO students (id, name, gender, birthdate, math, English, Java, computer, score, average) "
                        + "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")) {  // 准备插入学生信息的 SQL 语句
            stmt.setInt(1, student.getId());  // 设置学生id
            stmt.setString(2, student.getName());  // 设置学生姓名
            stmt.setString(3, String.valueOf(student.getGender()));  // 设置学生性别
            stmt.setDate(4, student.getBirthdate());  // 设置学生出生日期
            stmt.setDouble(5, student.getMath());  // 设置学生数学成绩
            stmt.setDouble(6, student.getEnglish());  // 设置学生英语成绩
            stmt.setDouble(7, student.getJava());  // 设置学生Java成绩
            stmt.setDouble(8, student.getComputer());  // 设置学生计算机科学成绩
            stmt.setDouble(9, student.getScore());  // 设置学生总分
            stmt.setDouble(10, student.getAverage());  // 设置学生平均分

            stmt.executeUpdate();  // 执行插入操作
        } catch (SQLException ex) {
            ex.printStackTrace();  // 打印异常信息
        }
    }

    public void updateStudent(Student student) {  // 更新学生信息的方法
        try (PreparedStatement stmt = conn
                .prepareStatement("UPDATE students SET name = ?, gender = ?, birthdate = ?, math = ?, "
                        + "English = ?, Java = ?, computer = ?, score = ?, average = ? WHERE id = ?")) {  // 准备更新学生信息的 SQL 语句
            stmt.setString(1, student.getName());  // 设置学生姓名
            stmt.setString(2, String.valueOf(student.getGender()));  // 设置学生性别
            stmt.setDate(3, student.getBirthdate());  // 设置学生出生日期
            stmt.setDouble(4, student.getMath());  // 设置学生数学成绩
            stmt.setDouble(5, student.getEnglish());  // 设置学生英语成绩
            stmt.setDouble(6, student.getJava());  // 设置学生Java成绩
            stmt.setDouble(7, student.getComputer());  // 设置学生计算机科学成绩
            stmt.setDouble(8, student.getScore());  // 设置学生总分
            stmt.setDouble(9, student.getAverage());  // 设置学生平均分
            stmt.setInt(10, student.getId());  // 设置学生id

            stmt.executeUpdate();  // 执行更新操作
        } catch (SQLException ex) {
            ex.printStackTrace();  // 打印异常信息
        }
    }

    public void deleteStudent(int id) {  // 删除学生的方法
        try (PreparedStatement stmt = conn.prepareStatement("DELETE FROM students WHERE id = ?")) {  // 准备删除学生信息的 SQL 语句
            stmt.setInt(1, id);  // 设置要删除的学生id
            stmt.executeUpdate();  // 执行删除操作
        } catch (SQLException ex) {
            ex.printStackTrace();  // 打印异常信息
        }
    }
}

student

package model;

import java.sql.Date;

public class Student {
	private int id;
	private String name;
	private char gender;
	private Date birthdate;
	private double math;
	private double english;
	private double java;
	private double computer;
	private double score;
	private double average;

	// 构造函数
	public Student(int id, String name, char gender, Date birthdate, double math, double english, double java,
			double computer, double score, double average) {
		this.id = id;
		this.name = name;
		this.gender = gender;
		this.birthdate = birthdate;
		this.math = math;
		this.english = english;
		this.java = java;
		this.computer = computer;
		this.score = score;
		this.average = average;
	}

	public int getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

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

	public char getGender() {
		return gender;
	}

	public void setGender(char gender) {
		this.gender = gender;
	}

	public Date getBirthdate() {
		return birthdate;
	}

	public void setBirthdate(Date birthdate) {
		this.birthdate = birthdate;
	}

	public double getMath() {
		return math;
	}

	public void setMath(double math) {
		this.math = math;
	}

	public double getEnglish() {
		return english;
	}

	public void setEnglish(double english) {
		this.english = english;
	}

	public double getJava() {
		return java;
	}

	public void setJava(double java) {
		this.java = java;
	}

	public double getComputer() {
		return computer;
	}

	public void setComputer(double computer) {
		this.computer = computer;
	}

	public double getScore() {
		return score;
	}

	public void setScore(double score) {
		this.score = score;
	}

	public double getAverage() {
		return average;
	}

	public void setAverage(double average) {
		this.average = average;
	}

	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", gender=" + gender + ", birthdate=" + birthdate + ", math="
				+ math + ", english=" + english + ", java=" + java + ", computer=" + computer + ", score=" + score
				+ ", average=" + average + "]";
	}
}

JDBCutils

package utils;  // 包声明

import java.sql.Connection;  // 导入所需的类库
import java.sql.DriverManager;
import java.sql.SQLException;

public class JDBCUtil implements AutoCloseable {  // 类声明并实现 AutoCloseable 接口

    private Connection conn;  // 数据库连接对象

    // 构造函数中建立数据库连接
    public JDBCUtil() {  // 构造函数
        try {
            String url = "jdbc:mysql://localhost:3306/test";  // 数据库连接的 URL
            String username = "root";  // 数据库用户名
            String password = "20041015";  // 数据库密码
            conn = DriverManager.getConnection(url, username, password);  // 建立数据库连接
        } catch (SQLException ex) {
            ex.printStackTrace();  // 打印异常信息
        }
    }

    public Connection getConn() {  // 获取数据库连接的方法
        return conn;  // 返回数据库连接对象
    }

    // 实现 close 方法
    @Override
    public void close() throws Exception {  // 实现 close 方法
        if (conn != null && !conn.isClosed()) {  // 如果数据库连接不为null且未关闭
            conn.close();  // 关闭数据库连接
        }
    }
}