zqy173590939 发表于 2023-12-31 23:19:22

专用

专用

FishC 发表于 2023-12-31 23:19:35

嗨!看来你遇到了问题,我会尽力帮助你解答。请告诉我你在编程方面遇到的问题,我会尽力给出通俗易懂且幽默的解答。不过还是需要你提供具体的问题,这样我才能帮到你。所以,请问你在编程中遇到了什么困难呢?

以上回复来自 FishC AI 小助理,如未能正确解答您的问题,请继续追问。

zqy173590939 发表于 2023-12-31 23:20:17

@FishC
package com.example.javafxmw;

import gaijin3.*;
import javafx.application.Application;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.scene.Node;
import javafx.scene.Scene;
import javafx.scene.chart.PieChart;
import javafx.scene.control.*;
import javafx.scene.image.Image;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.FlowPane;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.stage.Stage;
import javafx.util.Pair;

import java.io.IOException;
import java.sql.*;
import java.util.Optional;

public class HelloApplication extends Application
{
    // 定义全局变量
    //定义一个TextArea控件作为全局变量
    TextArea infoTextArea = new TextArea();

    Button viewAccuracyButton = new Button("View Accuracy");

    FlowPane flowPane = new FlowPane();
    ScrollPane scrollPane = new ScrollPane();// 创建一个滚动面板对象
    private int maxID = 0;

    @Override
    public void start(Stage stage) throws IOException {
      MenuItem generateMenuItem = new MenuItem("Generate");

      // 事件处理器代码
      generateMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                generateEquation();
            }
      });

      MenuItem saveMenuItem = new MenuItem("Save");

      saveMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                saveEquations();
                connectDatabase();
            }
      });

      MenuItem readMenuItem = new MenuItem("Read");

      readMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                flowPane.getChildren().clear(); // 清空当前GUI界面
                showAlert("习题已读取");
                displayAllEquationsFromDatabase();
            }
      });

      MenuItem checkMenuItem = new MenuItem("Check");

      checkMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                // 检查习题
                checkEquations();
            }
      });

      // View Accuracy按钮的点击事件监听器
      viewAccuracyButton.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                // 显示饼状图
                showAccuracyChart();
            }
      });

      MenuItem deleteMenuItem = new MenuItem("Delete by serial number");

      // Delete by serial number按钮的点击事件监听器,部分删除算数式
      deleteMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                deleteEquations();
            }
      });

      MenuItem deleteMenuItem1 = new MenuItem("Delete all");

      // Delete all按钮的点击事件监听器,全部删除
      deleteMenuItem1.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                // 删除数据库中的所有算术式
                deleteAllEquations();

                // 清空界面上的所有算术式
                flowPane.getChildren().clear();

                showAlert("所有算术式删除成功!");
            }
      });

      MenuItem mistakesEquationsCollection = new MenuItem("Redo Mistakes Equations");

      Menu fileMenu = new Menu("File");
      Menu saveMenu = new Menu("SaveEquation");
      Menu readMenu = new Menu("ReadEquation");
      Menu checkMenu = new Menu("CheckEquation");
      Menu deleteMenu = new Menu("Delete");
      Menu mistakesEquationsCollectionMenu = new Menu("MistakesEquationsCollection");

      fileMenu.getItems().addAll(generateMenuItem);
      saveMenu.getItems().add(saveMenuItem);
      readMenu.getItems().add(readMenuItem);
      checkMenu.getItems().add(checkMenuItem);
      deleteMenu.getItems().addAll(deleteMenuItem,deleteMenuItem1);
      mistakesEquationsCollectionMenu.getItems().add(mistakesEquationsCollection);

      MenuBar menuBar = new MenuBar();
      menuBar.getMenus().addAll(fileMenu);
      menuBar.getMenus().add(saveMenu);
      menuBar.getMenus().add(readMenu);
      menuBar.getMenus().add(checkMenu);
      menuBar.getMenus().add(deleteMenu);
      menuBar.getMenus().add(mistakesEquationsCollectionMenu);

      flowPane.setHgap(50);
      flowPane.setVgap(30);
      flowPane.setPadding(new Insets(20));
      flowPane.setPrefSize(800, 560); // 设置 FlowPane 的大小

      BorderPane borderPane = new BorderPane();
      borderPane.setTop(menuBar);
      borderPane.setCenter(flowPane);

      //为了解决题目生成或多flowpane没有拖动条无法显示的问题
      // 将FlowPane放在一个ScrollPane中
      scrollPane.setContent(flowPane);// 设置滚动面板的内容为 flowPane,即将 flowPane 放入滚动面板中
      scrollPane.setFitToHeight(true);// 可以让滚动面板的高度自适应内容的高度
      borderPane.setCenter(scrollPane); // 将ScrollPane放置在中心位置

      HBox bottomBox = new HBox(10, viewAccuracyButton);
      HBox.setMargin(viewAccuracyButton, new Insets(50, 0, 20, 140));
      borderPane.setBottom(bottomBox);

      Scene scene = new Scene(borderPane, 800, 640);
      stage.setTitle("口算习题薄");
      stage.setScene(scene);
      stage.show();

      infoTextArea.setPrefSize(400, 110);
      //将TextArea控件其设置为只读
      infoTextArea.setEditable(false);

      HBox showbottomBox = new HBox(140, viewAccuracyButton, infoTextArea);
      HBox.setMargin(infoTextArea, new Insets(20, 0, 20, 0));
      borderPane.setBottom(showbottomBox);


    }


    public static void main(String[] args) {
      launch();
    }

    //为了使generate的事件处理器更美观特意拉出了这个类
    public EquationCollection generateEquation() {
      // 创建一个警示对话框
      TextInputDialog dialog = new TextInputDialog("5");
      dialog.setTitle("请输入算式数量");
      dialog.setHeaderText(null);
      dialog.setContentText("算式数量:");

      // 显示对话框,并获取用户输入的算式数量
      Optional<String> result = dialog.showAndWait();
      if (result.isPresent())
      {
            int n = Integer.parseInt(result.get());

            // 生成算式
            EquationCollection equationCollection = generateEquations(n);

            // 清空之前的内容
            flowPane.getChildren().clear();

            // 遍历算式集合并显示在GUI中
            for (IEquation equation : equationCollection)
            {
                maxID++; // id自增
                Label idLabel = new Label(String.valueOf(maxID)); // 获取当前最大ID,并将新的算式ID设为其加1
                Label equationLabel = new Label(equation.toString());
                TextField answerField = new TextField(); // 创建一个新的文本框
                HBox equationBox = new HBox(10, idLabel, new Label("、"), equationLabel, answerField); // 将算式ID标签、顿号、算式标签和文本框放入水平布局
                flowPane.getChildren().add(equationBox); // 将水平布局添加到 flowPane 中
            }

            // 连接数据库
            connectDatabase();
      }
      return null;
    }

    // 生成算式的方法
    public EquationCollection generateEquations(int n) {
      EquationCollection equationCollection = new EquationCollection();
      EquationCheckerOfRange equationChecker = new EquationCheckerOfRange(0, 100);
      equationCollection.generate(n, equationChecker);
      return equationCollection;
    }

    // 连接数据库的方法
    public void connectDatabase() {
      Connection conn = null;
      Statement stmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            DatabaseMetaData dbMeta = conn.getMetaData();
            System.out.println("当前用户:" + dbMeta.getUserName());
            System.out.println("驱动版本:" + dbMeta.getDriverVersion());
            System.out.println("MySQL版本:" + dbMeta.getDatabaseProductVersion());

            stmt = conn.createStatement();

            // 查询最大ID值
            ResultSet rs = stmt.executeQuery("SELECT MAX(id) FROM equationtable");
            if (rs.next()) {
                maxID = rs.getInt(1);
            }

      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (stmt != null)
                  stmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }

    private void saveEquations() {
      Connection conn = null;
      PreparedStatement pstmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            for (Node node : flowPane.getChildren()) {
                if (node instanceof HBox) {
                  HBox equationBox = (HBox) node;
                  Label idLabel = (Label) equationBox.getChildren().get(0); // 获取算式ID标签
                  Label equationLabel = (Label) equationBox.getChildren().get(2);
                  TextField answerField = (TextField) equationBox.getChildren().get(3);

                  String equation = equationLabel.getText();
                  String answerText = answerField.getText();

                  // 检查答案字段是否为空
                  int answer = 0;
                  if (!answerText.isEmpty()) {
                        answer = Integer.parseInt(answerText);
                  }

                  // 计算正确结果
                  int result = calculateResult(equation);

                  // 保存到数据库
                  String sql = "INSERT INTO equationtable (id, Operand1, Operator, Operand2, Result) VALUES (?, ?, ?, ?, ?)";
                  pstmt = conn.prepareStatement(sql);
                  pstmt.setInt(1, Integer.parseInt(idLabel.getText())); // 将算式ID插入到数据库中
                  pstmt.setInt(2, getOperand1(equation));
                  pstmt.setString(3, getOperator(equation));
                  pstmt.setInt(4, getOperand2(equation));
                  pstmt.setInt(5, result);
                  pstmt.executeUpdate();
                }
            }

            System.out.println("算式保存成功!!!");
            showAlert("保存成功!");
      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (pstmt != null)
                  pstmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }



    private int calculateResult(String equation) {
      String[] parts = equation.split(" ");
      int operand1 = Integer.parseInt(parts);
      int operand2 = Integer.parseInt(parts);
      String operator = parts;

      int result = 0;
      switch (operator) {
            case "+":
                result = operand1 + operand2;
                break;
            case "-":
                result = operand1 - operand2;
                break;
            case "*":          //此处预设乘法和除法便于以后相应的添加功能
                result = operand1 * operand2;
                break;
            case "/":
                result = operand1 / operand2;
                break;
      }

      return result;
    }

    private int getOperand1(String equation) {
      String[] parts = equation.split(" ");
      return Integer.parseInt(parts);
    }

    private String getOperator(String equation) {
      String[] parts = equation.split(" ");
      return parts;
    }

    private int getOperand2(String equation) {
      String[] parts = equation.split(" ");
      return Integer.parseInt(parts);
    }

    private void showAlert(String message) {
      Alert alert = new Alert(Alert.AlertType.INFORMATION);
      alert.setTitle("提示信息");
      alert.setHeaderText(null);
      alert.setContentText(message);
      alert.showAndWait();
    }

    private void displayAllEquationsFromDatabase() {
      Connection conn = null;
      Statement stmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            stmt = conn.createStatement();

            ResultSet rs = stmt.executeQuery("SELECT * FROM equationtable");
            if (!rs.next()) {
                showAlert("当前题库为空");
            } else {
                do {
                  int id = rs.getInt("id");
                  String equation = id + "、 " + rs.getInt("Operand1") + " " + rs.getString("Operator") + " " +
                            rs.getInt("Operand2") + " = " + rs.getInt("Result");
                  Label equationLabel = new Label(equation);
                  flowPane.getChildren().add(equationLabel);
                } while (rs.next());
            }

      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (stmt != null)
                  stmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }

    private void checkEquations() {
      int totalEquations = 0; // 总题数
      int correctAnswers = 0; // 答对题数
      int incorrectAnswers = 0; // 答错题数

      for (Node node : flowPane.getChildren()) {
            if (node instanceof HBox) {
                HBox equationBox = (HBox) node;
                Label equationLabel = (Label) equationBox.getChildren().get(2);
                TextField answerField = (TextField) equationBox.getChildren().get(3);
                String equation = equationLabel.getText();
                String answerText = answerField.getText();
                // 检查答案字段是否为空
                if (!answerText.isEmpty()) {
                  totalEquations++;
                  int userAnswer = Integer.parseInt(answerText);
                  int result = calculateResult(equation);
                  if (userAnswer == result) { // 答案正确
                        equationBox.setStyle("-fx-background-color: #99ff99"); // 设置背景色为绿色
                        correctAnswers++;
                  } else { // 答案错误
                        equationBox.setStyle("-fx-background-color: #ff9999"); // 设置背景色为红色
                        incorrectAnswers++;
                  }
                }
            }
      }

      double correctPercentage = (double) correctAnswers / totalEquations * 100;
      double incorrectPercentage = (double) incorrectAnswers / totalEquations * 100;

      infoTextArea.setText("统计信息:\n" +
                "总题数:" + totalEquations + "\n" +
                "正确题数:" + correctAnswers + "\n" +
                "错误题数:" + incorrectAnswers + "\n" +
                "正确率:" + String.format("%.2f", correctPercentage) + "%\n" +
                "错误率:" + String.format("%.2f", incorrectPercentage) + "%");
    }

    private void showAccuracyChart() {
      int totalEquations = 0; // 总题数
      int correctAnswers = 0; // 答对题数
      for (Node node : flowPane.getChildren()) {
            if (node instanceof HBox) {
                HBox equationBox = (HBox) node;
                Label equationLabel = (Label) equationBox.getChildren().get(2);
                TextField answerField = (TextField) equationBox.getChildren().get(3);
                String equation = equationLabel.getText();
                String answerText = answerField.getText();
                // 检查答案字段是否为空
                if (!answerText.isEmpty()) {
                  totalEquations++;
                  int userAnswer = Integer.parseInt(answerText);
                  int result = calculateResult(equation);
                  if (userAnswer == result) { // 答案正确
                        correctAnswers++;
                  }
                }
            }
      }
      // 创建一个饼状图数据
      double correctPercentage = (double) correctAnswers / totalEquations * 100;
      double incorrectPercentage = 100 - correctPercentage;

      infoTextArea.setText("统计信息:\n" +
                "总题数:" + totalEquations + "\n" +
                "正确题数:" + correctAnswers + "\n" +
                "错误题数:" + (totalEquations - correctAnswers) + "\n" +
                "正确率:" + String.format("%.2f", correctPercentage) + "%\n" +
                "错误率:" + String.format("%.2f", incorrectPercentage) + "%");

      // 创建饼状图并显示
      PieChart chart = new PieChart();
      ObservableList<PieChart.Data> pieChartData = FXCollections.observableArrayList(
                new PieChart.Data("Correct", correctAnswers),
                new PieChart.Data("Incorrect", totalEquations - correctAnswers)
      );
      chart.setData(pieChartData);
      chart.setTitle("Accuracy Chart");

      // 创建一个新的Stage来显示饼状图
      Stage chartStage = new Stage();
      chartStage.setScene(new Scene(chart, 600, 400));
      chartStage.show();
    }

    //为了使事件处理器的代码更简洁,刻意独立出了这个方法,没有具体意义
    private void deleteEquations() {
      // 读取数据库中所有题目展示到界面中
      flowPane.getChildren().clear();
      displayAllEquationsFromDatabase();

      // 创建一个警示对话框
      Dialog<Pair<String, String>> dialog = new Dialog<>();
      dialog.setTitle("删除算术式范围");
      dialog.setHeaderText(null);

      // 设置对话框的按钮
      ButtonType deleteButtonType = new ButtonType("删除", ButtonBar.ButtonData.OK_DONE);
      dialog.getDialogPane().getButtonTypes().addAll(deleteButtonType, ButtonType.CANCEL);

      // 创建并设置对话框的内容
      GridPane grid = new GridPane();
      grid.setHgap(10);
      grid.setVgap(10);
      grid.setPadding(new Insets(20, 150, 10, 10));

      TextField startIDTextField = new TextField();
      TextField endIDTextField = new TextField();

      grid.add(new Label("起始ID:"), 0, 0);
      grid.add(startIDTextField, 1, 0);
      grid.add(new Label("结束ID:"), 2, 0);
      grid.add(endIDTextField, 3, 0);

      dialog.getDialogPane().setContent(grid);

      // 点击删除按钮时的逻辑
      dialog.setResultConverter(dialogButton -> {
            if (dialogButton == deleteButtonType) {
                int startID = Integer.parseInt(startIDTextField.getText());
                int endID = Integer.parseInt(endIDTextField.getText());

                // 删除数据库中匹配的算术式
                deleteEquationsByRange(startID, endID);

                // 清空界面上的匹配的算术式
                for (Node node : flowPane.getChildren()) {
                  if (node instanceof HBox) {
                        HBox equationBox = (HBox) node;
                        Label idLabel = (Label) equationBox.getChildren().get(0); // 获取算式ID标签

                        int id = Integer.parseInt(idLabel.getText());
                        if (id >= startID && id <= endID) {
                            flowPane.getChildren().remove(equationBox);
                        }
                  }
                }

                showAlert("算术式删除成功!");
            }
            return null;
      });

      dialog.showAndWait();
    }

    private void deleteEquationsByRange(int startID, int endID) {
      Connection conn = null;
      PreparedStatement pstmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            String sql = "DELETE FROM equationtable WHERE id >= ? AND id <= ?";
            pstmt = conn.prepareStatement(sql);
            pstmt.setInt(1, startID);
            pstmt.setInt(2, endID);
            pstmt.executeUpdate();
      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (pstmt != null)
                  pstmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }

    // 删除数据库中的所有算术式
    private void deleteAllEquations() {
      Connection conn = null;
      Statement stmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            stmt = conn.createStatement();

            String sql = "DELETE FROM equationtable";
            stmt.executeUpdate(sql);
      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (stmt != null)
                  stmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }



}
现在数据库中新增了一个错题集表mistakesequationtable,表的结构跟equationtable完全一样,表中有
Operand1
Operator
Operand2
Result
ID
数据结构分别为:
int
char
int
int
int
,现在需要增加错题集功能,已经创建了错题集菜单栏和重做错题按钮,现在为Redo Mistakes Equations添加事件处理器。点击Redo Mistakes Equations后,弹出警示对话框,提示用户输入本次想要重做多少道错题,确认后则从错题集中随机抽取出相应的数目显示在界面中,要求这部分区别于读取习题,错误的题目用户可以重做,重做的题目展示时要有textfield,重做后也可检查对错和查看正确率。
要求修改checkequation的逻辑,使其链接数据库,点击check后,被判定为错题的题目直接保存在错题集表mistakesequationtable中,错题集表mistakesequationtable表的ID列已被我设置为自增,顺序存入即可。
给出需要添加或修改的部分的代码。

FishC 发表于 2023-12-31 23:20:31

zqy173590939 发表于 2023-12-31 23:20
@FishC
package com.example.javafxmw;

import ga ...

这段代码是一个JavaFX的应用程序,主要是用于生成和保存算术题目,并提供一些功能如查看正确率、删除题目等。

首先,我们来看看程序的整体结构。程序的入口点是main()方法,通过调用launch()方法启动JavaFX应用程序。启动后,会创建一个Stage(舞台)对象,并将stage传递给start()方法。在start()方法中,我们创建了一个菜单栏和一个FlowPane布局容器。菜单栏包含了一系列菜单项,用于生成、保存、读取和检查题目,以及删除全部或部分题目。FlowPane用于展示生成的题目。最后,我们创建了一个场景并将其设置为舞台的场景,然后显示舞台。

现在,让我们来具体了解每个功能的实现。

1. generateEquation()方法用于生成算术题目,并将题目展示在GUI界面中。它首先弹出一个对话框让用户输入题目数量,然后调用generateEquations()方法生成具体的题目,并将题目显示在GUI界面中。同时,它还连接到数据库,以便在保存题目时使用。

2. generateEquations()方法用于生成具体的算术题目。它接受一个整数参数n,表示题目数量,然后使用EquationCheckerOfRange类限定题目的范围(0到100),并生成n个题目。最后,它将题目存放在EquationCollection对象中并返回。

3. connectDatabase()方法用于连接到数据库。它使用JDBC驱动程序连接到名为"rjgzdatabase"的数据库,并获取一些数据库元数据信息。

4. saveEquations()方法用于保存题目到数据库。它首先连接到数据库,然后遍历GUI界面上的所有题目,并将题目的各个部分(操作数1、运算符、操作数2和结果)插入到equationtable表中。

5. calculateResult()方法用于计算给定算术题目的结果。它首先将算术题目字符串分割为操作数1、运算符和操作数2,然后根据运算符计算结果,并返回结果。

6. deleteEquationsByRange()方法用于根据给定范围删除数据库中的算术题目。

以上回复来自 FishC AI 小助理,如未能正确解答您的问题,请继续追问。

zqy173590939 发表于 2024-1-1 13:17:20

@FishC
package com.example.javafxmw;

import gaijin3.*;
import javafx.application.Application;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.scene.Node;
import javafx.scene.Scene;
import javafx.scene.chart.PieChart;
import javafx.scene.control.*;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.FlowPane;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.stage.Stage;
import javafx.util.Pair;

import java.io.IOException;
import java.sql.*;
import java.util.*;

public class HelloApplication extends Application
{
    // 定义全局变量
    //定义一个TextArea控件作为全局变量
    TextArea infoTextArea = new TextArea();

    Button viewAccuracyButton = new Button("View Accuracy");

    FlowPane flowPane = new FlowPane();
    ScrollPane scrollPane = new ScrollPane();// 创建一个滚动面板对象
    private int maxID = 0;

    // 定义一个缓存用于保存被判定为错题的题目
    private Set<String> mistakesSet = new HashSet<>();

    @Override
    public void start(Stage stage) throws IOException {
      MenuItem generateMenuItem = new MenuItem("Generate");

      // 事件处理器代码
      generateMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                generateEquation();
            }
      });

      MenuItem saveMenuItem = new MenuItem("Normal Save");

      saveMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                saveEquations();
                connectDatabase();
            }
      });

      MenuItem readMenuItem = new MenuItem("Read");

      readMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                flowPane.getChildren().clear(); // 清空当前GUI界面
                showAlert("习题已读取");
                displayAllEquationsFromDatabase();
            }
      });

      MenuItem checkMenuItem = new MenuItem("Check");

      checkMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                // 清空之前的错题缓存
                mistakesSet.clear();

                // 检查习题并记录错题到缓存中
                checkEquations();
            }
      });

      // View Accuracy按钮的点击事件监听器
      viewAccuracyButton.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                // 显示饼状图
                showAccuracyChart();
            }
      });

      MenuItem deleteMenuItem = new MenuItem("Delete by serial number");

      // Delete by serial number按钮的点击事件监听器,部分删除算数式
      deleteMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                deleteEquations();
            }
      });

      MenuItem deleteMenuItem1 = new MenuItem("Delete all");

      // Delete all按钮的点击事件监听器,全部删除
      deleteMenuItem1.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                // 删除数据库中的所有算术式
                deleteAllEquations();

                // 清空界面上的所有算术式
                flowPane.getChildren().clear();

                showAlert("所有算术式删除成功!");
            }
      });

      MenuItem saveMistakesEquationsMenuItem = new MenuItem("Save Mistakes Equations");

      saveMistakesEquationsMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                saveMistakesEquationsToDatabase();
            }
      });

      MenuItem mistakesEquationsCollection = new MenuItem("Redo Mistakes Equations");

      mistakesEquationsCollection.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                redoMistakesEquations();
            }
      });

      Menu fileMenu = new Menu("File");
      Menu saveMenu = new Menu("Save Equation");
      Menu readMenu = new Menu("Read Equation");
      Menu checkMenu = new Menu("Check Equation");
      Menu deleteMenu = new Menu("Delete");
      Menu mistakesEquationsCollectionMenu = new Menu("Mistakes Equations Collection");

      fileMenu.getItems().addAll(generateMenuItem);
      saveMenu.getItems().addAll(saveMenuItem,saveMistakesEquationsMenuItem);
      readMenu.getItems().add(readMenuItem);
      checkMenu.getItems().add(checkMenuItem);
      deleteMenu.getItems().addAll(deleteMenuItem,deleteMenuItem1);
      mistakesEquationsCollectionMenu.getItems().add(mistakesEquationsCollection);

      MenuBar menuBar = new MenuBar();
      menuBar.getMenus().addAll(fileMenu);
      menuBar.getMenus().addAll(saveMenu);
      menuBar.getMenus().add(readMenu);
      menuBar.getMenus().add(checkMenu);
      menuBar.getMenus().add(deleteMenu);
      menuBar.getMenus().add(mistakesEquationsCollectionMenu);

      flowPane.setHgap(50);
      flowPane.setVgap(30);
      flowPane.setPadding(new Insets(20));
      flowPane.setPrefSize(800, 560); // 设置 FlowPane 的大小

      BorderPane borderPane = new BorderPane();
      borderPane.setTop(menuBar);
      borderPane.setCenter(flowPane);

      //为了解决题目生成或多flowpane没有拖动条无法显示的问题
      // 将FlowPane放在一个ScrollPane中
      scrollPane.setContent(flowPane);// 设置滚动面板的内容为 flowPane,即将 flowPane 放入滚动面板中
      scrollPane.setFitToHeight(true);// 可以让滚动面板的高度自适应内容的高度
      borderPane.setCenter(scrollPane); // 将ScrollPane放置在中心位置

      HBox bottomBox = new HBox(10, viewAccuracyButton);
      HBox.setMargin(viewAccuracyButton, new Insets(50, 0, 20, 140));
      borderPane.setBottom(bottomBox);

      Scene scene = new Scene(borderPane, 800, 640);
      stage.setTitle("口算习题薄");
      stage.setScene(scene);
      stage.show();

      infoTextArea.setPrefSize(400, 110);
      //将TextArea控件其设置为只读
      infoTextArea.setEditable(false);

      HBox showBottomBox = new HBox(140, viewAccuracyButton, infoTextArea);
      HBox.setMargin(infoTextArea, new Insets(20, 0, 20, 0));
      borderPane.setBottom(showBottomBox);


    }


    public static void main(String[] args) {
      launch();
    }

    //为了使generate的事件处理器更美观特意拉出了这个类
    public EquationCollection generateEquation() {
      // 创建一个警示对话框
      TextInputDialog dialog = new TextInputDialog("5");
      dialog.setTitle("请输入算式数量");
      dialog.setHeaderText(null);
      dialog.setContentText("算式数量:");

      // 显示对话框,并获取用户输入的算式数量
      Optional<String> result = dialog.showAndWait();
      if (result.isPresent())
      {
            int n = Integer.parseInt(result.get());

            // 生成算式
            EquationCollection equationCollection = generateEquations(n);

            // 清空之前的内容
            flowPane.getChildren().clear();

            // 遍历算式集合并显示在GUI中
            for (IEquation equation : equationCollection)
            {
                maxID++; // id自增
                Label idLabel = new Label(String.valueOf(maxID)); // 获取当前最大ID,并将新的算式ID设为其加1
                Label equationLabel = new Label(equation.toString());
                TextField answerField = new TextField(); // 创建一个新的文本框
                HBox equationBox = new HBox(10, idLabel, new Label("、"), equationLabel, answerField); // 将算式ID标签、顿号、算式标签和文本框放入水平布局
                flowPane.getChildren().add(equationBox); // 将水平布局添加到 flowPane 中
            }

            // 连接数据库
            connectDatabase();
      }
      return null;
    }

    // 生成算式的方法
    public EquationCollection generateEquations(int n) {
      EquationCollection equationCollection = new EquationCollection();
      EquationCheckerOfRange equationChecker = new EquationCheckerOfRange(0, 100);
      equationCollection.generate(n, equationChecker);
      return equationCollection;
    }

    // 连接数据库的方法
    public void connectDatabase() {
      Connection conn = null;
      Statement stmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            DatabaseMetaData dbMeta = conn.getMetaData();
            System.out.println("当前用户:" + dbMeta.getUserName());
            System.out.println("驱动版本:" + dbMeta.getDriverVersion());
            System.out.println("MySQL版本:" + dbMeta.getDatabaseProductVersion());

            stmt = conn.createStatement();

            // 查询最大ID值
            ResultSet rs = stmt.executeQuery("SELECT MAX(id) FROM equationtable");
            if (rs.next()) {
                maxID = rs.getInt(1);
            }

      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (stmt != null)
                  stmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }

    private void saveEquations() {
      Connection conn = null;
      PreparedStatement pstmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            for (Node node : flowPane.getChildren()) {
                if (node instanceof HBox) {
                  HBox equationBox = (HBox) node;
                  Label idLabel = (Label) equationBox.getChildren().get(0); // 获取算式ID标签
                  Label equationLabel = (Label) equationBox.getChildren().get(2);
                  TextField answerField = (TextField) equationBox.getChildren().get(3);

                  String equation = equationLabel.getText();
                  String answerText = answerField.getText();

                  // 检查答案字段是否为空
                  int answer = 0;
                  if (!answerText.isEmpty()) {
                        answer = Integer.parseInt(answerText);
                  }

                  // 计算正确结果
                  int result = calculateResult(equation);

                  // 保存到数据库
                  String sql = "INSERT INTO equationtable (id, Operand1, Operator, Operand2, Result) VALUES (?, ?, ?, ?, ?)";
                  pstmt = conn.prepareStatement(sql);
                  pstmt.setInt(1, Integer.parseInt(idLabel.getText())); // 将算式ID插入到数据库中
                  pstmt.setInt(2, getOperand1(equation));
                  pstmt.setString(3, getOperator(equation));
                  pstmt.setInt(4, getOperand2(equation));
                  pstmt.setInt(5, result);
                  pstmt.executeUpdate();
                }
            }

            System.out.println("算式保存成功!!!");
            showAlert("保存成功!");
      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (pstmt != null)
                  pstmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }



    private int calculateResult(String equation) {
      String[] parts = equation.split(" ");
      int operand1 = Integer.parseInt(parts);
      int operand2 = Integer.parseInt(parts);
      String operator = parts;

      int result = 0;
      switch (operator) {
            case "+":
                result = operand1 + operand2;
                break;
            case "-":
                result = operand1 - operand2;
                break;
            case "*":          //此处预设乘法和除法便于以后相应的添加功能
                result = operand1 * operand2;
                break;
            case "/":
                result = operand1 / operand2;
                break;
      }

      return result;
    }

    private int getOperand1(String equation) {
      String[] parts = equation.split(" ");
      return Integer.parseInt(parts);
    }

    private String getOperator(String equation) {
      String[] parts = equation.split(" ");
      return parts;
    }

    private int getOperand2(String equation) {
      String[] parts = equation.split(" ");
      return Integer.parseInt(parts);
    }

    private void showAlert(String message) {
      Alert alert = new Alert(Alert.AlertType.INFORMATION);
      alert.setTitle("提示信息");
      alert.setHeaderText(null);
      alert.setContentText(message);
      alert.showAndWait();
    }

    private void displayAllEquationsFromDatabase() {
      Connection conn = null;
      Statement stmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            stmt = conn.createStatement();

            ResultSet rs = stmt.executeQuery("SELECT * FROM equationtable");
            if (!rs.next()) {
                showAlert("当前题库为空");
            } else {
                do {
                  int id = rs.getInt("id");
                  String equation = id + "、 " + rs.getInt("Operand1") + " " + rs.getString("Operator") + " " +
                            rs.getInt("Operand2") + " = " + rs.getInt("Result");
                  Label equationLabel = new Label(equation);
                  flowPane.getChildren().add(equationLabel);
                } while (rs.next());
            }

      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (stmt != null)
                  stmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }

    private void checkEquations() {
      int totalEquations = 0; // 总题数
      int correctAnswers = 0; // 答对题数
      int incorrectAnswers = 0; // 答错题数

      for (Node node : flowPane.getChildren()) {
            if (node instanceof HBox) {
                HBox equationBox = (HBox) node;
                Label equationLabel = (Label) equationBox.getChildren().get(2);
                TextField answerField = (TextField) equationBox.getChildren().get(3);
                String equation = equationLabel.getText();
                String answerText = answerField.getText();
                // 检查答案字段是否为空
                if (!answerText.isEmpty()) {
                  totalEquations++;
                  int userAnswer = Integer.parseInt(answerText);
                  int result = calculateResult(equation);
                  if (userAnswer == result) { // 答案正确
                        equationBox.setStyle("-fx-background-color: #99ff99"); // 设置背景色为绿色
                        correctAnswers++;
                  } else { // 答案错误
                        equationBox.setStyle("-fx-background-color: #ff9999"); // 设置背景色为红色
                        incorrectAnswers++;

                        // 将判定为错题的题目记录到缓存中
                        mistakesSet.add(equation); // 将错误的题目加入错题集缓存
                  }
                }
            }
      }

      double correctPercentage = (double) correctAnswers / totalEquations * 100;
      double incorrectPercentage = (double) incorrectAnswers / totalEquations * 100;

      infoTextArea.setText("统计信息:\n" +
                "总题数:" + totalEquations + "\n" +
                "正确题数:" + correctAnswers + "\n" +
                "错误题数:" + incorrectAnswers + "\n" +
                "正确率:" + String.format("%.2f", correctPercentage) + "%\n" +
                "错误率:" + String.format("%.2f", incorrectPercentage) + "%");
    }



    private void showAccuracyChart() {
      int totalEquations = 0; // 总题数
      int correctAnswers = 0; // 答对题数
      for (Node node : flowPane.getChildren()) {
            if (node instanceof HBox) {
                HBox equationBox = (HBox) node;
                Label equationLabel = (Label) equationBox.getChildren().get(2);
                TextField answerField = (TextField) equationBox.getChildren().get(3);
                String equation = equationLabel.getText();
                String answerText = answerField.getText();
                // 检查答案字段是否为空
                if (!answerText.isEmpty()) {
                  totalEquations++;
                  int userAnswer = Integer.parseInt(answerText);
                  int result = calculateResult(equation);
                  if (userAnswer == result) { // 答案正确
                        correctAnswers++;
                  }
                }
            }
      }
      // 创建一个饼状图数据
      double correctPercentage = (double) correctAnswers / totalEquations * 100;
      double incorrectPercentage = 100 - correctPercentage;

      infoTextArea.setText("统计信息:\n" +
                "总题数:" + totalEquations + "\n" +
                "正确题数:" + correctAnswers + "\n" +
                "错误题数:" + (totalEquations - correctAnswers) + "\n" +
                "正确率:" + String.format("%.2f", correctPercentage) + "%\n" +
                "错误率:" + String.format("%.2f", incorrectPercentage) + "%");

      // 创建饼状图并显示
      PieChart chart = new PieChart();
      ObservableList<PieChart.Data> pieChartData = FXCollections.observableArrayList(
                new PieChart.Data("Correct", correctAnswers),
                new PieChart.Data("Incorrect", totalEquations - correctAnswers)
      );
      chart.setData(pieChartData);
      chart.setTitle("Accuracy Chart");

      // 创建一个新的Stage来显示饼状图
      Stage chartStage = new Stage();
      chartStage.setScene(new Scene(chart, 600, 400));
      chartStage.show();
    }

    //为了使事件处理器的代码更简洁,刻意独立出了这个方法,没有具体意义
    private void deleteEquations() {
      // 读取数据库中所有题目展示到界面中
      flowPane.getChildren().clear();
      displayAllEquationsFromDatabase();

      // 创建一个警示对话框
      Dialog<Pair<String, String>> dialog = new Dialog<>();
      dialog.setTitle("删除算术式范围");
      dialog.setHeaderText(null);

      // 设置对话框的按钮
      ButtonType deleteButtonType = new ButtonType("删除", ButtonBar.ButtonData.OK_DONE);
      dialog.getDialogPane().getButtonTypes().addAll(deleteButtonType, ButtonType.CANCEL);

      // 创建并设置对话框的内容
      GridPane grid = new GridPane();
      grid.setHgap(10);
      grid.setVgap(10);
      grid.setPadding(new Insets(20, 150, 10, 10));

      TextField startIDTextField = new TextField();
      TextField endIDTextField = new TextField();

      grid.add(new Label("起始ID:"), 0, 0);
      grid.add(startIDTextField, 1, 0);
      grid.add(new Label("结束ID:"), 2, 0);
      grid.add(endIDTextField, 3, 0);

      dialog.getDialogPane().setContent(grid);

      // 点击删除按钮时的逻辑
      dialog.setResultConverter(dialogButton -> {
            if (dialogButton == deleteButtonType) {
                int startID = Integer.parseInt(startIDTextField.getText());
                int endID = Integer.parseInt(endIDTextField.getText());

                // 删除数据库中匹配的算术式
                deleteEquationsByRange(startID, endID);

                // 清空界面上的匹配的算术式
                for (Node node : flowPane.getChildren()) {
                  if (node instanceof HBox) {
                        HBox equationBox = (HBox) node;
                        Label idLabel = (Label) equationBox.getChildren().get(0); // 获取算式ID标签

                        int id = Integer.parseInt(idLabel.getText());
                        if (id >= startID && id <= endID) {
                            flowPane.getChildren().remove(equationBox);
                        }
                  }
                }

                showAlert("算术式删除成功!");
            }
            return null;
      });

      dialog.showAndWait();
    }

    private void deleteEquationsByRange(int startID, int endID) {
      Connection conn = null;
      PreparedStatement pstmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            String sql = "DELETE FROM equationtable WHERE id >= ? AND id <= ?";
            pstmt = conn.prepareStatement(sql);
            pstmt.setInt(1, startID);
            pstmt.setInt(2, endID);
            pstmt.executeUpdate();
      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (pstmt != null)
                  pstmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }

    // 删除数据库中的所有算术式
    private void deleteAllEquations() {
      Connection conn = null;
      Statement stmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            stmt = conn.createStatement();

            String sql = "DELETE FROM equationtable";
            stmt.executeUpdate(sql);
      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (stmt != null)
                  stmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }

    // 保存错题到错题集表的方法
    private void saveMistakesEquationsToDatabase() {
      Connection conn = null;
      PreparedStatement pstmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            for (String equation : mistakesSet) {
                String[] parts = equation.split(" ");
                int operand1 = Integer.parseInt(parts);
                String operator = parts;
                int operand2 = Integer.parseInt(parts);
                int result = calculateResult(equation);

                String sql = "INSERT INTO mistakesequationtable (Operand1, Operator, Operand2, Result) VALUES (?, ?, ?, ?)";
                pstmt = conn.prepareStatement(sql);
                pstmt.setInt(1, operand1);
                pstmt.setString(2, operator);
                pstmt.setInt(3, operand2);
                pstmt.setInt(4, result);
                pstmt.executeUpdate();
            }

            showAlert("保存错题集成功!");
      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (pstmt != null)
                  pstmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }

    // 添加redoMistakesEquations方法实现重新做错题的功能
    private void redoMistakesEquations() {
      TextInputDialog dialog = new TextInputDialog("5");
      dialog.setTitle("请输入错题数量");
      dialog.setHeaderText(null);
      dialog.setContentText("错题数量:");

      Optional<String> result = dialog.showAndWait();
      if (result.isPresent()) {
            int n = Integer.parseInt(result.get());

            // 清空界面上的所有算术式
            flowPane.getChildren().clear();

            // 查询数据库中的错题数量
            int totalMistakes = getMistakesCountFromDatabase();

            if (n > totalMistakes) {
                showAlert("错题集中没有那么多错题,继续加油!");
            } else {
                // 从mistakesequationtable中随机抽出n道错题显示到界面中
                displayRandomMistakesEquations(n);
            }
      }
    }

    private int getMistakesCountFromDatabase() {
      Connection conn = null;
      Statement stmt = null;
      int totalMistakes = 0;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            stmt = conn.createStatement();

            // 查询mistakesequationtable中的记录总数
            ResultSet countResult = stmt.executeQuery("SELECT COUNT(*) FROM mistakesequationtable");
            countResult.next();
            totalMistakes = countResult.getInt(1);
      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (stmt != null)
                  stmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }System.out.println("Goodbye!");

      return totalMistakes;
    }

    private void displayRandomMistakesEquations(int n) {
      Connection conn = null;
      Statement stmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            stmt = conn.createStatement();

            // 查询mistakesequationtable中的记录总数
            ResultSet countResult = stmt.executeQuery("SELECT COUNT(*) FROM mistakesequationtable");
            countResult.next();
            int totalCount = countResult.getInt(1);

            // 随机抽取n道错题的ID
            Set<Integer> selectedIDs = new HashSet<>();
            Random random = new Random();
            while (selectedIDs.size() < n) {
                int randomID = random.nextInt(totalCount) + 1;
                selectedIDs.add(randomID);
            }

            // 查询并显示随机抽取的错题
            for (int id : selectedIDs) {
                ResultSet rs = stmt.executeQuery("SELECT * FROM mistakesequationtable WHERE ID = " + id);
                if (rs.next()) {
                  String equation = rs.getInt("Operand1") + " " + rs.getString("Operator") + " " +
                            rs.getInt("Operand2") + " = ?";
                  Label equationLabel = new Label(equation);
                  TextField answerField = new TextField(); // 创建一个新的文本框
                  HBox equationBox = new HBox(10, equationLabel, answerField); // 将错题和文本框放入水平布局
                  flowPane.getChildren().add(equationBox); // 将水平布局添加到 flowPane 中
                }
            }
      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (stmt != null)
                  stmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }

}
修改代码,使得查看正确率和检查功能也支持统计错题表中的错题。
给出需要添加或修改的部分的代码

FishC 发表于 2024-1-1 13:17:32

zqy173590939 发表于 2024-01-01 13:17
@FishC
package com.example.javafxmw;

import ga ...

为了实现查看正确率和检查功能支持统计错题表中的错题,我们需要对代码进行如下修改:

1. 在类的开头添加以下变量:
```java
private Set

以上回复来自 FishC AI 小助理,如未能正确解答您的问题,请继续追问。

zqy173590939 发表于 2024-1-1 13:41:33

package com.example.javafxmw;

import gaijin3.*;
import javafx.application.Application;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.scene.Node;
import javafx.scene.Scene;
import javafx.scene.chart.PieChart;
import javafx.scene.control.*;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.FlowPane;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.stage.Stage;
import javafx.util.Pair;

import java.io.IOException;
import java.sql.*;
import java.util.*;

public class HelloApplication extends Application
{
    // 定义全局变量
    //定义一个TextArea控件作为全局变量
    TextArea infoTextArea = new TextArea();

    Button viewAccuracyButton = new Button("View Accuracy");

    FlowPane flowPane = new FlowPane();
    ScrollPane scrollPane = new ScrollPane();// 创建一个滚动面板对象
    private int maxID = 0;

    // 定义一个缓存用于保存被判定为错题的题目
    private Set<String> mistakesSet = new HashSet<>();

    @Override
    public void start(Stage stage) throws IOException {
      MenuItem generateMenuItem = new MenuItem("Generate");

      // 事件处理器代码
      generateMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                generateEquation();
            }
      });

      MenuItem saveMenuItem = new MenuItem("Normal Save");

      saveMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                saveEquations();
                connectDatabase();
            }
      });

      MenuItem readMenuItem = new MenuItem("Read");

      readMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                flowPane.getChildren().clear(); // 清空当前GUI界面
                showAlert("习题已读取");
                displayAllEquationsFromDatabase();
            }
      });

      MenuItem checkMenuItem = new MenuItem("Check");

      checkMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                // 清空之前的错题缓存
                mistakesSet.clear();

                // 检查习题并记录错题到缓存中
                checkEquations();
            }
      });

      // View Accuracy按钮的点击事件监听器
      viewAccuracyButton.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                // 显示饼状图
                showAccuracyChart();
            }
      });

      MenuItem deleteMenuItem = new MenuItem("Delete by serial number");

      

      MenuItem saveMistakesEquationsMenuItem = new MenuItem("Save Mistakes Equations");

      saveMistakesEquationsMenuItem.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                saveMistakesEquationsToDatabase();
            }
      });

      MenuItem mistakesEquationsCollection = new MenuItem("Redo Mistakes Equations");

      mistakesEquationsCollection.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent event) {
                redoMistakesEquations();
            }
      });

      Menu fileMenu = new Menu("File");
      Menu saveMenu = new Menu("Save Equation");
      Menu readMenu = new Menu("Read Equation");
      Menu checkMenu = new Menu("Check Equation");
      Menu deleteMenu = new Menu("Delete");
      Menu mistakesEquationsCollectionMenu = new Menu("Mistakes Equations Collection");

      fileMenu.getItems().addAll(generateMenuItem);
      saveMenu.getItems().addAll(saveMenuItem,saveMistakesEquationsMenuItem);
      readMenu.getItems().add(readMenuItem);
      checkMenu.getItems().add(checkMenuItem);
      
      mistakesEquationsCollectionMenu.getItems().add(mistakesEquationsCollection);

      MenuBar menuBar = new MenuBar();
      menuBar.getMenus().addAll(fileMenu);
      menuBar.getMenus().addAll(saveMenu);
      menuBar.getMenus().add(readMenu);
      menuBar.getMenus().add(checkMenu);
      menuBar.getMenus().add(deleteMenu);
      menuBar.getMenus().add(mistakesEquationsCollectionMenu);

      flowPane.setHgap(50);
      flowPane.setVgap(30);
      flowPane.setPadding(new Insets(20));
      flowPane.setPrefSize(800, 560); // 设置 FlowPane 的大小

      BorderPane borderPane = new BorderPane();
      borderPane.setTop(menuBar);
      borderPane.setCenter(flowPane);

      //为了解决题目生成或多flowpane没有拖动条无法显示的问题
      // 将FlowPane放在一个ScrollPane中
      scrollPane.setContent(flowPane);// 设置滚动面板的内容为 flowPane,即将 flowPane 放入滚动面板中
      scrollPane.setFitToHeight(true);// 可以让滚动面板的高度自适应内容的高度
      borderPane.setCenter(scrollPane); // 将ScrollPane放置在中心位置

      HBox bottomBox = new HBox(10, viewAccuracyButton);
      HBox.setMargin(viewAccuracyButton, new Insets(50, 0, 20, 140));
      borderPane.setBottom(bottomBox);

      Scene scene = new Scene(borderPane, 800, 640);
      stage.setTitle("口算习题薄");
      stage.setScene(scene);
      stage.show();

      infoTextArea.setPrefSize(400, 110);
      //将TextArea控件其设置为只读
      infoTextArea.setEditable(false);

      HBox showBottomBox = new HBox(140, viewAccuracyButton, infoTextArea);
      HBox.setMargin(infoTextArea, new Insets(20, 0, 20, 0));
      borderPane.setBottom(showBottomBox);


    }


    public static void main(String[] args) {
      launch();
    }

    //为了使generate的事件处理器更美观特意拉出了这个类
    public EquationCollection generateEquation() {
      // 创建一个警示对话框
      TextInputDialog dialog = new TextInputDialog("5");
      dialog.setTitle("请输入算式数量");
      dialog.setHeaderText(null);
      dialog.setContentText("算式数量:");

      // 显示对话框,并获取用户输入的算式数量
      Optional<String> result = dialog.showAndWait();
      if (result.isPresent())
      {
            int n = Integer.parseInt(result.get());

            // 生成算式
            EquationCollection equationCollection = generateEquations(n);

            // 清空之前的内容
            flowPane.getChildren().clear();

            // 遍历算式集合并显示在GUI中
            for (IEquation equation : equationCollection)
            {
                maxID++; // id自增
                Label idLabel = new Label(String.valueOf(maxID)); // 获取当前最大ID,并将新的算式ID设为其加1
                Label equationLabel = new Label(equation.toString());
                TextField answerField = new TextField(); // 创建一个新的文本框
                HBox equationBox = new HBox(10, idLabel, new Label("、"), equationLabel, answerField); // 将算式ID标签、顿号、算式标签和文本框放入水平布局
                flowPane.getChildren().add(equationBox); // 将水平布局添加到 flowPane 中
            }

            // 连接数据库
            connectDatabase();
      }
      return null;
    }

    // 生成算式的方法
    public EquationCollection generateEquations(int n) {
      EquationCollection equationCollection = new EquationCollection();
      EquationCheckerOfRange equationChecker = new EquationCheckerOfRange(0, 100);
      equationCollection.generate(n, equationChecker);
      return equationCollection;
    }

    // 连接数据库的方法
    public void connectDatabase() {
      Connection conn = null;
      Statement stmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            DatabaseMetaData dbMeta = conn.getMetaData();
            System.out.println("当前用户:" + dbMeta.getUserName());
            System.out.println("驱动版本:" + dbMeta.getDriverVersion());
            System.out.println("MySQL版本:" + dbMeta.getDatabaseProductVersion());

            stmt = conn.createStatement();

            // 查询最大ID值
            ResultSet rs = stmt.executeQuery("SELECT MAX(id) FROM equationtable");
            if (rs.next()) {
                maxID = rs.getInt(1);
            }

      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (stmt != null)
                  stmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }

    private void saveEquations() {
      Connection conn = null;
      PreparedStatement pstmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            for (Node node : flowPane.getChildren()) {
                if (node instanceof HBox) {
                  HBox equationBox = (HBox) node;
                  Label idLabel = (Label) equationBox.getChildren().get(0); // 获取算式ID标签
                  Label equationLabel = (Label) equationBox.getChildren().get(2);
                  TextField answerField = (TextField) equationBox.getChildren().get(3);

                  String equation = equationLabel.getText();
                  String answerText = answerField.getText();

                  // 检查答案字段是否为空
                  int answer = 0;
                  if (!answerText.isEmpty()) {
                        answer = Integer.parseInt(answerText);
                  }

                  // 计算正确结果
                  int result = calculateResult(equation);

                  // 保存到数据库
                  String sql = "INSERT INTO equationtable (id, Operand1, Operator, Operand2, Result) VALUES (?, ?, ?, ?, ?)";
                  pstmt = conn.prepareStatement(sql);
                  pstmt.setInt(1, Integer.parseInt(idLabel.getText())); // 将算式ID插入到数据库中
                  pstmt.setInt(2, getOperand1(equation));
                  pstmt.setString(3, getOperator(equation));
                  pstmt.setInt(4, getOperand2(equation));
                  pstmt.setInt(5, result);
                  pstmt.executeUpdate();
                }
            }

            System.out.println("算式保存成功!!!");
            showAlert("保存成功!");
      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (pstmt != null)
                  pstmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }



    private int calculateResult(String equation) {
      String[] parts = equation.split(" ");
      int operand1 = Integer.parseInt(parts);
      int operand2 = Integer.parseInt(parts);
      String operator = parts;

      int result = 0;
      switch (operator) {
            case "+":
                result = operand1 + operand2;
                break;
            case "-":
                result = operand1 - operand2;
                break;
            case "*":          //此处预设乘法和除法便于以后相应的添加功能
                result = operand1 * operand2;
                break;
            case "/":
                result = operand1 / operand2;
                break;
      }

      return result;
    }

    private int getOperand1(String equation) {
      String[] parts = equation.split(" ");
      return Integer.parseInt(parts);
    }

    private String getOperator(String equation) {
      String[] parts = equation.split(" ");
      return parts;
    }

    private int getOperand2(String equation) {
      String[] parts = equation.split(" ");
      return Integer.parseInt(parts);
    }

    private void showAlert(String message) {
      Alert alert = new Alert(Alert.AlertType.INFORMATION);
      alert.setTitle("提示信息");
      alert.setHeaderText(null);
      alert.setContentText(message);
      alert.showAndWait();
    }

    private void displayAllEquationsFromDatabase() {
      Connection conn = null;
      Statement stmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            stmt = conn.createStatement();

            ResultSet rs = stmt.executeQuery("SELECT * FROM equationtable");
            if (!rs.next()) {
                showAlert("当前题库为空");
            } else {
                do {
                  int id = rs.getInt("id");
                  String equation = id + "、 " + rs.getInt("Operand1") + " " + rs.getString("Operator") + " " +
                            rs.getInt("Operand2") + " = " + rs.getInt("Result");
                  Label equationLabel = new Label(equation);
                  flowPane.getChildren().add(equationLabel);
                } while (rs.next());
            }

      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (stmt != null)
                  stmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }

    private void checkEquations() {
      int totalEquations = 0; // 总题数
      int correctAnswers = 0; // 答对题数
      int incorrectAnswers = 0; // 答错题数

      for (Node node : flowPane.getChildren()) {
            if (node instanceof HBox) {
                HBox equationBox = (HBox) node;
                Label equationLabel = (Label) equationBox.getChildren().get(2);
                TextField answerField = (TextField) equationBox.getChildren().get(3);
                String equation = equationLabel.getText();
                String answerText = answerField.getText();
                // 检查答案字段是否为空
                if (!answerText.isEmpty()) {
                  totalEquations++;
                  int userAnswer = Integer.parseInt(answerText);
                  int result = calculateResult(equation);
                  if (userAnswer == result) { // 答案正确
                        equationBox.setStyle("-fx-background-color: #99ff99"); // 设置背景色为绿色
                        correctAnswers++;
                  } else { // 答案错误
                        equationBox.setStyle("-fx-background-color: #ff9999"); // 设置背景色为红色
                        incorrectAnswers++;

                        // 将判定为错题的题目记录到缓存中
                        mistakesSet.add(equation); // 将错误的题目加入错题集缓存
                  }
                }
            }
      }

      double correctPercentage = (double) correctAnswers / totalEquations * 100;
      double incorrectPercentage = (double) incorrectAnswers / totalEquations * 100;

      infoTextArea.setText("统计信息:\n" +
                "总题数:" + totalEquations + "\n" +
                "正确题数:" + correctAnswers + "\n" +
                "错误题数:" + incorrectAnswers + "\n" +
                "正确率:" + String.format("%.2f", correctPercentage) + "%\n" +
                "错误率:" + String.format("%.2f", incorrectPercentage) + "%");
    }



    private void showAccuracyChart() {
      int totalEquations = 0; // 总题数
      int correctAnswers = 0; // 答对题数
      for (Node node : flowPane.getChildren()) {
            if (node instanceof HBox) {
                HBox equationBox = (HBox) node;
                Label equationLabel = (Label) equationBox.getChildren().get(2);
                TextField answerField = (TextField) equationBox.getChildren().get(3);
                String equation = equationLabel.getText();
                String answerText = answerField.getText();
                // 检查答案字段是否为空
                if (!answerText.isEmpty()) {
                  totalEquations++;
                  int userAnswer = Integer.parseInt(answerText);
                  int result = calculateResult(equation);
                  if (userAnswer == result) { // 答案正确
                        correctAnswers++;
                  }
                }
            }
      }
      // 创建一个饼状图数据
      double correctPercentage = (double) correctAnswers / totalEquations * 100;
      double incorrectPercentage = 100 - correctPercentage;

      infoTextArea.setText("统计信息:\n" +
                "总题数:" + totalEquations + "\n" +
                "正确题数:" + correctAnswers + "\n" +
                "错误题数:" + (totalEquations - correctAnswers) + "\n" +
                "正确率:" + String.format("%.2f", correctPercentage) + "%\n" +
                "错误率:" + String.format("%.2f", incorrectPercentage) + "%");

      // 创建饼状图并显示
      PieChart chart = new PieChart();
      ObservableList<PieChart.Data> pieChartData = FXCollections.observableArrayList(
                new PieChart.Data("Correct", correctAnswers),
                new PieChart.Data("Incorrect", totalEquations - correctAnswers)
      );
      chart.setData(pieChartData);
      chart.setTitle("Accuracy Chart");

      // 创建一个新的Stage来显示饼状图
      Stage chartStage = new Stage();
      chartStage.setScene(new Scene(chart, 600, 400));
      chartStage.show();
    }

   

    // 保存错题到错题集表的方法
    private void saveMistakesEquationsToDatabase() {
      Connection conn = null;
      PreparedStatement pstmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            for (String equation : mistakesSet) {
                String[] parts = equation.split(" ");
                int operand1 = Integer.parseInt(parts);
                String operator = parts;
                int operand2 = Integer.parseInt(parts);
                int result = calculateResult(equation);

                String sql = "INSERT INTO mistakesequationtable (Operand1, Operator, Operand2, Result) VALUES (?, ?, ?, ?)";
                pstmt = conn.prepareStatement(sql);
                pstmt.setInt(1, operand1);
                pstmt.setString(2, operator);
                pstmt.setInt(3, operand2);
                pstmt.setInt(4, result);
                pstmt.executeUpdate();
            }

            showAlert("保存错题集成功!");
      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (pstmt != null)
                  pstmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }

    // 添加redoMistakesEquations方法实现重新做错题的功能
    private void redoMistakesEquations() {
      TextInputDialog dialog = new TextInputDialog("5");
      dialog.setTitle("请输入错题数量");
      dialog.setHeaderText(null);
      dialog.setContentText("错题数量:");

      Optional<String> result = dialog.showAndWait();
      if (result.isPresent()) {
            int n = Integer.parseInt(result.get());

            // 清空界面上的所有算术式
            flowPane.getChildren().clear();

            // 查询数据库中的错题数量
            int totalMistakes = getMistakesCountFromDatabase();

            if (n > totalMistakes) {
                showAlert("错题集中没有那么多错题,继续加油!");
            } else {
                // 从mistakesequationtable中随机抽出n道错题显示到界面中
                displayRandomMistakesEquations(n);
            }
      }
    }

    private int getMistakesCountFromDatabase() {
      Connection conn = null;
      Statement stmt = null;
      int totalMistakes = 0;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            stmt = conn.createStatement();

            // 查询mistakesequationtable中的记录总数
            ResultSet countResult = stmt.executeQuery("SELECT COUNT(*) FROM mistakesequationtable");
            countResult.next();
            totalMistakes = countResult.getInt(1);
      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (stmt != null)
                  stmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }System.out.println("Goodbye!");

      return totalMistakes;
    }

    private void displayRandomMistakesEquations(int n) {
      Connection conn = null;
      Statement stmt = null;
      try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                  "jdbc:mysql://localhost:3306/rjgzdatabase?characterEncoding=utf8&serverTimezone=Asia/Shanghai&useSSL=false",
                  "root", "Zqy173590939");

            stmt = conn.createStatement();

            // 查询mistakesequationtable中的记录总数
            ResultSet countResult = stmt.executeQuery("SELECT COUNT(*) FROM mistakesequationtable");
            countResult.next();
            int totalCount = countResult.getInt(1);

            // 随机抽取n道错题的ID
            Set<Integer> selectedIDs = new HashSet<>();
            Random random = new Random();
            while (selectedIDs.size() < n) {
                int randomID = random.nextInt(totalCount) + 1;
                selectedIDs.add(randomID);
            }

            // 查询并显示随机抽取的错题
            for (int id : selectedIDs) {
                ResultSet rs = stmt.executeQuery("SELECT * FROM mistakesequationtable WHERE ID = " + id);
                if (rs.next()) {
                  String equation = rs.getInt("Operand1") + " " + rs.getString("Operator") + " " +
                            rs.getInt("Operand2") + " = ?";
                  Label equationLabel = new Label(equation);
                  TextField answerField = new TextField(); // 创建一个新的文本框
                  HBox equationBox = new HBox(10, equationLabel, answerField); // 将错题和文本框放入水平布局
                  flowPane.getChildren().add(equationBox); // 将水平布局添加到 flowPane 中
                }
            }
      } catch (SQLException se) {
            se.printStackTrace();
      } catch (Exception e) {
            e.printStackTrace();
      } finally {
            try {
                if (stmt != null)
                  stmt.close();
                if (conn != null)
                  conn.close();
            } catch (SQLException se) {
                se.printStackTrace();
            }
      }
      System.out.println("Goodbye!");
    }

}
修改代码,使得重做错题后,也可以使用查看正确率和检查功能,点击check检查重做的错题的对错和点击viewaccuracy查看重做的题目的正确率

FishC 发表于 2024-1-1 13:41:44

zqy173590939 发表于 2024-01-01 13:41
package com.example.javafxmw;

import gaijin3.*; ...

您好!根据您的需求,我稍作修改代码,使得重做错题后可以使用查看正确率和检查功能。具体修改如下:

1. 首先,在generate

以上回复来自 FishC AI 小助理,如未能正确解答您的问题,请继续追问。

zqy173590939 发表于 2024-1-4 11:03:34

@FishC
package com.example.javafxmw;

import DatabaseOperations.*;
import TeacherPostsSystem.*;
import javafx.application.Application;
import javafx.beans.property.ReadOnlyObjectWrapper;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Node;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

import java.sql.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Optional;

public class HelloApplicationextends Application{
    //初始界面的账号输入框
    public TextField accountField = new TextField("abc");

    //初始界面的密码输入框
    public PasswordField passwordField = new PasswordField();

    //创建单选选项
    ToggleGroup toggleGroup = new ToggleGroup();

    //选项,管理员登录
    RadioButton adminRadioButton = new RadioButton("管理员");

    //基础界面使用borderPane布局
    BorderPane borderPane = new BorderPane();
    //存放输入框

    //执行和数据库相关的方法所用
    DatabaseConnect connect = new DatabaseConnect();

    // 创建菜单栏
    MenuBar menuBar = new MenuBar();

    @Override
    public void start(Stage stage) {

      VBox vBox = new VBox();
      vBox.setSpacing(10);

      // 创建账号输入框
      HBox accountBox = new HBox();
      Label accountLabel = new Label("账号:");
      accountBox.getChildren().addAll(accountLabel, accountField);

      // 创建密码输入框
      HBox passwordBox = new HBox();
      Label passwordLabel = new Label("密码:");
      passwordBox.getChildren().addAll(passwordLabel, passwordField);

      // 创建登录按钮
      Button loginButton = new Button("登录");
      loginButton.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent actionEvent) {
                // 登录功能
                login();
            }
      });

      // 创建注册按钮
      Button registerButton = new Button("注册");
      registerButton.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent actionEvent) {
                // 注册功能,管理员账号写死,不可注册和修改,教师账号可注册
                register();
            }
      });


      // 创建单选按钮

      adminRadioButton.setToggleGroup(toggleGroup);
      adminRadioButton.setSelected(true); // 默认选中管理员登录

      RadioButton teacherRadioButton = new RadioButton("教师");
      teacherRadioButton.setToggleGroup(toggleGroup);

      // 将登录按钮和注册按钮添加到水平布局中
      HBox buttonsBox = new HBox();
      buttonsBox.getChildren().addAll(loginButton, registerButton);
      buttonsBox.setSpacing(130);

      // 将单选按钮添加到水平布局中
      HBox radioButtonsBox = new HBox();
      radioButtonsBox.getChildren().addAll(adminRadioButton, teacherRadioButton);
      radioButtonsBox.setSpacing(100);

      // 将控件添加到布局中
      vBox.getChildren().addAll(accountBox, passwordBox, buttonsBox, radioButtonsBox);
      BorderPane.setMargin(vBox, new Insets(180, 250, 180, 250));

      // 设置vBox居中显示
      borderPane.setAlignment(vBox, Pos.CENTER);
      borderPane.setCenter(vBox);

      Scene scene = new Scene(borderPane, 800, 640);
      stage.setTitle("教师岗位管理系统");
      stage.setScene(scene);
      stage.show();
    }

    //登录方法
    public void login() {

      // 清空之前的界面内容,为了第二次返回调用登录时,先清空一次界面
      borderPane.getChildren().clear();

      // 判断用户是否选中了单选按钮
      if (toggleGroup.getSelectedToggle() == null) {
            Alert alert = new Alert(Alert.AlertType.WARNING);
            alert.setTitle("提示");
            alert.setHeaderText(null);
            alert.setContentText("请选择用户类型!");
            alert.showAndWait();
            return;
      }

      // 获取用户输入的账号和密码
      String account = accountField.getText().trim();
      String password = passwordField.getText().trim();


      // 判断选择的身份
      boolean isAdmin = toggleGroup.getSelectedToggle().equals(adminRadioButton);
      String tableName = isAdmin ? "admin" : "teacher";

      // 从对应的表中查询账号和密码
      String sql = "SELECT * FROM " + tableName + " WHERE account = ?";
      try (Connection conn = connect.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            stmt.setString(1, account);
            ResultSet rs = stmt.executeQuery();
            if (rs.next()) {
                String dbPassword = rs.getString("password");
                // 对用户输入的密码进行加密,比对数据库中的密码是否一致
                if (password.equals(dbPassword)) {
                  // 登录成功,弹出提示框
                  Alert alert = new Alert(Alert.AlertType.INFORMATION);
                  alert.setTitle("提示");
                  alert.setHeaderText(null);
                  alert.setContentText("登录成功!");
                  alert.showAndWait();

                  // 展示新的界面
                  if(isAdmin) {
                        showMainScene();
                  }else {
                        showTeacherScene();
                  }
                } else {
                  // 密码错误,弹出提示框
                  Alert alert = new Alert(Alert.AlertType.ERROR);
                  alert.setTitle("错误");
                  alert.setHeaderText(null);
                  alert.setContentText("用户名或密码错误!");
                  alert.showAndWait();
                }
            } else {
                // 账号不存在,弹出提示框
                Alert alert = new Alert(Alert.AlertType.ERROR);
                alert.setTitle("错误");
                alert.setHeaderText(null);
                alert.setContentText("用户名或密码错误!");
                alert.showAndWait();
            }
      } catch (SQLException e) {
            e.printStackTrace();
      }
    }

    public void showTeacherScene() {
      // 清空之前的界面内容
      borderPane.getChildren().clear();

      try (Connection conn = connect.getConnection();
             Statement stmt = conn.createStatement()) {

            // 从teacher表和teacherinfomation表中联合查询教师信息
            String sql = "SELECT t.id, t.account, t.password, ti.name, ti.gender, ti.age, ti.position, ti.worktime, ti.college " +
                  "FROM teacher t JOIN teacherinformation ti ON t.workid = ti.workid";
            ResultSet rs = stmt.executeQuery(sql);

            // 获取列数,将获取到的列放到结果集中
            ResultSetMetaData metaData = rs.getMetaData();
            int columnCount = metaData.getColumnCount();

            // 创建表格
            TableView<ObservableList<String>> table = new TableView<>();

            // 添加表头,根据获取到的列,添加表头
            for (int i = 1; i <= columnCount; i++) {
                String columnName = metaData.getColumnName(i);
            /*
            ObservableList<String> 是每一行数据的类型,表示一行数据是一个字符串列表。
            String 是单元格中数据的类型,表示每个单元格中的数据是字符串类型。
            */
                TableColumn<ObservableList<String>, String> column = new TableColumn<>(columnName);
                // 设置表头内容居中,并设置内容只读
                column.setCellValueFactory(param -> new ReadOnlyObjectWrapper<>(param.getValue().get(table.getColumns().indexOf(column))));
                table.getColumns().add(column);
            }

            // 添加数据行
            while (rs.next()) {
                ObservableList<String> data = FXCollections.observableArrayList();
                for (int i = 1; i <= columnCount; i++) {
                  String cellValue = rs.getString(i);
                  data.add(cellValue);
                }
                table.getItems().add(data);
            }

            // 创建ScrollPane并将表格放入其中
            ScrollPane scrollPane = new ScrollPane();
            scrollPane.setContent(table);
            scrollPane.setFitToHeight(true);
            scrollPane.setFitToWidth(true);

            // 将ScrollPane添加到BorderPane的中央
            borderPane.setCenter(scrollPane);
            // 创建按钮组
            HBox buttonBox = new HBox(10);
            buttonBox.setAlignment(Pos.CENTER);

            Button changePassWordButton = new Button("修改密码");
            //给按钮添加点击事件
            changePassWordButton.setOnAction(actionEvent -> changePassWord());


      } catch (SQLException e) {
            e.printStackTrace();
      }
    }

    public void changePassWord() {

    }


    public void showMainScene() {
      // 清空之前的界面内容
      borderPane.getChildren().clear();

      // 创建菜单
      Menu fileMenu = new Menu("File");
      Menu addMenu = new Menu("Add");
      Menu deleteMenu = new Menu("Delete");
      Menu editMenu = new Menu("Edit");
      Menu searchMenu = new Menu("Search");
      Menu setMenu = new Menu("Settings");

      // 创建菜单项
      MenuItem addTeacherItem = new MenuItem("Add Teacher");
      MenuItem editTeacherItem = new MenuItem("Edit Teacher");
      MenuItem deleteTeacherItem = new MenuItem("Delete Teacher");
      MenuItem searchTeacherItem = new MenuItem("Search Teacher");
      MenuItem logoutItem = new MenuItem("Log Out");

      // 为菜单项添加事件处理程序
      addTeacherItem.setOnAction(e -> addTeacher());
      editTeacherItem.setOnAction(e -> amend());
      deleteTeacherItem.setOnAction(e -> deleteTeacher());
      searchTeacherItem.setOnAction(e -> searchTeacher());
      logoutItem.setOnAction(e -> logout());

      // 将菜单项添加到菜单中
      fileMenu.getItems().addAll(setMenu);
      addMenu.getItems().addAll(addTeacherItem);
      deleteMenu.getItems().addAll(deleteTeacherItem);
      editMenu.getItems().addAll(editTeacherItem);
      searchMenu.getItems().addAll(searchTeacherItem);
      setMenu.getItems().addAll(logoutItem);


      // 将菜单添加到菜单栏
      menuBar.getMenus().add(fileMenu);
      menuBar.getMenus().add(addMenu);
      menuBar.getMenus().add(deleteMenu);
      menuBar.getMenus().add(editMenu);
      menuBar.getMenus().add(searchMenu);

      // 将菜单栏添加到布局中
      borderPane.setTop(menuBar);




      try (Connection conn = connect.getConnection();
             Statement stmt = conn.createStatement()) {

            // 从teacher表中查询教师信息
            String sql = "SELECT * FROM teacherinformation";
            ResultSet rs = stmt.executeQuery(sql);

            // 获取列数,将获取到的列放到结果集中
            ResultSetMetaData metaData = rs.getMetaData();
            int columnCount = metaData.getColumnCount();

            // 创建表格
            TableView<ObservableList<String>> table = new TableView<>();

            // 添加表头,根据获取到的列,添加表头
            for (int i = 1; i <= columnCount; i++) {
                String columnName = metaData.getColumnName(i);
            /*
            ObservableList<String> 是每一行数据的类型,表示一行数据是一个字符串列表。
            String 是单元格中数据的类型,表示每个单元格中的数据是字符串类型。
            */
                TableColumn<ObservableList<String>, String> column = new TableColumn<>(columnName);
                // 设置表头内容居中,并设置内容只读
                column.setCellValueFactory(param -> new ReadOnlyObjectWrapper<>(param.getValue().get(table.getColumns().indexOf(column))));
                table.getColumns().add(column);
            }

            // 添加数据行
            while (rs.next()) {
                ObservableList<String> data = FXCollections.observableArrayList();
                for (int i = 1; i <= columnCount; i++) {
                  String cellValue = rs.getString(i);
                  data.add(cellValue);
                }
                table.getItems().add(data);
            }

            // 创建ScrollPane并将表格放入其中
            ScrollPane scrollPane = new ScrollPane();
            scrollPane.setContent(table);
            scrollPane.setFitToHeight(true);
            scrollPane.setFitToWidth(true);


            // 添加ScrollPane到布局中
            borderPane.setCenter(scrollPane);

            // 创建按钮组
            HBox buttonBox = new HBox(10);
            buttonBox.setAlignment(Pos.CENTER);

            // 添加按钮
            Button addButton = new Button("添加");
            addButton.setOnAction(new EventHandler<ActionEvent>() {
                @Override
                public void handle(ActionEvent actionEvent) {
                  // 调用添加教师的方法
                  addTeacher();
                }
            });

            // 修改按钮
            Button editButton = new Button("修改");
            editButton.setOnAction(new EventHandler<ActionEvent>() {
                @Override
                public void handle(ActionEvent actionEvent) {
                  amend();
                }
            });

            // 删除按钮
            Button deleteButton = new Button("删除");
            deleteButton.setOnAction(new EventHandler<ActionEvent>() {
                @Override
                public void handle(ActionEvent actionEvent) {
                  // 调用删除教师的方法
                  deleteTeacher();
                }
            });

            // 查询按钮
            Button searchButton = new Button("查询");
            searchButton.setOnAction(new EventHandler<ActionEvent>() {
                @Override
                public void handle(ActionEvent actionEvent) {
                  // 调用查询教师的方法
                  searchTeacher();
                }
            });

            // 将按钮添加到按钮组中
            buttonBox.getChildren().addAll(addButton, editButton, deleteButton, searchButton);

            // 添加按钮组到布局底部
            borderPane.setBottom(buttonBox);

      } catch (SQLException e) {
            e.printStackTrace();
            // 异常处理
            Alert alert = new Alert(Alert.AlertType.ERROR);
            alert.setTitle("错误");
            alert.setHeaderText(null);
            alert.setContentText("显示教师信息失败!");
            alert.showAndWait();
      }
    }

    private void logout() {
      Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
      alert.setTitle("确认退出");
      alert.setHeaderText(null);
      alert.setContentText("确定要退出登录吗?");

      Optional<ButtonType> result = alert.showAndWait();
      if (result.isPresent() && result.get() == ButtonType.OK) {
            // 用户点击了确定按钮,执行退出登录操作
            Stage stage = new Stage();
            start(stage);
      }
    }



    private void searchTeacher() {
      // 调用创建对话框的方法,并让用户输入要查询的教师工号
      Optional<ArrayList<TextField>> result = createInputDialog("查询", "请输入要查询的教师工号");

      if (result.isPresent()) {
            // 用户点击了 "确定" 按钮,获取输入的工号
            ArrayList<TextField> idField = result.get();
            String workId = idField.get(0).getText();


            // 根据工号从数据库中查询对应的教师信息
            TeacherInformation teacher = queryById(workId);

            if (teacher == null) {
                // 如果没有查询到对应的教师信息,提示用户并返回
                Alert alert = new Alert(Alert.AlertType.ERROR);
                alert.setTitle("错误");
                alert.setHeaderText("未找到对应的教师信息");
                alert.setContentText("请检查输入的工号是否正确!");
                alert.showAndWait();
            } else {
                // 创建一个新的对话框,显示查询到的教师信息
                Dialog<String> infoDialog = new Dialog<>();
                infoDialog.setTitle("查询结果");
                infoDialog.setHeaderText(null);

                // 创建文本区域显示教师信息
                TextArea textArea = new TextArea();
                textArea.setEditable(false);
                textArea.appendText("姓名: " + teacher.getName() + "\n");
                textArea.appendText("性别: " + teacher.getGender() + "\n");
                textArea.appendText("年龄: " + teacher.getAge() + "\n");
                textArea.appendText("工号: " + teacher.getWorkid() + "\n");
                textArea.appendText("职称: " + teacher.getPosition() + "\n");
                textArea.appendText("工作时间: " + teacher.getWorktime() + "\n");

                // 将文本区域添加到对话框中
                infoDialog.getDialogPane().setContent(textArea);

                // 添加 "确定" 按钮
                infoDialog.getDialogPane().getButtonTypes().add(ButtonType.OK);

                // 显示对话框并等待用户响应
                infoDialog.showAndWait();
            }
      }
    }

    //删除教师
    private void deleteTeacher() {
      // 调用创建对话框的方法,并让用户输入要删除的教师工号
      Optional<ArrayList<TextField>> result = createInputDialog("删除", "请输入要删除的教师工号");

      if (result.isPresent()) {
            // 用户点击了 "确定" 按钮,获取输入的工号
            ArrayList<TextField> idField = result.get();
            String workId = idField.get(0).getText();


            // 根据工号从数据库中查询对应的教师信息
            TeacherInformation teacher = queryById(workId);

            if (teacher == null) {
                // 如果没有查询到对应的教师信息,提示用户并返回
                Alert alert = new Alert(Alert.AlertType.ERROR);
                alert.setTitle("错误");
                alert.setHeaderText("未找到对应的教师信息");
                alert.setContentText("请检查输入的工号是否正确!");
                alert.showAndWait();
            } else {
                // 执行删除操作
                if (connect.deleteTeacherById(workId)) {
                  // 删除成功,提示用户
                  Alert successAlert = new Alert(Alert.AlertType.INFORMATION);
                  successAlert.setTitle("删除成功");
                  successAlert.setHeaderText(null);
                  successAlert.setContentText("教师信息删除成功!");
                  successAlert.showAndWait();

                  // 刷新界面
                  showMainScene();
                } else {
                  // 删除失败,提示用户
                  Alert errorAlert = new Alert(Alert.AlertType.ERROR);
                  errorAlert.setTitle("删除失败");
                  errorAlert.setHeaderText(null);
                  errorAlert.setContentText("教师信息删除失败!");
                  errorAlert.showAndWait();
                }
            }
      }
    }



    private void addTeacher() {

      // 创建一个对话框窗口
      Dialog<ArrayList<TextField>> dialog = new Dialog<>();
      dialog.setTitle("添加教师");
      dialog.setHeaderText(null);

      // 设置对话框的按钮
      ButtonType addButton = new ButtonType("添加", ButtonBar.ButtonData.OK_DONE);
      ButtonType cancelButton = new ButtonType("取消", ButtonBar.ButtonData.CANCEL_CLOSE);
      dialog.getDialogPane().getButtonTypes().addAll(addButton, cancelButton);

      // 创建表单布局
      GridPane formGrid = new GridPane();
      formGrid.setHgap(10);
      formGrid.setVgap(10);
      formGrid.setPadding(new Insets(20));

      // 创建表单字段和标签
      ArrayList<TextField> fields = new ArrayList<>();
      ArrayList<String> labels = new ArrayList<>(Arrays.asList("姓名:", "性别:", "年龄:", "工号:", "职位:", "所属学院:", "工作时间:"));
      for (int i = 0; i < labels.size(); i++) {
            TextField field = new TextField();
            Label label = new Label(labels.get(i));
            formGrid.add(label, 0, i);
            formGrid.add(field, 1, i);
            fields.add(field);
      }

      // 将表单布局设置为对话框的内容
      dialog.getDialogPane().setContent(formGrid);

      // 设置对话框的结果转换器
      dialog.setResultConverter(dialogButton -> {
            if (dialogButton == addButton) {
                // 点击添加按钮时,将输入的教师信息返回
                return fields;
            }
            return null;
      });

      // 显示对话框并等待用户操作
      Optional<ArrayList<TextField>> result = dialog.showAndWait();

      // 处理用户操作结果
      result.ifPresent(inputs -> {
            // 获取用户输入的教师信息
            String name = inputs.get(0).getText();
            String gender = inputs.get(1).getText();
            int age = Integer.parseInt(inputs.get(2).getText());
            String workid = inputs.get(3).getText();
            String position = inputs.get(4).getText();
            String college = inputs.get(5).getText();
            String worktime = inputs.get(6).getText();

            // 将教师信息插入到数据库中
            try {
                connect.insertTeacher(name, gender, age, workid, position, college, worktime);
                // 插入成功后,刷新主界面
                showMainScene();
            } catch (SQLException e) {
                e.printStackTrace();
            }


      });
    }

    //创建对话框
    private GridPane createTeacherForm() {
      // 创建表单布局
      GridPane formGrid = new GridPane();
      formGrid.setHgap(10);
      formGrid.setVgap(10);

      // 定义表单字段和标签的名称
      ArrayList<String> fieldLabels = new ArrayList<>(Arrays.asList("姓名:", "性别:", "年龄:", "职位:", "所属学院:", "工作时间:"));
      ArrayList<TextField> fields = new ArrayList<>();

      // 使用循环创建表单字段和标签
      for (int i = 0; i < fieldLabels.size(); i++) {
            TextField field = new TextField();
            Label label = new Label(fieldLabels.get(i));
            formGrid.add(label, 0, i);
            formGrid.add(field, 1, i);
            fields.add(field);
      }

      return formGrid;
    }


    //修改教师信息
    private void amend() {
      // 调用创建对话框的方法,并让用户输入要查询的教师工号
      Optional<ArrayList<TextField>> result = createInputDialog("修改", "请输入要修改的教师工号");

      if(result.isPresent()) {
            // 用户点击了 "确定" 按钮,获取输入的工号
            ArrayList<TextField> idField = result.get();
            String workId = idField.get(0).getText();


            // 根据工号从数据库中查询对应的教师信息
            TeacherInformation teacher = queryById(workId);

            if(teacher == null) {
                // 如果没有查询到对应的教师信息,提示用户并返回
                Alert alert = new Alert(Alert.AlertType.ERROR);
                alert.setTitle("错误");
                alert.setHeaderText("未找到对应的教师信息");
                alert.setContentText("请检查输入的工号是否正确!");
                alert.showAndWait();
            } else {
                // 创建一个对话框窗口
                Dialog<ArrayList<TextField>> dialog1 = new Dialog<>();
                dialog1.setTitle("修改教师岗位信息");
                dialog1.setHeaderText(null);

                // 设置对话框的按钮
                ButtonType addButton = new ButtonType("修改" , ButtonBar.ButtonData.OK_DONE);
                ButtonType cancelButton = new ButtonType("取消" , ButtonBar.ButtonData.CANCEL_CLOSE);
                dialog1.getDialogPane().getButtonTypes().addAll(addButton , cancelButton);

                // 创建表单布局并获取字段对象
                GridPane formGrid = createTeacherForm();
                ArrayList<TextField> fields = new ArrayList<>(formGrid.getChildren().size());
                for(Node node : formGrid.getChildren()) {
                  if(node instanceof TextField) {
                        fields.add((TextField) node);
                  }
                }

                // 设置对话框的结果转换器
                dialog1.setResultConverter(dialogButton -> {
                  if(dialogButton == addButton) {
                        // 点击添加按钮时,将输入的教师信息返回
                        return fields;
                  }
                  return null;
                });

                // 将表单布局设置为对话框的内容
                dialog1.getDialogPane().setContent(formGrid);
                // 显示对话框并等待用户操作
                Optional<ArrayList<TextField>> result1 = dialog1.showAndWait();
                // 处理用户操作结果
                result1.ifPresent(inputs -> {
                  // 获取用户输入的教师信息
                  String name = inputs.get(0).getText();
                  String gender = inputs.get(1).getText();
                  int age = Integer.parseInt(inputs.get(2).getText());
                  String position = inputs.get(3).getText();
                  String college = inputs.get(4).getText();
                  String worktime = inputs.get(5).getText();

                  // 将教师信息插入到数据库中
                  connect.updateTeacher(name, gender, age ,workId , position, college, worktime);

                  // 刷新教师列表
                  showMainScene();
                });
            }
      }
    }

    //根据工号查询数据库中是否有对应的教师信息
    public TeacherInformation queryById(String workId) {
      Connection conn = null;
      PreparedStatement stmt = null;
      ResultSet rs = null;
      TeacherInformation teacher = null;

      try {
            // 获取数据库连接
            conn = connect.getConnection();

            // 创建 PreparedStatement 对象,并设置占位符参数
            String sql = "SELECT * FROM teacherinformation WHERE workid=?";
            stmt = conn.prepareStatement(sql);
            stmt.setString(1, workId);

            // 执行查询操作
            rs = stmt.executeQuery();

            // 处理结果集,将查询到的教师信息保存到一个 Teacher 对象中
            if (rs.next()) {
                String name = rs.getString("name");
                String gender = rs.getString("gender");
                int age = rs.getInt("age");
                String position = rs.getString("position");
                String worktime = rs.getString("worktime");
                String college = rs.getString("college");
                teacher = new TeacherInformation(name, gender, age, workId, position,worktime,college);
            }
      } catch (SQLException e) {
            e.printStackTrace();
      }finally {
            // 关闭数据库连接,语句和结果集
            if (rs != null) {
                try {
                  rs.close();
                } catch (SQLException e) {
                  e.printStackTrace();
                }
            }
            if (stmt != null) {
                try {
                  stmt.close();
                } catch (SQLException e) {
                  e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                  conn.close();
                } catch (SQLException e) {
                  e.printStackTrace();
                }
            }
      }
      return teacher;
    }

    public void register() {
      String account = accountField.getText();
      String password = passwordField.getText();

      // 检查用户名是否已存在
      if (checkNameExist(account)) {
            Alert alert = new Alert(Alert.AlertType.ERROR);
            alert.setTitle("错误");
            alert.setHeaderText(null);
            alert.setContentText("用户名已存在!");
            alert.showAndWait();
            return;
      }

      // 注册新用户
      if (createTeacherAccount(account, password)) {
            Alert alert = new Alert(Alert.AlertType.INFORMATION);
            alert.setTitle("提示");
            alert.setHeaderText(null);
            alert.setContentText("注册成功!");
            alert.showAndWait();
      } else {
            Alert alert = new Alert(Alert.AlertType.ERROR);
            alert.setTitle("错误");
            alert.setHeaderText(null);
            alert.setContentText("注册失败!");
            alert.showAndWait();
      }
    }


    private boolean createTeacherAccount(String account, String password) {
      String sql = "INSERT INTO teacher (account, password) VALUES (?, ?)";
      try (Connection conn = connect.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            stmt.setString(1, account);
            stmt.setString(2, password);
            int result = stmt.executeUpdate();
            return result > 0;
      } catch (SQLException e) {
            e.printStackTrace();
      }
      return false;
    }

    private boolean checkNameExist(String name) {
      boolean result = false;
      Connection conn = null;
      Statement stmt = null;
      ResultSet rs = null;
      try {
            conn = connect.getConnection();
            // 执行查询语句
            String sql = "SELECT account FROM teacher";
            stmt = conn.createStatement();
            rs = stmt.executeQuery(sql);

            // 判断是否有和name相同的值
            while (rs.next()) {
                String account = rs.getString("account");
                if (account.equals(name)) {
                  result = true;
                  break;
                }
            }

      } catch (SQLException e) {
            e.printStackTrace();
      } finally {
            // 关闭数据库连接
            try {
                if (rs != null) {
                  rs.close();
                }
                if (stmt != null) {
                  stmt.close();
                }
                if (conn != null) {
                  conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
      }

      return result;
    }

    //创建一个对话框
    private Optional<ArrayList<TextField>> createInputDialog(String title, String headerText) {
      Dialog<ButtonType> dialog = new Dialog<>();
      dialog.setTitle(title);
      dialog.setHeaderText(headerText);

      // 创建工号输入框并添加到对话框中
      TextField workIdField = new TextField();
      dialog.getDialogPane().setContent(workIdField);

      // 创建 "确定" 和 "取消" 按钮并添加到对话框中
      ButtonType confirmButtonType = new ButtonType("确定", ButtonBar.ButtonData.OK_DONE);
      dialog.getDialogPane().getButtonTypes().addAll(confirmButtonType, ButtonType.CANCEL);

      // 设置按钮的可用性
      Node confirmButton = dialog.getDialogPane().lookupButton(confirmButtonType);
      confirmButton.setDisable(true);
      workIdField.textProperty().addListener((observable, oldValue, newValue) -> {
            confirmButton.setDisable(newValue.trim().isEmpty());
      });

      // 显示对话框并等待用户响应
      Optional<ButtonType> result = dialog.showAndWait();

      if (result.isPresent() && result.get() == confirmButtonType) {
            ArrayList<TextField> fields = new ArrayList<>();
            fields.add(workIdField);
            return Optional.of(fields);
      } else {
            return Optional.empty();
      }
    }

    public static void main(String[] args) {
      launch();
    }
}
修改代码,点击logout后,发生错误“你正在尝试将一个已经作为另一个场景的根节点的BorderPane设置为另一个场景的根节点,这是不允许的。你需要确保每个场景只有一个根节点,并且根节点只能属于一个场景。”在退出登录后,调用start方法前,将BorderPane从前一个场景中移除,再调用start方法

FishC 发表于 2024-1-4 11:03:51

zqy173590939 发表于 2024-01-04 11:03
@FishC
package com.example.javafxmw;

import Da ...

你好!你遇到的问题是因为在退出登录后,调用start方法前,没有将前一个场景中的BorderPane从界面中移除。这就导致了你想要

以上回复来自 FishC AI 小助理,如未能正确解答您的问题,请继续追问。

zqy173590939 发表于 2024-1-4 11:04:30

FishC 发表于 2024-1-4 11:03
你好!你遇到的问题是因为在退出登录后,调用start方法前,没有将前一个场景中的BorderPane从界面中移 ...

你的回复为什么没有完全显示?

FishC 发表于 2024-1-4 11:04:40

zqy173590939 发表于 2024-01-04 11:04
你的回复为什么没有完全显示?

非常抱歉,我的回复似乎被截断了。让我重新回答你的问题。

你遇到的问题是因为在退出登录后,调用start方法前,没有将前一个场景中的BorderPane从界面中移除。这就导致了你想要将一个已经作为另一个场景的根节点的BorderPane设置为另一个场景的根节点时发生了错误。

要解决这个问题,我们可以在退出登录时将BorderPane从前一个场景中移除,然后再调用start方法来展示新的场景。

具体做法是,在logout方法中添加以下代码来移除BorderPane:
borderPane.getChildren().clear();

然后在showMainScene和showTeacherScene方法中也加上清空BorderPane的代码,以确保每次展示新场景时都没有之前的内容残留:
borderPane.getChildren().clear();

这样,在退出登录后调用start方法时,就能正常地展示新的场景了。希望这次回答能够解决你的问题!如果还有其他疑问,请随时提问。

以上回复来自 FishC AI 小助理,如未能正确解答您的问题,请继续追问。

zqy173590939 发表于 2024-1-4 11:27:38

@FishC
写一份教师岗位管理系统的背景调查报告,写出开发这个系统的必要性

FishC 发表于 2024-1-4 11:27:55

zqy173590939 发表于 2024-01-04 11:27
@FishC
写一份教师岗位管理系统的背景调查报告,写出 ...

教师岗位管理系统的背景调查报告

1. 引言
教师是社会中非常重要的一群人,他们肩负着培养下一代的重任。然而,在当前的教育领域,对于教师的管理和评估仍然存在一些困难和挑战。因此,我们有必要开发一种教师岗位管理系统,以提高教师管理的效率和准确性。

2. 必要性
教师岗位管理系统的开发有以下几个必要性:

2.1 提高管理效率
传统的教师管理方式使用纸质档案和表格进行记录,工作量大且容易出现错误。而一套完善的教师岗位管理系统可以集成各类教师信息,方便管理者实时查看和处理相关数据,从而提高管理效率。

2.2 优化资源分配
通过教师岗位管理系统,我们可以更好地了解教师的背景、能力和特长,以便更好地进行教师岗位分配。系统可以根据教师的专业知识和经验,自动匹配合适的岗位,从而优化资源分配。

2.3 支持绩效评估
教师绩效评估是教育系统中重要的一环,可以帮助提高教学质量和教师的发展。通过教师岗位管理系统,可以记录和分析教师的教学成果、学术研究等数据,为教师绩效评估提供支持和依据。

2.4 促进交流共享
教师岗位管理系统可以提供一个交流平台,方便教师之间的沟通和经验分享。教师可以通过系统发布教学资源、交流心得,从而促进教师团队的合作和共享。

3. 结论
教师岗位管理系统的开发对于优化教师管理、提高教学质量具有重要意义。它能够提高管理效率、优化资源分配、支持绩效评估并促进教师交流共享。因此,开发这个系统是必要且值得推进的工作。

希望这份背景调查报告能够对您有所帮助!

以上回复来自 FishC AI 小助理,如未能正确解答您的问题,请继续追问。

zqy173590939 发表于 2024-1-5 15:11:17

@FishC
package com.example.javafxmw;

import DatabaseOperations.*;
import TeacherPostsSystem.*;
import javafx.application.Application;
import javafx.beans.property.ReadOnlyObjectWrapper;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Node;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

import java.sql.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Optional;

public class HelloApplicationextends Application{
    //初始界面的账号输入框
    public TextField accountField = new TextField("abc");

    //初始界面的密码输入框
    public PasswordField passwordField = new PasswordField();

    //创建单选选项
    public ToggleGroup toggleGroup = new ToggleGroup();

    //选项,管理员登录
    public RadioButton adminRadioButton = new RadioButton("管理员");
    public RadioButton teacherRadioButton = new RadioButton("教师");

    //基础界面使用borderPane布局
    private BorderPane borderPane = new BorderPane();
    //存放输入框

    //执行和数据库相关的方法所用
    public DatabaseConnect connect = new DatabaseConnect();
    // 创建菜单栏



    @Override
    public void start(Stage stage) {

      borderPane.getChildren().clear();
      VBox vBox = new VBox();
      vBox.setSpacing(10);

      // 创建账号输入框
      HBox accountBox = new HBox();
      Label accountLabel = new Label("账号:");
      accountBox.getChildren().addAll(accountLabel, accountField);

      // 创建密码输入框
      HBox passwordBox = new HBox();
      Label passwordLabel = new Label("密码:");
      passwordBox.getChildren().addAll(passwordLabel, passwordField);

      // 创建登录按钮
      Button loginButton = new Button("登录");
      loginButton.setOnAction(actionEvent -> login());

      // 创建注册按钮
      Button registerButton = new Button("注册");
      registerButton.setOnAction(new EventHandler<ActionEvent>() {
            @Override
            public void handle(ActionEvent actionEvent) {
                // 获取当前选中的单选按钮
                RadioButton selectedRadioButton = (RadioButton) toggleGroup.getSelectedToggle();

                // 判断是否为教师选项
                if (selectedRadioButton == teacherRadioButton) {
                  // 执行教师注册功能
                  register();
                } else {
                  // 弹出提示框,告知不能进行管理员注册
                  Alert alert = new Alert(Alert.AlertType.ERROR);
                  alert.setTitle("错误");
                  alert.setHeaderText(null);
                  alert.setContentText("不能进行管理员注册!");
                  alert.showAndWait();
                }
            }
      });



      // 创建单选按钮

      adminRadioButton.setToggleGroup(toggleGroup);
      adminRadioButton.setSelected(true); // 默认选中管理员登录

      teacherRadioButton.setToggleGroup(toggleGroup);

      // 将登录按钮和注册按钮添加到水平布局中
      HBox buttonsBox = new HBox();
      buttonsBox.getChildren().addAll(loginButton, registerButton);
      buttonsBox.setSpacing(130);

      // 将单选按钮添加到水平布局中
      HBox radioButtonsBox = new HBox();
      radioButtonsBox.getChildren().addAll(adminRadioButton, teacherRadioButton);
      radioButtonsBox.setSpacing(100);

      // 将控件添加到布局中
      vBox.getChildren().addAll(accountBox, passwordBox, buttonsBox, radioButtonsBox);
      BorderPane.setMargin(vBox, new Insets(180, 250, 180, 250));

      // 设置vBox居中显示
      borderPane.setAlignment(vBox, Pos.CENTER);
      borderPane.setCenter(vBox);

      Scene scene = new Scene(borderPane, 800, 640);
      stage.setTitle("教师岗位管理系统");
      stage.setScene(scene);
      stage.show();
    }

    //登录方法
    public void login() {
      String currentAccountWorkId ;

      // 获取用户输入的账号和密码,并去掉空白字符
      String account = accountField.getText().trim();
      String password = passwordField.getText().trim();

      // 判断选择的身份
      boolean isAdmin = toggleGroup.getSelectedToggle().equals(adminRadioButton);
      String tableName = isAdmin ? "admin" : "teacher";

      // 从对应的表中查询账号和密码
      String sql = "SELECT * FROM " + tableName + " WHERE account = ?";
      try (Connection conn = connect.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            stmt.setString(1, account);
            ResultSet rs = stmt.executeQuery();
            if (rs.next()) {
                String dbPassword = rs.getString("password");
                // 对用户输入的密码进行加密,比对数据库中的密码是否一致
                if (password.equals(dbPassword)) {
                  // 登录成功,弹出提示框
                  Alert alert = new Alert(Alert.AlertType.INFORMATION);
                  alert.setTitle("提示");
                  alert.setHeaderText(null);
                  alert.setContentText("登录成功!");
                  alert.showAndWait();

                  // 展示新的界面
                  if(isAdmin) {

                        showAdminScene();
                  }else {
                        currentAccountWorkId = getWorkIdByAccount(account);
                        showTeacherScene(currentAccountWorkId);
                  }
                } else {
                  // 密码错误,弹出提示框
                  Alert alert = new Alert(Alert.AlertType.ERROR);
                  alert.setTitle("错误");
                  alert.setHeaderText(null);
                  alert.setContentText("用户名或密码错误!");
                  alert.showAndWait();
                }
            } else {
                // 账号不存在,弹出提示框
                Alert alert = new Alert(Alert.AlertType.ERROR);
                alert.setTitle("错误");
                alert.setHeaderText(null);
                alert.setContentText("用户名或密码错误!");
                alert.showAndWait();
            }
      } catch (SQLException e) {
            e.printStackTrace();
      }
    }

    private String getWorkIdByAccount(String account) {
      String sql = "SELECT workid FROM teacher WHERE account = ?";
      try (Connection conn = connect.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            stmt.setString(1, account);
            ResultSet rs = stmt.executeQuery();
            if (rs.next()) {
                return rs.getString("workid");
            } else {
                return null;
            }
      } catch (SQLException e) {
            e.printStackTrace();
            return null;
      }
    }
    public void showTeacherScene(String currentAccountWorkId) {
      // 清空之前的界面内容
      borderPane.getChildren().clear();

      try (Connection conn = connect.getConnection()) {
            // 从teacher表和teacherinfomation表中联合查询教师信息,获取的信息是当前账户对应workid的信息
            String sql = "SELECT t.id, t.account, t.password, ti.name, ti.gender, ti.age, ti.position, ti.worktime, ti.college "
                  + "FROM teacher t LEFT JOIN teacherinformation ti ON t.workid = ti.workid "
                  + "WHERE t.workid = ?";
            PreparedStatement stmt = conn.prepareStatement(sql);
            stmt.setString(1, currentAccountWorkId);
            ResultSet rs = stmt.executeQuery();

            // 获取列数,将获取到的列放到结果集中
            ResultSetMetaData metaData = rs.getMetaData();
            int columnCount = metaData.getColumnCount();

            // 创建表格
            TableView<ObservableList<String>> table = new TableView<>();

            // 添加表头,根据获取到的列,添加表头
            for (int i = 1; i <= columnCount; i++) {
                String columnName = metaData.getColumnName(i);
                /*
               * ObservableList<String> 是每一行数据的类型,表示一行数据是一个字符串列表。 String 是单元格中数据的类型,
               * 表示每个单元格中的数据是字符串类型。
               */
                TableColumn<ObservableList<String>, String> column = new TableColumn<>(columnName);
                // 设置表头内容居中,并设置内容只读
                column.setCellValueFactory(
                        param -> new ReadOnlyObjectWrapper<>(param.getValue().get(table.getColumns().indexOf(column))));
                table.getColumns().add(column);
            }

            // 添加数据行
            while (rs.next()) {
                ObservableList<String> data = FXCollections.observableArrayList();
                for (int i = 1; i <= columnCount; i++) {
                  String cellValue = rs.getString(i);
                  // 处理空值
                  if (cellValue == null) {
                        cellValue = "无";
                  }
                  data.add(cellValue);
                }
                table.getItems().add(data);
            }

            // 创建ScrollPane并将表格放入其中
            ScrollPane scrollPane = new ScrollPane();
            scrollPane.setContent(table);
            scrollPane.setFitToHeight(true);
            scrollPane.setFitToWidth(true);

            // 将ScrollPane添加到BorderPane的中央
            borderPane.setCenter(scrollPane);

            // 创建按钮组
            HBox buttonBox = new HBox(10);
            buttonBox.setAlignment(Pos.CENTER);

            //添加个人信息
            Button personalInfoButton = new Button("添加个人信息");
            personalInfoButton.setOnAction(actionEvent -> addPersonalInfo());

            Button changePassWordButton = new Button("修改密码");
            changePassWordButton.setOnAction(actionEvent -> changePassWord());

            buttonBox.getChildren().addAll(changePassWordButton,personalInfoButton);
            borderPane.setBottom(buttonBox);

      } catch (SQLException e) {
            e.printStackTrace();
      }
    }

    public void addPersonalInfo() {

    }


    public void changePassWord() {
      // 调用创建对话框的方法,并让用户输入要修改密码的教师账号
      Optional<ArrayList<TextField>> result = createInputDialog("修改密码", "请输入账号");
      if (result.isPresent()) {
            ArrayList<TextField> idField = result.get();

            //获取用户输入的账号
            String enteredAccount = idField.get(0).getText();

            // 创建对话框,让用户输入工号
            TextInputDialog dialog = new TextInputDialog();
            dialog.setTitle("修改密码");
            dialog.setHeaderText(null);
            dialog.setContentText("请输入工号:");

            // 等待用户输入工号
            Optional<String> workIdResult = dialog.showAndWait();

            if (workIdResult.isPresent()) {
                // 获取用户输入的工号
                String enteredWorkId = workIdResult.get();

                // 获取数据库中的工号
                String storedWorkId = getWorkIdByAccount(enteredAccount);

                if (storedWorkId != null) {
                  if (storedWorkId.equals(enteredWorkId)) {
                        // 创建表单布局
                        GridPane formGrid = new GridPane();
                        formGrid.setHgap(10);
                        formGrid.setVgap(10);

                        // 定义表单字段和标签的名称
                        ArrayList<String> fieldLabels = new ArrayList<>(Arrays.asList("新密码", "确认新密码"));
                        ArrayList<TextField> fields = new ArrayList<>();

                        // 使用循环创建表单字段和标签
                        for (int i = 0; i < fieldLabels.size(); i++) {
                            TextField field = new TextField();
                            Label label = new Label(fieldLabels.get(i));
                            formGrid.add(label, 0, i);
                            formGrid.add(field, 1, i);
                            fields.add(field);
                        }

                        // 显示对话框,并等待用户点击按钮
                        Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
                        alert.setTitle("修改密码");
                        alert.setHeaderText(null);
                        alert.getDialogPane().setContent(formGrid);
                        Optional<ButtonType> buttonResult = alert.showAndWait();

                        if (buttonResult.isPresent() && buttonResult.get() == ButtonType.OK) {
                            // 检查两次输入的密码是否一致
                            if (fields.get(0).getText().equals(fields.get(1).getText())) {
                              String newPassword = fields.get(0).getText();
                              // 调用数据库操作类的方法更新密码
                              connect.updatePassWord(enteredAccount, newPassword);
                              //刷新界面
                              showTeacherScene(enteredWorkId);
                            }
                        }
                  } else {
                        // 工号不匹配,提示错误信息
                        Alert alert = new Alert(Alert.AlertType.ERROR);
                        alert.setTitle("错误");
                        alert.setHeaderText(null);
                        alert.setContentText("输入的工号与账号不匹配!");
                        alert.showAndWait();
                  }
                } else {
                  // 账号不存在,提示错误信息
                  Alert alert = new Alert(Alert.AlertType.ERROR);
                  alert.setTitle("错误");
                  alert.setHeaderText(null);
                  alert.setContentText("输入的账号不存在!");
                  alert.showAndWait();
                }
            }
      }
    }

    //管理员界面
    public void showAdminScene() {
      // 清空之前的界面内容
      borderPane.getChildren().clear();

      try (Connection conn = connect.getConnection();
             Statement stmt = conn.createStatement()) {

            // 从teacher表中查询教师信息
            String sql = "SELECT * FROM teacherinformation";
            ResultSet rs = stmt.executeQuery(sql);

            // 获取列数,将获取到的列放到结果集中
            ResultSetMetaData metaData = rs.getMetaData();
            int columnCount = metaData.getColumnCount();

            // 创建表格
            TableView<ObservableList<String>> table = new TableView<>();

            // 添加表头,根据获取到的列,添加表头
            for (int i = 1; i <= columnCount; i++) {
                String columnName = metaData.getColumnName(i);
            /*
            ObservableList<String> 是每一行数据的类型,表示一行数据是一个字符串列表。
            String 是单元格中数据的类型,表示每个单元格中的数据是字符串类型。
            */
                TableColumn<ObservableList<String>, String> column = new TableColumn<>(columnName);
                // 设置表头内容居中,并设置内容只读
                column.setCellValueFactory(param -> new ReadOnlyObjectWrapper<>(param.getValue().get(table.getColumns().indexOf(column))));
                table.getColumns().add(column);
            }

            // 添加数据行
            while (rs.next()) {
                ObservableList<String> data = FXCollections.observableArrayList();
                for (int i = 1; i <= columnCount; i++) {
                  String cellValue = rs.getString(i);
                  data.add(cellValue);
                }
                table.getItems().add(data);
            }

            // 创建ScrollPane并将表格放入其中
            ScrollPane scrollPane = new ScrollPane();
            scrollPane.setContent(table);
            scrollPane.setFitToHeight(true);
            scrollPane.setFitToWidth(true);


            // 添加ScrollPane到布局中
            borderPane.setCenter(scrollPane);

            // 创建菜单
            Menu fileMenu = new Menu("File");
            Menu addMenu = new Menu("Add");
            Menu deleteMenu = new Menu("Delete");
            Menu editMenu = new Menu("Edit");
            Menu searchMenu = new Menu("Search");
            Menu setMenu = new Menu("Settings");

            // 创建菜单项
            MenuItem addTeacherItem = new MenuItem("Add Teacher");
            MenuItem editTeacherItem = new MenuItem("Edit Teacher");
            MenuItem deleteTeacherItem = new MenuItem("Delete Teacher");
            MenuItem searchTeacherItem = new MenuItem("Search Teacher");
            MenuItem logoutItem = new MenuItem("Log Out");

            // 为菜单项添加事件处理程序
            addTeacherItem.setOnAction(e -> addTeacher());
            editTeacherItem.setOnAction(e -> amend());
            deleteTeacherItem.setOnAction(e -> deleteTeacher());
            searchTeacherItem.setOnAction(e -> searchTeacher());
            logoutItem.setOnAction(e -> logout());

            // 将菜单项添加到菜单中
            fileMenu.getItems().addAll(setMenu);
            addMenu.getItems().addAll(addTeacherItem);
            deleteMenu.getItems().addAll(deleteTeacherItem);
            editMenu.getItems().addAll(editTeacherItem);
            searchMenu.getItems().addAll(searchTeacherItem);
            setMenu.getItems().addAll(logoutItem);

            MenuBar menuBar = new MenuBar();
            // 将菜单添加到菜单栏
            menuBar.getMenus().addAll(fileMenu, addMenu,editMenu, deleteMenu, searchMenu);

            // 将菜单栏添加到布局中
            borderPane.setTop(menuBar);

      } catch (SQLException e) {
            e.printStackTrace();
            // 异常处理
            Alert alert = new Alert(Alert.AlertType.ERROR);
            alert.setTitle("错误");
            alert.setHeaderText(null);
            alert.setContentText("显示教师信息失败!");
            alert.showAndWait();
      }
    }

    private void logout() {
      BorderPane borderPane = new BorderPane();

      Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
      alert.setTitle("确认退出");
      alert.setHeaderText(null);
      alert.setContentText("确定要退出登录吗?");

      Optional<ButtonType> result = alert.showAndWait();
      if (result.isPresent() && result.get() == ButtonType.OK) {
            // 用户点击了确定按钮,执行退出登录操作

            initializeLoginData();

            borderPane.getChildren().clear();

            Stage stage = new Stage();
            start(stage);
      }
    }

    private void initializeLoginData() {
      // 重置登录界面的数据
      accountField.clear();
      passwordField.clear();
    }

    private void searchTeacher() {
      // 调用创建对话框的方法,并让用户输入要查询的教师工号
      Optional<ArrayList<TextField>> result = createInputDialog("查询", "请输入要查询的教师工号");

      if (result.isPresent()) {
            // 用户点击了 "确定" 按钮,获取输入的工号
            ArrayList<TextField> idField = result.get();
            String workId = idField.get(0).getText();


            // 根据工号从数据库中查询对应的教师信息
            TeacherInformation teacher = queryById(workId);

            if (teacher == null) {
                // 如果没有查询到对应的教师信息,提示用户并返回
                Alert alert = new Alert(Alert.AlertType.ERROR);
                alert.setTitle("错误");
                alert.setHeaderText("未找到对应的教师信息");
                alert.setContentText("请检查输入的工号是否正确!");
                alert.showAndWait();
            } else {
                // 创建一个新的对话框,显示查询到的教师信息
                Dialog<String> infoDialog = new Dialog<>();
                infoDialog.setTitle("查询结果");
                infoDialog.setHeaderText(null);

                // 创建文本区域显示教师信息
                TextArea textArea = new TextArea();
                textArea.setEditable(false);
                textArea.appendText("姓名: " + teacher.getName() + "\n");
                textArea.appendText("性别: " + teacher.getGender() + "\n");
                textArea.appendText("年龄: " + teacher.getAge() + "\n");
                textArea.appendText("工号: " + teacher.getWorkid() + "\n");
                textArea.appendText("职称: " + teacher.getPosition() + "\n");
                textArea.appendText("工作时间: " + teacher.getWorktime() + "\n");

                // 将文本区域添加到对话框中
                infoDialog.getDialogPane().setContent(textArea);

                // 添加 "确定" 按钮
                infoDialog.getDialogPane().getButtonTypes().add(ButtonType.OK);

                // 显示对话框并等待用户响应
                infoDialog.showAndWait();
            }
      }
    }

    //删除教师
    private void deleteTeacher() {
      // 调用创建对话框的方法,并让用户输入要删除的教师工号
      Optional<ArrayList<TextField>> result = createInputDialog("删除", "请输入要删除的教师工号");

      if (result.isPresent()) {
            // 用户点击了 "确定" 按钮,获取输入的工号
            ArrayList<TextField> idField = result.get();
            String workId = idField.get(0).getText();


            // 根据工号从数据库中查询对应的教师信息
            TeacherInformation teacher = queryById(workId);

            if (teacher == null) {
                // 如果没有查询到对应的教师信息,提示用户并返回
                Alert alert = new Alert(Alert.AlertType.ERROR);
                alert.setTitle("错误");
                alert.setHeaderText("未找到对应的教师信息");
                alert.setContentText("请检查输入的工号是否正确!");
                alert.showAndWait();
            } else {
                // 执行删除操作
                if (connect.deleteTeacherById(workId)) {
                  // 删除成功,提示用户
                  Alert successAlert = new Alert(Alert.AlertType.INFORMATION);
                  successAlert.setTitle("删除成功");
                  successAlert.setHeaderText(null);
                  successAlert.setContentText("教师信息删除成功!");
                  successAlert.showAndWait();

                  // 刷新界面
                  showAdminScene();
                } else {
                  // 删除失败,提示用户
                  Alert errorAlert = new Alert(Alert.AlertType.ERROR);
                  errorAlert.setTitle("删除失败");
                  errorAlert.setHeaderText(null);
                  errorAlert.setContentText("教师信息删除失败!");
                  errorAlert.showAndWait();
                }
            }
      }
    }


    private void addTeacher() {
      // 创建一个对话框窗口
      Dialog<ArrayList<Control>> dialog = new Dialog<>();
      dialog.setTitle("添加教师");
      dialog.setHeaderText(null);

      // 设置对话框的按钮
      ButtonType addButton = new ButtonType("添加", ButtonBar.ButtonData.OK_DONE);
      ButtonType cancelButton = new ButtonType("取消", ButtonBar.ButtonData.CANCEL_CLOSE);
      dialog.getDialogPane().getButtonTypes().addAll(addButton, cancelButton);

      // 创建表单布局
      GridPane formGrid = new GridPane();
      formGrid.setHgap(10);
      formGrid.setVgap(10);
      formGrid.setPadding(new Insets(20));

      // 创建表单字段和标签
      ArrayList<Control> controls = new ArrayList<>();
      ArrayList<String> labels = new ArrayList<>(Arrays.asList("姓名:", "性别:", "年龄:", "工号:", "职位:", "所属学院:", "工作时间:"));
      for (int i = 0; i < labels.size(); i++) {
            Label label = new Label(labels.get(i));
            formGrid.add(label, 0, i);
            if(i == 5){
                ComboBox<String> collegeComboBox = new ComboBox<>();
                collegeComboBox.getItems().addAll(
                        "法学院(法律事务中心)",
                        "信息工程学院",
                        "水利学院",
                        "地球科学与工程学院(地球物理研究所)",
                        "测绘与地理信息学院",
                        "材料学院",
                        "土木与交通学院(钢结构与工程研究院)",
                        "电气工程学院",
                        "能源与动力工程学院",
                        "机械学院",
                        "环境与市政工程学院",
                        "水资源学院(黄河科学研究院)",
                        "管理与经济学院(MBA教育中心)",
                        "数学与统计学院",
                        "建筑学院",
                        "电子工程学院",
                        "外国语学院",
                        "公共管理学院(MPA教育中心)",
                        "国际教育学院(语言培训中心)",
                        "马克思主义学院",
                        "艺术学院",
                        "乌拉尔学院",
                        "体育教学部"
                );
                controls.add(collegeComboBox);
                formGrid.add(collegeComboBox, 1, i);
            } else {
                TextField field = new TextField();
                formGrid.add(field, 1, i);
                controls.add(field);

                // 为年龄和工号文本框添加事件监听器,设置正则表达式
                if (i == 2 || i == 3) {
                  field.textProperty().addListener((observable, oldValue, newValue) -> {
                        if (!newValue.matches("\\d*")) {
                            field.setText(oldValue);
                        }
                  });
                }
            }
      }

      // 将表单布局设置为对话框的内容
      dialog.getDialogPane().setContent(formGrid);

      // 设置对话框的结果转换器
      dialog.setResultConverter(dialogButton -> {
            if (dialogButton == addButton) {
                // 点击添加按钮时,将输入的教师信息返回
                return controls;
            }
            return null;
      });

      // 显示对话框并等待用户操作
      Optional<ArrayList<Control>> result = dialog.showAndWait();

      // 处理用户操作结果
      result.ifPresent(inputs -> {
            // 获取用户输入的教师信息
            String name = ((TextField) inputs.get(0)).getText();
            String gender = ((TextField) inputs.get(1)).getText();
            int age = Integer.parseInt(((TextField) inputs.get(2)).getText());
            String workid = ((TextField) inputs.get(3)).getText();
            String position = ((TextField) inputs.get(4)).getText();
            String college = ((ComboBox<String>) inputs.get(5)).getValue();
            String worktime = ((TextField) inputs.get(6)).getText();

            // 将教师信息插入到数据库中
            try {
                connect.insertTeacher(name, gender, age, workid, position, college, worktime);
                // 插入成功后,刷新主界面
                showAdminScene();
            } catch (SQLException e) {
                e.printStackTrace();
            }
      });
    }

    //创建对话框
    private GridPane createTeacherForm() {
      // 创建表单布局
      GridPane formGrid = new GridPane();
      formGrid.setHgap(10);
      formGrid.setVgap(10);

      // 定义表单字段和标签的名称
      ArrayList<String> fieldLabels = new ArrayList<>(Arrays.asList("姓名:", "性别:", "年龄:", "职位:", "所属学院:", "工作时间:"));
      ArrayList<TextField> fields = new ArrayList<>();

      // 使用循环创建表单字段和标签
      for (int i = 0; i < fieldLabels.size(); i++) {
            TextField field = new TextField();
            Label label = new Label(fieldLabels.get(i));
            formGrid.add(label, 0, i);
            formGrid.add(field, 1, i);
            fields.add(field);
      }

      return formGrid;
    }


    //修改教师信息
    private void amend() {
      // 调用创建对话框的方法,并让用户输入要查询的教师工号
      Optional<ArrayList<TextField>> result = createInputDialog("修改", "请输入要修改的教师工号");

      if(result.isPresent()) {
            // 用户点击了 "确定" 按钮,获取输入的工号
            ArrayList<TextField> idField = result.get();
            String workId = idField.get(0).getText();

            // 使用正则表达式限制工号只能输入数字
            if (!workId.matches("\\d+")) {
                // 如果工号不符合要求,提示用户并返回
                Alert alert = new Alert(Alert.AlertType.ERROR);
                alert.setTitle("错误");
                alert.setHeaderText(null);
                alert.setContentText("请输入正确的教师工号!");
                alert.showAndWait();
                return;
            }

            // 根据工号从数据库中查询对应的教师信息
            TeacherInformation teacher = queryById(workId);

            if(teacher == null) {
                // 如果没有查询到对应的教师信息,提示用户并返回
                Alert alert = new Alert(Alert.AlertType.ERROR);
                alert.setTitle("错误");
                alert.setHeaderText("未找到对应的教师信息");
                alert.setContentText("请检查输入的工号是否正确!");
                alert.showAndWait();
            } else {
                // 创建一个对话框窗口
                Dialog<ArrayList<TextField>> dialog1 = new Dialog<>();
                dialog1.setTitle("修改教师岗位信息");
                dialog1.setHeaderText(null);

                // 设置对话框的按钮
                ButtonType addButton = new ButtonType("修改" , ButtonBar.ButtonData.OK_DONE);
                ButtonType cancelButton = new ButtonType("取消" , ButtonBar.ButtonData.CANCEL_CLOSE);
                dialog1.getDialogPane().getButtonTypes().addAll(addButton , cancelButton);

                // 创建表单布局并获取字段对象
                GridPane formGrid = createTeacherForm();
                ArrayList<TextField> fields = new ArrayList<>(formGrid.getChildren().size());
                for(Node node : formGrid.getChildren()) {
                  if(node instanceof TextField) {
                        fields.add((TextField) node);
                  }
                }

                // 在addTeacher和amend方法中创建下拉列表,设置可选项并添加到表单布局中
                ComboBox<String> collegeComboBox = new ComboBox<>();
                collegeComboBox.getItems().addAll(
                        "法学院(法律事务中心)",
                        "信息工程学院",
                        "水利学院",
                        "地球科学与工程学院(地球物理研究所)",
                        "测绘与地理信息学院",
                        "材料学院",
                        "土木与交通学院(钢结构与工程研究院)",
                        "电气工程学院",
                        "能源与动力工程学院",
                        "机械学院",
                        "环境与市政工程学院",
                        "水资源学院(黄河科学研究院)",
                        "管理与经济学院(MBA教育中心)",
                        "数学与统计学院",
                        "建筑学院",
                        "电子工程学院",
                        "外国语学院",
                        "公共管理学院(MPA教育中心)",
                        "国际教育学院(语言培训中心)",
                        "马克思主义学院",
                        "艺术学院",
                        "乌拉尔学院",
                        "体育教学部"
                );
                formGrid.add(collegeComboBox, 1, 4);

                // 使用正则表达式限制年龄只能输入数字
                TextField ageField = fields.get(2);
                ageField.textProperty().addListener((observable, oldValue, newValue) -> {
                  if (!newValue.matches("\\d*")) {
                        ageField.setText(newValue.replaceAll("[^\\d]", ""));
                  }
                });

                // 设置对话框的结果转换器
                dialog1.setResultConverter(dialogButton -> {
                  if(dialogButton == addButton) {
                        // 点击添加按钮时,将输入的教师信息返回
                        return fields;
                  }
                  return null;
                });

                // 将表单布局设置为对话框的内容
                dialog1.getDialogPane().setContent(formGrid);
                // 显示对话框并等待用户操作
                Optional<ArrayList<TextField>> result1 = dialog1.showAndWait();
                // 处理用户操作结果
                result1.ifPresent(inputs -> {
                  // 获取用户输入的教师信息
                  String name = inputs.get(0).getText();
                  String gender = inputs.get(1).getText();
                  int age = Integer.parseInt(inputs.get(2).getText());
                  String position = inputs.get(3).getText();
                  String college = collegeComboBox.getValue();
                  String worktime = inputs.get(5).getText();

                  // 将教师信息插入到数据库中
                  connect.updateTeacher(name, gender, age ,workId , position, college, worktime);
                  System.out.println("UPDATE teacherinformation SET name='" + name + "', gender='" + gender + "', age=" + age + ", position='" + position + "', worktime='" + worktime + "', college='" + college + "' WHERE workid='" + workId + "'");

                  // 刷新教师列表
                  showAdminScene();
                });
            }
      }
    }


    //根据工号查询数据库中是否有对应的教师信息
    public TeacherInformation queryById(String workId) {
      Connection conn = null;
      PreparedStatement stmt = null;
      ResultSet rs = null;
      TeacherInformation teacher = null;

      try {
            // 获取数据库连接
            conn = connect.getConnection();

            // 创建 PreparedStatement 对象,并设置占位符参数
            String sql = "SELECT * FROM teacherinformation WHERE workid=?";
            stmt = conn.prepareStatement(sql);
            stmt.setString(1, workId);

            // 执行查询操作
            rs = stmt.executeQuery();

            // 处理结果集,将查询到的教师信息保存到一个 Teacher 对象中
            if (rs.next()) {
                String name = rs.getString("name");
                String gender = rs.getString("gender");
                int age = rs.getInt("age");
                String position = rs.getString("position");
                String worktime = rs.getString("worktime");
                String college = rs.getString("college");
                teacher = new TeacherInformation(name, gender, age, workId, position,worktime,college);
            }
      } catch (SQLException e) {
            e.printStackTrace();
      }finally {
            // 关闭数据库连接,语句和结果集
            if (rs != null) {
                try {
                  rs.close();
                } catch (SQLException e) {
                  e.printStackTrace();
                }
            }
            if (stmt != null) {
                try {
                  stmt.close();
                } catch (SQLException e) {
                  e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                  conn.close();
                } catch (SQLException e) {
                  e.printStackTrace();
                }
            }
      }
      return teacher;
    }

    public void register() {
      // 创建表单布局
      GridPane formGrid = new GridPane();
      formGrid.setHgap(10);
      formGrid.setVgap(10);

      // 定义表单字段和标签的名称
      ArrayList<String> fieldLabels = new ArrayList<>(Arrays.asList("账户", "密码", "工号"));
      ArrayList<TextField> fields = new ArrayList<>();

      // 使用循环创建表单字段和标签
      for (int i = 0; i < fieldLabels.size(); i++) {
            TextField field = new TextField();
            Label label = new Label(fieldLabels.get(i));
            formGrid.add(label, 0, i);
            formGrid.add(field, 1, i);
            fields.add(field);

            // 添加事件监听器,验证输入的内容是否符合要求
            if (i == 0 || i == 1) {
                field.textProperty().addListener((observable, oldValue, newValue) -> {
                  if (!newValue.matches("*")) {
                        field.setText(oldValue);
                  }
                });
            }
            else {
                field.textProperty().addListener((observable, oldValue, newValue) -> {
                  if (!newValue.matches("*")) {
                        field.setText(oldValue);
                  }
                });
            }
      }

      // 显示对话框,并等待用户点击按钮
      Dialog<ButtonType> dialog = new Dialog<>();
      dialog.setTitle("注册账户");
      dialog.getDialogPane().setContent(formGrid);
      // 添加OK和Cancel按钮
      ButtonType okButton = new ButtonType("确定", ButtonBar.ButtonData.OK_DONE);
      ButtonType cancelButton = new ButtonType("取消", ButtonBar.ButtonData.CANCEL_CLOSE);
      dialog.getDialogPane().getButtonTypes().addAll(okButton, cancelButton);



      // 等待用户点击按钮并获取结果
      Optional<ButtonType> result = dialog.showAndWait();

      if (result.isPresent() && result.get() == okButton) {
            String account = fields.get(0).getText();
            String password = fields.get(1).getText();
            String workId = fields.get(2).getText();
            // 检查用户名是否已存在
            if (checkNameExist(account)) {
                Alert alert = new Alert(Alert.AlertType.ERROR);
                alert.setTitle("错误");
                alert.setHeaderText(null);
                alert.setContentText("用户名已存在!");
                alert.showAndWait();
                return;
            }

            // 注册新用户
            if (createTeacherAccount(account, password, workId)) {
                Alert alert = new Alert(Alert.AlertType.INFORMATION);
                alert.setTitle("提示");
                alert.setHeaderText(null);
                alert.setContentText("注册成功!");
                alert.showAndWait();
            } else {
                Alert alert = new Alert(Alert.AlertType.ERROR);
                alert.setTitle("错误");
                alert.setHeaderText(null);
                alert.setContentText("注册失败!");
                alert.showAndWait();
            }
      }
    }

    //将创建的新用户添加到数据库中
    public boolean createTeacherAccount(String account, String password,String workId) {
      String sql = "INSERT INTO teacher (account, password, workid) VALUES (?, ? ,?)";
      try (Connection conn = connect.getConnection();
             PreparedStatement stmt = conn.prepareStatement(sql)) {
            stmt.setString(1, account);
            stmt.setString(2, password);
            stmt.setString(3, workId);
            int result = stmt.executeUpdate();
            return result > 0;
      } catch (SQLException e) {
            e.printStackTrace();
      }
      return false;
    }

    private boolean checkNameExist(String name) {
      boolean result = false;
      Connection conn = null;
      Statement stmt = null;
      ResultSet rs = null;
      try {
            conn = connect.getConnection();
            // 执行查询语句
            String sql = "SELECT account FROM teacher";
            stmt = conn.createStatement();
            rs = stmt.executeQuery(sql);

            // 判断是否有和name相同的值
            while (rs.next()) {
                String account = rs.getString("account");
                if (account.equals(name)) {
                  result = true;
                  break;
                }
            }

      } catch (SQLException e) {
            e.printStackTrace();
      } finally {
            // 关闭数据库连接
            try {
                if (rs != null) {
                  rs.close();
                }
                if (stmt != null) {
                  stmt.close();
                }
                if (conn != null) {
                  conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
      }

      return result;
    }

    //创建一个对话框
    public Optional<ArrayList<TextField>> createInputDialog(String title, String headerText) {
      Dialog<ButtonType> dialog = new Dialog<>();
      dialog.setTitle(title);
      dialog.setHeaderText(headerText);

      // 创建工号输入框并添加到对话框中
      TextField workIdField = new TextField();
      dialog.getDialogPane().setContent(workIdField);

      // 创建 "确定" 和 "取消" 按钮并添加到对话框中
      ButtonType confirmButtonType = new ButtonType("确定", ButtonBar.ButtonData.OK_DONE);
      dialog.getDialogPane().getButtonTypes().addAll(confirmButtonType, ButtonType.CANCEL);

      // 设置按钮的可用性
      Node confirmButton = dialog.getDialogPane().lookupButton(confirmButtonType);
      confirmButton.setDisable(true);
      workIdField.textProperty().addListener((observable, oldValue, newValue) -> {
            confirmButton.setDisable(newValue.trim().isEmpty());
      });

      // 显示对话框并等待用户响应
      Optional<ButtonType> result = dialog.showAndWait();

      if (result.isPresent() && result.get() == confirmButtonType) {
            ArrayList<TextField> fields = new ArrayList<>();
            fields.add(workIdField);
            return Optional.of(fields);
      } else {
            return Optional.empty();
      }
    }

    public static void main(String[] args) {
      launch();
    }
}
根据上述代码,帮我写以上系统的详细描述。
要求:总结设计用到的主要工具,详细介绍一下整个系统的主要功能模块。

FishC 发表于 2024-1-5 15:11:36

zqy173590939 发表于 2024-01-05 15:11
@FishC
package com.example.javafxmw;

import Da ...

该系统是一个教师岗位管理系统,主要用于管理员和教师登录后进行相应的操作。

设计中使用了JavaFX框架进行界面的构建,使用

以上回复来自 FishC AI 小助理,如未能正确解答您的问题,请继续追问。

zqy173590939 发表于 2024-1-5 15:12:03

FishC 发表于 2024-1-5 15:11
该系统是一个教师岗位管理系统,主要用于管理员和教师登录后进行相应的操作。

设计中使用了JavaFX框 ...

回答内容为什么被截断了?

FishC 发表于 2024-1-5 15:13:18

zqy173590939 发表于 2024-01-05 15:12
回答内容为什么被截断了?

非常抱歉,可能是因为回答的内容过长,导致被截断了。下面是完整的回答:

该系统使用JavaFX框架进行界

以上回复来自 FishC AI 小助理,如未能正确解答您的问题,请继续追问。

zqy173590939 发表于 2024-1-5 15:14:31

FishC 发表于 2024-1-5 15:11
该系统是一个教师岗位管理系统,主要用于管理员和教师登录后进行相应的操作。

设计中使用了JavaFX框 ...

内容没有显示完整,请给出完整内容

FishC 发表于 2024-1-5 15:15:02

zqy173590939 发表于 2024-01-05 15:14
内容没有显示完整,请给出完整内容

抱歉,之前的回答有些内容被截断了。根据你提供的代码,该系统是一个教师岗位管理系统,主要由管理员和

以上回复来自 FishC AI 小助理,如未能正确解答您的问题,请继续追问。
页: [1] 2 3
查看完整版本: 专用