Java图书管理系统（可视化界面）连接达梦（DM）数据库

最新推荐文章于 2024-09-04 10:30:34 发布

2301_81290348

最新推荐文章于 2024-09-04 10:30:34 发布

阅读量1.8k

点赞数 52

文章标签： java 数据库

本文链接：https://blog.csdn.net/2301_81290348/article/details/140159252

版权

前言

Java的图书管理系统的项目非常多，但是大部分连接的数据库都是MySQL、Oracle、SQL Server等，这些数据库以其成熟稳定、社区活跃的特点，在市场中占据了举足轻重的地位。而国产数据库像达梦数据库的却很少见，所以这个项目我打算用达梦数据库来作为数据支撑，体验一下国产数据库数据支撑能力。

作为一个Java的初学者，这个图书管理系统都是一些很基础的布局设置，以及一些基本的操作业务逻辑，连接的达梦数据库的操作和MySQL的没有太大的差异，就是连接时的驱动，数据库名，连接的用户名和密码有不同，sql语句基本能兼容，因此Java代码上没有太大变化。

这是图书管理界面的一些基本界面展示

接下来就是图书管理系统的具体内容

1.连接达梦数据库

点击IDEA菜单上的文件选项，选择项目结构条目，然后在左侧的项目设置里选择库，新建项目库，然后选择达梦数据库安装的文件，找到相应的驱动，具体路径如下

点击应用，接下就是创建一个类，用来连接数据库和处理sql语句，这是我创建的一个叫Database的类。

public class DataBase {
    List<User> list;
    Connection con;
    //驱动程序名
    private	String driver ;
    //URL指向要访问的数据库名
    private	String url;
    //配置时的用户名
    private String user;
    //配置时的密码
    private String password;


    public DataBase(){
        driver = "dm.jdbc.driver.DmDriver";
        url = "jdbc:dm://localhost:5236/SYSDBA";
        user = "SYSDBA";
        password = "SYSDBA";

        try {
            Class.forName(driver);
            con = DriverManager.getConnection(url,user,password);
            if (!con.isClosed()){
                System.out.println("数据库连接成功");
            }else {
                System.out.println("数据库连接失败");
            }
        }catch (Exception e){
            System.out.println("数据库连接失败");
            e.printStackTrace();
        }

    }
}

运行这段代码，在运行后如果打印了数据库连接成功，这说明该项目已经成功连接到了达梦数据库。接下来在达梦数据库中创建相应的表：

普通用户信息表：

CREATE TABLE "SYSDBA"."user"
(
"id" VARCHAR(30) NOT NULL,
"password" VARCHAR(30) NOT NULL,
NOT CLUSTER PRIMARY KEY("id")) STORAGE(ON "MAIN", CLUSTERBTR) ;

管理员信息表：

CREATE TABLE "SYSDBA"."manager"
(
"id" VARCHAR(30) NOT NULL,
"password" VARCHAR(30) NOT NULL,
NOT CLUSTER PRIMARY KEY("id")) STORAGE(ON "MAIN", CLUSTERBTR) ;

图书信息表：

CREATE TABLE "SYSDBA"."book"
(
"bookId" INT AUTO_INCREMENT NOT NULL,
"bookName" VARCHAR(30),
"author" VARCHAR(30),
"publishTime" VARCHAR(30),
"price" DOUBLE,
"bookNumber" INT,
NOT CLUSTER PRIMARY KEY("bookId")) STORAGE(ON "MAIN", CLUSTERBTR) AUTO_INCREMENT = 40;

接下来就可以回到IDEA中，创建界面并设置相应的业务逻辑。

2.图书管理系统代码

用户类

package system;


public class User {
    private String id;
    private String password;

    public User(){

    }

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

    public String getId() {
        return id;
    }

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

    public String getPassword() {
        return password;
    }

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

}

这部分是普通用户和管理员共用的类，包含id和password两个属性，与数据库的表相对应，并提供了setter和getter的方法。

图书类

package system;

public class Book {
    private int bookId;
    private String bookName;
    private String author;
    private String publishTime;
    private double price;
    private int bookNumber;

    public Book (){

    }

    public Book (int bookId,String bookName,String author,String publishTime,double price,int bookNumber){
        this.bookId = bookId;
        this.bookName = bookName;
        this.author = author;
        this.publishTime = publishTime;
        this.price = price;
        this.bookNumber = bookNumber;
    }

    public int getBookID() {
        return bookId;
    }

    public void setBookID(int bookID) {
        this.bookId = bookID;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getPublishTime() {
        return publishTime;
    }

    public void setPublishTime(String publishTime) {
        this.publishTime = publishTime;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getBookNumber() {
        return bookNumber;
    }

    public void setBookNumber(int bookNumber) {
        this.bookNumber = bookNumber;
    }
}

这部分是图书的信息类，包含图书的ID、名称、作者、出版时间、价格和数量，与数据库的表相对应，并提供了setter和getter方法。

数据库操作类(DataBase)

package system;

import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class DataBase {
    Connection con;
    //驱动程序名
    private	String driver ;
    //URL指向要访问的数据库名
    private	String url;
    //配置时的用户名
    private String user;
    //配置时的密码
    private String password;


    public DataBase(){
        driver = "dm.jdbc.driver.DmDriver";
        url = "jdbc:dm://localhost:5236/SYSDBA";
        user = "SYSDBA";
        password = "SYSDBA";

        try {
            Class.forName(driver);
            con = DriverManager.getConnection(url,user,password);
            if (!con.isClosed()){
                System.out.println("数据库连接成功");
            }else {
                System.out.println("数据库连接失败");
            }
        }catch (Exception e){
            System.out.println("数据库连接失败");
            e.printStackTrace();
        }

    }



    //添加用户
    public void addUser(User user){
        try {
            String sql = "INSERT INTO \"user\"(\"id\",\"password\") VALUES (?,?)";
            PreparedStatement pstat = con.prepareStatement(sql);
            pstat.setString(1,user.getId());
            pstat.setString(2,user.getPassword());
            int rs = pstat.executeUpdate();
            if (rs != 0){
                System.out.println("注册保存成功");
            }else {
                System.out.println("注册失败");
            }
        }catch (Exception e){
            e.printStackTrace();
        }

    }


    //添加管理员
    public void addManager(User user){
        try {
            String sql = "INSERT INTO \"manager\"(\"id\",\"password\") VALUES (?,?)";
            PreparedStatement pstat = con.prepareStatement(sql);
            pstat.setString(1,user.getId());
            pstat.setString(2,user.getPassword());;
            int rs = pstat.executeUpdate();
            if (rs != 0){
                System.out.println("注册保存成功");
            }else {
                System.out.println("注册失败");
            }
        }catch (Exception e){
            e.printStackTrace();
        }

    }


    //查看用户id和密码
    public ArrayList<User> getUser(){
        ArrayList<User> userList = new ArrayList<>();
        try{

            String sql = "SELECT * FROM \"user\";";
            PreparedStatement pstat = con.prepareStatement(sql);
            ResultSet rs = pstat.executeQuery();//executeQuery用于执行SQL查询并返回查询结果  ResultSet 包含了查询结果的数据。
            while (rs.next()){
                User user = new User(rs.getString("id"), rs.getNString("password"));
                //使用 ResultSet 对象的 getString 方法从当前行（由 rs.next() 控制）中获取名为 "id" 的列的值，并将其作为字符串返回,password也是如此
                userList.add(user);
            }

        }catch (Exception e){
            e.printStackTrace();
        }
        return userList;
    }


    //查看管理员id和密码
    public ArrayList<User> getManager(){
        ArrayList<User> userList = new ArrayList<>();
        try{

            String sql = "SELECT * FROM \"manager\";";
            PreparedStatement pstat = con.prepareStatement(sql);
            ResultSet rs = pstat.executeQuery();//executeQuery用于执行SQL查询并返回查询结果  ResultSet 包含了查询结果的数据。
            while (rs.next()){
                User user = new User(rs.getString("id"), rs.getNString("password"));
                //使用 ResultSet 对象的 getString 方法从当前行（由 rs.next() 控制）中获取名为 "id" 的列的值，并将其作为字符串返回,password也是如此
                userList.add(user);
            }

        }catch (Exception e){
            e.printStackTrace();
        }
        return userList;
    }

    //获取所有用户的账号信息并转化为二维表格
    public Object[][] getAllUser(){
        ArrayList<User> userList = new ArrayList<>();
        Object[][] data = null;

        try {
            String sql = "SELECT * FROM \"user\";";
            PreparedStatement pstat = con.prepareStatement(sql);
            ResultSet rs = pstat.executeQuery();
            while (rs.next()){userList.add(new User(
                    rs.getString("id"),
                    rs.getString("password")
            ));
                if (!userList.isEmpty()){
                    data = new Object[userList.size()][2];
                    int i = 0;
                    for (User user : userList){
                        data[i][0] = user.getId();
                        data[i][1] = user.getPassword();
                        i++;
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return data;
    }


    //查询用户并转化为二维数组
    public Object[][] selectUser(String id){
        ArrayList<User> userList = new ArrayList<>();
        Object[][] data = null;

        try {
            String sql = "SELECT * FROM \"user\" WHERE \"id\" = ?;";
            PreparedStatement pstat = con.prepareStatement(sql);
            pstat.setString(1,id);
            ResultSet rs = pstat.executeQuery();
            while (rs.next()){userList.add(new User(
                    rs.getString("id"),
                    rs.getString("password")
            ));
                if (!userList.isEmpty()){
                    data = new Object[userList.size()][2];
                    int i = 0;
                    for (User user : userList){
                        data[i][0] = user.getId();
                        data[i][1] = user.getPassword();
                        i++;
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return data;
    }


    //删除用户信息
    public void deleteUser(String id){
        try {
            String sql = "DELETE \"user\" WHERE \"id\" = ?;";
            PreparedStatement pstat = con.prepareStatement(sql);
            pstat.setString(1,id);
            int rs = pstat.executeUpdate();
            if (rs != 0){
                System.out.println("删除成功");
            }else {
                System.out.println("删除失败");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    //修改账号信息
    public void changePassword (User user){
        try {
            String sql = "UPDATE \"user\" SET \"password\"=? WHERE \"id\"=?;";
            PreparedStatement pstat = con.prepareStatement(sql);
            pstat.setString(1,user.getPassword());
            pstat.setString(2,user.getId());
            int rs = pstat.executeUpdate();
            if (rs != 0){
                System.out.println("修改成功");
            }else {
                System.out.println("修改失败");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    //插入图书信息
    public void addBook(Book book){
        try {
            String sql = "INSERT INTO \"book\" (\"bookName\",\"author\",\"publishTime\",\"price\",\"bookNumber\") VALUES (?,?,?,?,?);";
            PreparedStatement pstat = con.prepareStatement(sql);
            pstat.setString(1,book.getBookName());
            pstat.setString(2,book.getAuthor());
            pstat.setString(3,book.getPublishTime());
            pstat.setDouble(4,book.getPrice());
            pstat.setInt(5,book.getBookNumber());
            int rs = pstat.executeUpdate();
            if (rs != 0){
                System.out.println("图书信息保存成功");
            }else {
                System.out.println("图书信息保存失败");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    //获取全部图书信息
    public ArrayList<Book> getAllBook(){
        ArrayList<Book> bookList = new ArrayList<>();
        try{
            String sql = "SELECT * FROM \"book\";";
            PreparedStatement pstat = con.prepareStatement(sql);
            ResultSet rs = pstat.executeQuery();
            while (rs.next()){
                Book book = new Book(rs.getInt("bookId"),rs.getString("bookName"),rs.getString("author"),rs.getString("publishTime"),rs.getDouble("price"),rs.getInt("bookNumber"));
                bookList.add(book);
            }

        }catch (Exception e){
            e.printStackTrace();
        }
        return bookList;
    }



    //获取全部图书信息,并转化为二维数组
    public Object[][] getBook() {
        ArrayList<Book> BookList = new ArrayList<>();
        Object[][] data = null;

        try {
            String sql = "SELECT * FROM \"book\";";
            PreparedStatement pstat = con.prepareStatement(sql);
            ResultSet rs = pstat.executeQuery();

            while (rs.next()) {
                BookList.add(new Book(
                        rs.getInt("bookId"),
                        rs.getString("bookName"),
                        rs.getString("author"),
                        rs.getString("publishTime"),
                        rs.getDouble("price"),
                        rs.getInt("bookNumber")
                ));

            }
            if (!BookList.isEmpty()){
                data = new Object[BookList.size()][6];
                int i = 0;
                for (Book book : BookList){
                    data[i][0] = book.getBookID();
                    data[i][1] = book.getBookName();
                    data[i][2] = book.getAuthor();
                    data[i][3] = book.getPublishTime();
                    data[i][4] = book.getPrice();
                    data[i][5] = book.getBookNumber();
                    i++;
                }
            }else {
                System.out.println("空");
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return data;
    }



    // 查询图书并转换为表格数据
    public Object[][] selectBook(String selectBookName) {
        ArrayList<Book> selectBookList = new ArrayList<>();
        Object[][] data = null;

        try {
            String sql = "SELECT * FROM \"book\" WHERE \"bookName\" = ?;";
            PreparedStatement pstat = con.prepareStatement(sql);
            pstat.setString(1, selectBookName);
            ResultSet rs = pstat.executeQuery();

            while (rs.next()) {
                selectBookList.add(new Book(
                        rs.getInt("bookId"),
                        rs.getString("bookName"),
                        rs.getString("author"),
                        rs.getString("publishTime"),
                        rs.getDouble("price"),
                        rs.getInt("bookNumber")
                ));

            }
            if (!selectBookList.isEmpty()){
                data = new Object[selectBookList.size()][6];
                int i = 0;
                for (Book book : selectBookList){
                    data[i][0] = book.getBookID();
                    data[i][1] = book.getBookName();
                    data[i][2] = book.getAuthor();
                    data[i][3] = book.getPublishTime();
                    data[i][4] = book.getPrice();
                    data[i][5] = book.getBookNumber();
                    i++;
                }
            }else {
                System.out.println("未找到该图书");
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return data;
    }



    //删除图书
    public void deleteBook(int id){
        try {
            String sql = "DELETE \"book\" WHERE \"bookId\"=?;";
            PreparedStatement pstat = con.prepareStatement(sql);
            pstat.setInt(1,id);
            int rs = pstat.executeUpdate();
            if (rs != 0){
                System.out.println("删除成功");
            }else {
                System.out.println("删除失败");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    //借阅图书
    public void borrowBook(int id){
        try {
            String sql = "UPDATE \"book\" SET \"bookNumber\" = \"bookNumber\" - 1 WHERE \"bookId\" = ?;";
            PreparedStatement pstat = con.prepareStatement(sql);
            pstat.setInt(1,id);
            int rs = pstat.executeUpdate();
            if (rs != 0){
                System.out.println("借阅成功");
            }else {
                System.out.println("借阅失败");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }


    //归还图书
    public void returnBook(int id){
        try {
            String sql = "UPDATE \"book\" SET \"bookNumber\" = \"bookNumber\" + 1 WHERE \"bookId\" = ?;";
            PreparedStatement pstat = con.prepareStatement(sql);
            pstat.setInt(1,id);
            int rs = pstat.executeUpdate();
            if (rs != 0){
                System.out.println("归还成功");
            }else {
                System.out.println("归还失败");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }



    //修改图书
    public void updateBook(Book book){
        try {
            String sql = "UPDATE \"book\" SET \"bookName\" = ?,\"author\" = ?,\"publishTime\" = ?,\"price\" = ?,\"bookNumber\" = ? WHERE \"bookId\" = ?;";
            PreparedStatement pstat = con.prepareStatement(sql);
            pstat.setString(1,book.getBookName());
            pstat.setString(2, book.getAuthor());
            pstat.setString(3, book.getPublishTime());
            pstat.setDouble(4,book.getPrice());
            pstat.setInt(5,book.getBookNumber());
            pstat.setInt(6,book.getBookID());
            int rs = pstat.executeUpdate();
            if (rs != 0){
                System.out.println("修改成功");
            }else {
                System.out.println("修改失败");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }



}

这个类负责与达梦数据库的连接和执行SQL语句，包含连接数据库的方法、添加用户、管理员、修改账号信息、删除账号、查看图书信息的方法，以及添加、查询、删除、借阅、归还和修改图书信息的方法。

登录界面

package system;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

public class LoginJFrame extends JFrame{
    DataBase dataBase = new DataBase();
    public LoginJFrame(){

        setBounds(500,300,600,400);
        //设置页面标题
        this.setTitle("图书管理系统");
        //设置不可调整窗口大小
        setResizable(false);
        //设置界面居中
        this.setLocationRelativeTo(null);
        //关闭模式
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        //清除默认的布局管理器
        getContentPane().setLayout(null);



        //菜单
        //初始化菜单
        //创建菜单对象
        JMenuBar jMenuBar = new JMenuBar();

        //菜单选项
        JMenu functionJMenu = new JMenu("功能");

        //功能选项条目
        JMenuItem restartItem = new JMenuItem("重置");
        JMenuItem registerItem = new JMenuItem("注册");
        JMenuItem closeItem = new JMenuItem("退出");


        //添加条目到各个选项之中
        //功能选项
        functionJMenu.add(restartItem);
        functionJMenu.add(registerItem);
        functionJMenu.add(closeItem);



        //将选项添加到菜单之中
        jMenuBar.add(functionJMenu);

        //给整个界面设置菜单
        this.setJMenuBar(jMenuBar);


        //各个组件
        ArrayList<JComponent> listComponent = new ArrayList<>();
        //输入框
        JTextField idField = new JTextField();
        JPasswordField passwordField = new JPasswordField();
        idField.setBounds(200, 110, 200, 45);
        passwordField.setBounds(200, 175, 200, 45);
        //存入集合
        listComponent.add(idField);
        listComponent.add(passwordField);
        //放到页面上
        getContentPane().add(idField);
        getContentPane().add(passwordField);



        //按钮
        JButton registerButton = new JButton("注册");
        JButton loginButton = new JButton("登录");

        //设置位置
        registerButton.setBounds(210,240,80,40);
        loginButton.setBounds(310,240,80,40);

        //添加到页面
        listComponent.add(registerButton);
        listComponent.add(loginButton);
        getContentPane().add(loginButton);
        getContentPane().add(registerButton);


        //身份下拉表
        JComboBox<String> identityBox = new JComboBox<>();
        identityBox.addItem("普通用户");
        identityBox.addItem("管理员");
        identityBox.setBounds(410,110,90,35);
        getContentPane().add(identityBox);



        //标签
        JLabel idLabel = new JLabel("账号:");
        JLabel passwordLabel = new JLabel("密码:");
        JLabel titleLabel = new JLabel("图书管理系统");
        JLabel timeLabel = new JLabel();
        //设置坐标与宽高
        idLabel.setBounds(130, 110, 60, 45);
        passwordLabel.setBounds(130, 175, 60, 45);
        titleLabel.setBounds(225, 50, 200, 60);
        timeLabel.setBounds(5, 320, 305, 40);
        //存入集合
        listComponent.add(idLabel);
        listComponent.add(passwordLabel);
        listComponent.add(timeLabel);
        //titleLabel不存入集合单独设置
        titleLabel.setFont(new Font("黑体", Font.BOLD, 24));

        //放到页面上
        getContentPane().add(idLabel);
        getContentPane().add(passwordLabel);
        getContentPane().add(titleLabel);
        getContentPane().add(timeLabel);


        this.setVisible(true);


        //注册按钮
        registerButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String selectedRole = (String) identityBox.getSelectedItem();
                if ("管理员".equals(selectedRole)){
                    ManagerRegisterJFrame managerRegisterJFrame = new ManagerRegisterJFrame();
                } else if ("普通用户".equals(selectedRole)) {
                    UserRegisterJFrame registerJFrame = new UserRegisterJFrame();
                }

            }
        });


        //登录
        loginButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String selectedRole = (String) identityBox.getSelectedItem();
                if ("管理员".equals(selectedRole)){
                    ArrayList<User> userList;
                    userList=dataBase.getManager();
                    boolean found = false;
                    if (idField.getText().isEmpty()){
                        JOptionPane.showMessageDialog(getContentPane(),"请输入账号");
                        return;
                    }
                    for (User user : userList){
                        if (user.getId().equals(idField.getText())){
                            found = true;
                            if (user.getPassword().equals(new String(passwordField.getPassword()))){
                                System.out.println("登录成功");
                                JOptionPane.showMessageDialog(getContentPane(),"登录成功");
                                LoginJFrame.this.dispose();
                                ManageBookMenuJFrame manageBookMenuJFrame = new ManageBookMenuJFrame();
                            }else {
                                System.out.println("密码错误");
                                JOptionPane.showMessageDialog(getContentPane(),"密码错误");
                            }
                            break;
                        }
                    }
                    if (!found){
                        System.out.println("账号不存在");
                        JOptionPane.showMessageDialog(getContentPane(),"账号不存在");
                    }
                }else if ("普通用户".equals(selectedRole)){
                    ArrayList<User> userList;
                    userList=dataBase.getUser();
                    boolean found = false;
                    if (idField.getText().isEmpty()){
                        JOptionPane.showMessageDialog(getContentPane(),"请输入账号");
                        return;
                    }
                    for (User user : userList){
                        if (user.getId().equals(idField.getText())){
                            found = true;
                            if (user.getPassword().equals(new String(passwordField.getPassword()))){
                                System.out.println("登录成功");
                                JOptionPane.showMessageDialog(getContentPane(),"登录成功");
                                LoginJFrame.this.dispose();
                                UserBookMenuJFrame menuJFrame = new UserBookMenuJFrame();
                            }else {
                                System.out.println("密码错误");
                                JOptionPane.showMessageDialog(getContentPane(),"密码错误");
                            }
                            break;
                        }
                    }
                    if (!found){
                        System.out.println("账号不存在");
                        JOptionPane.showMessageDialog(getContentPane(),"账号不存在");
                    }
                }



            }
        });



        //重置条目
        restartItem.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                idField.setText("");
                passwordField.setText("");
            }
        });

        //注册条目
        registerItem.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String selectedRole = (String) identityBox.getSelectedItem();
                if ("管理员".equals(selectedRole)){
                    ManagerRegisterJFrame managerRegisterJFrame = new ManagerRegisterJFrame();
                } else if ("普通用户".equals(selectedRole)) {
                    UserRegisterJFrame registerJFrame = new UserRegisterJFrame();
                }
            }
        });



        //关闭条目
        closeItem.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                int result = JOptionPane.showConfirmDialog(getContentPane(),"是否确定退出？","确定",JOptionPane.YES_NO_OPTION);
                if (result == JOptionPane.YES_OPTION){
                    dispose();
                    System.exit(0);
                }

            }
        });



    }


}

1.界面布局：使用JFrame作为主窗口，通过设置setBounds方法来定义窗口的位置和大小。通过setResizable(false)设置窗口大小不可调整，setDefaultCloseOperation设置窗口关闭时退出程序。

2.菜单栏：通过JMenuBar和JMenu创建了一个简单的菜单栏，包含“功能”菜单和三个菜单项：“重置”、“注册”和“退出”。这些菜单项通过actionPerformed方法响应用户的点击事件。

3.输入组件：使用JTextField和JPasswordField创建账号和密码输入框。这些输入框被添加到一个ArrayList<JComponent>中，以便于管理。

4.按钮：创建了两个按钮：“注册”和“登录”，分别用于注册新用户和登录系统。按钮的点击事件通过actionPerformed方法处理。选择不同的身份后，注册后就会打开相应的注册界面，注册的的数据会保存到达梦数据库相应的表中，并在登录时会进行验证进入不同的界面。

5.身份下拉列表：使用JComboBox创建一个下拉列表，允许用户选择“普通用户”或“管理员”身份。

6.标签：创建了几个JLabel用于显示文本信息，如“账号:”、“密码:”和“图书管理系统”。

7.事件处理：为“注册”按钮和“登录”按钮添加了事件监听器，当用户点击这些按钮时，会根据选择的身份执行相应的操作。例如，如果用户选择“管理员”并点击“注册”，则会打开一个新的ManagerRegisterJFrame窗口用于管理员注册。如果用户点击“登录”，则会根据输入的账号和密码验证用户身份，并在验证成功后关闭登录窗口并打开相应的管理或用户界面。

8.退出功能：为“退出”菜单项添加了事件监听器，当用户选择退出时，会弹出一个确认对话框，如果用户确认退出，则关闭程序。

普通用户注册界面

package system;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

public class UserRegisterJFrame extends JFrame{
    DataBase dataBase = new DataBase();
    public UserRegisterJFrame(){
        setSize(300, 200);
        setTitle("普通用户注册");
        setLocationRelativeTo(null);
        // 创建并设置内容面板
        JPanel contentPane = new JPanel(new BorderLayout());

        // 创建中间面板来存放输入字段，使用GridLayout
        JPanel inputPanel = new JPanel(new GridLayout(3, 2, 10, 10)); // 5行2列，水平和垂直间距都是10

        // 组件
        JLabel idLabel = new JLabel("ID号:");
        JTextField idField = new JTextField(20);
        JLabel passwordLabel = new JLabel("密码:");
        JPasswordField passwordField = new JPasswordField(20);
        JLabel ensurePasswordLabel = new JLabel("确认密码");
        JPasswordField ensurePasswordField = new JPasswordField(20);


        // 添加组件到中间面板
        inputPanel.add(idLabel);
        inputPanel.add(idField);
        inputPanel.add(passwordLabel);
        inputPanel.add(passwordField);
        inputPanel.add(ensurePasswordLabel);
        inputPanel.add(ensurePasswordField);


        // 创建底部面板来存放注册按钮
        JPanel buttonPanel = new JPanel();
        JButton registerButton = new JButton("注册");
        buttonPanel.add(registerButton);

        // 将中间面板和底部面板添加到内容面板
        contentPane.add(inputPanel, BorderLayout.CENTER);
        contentPane.add(buttonPanel, BorderLayout.PAGE_END);

        // 将内容面板添加到JFrame
        setContentPane(contentPane);

        // 设置窗口可见
        setVisible(true);


        registerButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                User user = new User();
                String id = idField.getText().trim();//使用trim移除前后的空格
                char[] passwordChars = passwordField.getPassword();
                String password = new String(passwordChars);
                char[] ensurePasswordChars = ensurePasswordField.getPassword();
                String ensurePassword = new String(ensurePasswordChars);


                boolean found = true;

                //验证用户名或密码是否为空
                if (id == null || id.isEmpty()){
                    JOptionPane.showMessageDialog(getContentPane(),"用户名不得为空");
                    found = false;
                    return;
                }
                if(password == null || password.isEmpty()){
                    JOptionPane.showMessageDialog(getContentPane(),"密码不得为空");
                    found = false;
                    return;
                }
                if (ensurePassword == null || ensurePassword.isEmpty()){
                    JOptionPane.showMessageDialog(getContentPane(),"请确认密码");
                    found = false;
                    return;
                }
                if (!ensurePassword.equals(password)){
                    JOptionPane.showMessageDialog(getContentPane(),"密码不一致");
                    found = false;
                    return;
                }

                ArrayList<User> userList;
                userList=dataBase.getUser();

                //校验用户名是否重复
                for(User users :userList){

                    if (users.getId().equals(id)){
                        found = false;
                        JOptionPane.showMessageDialog(getContentPane(),"用户名已存在");
                        break;
                    }
                }
                if (found){
                    user.setId(id);
                    user.setPassword(password);
                    dataBase.addUser(user);
                    JOptionPane.showMessageDialog(getContentPane(),"注册成功");
                }
            }
        });
    }
}

1.界面设置：使用JFrame作为主窗口，通过setSize方法设置窗口的大小，setTitle方法设置窗口标题，并通过setLocationRelativeTo(null)确保窗口在屏幕中央显示。

2.内容面板：创建了一个JPanel作为内容面板，并使用BorderLayout布局管理器。这种布局允许将组件放置在不同的区域，如中间和底部。

3.输入面板：创建了一个JPanel，使用GridLayout布局管理器来组织输入字段。GridLayout将面板分为3行2列，每行和每列之间有10像素的间距。

4.输入组件：为用户ID号、密码和确认密码创建了三个标签和三个文本输入框。这些组件被添加到输入面板中。

5.注册按钮：创建了一个JButton，当用户点击时，会触发注册过程。

6.事件处理：为注册按钮添加了一个ActionListener，当按钮被点击时，会执行注册逻辑。注册逻辑包括：

创建一个User对象。
从输入框中获取用户输入的ID号、密码和确认密码。
验证输入的有效性，包括检查是否为空、密码是否一致以及用户名是否已存在。
如果所有验证通过，将新用户添加到数据库中，并显示注册成功的消息。

7.用户界面：使用JOptionPane.showMessageDialog显示错误消息或成功消息，以提供用户反馈。

8.数据库操作：通过DataBase类的实例dataBase来执行数据库操作，如添加新用户。

管理员注册界面

package system;


import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

public class ManagerRegisterJFrame extends JFrame {
    DataBase dataBase = new DataBase();
    public ManagerRegisterJFrame() {

        setSize(300, 200);
        setTitle("管理员注册");
        setLocationRelativeTo(null);

        // 创建并设置内容面板
        JPanel contentPane = new JPanel(new BorderLayout());

        // 创建中间面板来存放输入字段，使用GridLayout
        JPanel inputPanel = new JPanel(new GridLayout(3, 2, 10, 10));

        // 组件
        JLabel idLabel = new JLabel("ID号:");
        JTextField idField = new JTextField(20);
        JLabel passwordLabel = new JLabel("密码:");
        JPasswordField passwordField = new JPasswordField(20);
        JLabel ensurePasswordLabel = new JLabel("确认密码");
        JPasswordField ensurePasswordField = new JPasswordField(20);



        // 添加组件到中间面板
        inputPanel.add(idLabel);
        inputPanel.add(idField);
        inputPanel.add(passwordLabel);
        inputPanel.add(passwordField);
        inputPanel.add(ensurePasswordLabel);
        inputPanel.add(ensurePasswordField);


        // 创建底部面板来存放注册按钮
        JPanel buttonPanel = new JPanel();
        JButton registerButton = new JButton("注册");
        buttonPanel.add(registerButton);

        // 将中间面板和底部面板添加到内容面板
        contentPane.add(inputPanel, BorderLayout.CENTER);
        contentPane.add(buttonPanel, BorderLayout.PAGE_END);

        // 将内容面板添加到JFrame
        setContentPane(contentPane);

        // 设置窗口可见
        setVisible(true);


        registerButton.addActionListener(new ActionListener(){

            public void actionPerformed(ActionEvent e){

                User user = new User();
                String id = idField.getText().trim();//使用trim移除前后的空格
                char[] passwordChars = passwordField.getPassword();
                String password = new String(passwordChars);
                char[] ensurePasswordChars = ensurePasswordField.getPassword();
                String ensurePassword = new String(ensurePasswordChars);


                boolean found = true;

                //验证用户名或密码是否为空
                if (id == null || id.isEmpty()){
                    JOptionPane.showMessageDialog(getContentPane(),"管理员名不得为空");
                    found = false;
                    return;

                }
                if(password == null || password.isEmpty()){
                    JOptionPane.showMessageDialog(getContentPane(),"密码不得为空");
                    found = false;
                    return;
                }
                if (ensurePassword == null || ensurePassword.isEmpty()){
                    JOptionPane.showMessageDialog(getContentPane(),"请确认密码");
                    found = false;
                    return;
                }
                if (!ensurePassword.equals(password)){
                    JOptionPane.showMessageDialog(getContentPane(),"密码不一致");
                    found = false;
                    return;
                }

                ArrayList<User> userList;
                userList=dataBase.getManager();

                //校验管理员名是否重复
                for(User users :userList){
                    if (users.getId().equals(id)){
                        found = false;
                        JOptionPane.showMessageDialog(getContentPane(),"管理员名已存在");
                        break;
                    }
                }

                if (found){
                    user.setId(id);
                    user.setPassword(password);
                    dataBase.addManager(user);
                    JOptionPane.showMessageDialog(getContentPane(),"注册成功");
                }

            }
        });


    }



}

界面布局和业务逻辑与普通用户注册界面基本相同，管理员信息会保存到数据库相应的表中。

普通用户图书管理系统界面

package system;

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class UserBookMenuJFrame extends JFrame {
    DataBase dataBase = new DataBase();
    private JTable table;
    boolean isEdit = false;

    public UserBookMenuJFrame() {
        // 设置窗口大小和关闭操作
        this.setSize(800, 600);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        this.setTitle("图书管理系统 - 普通用户");
        this.setLocationRelativeTo(null);

        // 创建一个面板来放置按钮和表格
        JPanel contentPanel = new JPanel(new BorderLayout());

        //创建一个面板案例放置查询输入框和按钮
        JPanel selectPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
        JLabel selectJLabel = new JLabel("书名:");
        JTextField selectField = new JTextField(20);
        JButton selectButton = new JButton("查询");
        //添加到面板
        selectPanel.add(selectJLabel);
        selectPanel.add(selectField);
        selectPanel.add(selectButton);
        contentPanel.add(selectPanel,BorderLayout.NORTH);


        // 创建一个面板来放置按钮
        JPanel buttonPanel = new JPanel();
        buttonPanel.setLayout(new FlowLayout(FlowLayout.CENTER));

        // 添加按钮到按钮面板


        JButton borrowButton = new JButton("借阅");
        JButton returnButton = new JButton("归还");
        JButton restartButton = new JButton("刷新");
        buttonPanel.add(borrowButton);
        buttonPanel.add(returnButton);
        buttonPanel.add(restartButton);



        // 添加到内容面板的底部
        contentPanel.add(buttonPanel, BorderLayout.SOUTH);



        // 将图书列表转换为表格所需的数组格式
        Object[][] data = dataBase.getBook();
        // 创建一个表格模型
        String[] columnNames = {"图书ID", "书名", "作者", "出版时间", "价格", "数量"};

        DefaultTableModel model = new DefaultTableModel(data, columnNames) {
            @Override
            public boolean isCellEditable(int row, int column) {
                // 设置为不可编辑
                return isEdit;
            }
        };

        // 创建一个表格
        table = new JTable(model);

        // 禁止列重排序
        table.getTableHeader().setReorderingAllowed(false);

        // 将表格放在一个滚动面板中，以便在表格内容较多时可以滚动查看
        JScrollPane scrollPane = new JScrollPane(table);
        // 设置滚动面板的大小（小于窗口大小）
        scrollPane.setPreferredSize(new Dimension(600, 400));

        // 添加到内容面板的中心位置
        contentPanel.add(scrollPane, BorderLayout.CENTER);

        // 将内容面板添加到窗口中
        this.setContentPane(contentPanel);

        // 设置窗口可见
        this.setVisible(true);




        //查询按钮
        selectButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String bookName = selectField.getText();
                if (selectField.getText().isEmpty()){
                    JOptionPane.showMessageDialog(getContentPane(),"请输入书名");
                    return;
                }
                Object[][] selectData = dataBase.selectBook(bookName);
                if (selectData != null) {
                    // 创建新的表格模型
                    String[] columnNames = {"图书ID", "书名", "作者", "出版时间", "价格", "数量"};
                    DefaultTableModel newModel = new DefaultTableModel(selectData, columnNames) {
                        @Override
                        public boolean isCellEditable(int row, int column) {
                            return false;
                        }
                    };
                    // 将新的模型设置给表格
                    table.setModel(newModel);
                } else {
                    // 如果没有找到书籍信息，显示消息给用户
                    JOptionPane.showMessageDialog(UserBookMenuJFrame.this, "未找到书籍：" + bookName);
                }
            }
        });



        //刷新按钮
        restartButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                selectField.setText("");
                Object[][] data = dataBase.getBook();
                String[] columnNames = {"图书ID", "书名", "作者", "出版时间", "价格", "数量"};
                DefaultTableModel model = new DefaultTableModel(data, columnNames) {
                    @Override
                    public boolean isCellEditable(int row, int column) {
                        // 设置为不可编辑
                        return isEdit;
                    }
                };
                table.setModel(model);
            }
        });



        //借阅按钮
        borrowButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                BorrowBookJFrame borrowBookJFrame = new BorrowBookJFrame();
            }
        });


        returnButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                ReturnBookJFrame returnBookJFrame = new ReturnBookJFrame();
            }
        });


    }
}

1.界面布局：使用JFrame作为主窗口，通过setSize方法设置窗口的大小，setDefaultCloseOperation设置窗口关闭时退出程序，setTitle设置窗口标题，并通过setLocationRelativeTo(null)确保窗口在屏幕中央显示。

2.查询面板：创建了一个面板selectPanel，使用FlowLayout布局管理器，包含一个标签selectJLabel、一个文本输入框selectField和一个查询按钮selectButton。用户可以在文本框中输入书名进行查询。

3.操作按钮：创建了一个面板buttonPanel，同样使用FlowLayout布局管理器，包含三个按钮：“借阅”、“归还”和“刷新”。这些按钮用于执行相应的图书操作。

4.表格显示：使用JTable组件显示图书信息。通过DefaultTableModel创建表格模型，从DataBase类的实例dataBase获取图书数据，并设置表格的列名。

5.事件处理：为查询按钮、借阅按钮和归还按钮添加了事件监听器，当用户点击这些按钮时，会执行相应的操作。例如，点击查询按钮会根据输入的书名在数据库中搜索图书，如果找到则更新表格显示；点击借阅和归还按钮则会打开新的窗口BorrowBookJFrame和ReturnBookJFrame，用于处理借阅和归还的详细信息。

6.刷新功能：为刷新按钮添加了事件监听器，当用户点击时，会清空查询输入框，并重新从数据库获取所有图书数据，更新表格显示。

普通用户借阅图书界面

package system;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

public class BorrowBookJFrame extends JFrame {
    DataBase dataBase = new DataBase();
    public BorrowBookJFrame(){
        setTitle("借阅图书");
        setSize(300, 200);
        setLocationRelativeTo(null); // 居中显示

        // 创建一个居中的面板
        JPanel centeredPanel = new JPanel();
        centeredPanel.setLayout(new FlowLayout(FlowLayout.CENTER, 10, 10)); // 使用FlowLayout布局并居中

        // 添加书号标签和输入框
        JLabel bookIdLabel = new JLabel("书号:");
        JTextField bookIdField = new JTextField(10);
        centeredPanel.add(bookIdLabel);
        centeredPanel.add(bookIdField);

        // 添加借阅按钮
        JButton borrowButton = new JButton("借阅");
        centeredPanel.add(borrowButton);

        // 设置内容面板的布局为BorderLayout，并将centeredPanel添加到CENTER位置
        Container contentPane = getContentPane();
        contentPane.setLayout(new BorderLayout());
        contentPane.add(centeredPanel, BorderLayout.CENTER);

        // 显示窗口
        setVisible(true);


        borrowButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String id = bookIdField.getText();
                if (!id.isEmpty()) {
                    // 检查书号是否存在
                    boolean bookExists = false;
                    ArrayList<Book> bookList = dataBase.getAllBook();
                    for (Book book : bookList) {
                        if (book.getBookID() == Integer.parseInt(id)) {
                            bookExists = true;
                            break;
                        }
                    }
                    if (bookExists) {
                        // 如果书号存在，则执行操作
                        dataBase.borrowBook(Integer.parseInt(id));
                        JOptionPane.showMessageDialog(getContentPane(), "借阅成功");
                        bookIdField.setText("");
                    } else {
                        // 如果书号不存在，则提示用户
                        JOptionPane.showMessageDialog(getContentPane(), "书号不存在");
                    }
                } else {
                    // 如果书号为空，则提示用户输入书号
                    JOptionPane.showMessageDialog(getContentPane(), "请输入书号");
                }
            }
        });
    }
}

1.界面设置：使用JFrame作为主窗口，通过setTitle设置窗口标题，setSize设置窗口大小，并通过setLocationRelativeTo(null)确保窗口在屏幕中央显示。

2.布局管理：创建了一个JPanel作为内容面板，并使用FlowLayout布局管理器。这种布局允许组件按照水平和垂直方向的顺序排列，且组件之间有指定的间距。

3.输入组件：为用户输入书号创建了一个标签bookIdLabel和一个文本输入框bookIdField。

4.借阅按钮：创建了一个JButton，当用户点击时，会触发借阅操作。

5.事件处理：为借阅按钮添加了一个ActionListener，当按钮被点击时，会执行借阅逻辑。借阅逻辑包括：

从输入框中获取用户输入的书号。
验证书号是否为空。
检查书号是否存在于数据库中。
如果书号存在，则调用dataBase.borrowBook方法执行借阅操作，并显示借阅成功的消息。
如果书号不存在或用户未输入书号，则显示相应的错误消息。

6.数据库操作：通过DataBase类的实例dataBase来执行数据库操作，如检查书号是否存在和执行借阅操作。若借阅成功，该图书的数量就会减少一本。

普通用户归还图书界面

package system;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

public class ReturnBookJFrame extends JFrame {
    DataBase dataBase = new DataBase();
    public ReturnBookJFrame(){
        setTitle("归还图书");
        setSize(300, 200);
        setLocationRelativeTo(null); // 居中显示

        // 创建一个居中的面板
        JPanel centeredPanel = new JPanel();
        centeredPanel.setLayout(new FlowLayout(FlowLayout.CENTER, 10, 10)); // 使用FlowLayout布局并居中

        // 添加书号标签和输入框
        JLabel bookIdLabel = new JLabel("书号:");
        JTextField bookIdField = new JTextField(10);
        centeredPanel.add(bookIdLabel);
        centeredPanel.add(bookIdField);

        // 添加删除按钮
        JButton returnButton = new JButton("归还");
        centeredPanel.add(returnButton);

        // 设置内容面板的布局为BorderLayout，并将centeredPanel添加到CENTER位置
        Container contentPane = getContentPane();
        contentPane.setLayout(new BorderLayout());
        contentPane.add(centeredPanel, BorderLayout.CENTER);

        // 显示窗口
        setVisible(true);


        returnButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String id = bookIdField.getText();
                if (!id.isEmpty()) {
                    // 检查书号是否存在
                    boolean bookExists = false;
                    ArrayList<Book> bookList = dataBase.getAllBook();
                    for (Book book : bookList) {
                        if (book.getBookID() == Integer.parseInt(id)) {
                            bookExists = true;
                            break;
                        }
                    }
                    if (bookExists) {
                        // 如果书号存在，则执行操作
                        dataBase.returnBook(Integer.parseInt(id));
                        JOptionPane.showMessageDialog(getContentPane(), "归还成功");
                        bookIdField.setText("");
                    } else {
                        // 如果书号不存在，则提示用户
                        JOptionPane.showMessageDialog(getContentPane(), "书号不存在");
                    }
                } else {
                    // 如果书号为空，则提示用户输入书号
                    JOptionPane.showMessageDialog(getContentPane(), "请输入书号");
                }
            }
        });
    }
}

这段代码与归还图书的代码相似，若输入有效的书号通过检验后，会调用Database里的returnBook的方法来执行数据库的操作，若归还成功，相应的图书的数量就会增加一本。

管理员图书管理系统界面

package system;

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ManageBookMenuJFrame extends JFrame{
    DataBase dataBase = new DataBase();
    private JTable table;
    boolean isEdit = false;

    public ManageBookMenuJFrame() {
        this.setSize(800, 600);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        this.setTitle("图书管理系统 - 管理员");
        this.setLocationRelativeTo(null);

        //设置菜单
        JMenuBar jMenuBar = new JMenuBar();

        //设置菜单选项
        JMenu jMenu = new JMenu("切换");

        //设置条目
        JMenuItem jMenuItem = new JMenuItem("用户管理");

        //添加到界面中
        jMenu.add(jMenuItem);
        jMenuBar.add(jMenu);
        this.setJMenuBar(jMenuBar);

        // 创建一个面板来放置按钮和表格
        JPanel contentPanel = new JPanel(new BorderLayout());

        //创建一个面板案例放置查询输入框和按钮
        JPanel selectPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
        JLabel selectJLabel = new JLabel("书名:");
        JTextField selectField = new JTextField(20);
        JButton selectButton = new JButton("查询");
        //添加到面板
        selectPanel.add(selectJLabel);
        selectPanel.add(selectField);
        selectPanel.add(selectButton);
        contentPanel.add(selectPanel,BorderLayout.NORTH);


        // 创建一个面板来放置按钮
        JPanel buttonPanel = new JPanel();
        buttonPanel.setLayout(new FlowLayout(FlowLayout.CENTER));

        // 添加按钮到按钮面板
        JButton addButton = new JButton("增加");
        JButton editButton = new JButton("修改");
        JButton deleteButton = new JButton("删除");
        JButton restartButton = new JButton("刷新");
        buttonPanel.add(addButton);
        buttonPanel.add(editButton);
        buttonPanel.add(deleteButton);
        buttonPanel.add(restartButton);


        // 添加到内容面板的底部
        contentPanel.add(buttonPanel, BorderLayout.SOUTH);


        // 将图书列表转换为表格所需的数组格式
        Object[][] data = dataBase.getBook();
        // 创建一个表格模型
        String[] columnNames = {"图书ID", "书名", "作者", "出版时间", "价格", "数量"};

        DefaultTableModel model = new DefaultTableModel(data, columnNames) {
            @Override
            public boolean isCellEditable(int row, int column) {
                // 设置为不可编辑
                return isEdit;
            }
        };

        // 创建一个表格
        table = new JTable(model);

        // 禁止列重排序
        table.getTableHeader().setReorderingAllowed(false);

        // 将表格放在一个滚动面板中，以便在表格内容较多时可以滚动查看
        JScrollPane scrollPane = new JScrollPane(table);
        // 设置滚动面板的大小（小于窗口大小）
        scrollPane.setPreferredSize(new Dimension(600, 400));

        // 添加到内容面板的中心位置
        contentPanel.add(scrollPane, BorderLayout.CENTER);

        // 将内容面板添加到窗口中
        this.setContentPane(contentPanel);

        // 设置窗口可见
        this.setVisible(true);


        //添加按钮
        addButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                InsertBookJFrame insertBookJFrame = new InsertBookJFrame();
            }
        });



        //查询按钮
        selectButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String bookName = selectField.getText();
                if (selectField.getText().isEmpty()){
                    JOptionPane.showMessageDialog(getContentPane(),"请输入书名");
                    return;
                }
                Object[][] selectData = dataBase.selectBook(bookName);
                if (selectData != null) {
                    String[] columnNames = {"图书ID", "书名", "作者", "出版时间", "价格", "数量"};
                    DefaultTableModel newModel = new DefaultTableModel(selectData, columnNames) {
                        @Override
                        public boolean isCellEditable(int row, int column) {
                            return false;
                        }
                    };
                    // 将新的模型设置给表格
                    table.setModel(newModel);
                } else {
                    // 显示消息给用户
                    JOptionPane.showMessageDialog(getContentPane(), "未找到书籍：" + bookName);
                }
            }
        });



        //刷新按钮
        restartButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                selectField.setText("");
                Object[][] data = dataBase.getBook();
                String[] columnNames = {"图书ID", "书名", "作者", "出版时间", "价格", "数量"};
                DefaultTableModel model = new DefaultTableModel(data, columnNames) {
                    @Override
                    public boolean isCellEditable(int row, int column) {
                        // 设置为不可编辑
                        return isEdit;
                    }
                };
                table.setModel(model);
            }
        });



        //删除按钮
        deleteButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                DeleteBookJFrame deleteBookJFrame = new DeleteBookJFrame();
            }
        });


        //修改按钮
        editButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                UpdateBookJFrame updateBookJFrame = new UpdateBookJFrame();
            }
        });


        //切换条目
        jMenuItem.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //关闭当前窗口
                ManageBookMenuJFrame.this.dispose();;
                //打开对应的窗口
                ManageUserMenuJFrame manageUserMenuJFrame = new ManageUserMenuJFrame();
                //设置窗口可见
                manageUserMenuJFrame.setVisible(true);
            }
        });
    }
}

2.菜单栏：创建了一个JMenuBar，并添加了一个菜单JMenu，名为“切换”，其中包含一个菜单项“用户管理”。点击该菜单项会打开用户管理界面。

3.查询面板：创建了一个面板selectPanel，使用FlowLayout布局管理器，包含一个标签selectJLabel、一个文本输入框selectField和一个查询按钮selectButton。管理员可以在文本框中输入书名进行查询。

4.操作按钮：创建了一个面板buttonPanel，同样使用FlowLayout布局管理器，包含四个按钮：“增加”、“修改”、“删除”和“刷新”。这些按钮用于执行相应的图书操作。

5.表格显示：使用JTable组件显示图书信息。通过DefaultTableModel创建表格模型，从DataBase类的实例dataBase获取图书数据，并设置表格的列名。

6.事件处理：为增加、修改、删除、查询和刷新按钮添加了事件监听器，当用户点击这些按钮时，会执行相应的操作。例如，点击查询按钮会根据输入的书名在数据库中搜索图书，如果找到则更新表格显示；点击增加、修改和删除按钮则会打开新的窗口InsertBookJFrame、UpdateBookJFrame和DeleteBookJFrame，用于处理图书的增加、修改和删除的详细信息。

7.切换用户管理界面：为“用户管理”菜单项添加了事件监听器，当管理员点击时，会关闭当前的管理员界面，并打开用户管理界面。

管理员添加图书界面

package system;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

public class InsertBookJFrame extends JFrame {
    DataBase dataBase = new DataBase();
    public InsertBookJFrame (){
        setSize(400, 300);
        setTitle("添加图书");

        setLocationRelativeTo(null);

        // 创建并设置内容面板
        JPanel contentPane = new JPanel(new BorderLayout());

        // 创建中间面板来存放输入字段，使用GridLayout
        JPanel inputPanel = new JPanel(new GridLayout(5, 2, 10, 10)); // 5行2列，水平和垂直间距都是10

        // 组件
        JLabel bookNameLabel = new JLabel("书名:");
        JTextField bookNameField = new JTextField(20);
        JLabel authorLabel = new JLabel("作者:");
        JTextField authorField = new JTextField(20);
        JLabel publishTimeLabel = new JLabel("出版时间:");
        JTextField publishTimeField = new JTextField(20);
        JLabel priceLabel = new JLabel("价格:");
        JTextField priceField = new JTextField(20);
        JLabel bookNumberlLabel = new JLabel("数量:");
        JTextField bookNumberField = new JTextField(20);

        // 添加组件到中间面板
        inputPanel.add(bookNameLabel);
        inputPanel.add(bookNameField);
        inputPanel.add(authorLabel);
        inputPanel.add(authorField);
        inputPanel.add(publishTimeLabel);
        inputPanel.add(publishTimeField);
        inputPanel.add(priceLabel);
        inputPanel.add(priceField);
        inputPanel.add(bookNumberlLabel);
        inputPanel.add(bookNumberField);

        // 创建底部面板来存放注册按钮
        JPanel buttonPanel = new JPanel();
        JButton ensureButton = new JButton("确定");
        buttonPanel.add(ensureButton);

        // 将中间面板和底部面板添加到内容面板
        contentPane.add(inputPanel, BorderLayout.CENTER);
        contentPane.add(buttonPanel, BorderLayout.PAGE_END);

        // 将内容面板添加到JFrame
        setContentPane(contentPane);

        // 设置窗口可见
        setVisible(true);



        ensureButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String name = bookNameField.getText().trim();
                String author = authorField.getText().trim();
                String time = publishTimeField.getText().trim();
                String price = priceField.getText().trim();
                String number = bookNumberField.getText().trim();

                // 假设所有字段都是有效的
                boolean isValid = true;

                if (name.isEmpty() || author.isEmpty() || time.isEmpty() || price.isEmpty() || number.isEmpty()){
                    isValid = false;
                    JOptionPane.showMessageDialog(getContentPane(),"请输入图书基本信息");
                    return;
                }else {
                    isValid = true;
                }
                // 检查价格格式是否正确
                if (!price.matches("\\d+(\\.\\d{1,2})?")) {
                    JOptionPane.showMessageDialog(getContentPane(), "价格格式不正确，请输入有效的价格");
                    isValid = false;
                    return;
                }

                // 检查数量格式是否正确
                if (!number.matches("\\d+")) {
                    JOptionPane.showMessageDialog(getContentPane(), "数量格式不正确，请输入有效的数量");
                    isValid = false;
                    return;
                }
                if (isValid){
                    Book book = new Book();
                    book.setBookName(name);
                    book.setAuthor(author);
                    book.setPublishTime(time);
                    book.setPrice(Double.parseDouble(price));
                    book.setBookNumber(Integer.parseInt(number));
                    dataBase.addBook(book);
                    JOptionPane.showMessageDialog(getContentPane(),"保存成功");
                }
            }
        });
    }
}

1.界面设置：使用JFrame作为主窗口，通过setSize设置窗口大小，setTitle设置窗口标题，并通过setLocationRelativeTo(null)确保窗口在屏幕中央显示。

2.布局管理：创建了一个JPanel作为内容面板，并使用BorderLayout布局管理器。中间面板inputPanel使用GridLayout布局管理器来组织输入字段，底部面板buttonPanel用于放置按钮。

3.输入组件：为管理员输入图书的书名、作者、出版时间、价格和数量创建了五个标签和五个文本输入框。

4.确定按钮：创建了一个JButton，当用户点击时，会触发添加图书逻辑。

5.事件处理：为确定按钮添加了一个ActionListener，当按钮被点击时，会执行添加图书逻辑。添加图书逻辑包括：

从输入框中获取用户输入的图书信息。
验证输入的有效性，包括检查所有字段是否为空，以及价格和数量的格式是否正确。
如果所有验证通过，创建一个Book对象并设置其属性，然后调用dataBase.addBook方法将图书添加到数据库，并显示保存成功的消息。

6.数据库操作：通过DataBase类的实例dataBase来执行数据库操作。

管理员修改图书信息界面

package system;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

public class UpdateBookJFrame extends JFrame{
    DataBase dataBase = new DataBase();
    public UpdateBookJFrame(){
        setSize(400, 300);
        setTitle("修改图书");

        setLocationRelativeTo(null);

        // 创建并设置内容面板
        JPanel contentPane = new JPanel(new BorderLayout());

        // 创建中间面板来存放输入字段，使用GridLayout
        JPanel inputPanel = new JPanel(new GridLayout(6, 2, 10, 10)); // 6行2列，水平和垂直间距都是10

        // 组件
        JLabel bookIdLabel = new JLabel("修改的书号:");
        JTextField bookIdField = new JTextField(20);
        JLabel bookNameLabel = new JLabel("书名:");
        JTextField bookNameField = new JTextField(20);
        JLabel authorLabel = new JLabel("作者:");
        JTextField authorField = new JTextField(20);
        JLabel publishTimeLabel = new JLabel("出版时间:");
        JTextField publishTimeField = new JTextField(20);
        JLabel priceLabel = new JLabel("价格:");
        JTextField priceField = new JTextField(20);
        JLabel bookNumberlLabel = new JLabel("数量:");
        JTextField bookNumberField = new JTextField(20);

        // 添加组件到中间面板
        inputPanel.add(bookIdLabel);
        inputPanel.add(bookIdField);
        inputPanel.add(bookNameLabel);
        inputPanel.add(bookNameField);
        inputPanel.add(authorLabel);
        inputPanel.add(authorField);
        inputPanel.add(publishTimeLabel);
        inputPanel.add(publishTimeField);
        inputPanel.add(priceLabel);
        inputPanel.add(priceField);
        inputPanel.add(bookNumberlLabel);
        inputPanel.add(bookNumberField);

        // 创建底部面板来存放注册按钮
        JPanel buttonPanel = new JPanel();
        JButton ensureButton = new JButton("确定");
        buttonPanel.add(ensureButton);

        // 将中间面板和底部面板添加到内容面板
        contentPane.add(inputPanel, BorderLayout.CENTER);
        contentPane.add(buttonPanel, BorderLayout.PAGE_END);

        // 将内容面板添加到JFrame
        setContentPane(contentPane);

        // 设置窗口可见
        setVisible(true);



        ensureButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 获取输入框的值
                String id = bookIdField.getText().trim();
                String name = bookNameField.getText().trim();
                String author = authorField.getText().trim();
                String time = publishTimeField.getText().trim();
                String price = priceField.getText().trim();
                String number = bookNumberField.getText().trim();

                // 检查书号是否为空
                if (id.isEmpty()) {
                    JOptionPane.showMessageDialog(getContentPane(), "书号不能为空");
                    return;
                }

                // 检查书号是否存在
                boolean found = false;
                ArrayList<Book> bookList = dataBase.getAllBook();
                for (Book book : bookList) {
                    if (book.getBookID() == Integer.parseInt(id)) {
                        found = true;
                        break;
                    }
                }

                if (!found) {
                    JOptionPane.showMessageDialog(getContentPane(), "未找到该书号");
                    return;
                }

                // 检查其他字段是否为空
                if (name.isEmpty() || author.isEmpty() || time.isEmpty() || price.isEmpty() || number.isEmpty()) {
                    JOptionPane.showMessageDialog(getContentPane(), "请输入完整的修改信息");
                    return;
                }

                // 检查价格格式是否正确
                if (!price.matches("\\d+(\\.\\d{1,2})?")) {
                    JOptionPane.showMessageDialog(getContentPane(), "价格格式不正确，请输入有效的价格");
                    return;
                }

                // 检查数量格式是否正确
                if (!number.matches("\\d+")) {
                    JOptionPane.showMessageDialog(getContentPane(), "数量格式不正确，请输入有效的数量");
                    return;
                }

                // 创建Book对象并更新数据库
                Book book = new Book();
                book.setBookName(name);
                book.setAuthor(author);
                book.setPublishTime(time);
                book.setPrice(Double.parseDouble(price));
                book.setBookNumber(Integer.parseInt(number));
                book.setBookID(Integer.parseInt(id));

                // 更新数据库
                dataBase.updateBook(book);
                JOptionPane.showMessageDialog(getContentPane(), "修改成功");
                // 清空输入框
                bookIdField.setText("");
                bookNameField.setText("");
                authorField.setText("");
                priceField.setText("");
                publishTimeField.setText("");
                bookNumberField.setText("");
            }
        });
    }
}

1.界面设置：使用JFrame作为主窗口，通过setSize设置窗口大小，setTitle设置窗口标题，并通过setLocationRelativeTo(null)确保窗口在屏幕中央显示。

3.输入组件：为管理员输入书号、书名、作者、出版时间、价格和数量创建了六个标签和六个文本输入框。

4.确定按钮：创建了一个JButton，当用户点击时，会触发修改图书信息的逻辑。

5.事件处理：为确定按钮添加了一个ActionListener，当按钮被点击时，会执行修改图书信息的逻辑。修改图书信息的逻辑包括：

从输入框中获取用户输入的图书信息。
验证书号是否为空，并检查书号是否存在于数据库中。
验证其他输入字段是否为空。
检查价格和数量的格式是否正确。
如果所有验证通过，创建一个Book对象并设置其属性，然后调用dataBase.updateBook方法更新数据库中的图书信息，并显示修改成功的消息。
清空输入框，以便于进行下一次修改。

6.数据库操作：通过DataBase类的实例dataBase来执行数据库操作，如检查书号是否存在和执行图书信息的更新。

管理员删除图书界面

package system;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

public class DeleteBookJFrame extends JFrame {
    DataBase dataBase = new DataBase();
    public DeleteBookJFrame(){
        setTitle("删除图书");
        setSize(300, 200);
        setLocationRelativeTo(null); // 居中显示

        // 创建一个居中的面板
        JPanel centeredPanel = new JPanel();
        centeredPanel.setLayout(new FlowLayout(FlowLayout.CENTER, 10, 10)); // 使用FlowLayout布局并居中

        // 添加书号标签和输入框
        JLabel bookIdLabel = new JLabel("书号:");
        JTextField bookIdField = new JTextField(10);
        centeredPanel.add(bookIdLabel);
        centeredPanel.add(bookIdField);

        // 添加删除按钮
        JButton deleteButton = new JButton("删除");
        centeredPanel.add(deleteButton);

        // 设置内容面板的布局为BorderLayout，并将centeredPanel添加到CENTER位置
        Container contentPane = getContentPane();
        contentPane.setLayout(new BorderLayout());
        contentPane.add(centeredPanel, BorderLayout.CENTER);

        // 显示窗口
        setVisible(true);


        deleteButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String id = bookIdField.getText();
                if (!id.isEmpty()) {
                    // 检查书号是否存在
                    boolean bookExists = false;
                    ArrayList<Book> bookList = dataBase.getAllBook();
                    for (Book book : bookList) {
                        if (book.getBookID() == Integer.parseInt(id)) {
                            bookExists = true;
                            break;
                        }
                    }
                    if (bookExists) {
                        // 如果书号存在，则执行删除操作
                        dataBase.deleteBook(Integer.parseInt(id));
                        JOptionPane.showMessageDialog(getContentPane(), "删除成功");
                        bookIdField.setText("");
                    } else {
                        // 如果书号不存在，则提示用户
                        JOptionPane.showMessageDialog(getContentPane(), "书号不存在");
                    }
                } else {
                    // 如果书号为空，则提示用户输入书号
                    JOptionPane.showMessageDialog(getContentPane(), "请输入书号");
                }
            }
        });
    }
}

1.界面设置：使用JFrame作为主窗口，通过setTitle设置窗口标题，setSize设置窗口大小，并通过setLocationRelativeTo(null)确保窗口在屏幕中央显示。

3.输入组件：为管理员输入书号创建了一个标签bookIdLabel和一个文本输入框bookIdField。

4.删除按钮：创建了一个JButton，当用户点击时，会触发删除操作。

5.事件处理：为删除按钮添加了一个ActionListener，当按钮被点击时，会执行删除逻辑。删除逻辑包括：

从输入框中获取用户输入的书号。
验证书号是否为空。
检查书号是否存在于数据库中。
如果书号存在，则调用dataBase.deleteBook方法执行删除操作，并显示删除成功的消息。
如果书号不存在或用户未输入书号，则显示相应的错误消息。

6.数据库操作：通过DataBase类的实例dataBase来执行数据库操作，如检查书号是否存在和执行删除操作。

管理员普通用户账号管理界面

package system;

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ManageUserMenuJFrame extends JFrame {
    DataBase dataBase = new DataBase();
    private JTable table;
    boolean isEdit = false;
    public ManageUserMenuJFrame(){

        this.setSize(800,600);
        this.setTitle("用户管理");
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null);

        //设置菜单
        JMenuBar jMenuBar = new JMenuBar();

        //设置菜单选项
        JMenu jMenu = new JMenu("切换");

        //设置条目
        JMenuItem jMenuItem = new JMenuItem("图书管理");

        //添加到界面中
        jMenu.add(jMenuItem);
        jMenuBar.add(jMenu);
        this.setJMenuBar(jMenuBar);

        //创建一个面板来放置按钮和表格
        JPanel contentPanel = new JPanel(new BorderLayout());

        //创建一个面板案列放置查询输入框和按钮
        JPanel selectPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
        JLabel selectJLabel = new JLabel("ID:");
        JTextField selectField = new JTextField(20);
        JButton selectButton = new JButton("查询");
        //添加到面板
        selectPanel.add(selectJLabel);
        selectPanel.add(selectField);
        selectPanel.add(selectButton);
        contentPanel.add(selectPanel,BorderLayout.NORTH);

        //创建一个面板来放置按钮
        JPanel buttonPanel = new JPanel();
        buttonPanel.setLayout(new FlowLayout(FlowLayout.CENTER));

        //设置按钮
        JButton addButton = new JButton("增加");
        JButton editButton = new JButton("修改");
        JButton deleteButton = new JButton("删除");
        JButton restartButton = new JButton("刷新");
        buttonPanel.add(addButton);
        buttonPanel.add(editButton);
        buttonPanel.add(deleteButton);
        buttonPanel.add(restartButton);
        //添加内容面板的底部
        contentPanel.add(buttonPanel,BorderLayout.SOUTH);



        //获取数据
        Object[][] data = dataBase.getAllUser();
        //创建表格模型
        String[] columnNames = {"账号","密码"};

        DefaultTableModel model = new DefaultTableModel(data,columnNames){
            public boolean isCellEditable(int row,int column){
                //设置为不可编辑
                return isEdit;
            }
        };

        //创建一个表格
        table = new JTable(model);

        //禁止列重排列
        table.getTableHeader().setReorderingAllowed(false);

        //将表格放在一个滚动面板中
        JScrollPane scrollPane = new JScrollPane(table);
        // 设置滚动面板的大小（小于窗口大小）
        scrollPane.setPreferredSize(new Dimension(600, 400));

        //添加内容到面板中心位置
        contentPanel.add(scrollPane,BorderLayout.CENTER);

        //将内容面板添加到窗口中
        this.setContentPane(contentPanel);

        //设置窗口可见
        this.setVisible(true);


        //添加按钮
        addButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                UserRegisterJFrame userRegisterJFrame = new UserRegisterJFrame();
            }
        });



        //查找按钮
        selectButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String id = selectField.getText();
                if (selectField.getText().isEmpty()){
                    JOptionPane.showMessageDialog(getContentPane(),"请输入账号");
                    return;
                }
                Object[][] selectData = dataBase.selectUser(id);
                if (selectData != null){
                    String[] columnNames = {"ID","密码"};
                    DefaultTableModel newModel = new DefaultTableModel(selectData,columnNames){
                        public boolean isCellEditable(int row,int column){
                            return false;
                        }
                    };
                    table.setModel(newModel);
                }else {
                    JOptionPane.showMessageDialog(getContentPane(),"未找到该账号:"+id);
                }
            }
        });



        //刷新按钮
        restartButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                selectField.setText("");
                Object[][] data = dataBase.getAllUser();
                String[] columnNames = {"ID","密码"};
                DefaultTableModel model = new DefaultTableModel(data,columnNames){
                    public boolean isCellEditable(int row,int column){
                        //设置为不可编辑
                        return isEdit;
                    }
                };
                table.setModel(model);
            }
        });


        //删除按钮
        deleteButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                DeleteUserJFrame deleteUserJFrame = new DeleteUserJFrame();
            }
        });


        //修改按钮
        editButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                ChangePasswordJFrame changePasswordJFrame = new ChangePasswordJFrame();
            }
        });

        //切换条目
        jMenuItem.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //关闭当前窗口
                ManageUserMenuJFrame.this.dispose();;
                //打开对应的窗口
                ManageBookMenuJFrame manageBookMenuJFrame = new ManageBookMenuJFrame();
                //设置窗口可见
                manageBookMenuJFrame.setVisible(true);
            }
        });
    }
}

2.菜单栏：创建了一个JMenuBar，并添加了一个菜单JMenu，名为“切换”，其中包含一个菜单项“图书管理”。点击该菜单项会打开图书管理界面。

3.查询面板：创建了一个面板selectPanel，使用FlowLayout布局管理器，包含一个标签selectJLabel、一个文本输入框selectField和一个查询按钮selectButton。管理员可以在文本框中输入用户ID进行查询。

4.操作按钮：创建了一个面板buttonPanel，同样使用FlowLayout布局管理器，包含四个按钮：“增加”、“修改”、“删除”和“刷新”。这些按钮用于执行相应的用户操作。

5.表格显示：使用JTable组件显示用户信息。通过DefaultTableModel创建表格模型，从DataBase类的实例dataBase获取用户数据，并设置表格的列名。

6.事件处理：为增加、修改、删除、查询和刷新按钮添加了事件监听器，当用户点击这些按钮时，会执行相应的操作。例如，点击查询按钮会根据输入的用户ID在数据库中搜索用户，如果找到则更新表格显示；点击增加、修改和删除按钮则会打开新的窗口UserRegisterJFrame、ChangePasswordJFrame和DeleteUserJFrame，用于处理用户的增加、修改和删除的详细信息。

7.切换图书管理界面：为“图书管理”菜单项添加了事件监听器，当管理员点击时，会关闭当前的用户账号管理界面，并打开图书管理界面。

修改普通用户密码界面

package system;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

public class ChangePasswordJFrame extends JFrame{
    DataBase dataBase = new DataBase();
    public ChangePasswordJFrame() {

        setSize(300, 200);
        setTitle("修改用户密码");
        setLocationRelativeTo(null);

        // 创建并设置内容面板
        JPanel contentPane = new JPanel(new BorderLayout());

        // 创建中间面板来存放输入字段，使用GridLayout
        JPanel inputPanel = new JPanel(new GridLayout(3, 2, 10, 10));

        // 组件
        JLabel idLabel = new JLabel("ID号:");
        JTextField idField = new JTextField(20);
        JLabel passwordLabel = new JLabel("新密码:");
        JPasswordField passwordField = new JPasswordField(20);
        JLabel ensurePasswordLabel = new JLabel("确认密码");
        JPasswordField ensurePasswordField = new JPasswordField(20);


        // 添加组件到中间面板
        inputPanel.add(idLabel);
        inputPanel.add(idField);
        inputPanel.add(passwordLabel);
        inputPanel.add(passwordField);
        inputPanel.add(ensurePasswordLabel);
        inputPanel.add(ensurePasswordField);


        // 创建底部面板来存放注册按钮
        JPanel buttonPanel = new JPanel();
        JButton ensureButton = new JButton("确定");
        buttonPanel.add(ensureButton);

        // 将中间面板和底部面板添加到内容面板
        contentPane.add(inputPanel, BorderLayout.CENTER);
        contentPane.add(buttonPanel, BorderLayout.PAGE_END);

        // 将内容面板添加到JFrame
        setContentPane(contentPane);

        // 设置窗口可见
        setVisible(true);



        ensureButton.addActionListener(new ActionListener(){

            public void actionPerformed(ActionEvent e){


                String id = idField.getText().trim();//使用trim移除前后的空格
                char[] passwordChars = passwordField.getPassword();
                String password = new String(passwordChars);
                char[] ensurePasswordChars = ensurePasswordField.getPassword();
                String ensurePassword = new String(ensurePasswordChars);


                boolean found = false;


                if (id == null || id.isEmpty()){
                    JOptionPane.showMessageDialog(getContentPane(),"用户名不得为空");
                    found = false;
                    return;

                }
                if(password == null || password.isEmpty()){
                    JOptionPane.showMessageDialog(getContentPane(),"新密码不得为空");
                    found = false;
                    return;

                }
                if (ensurePassword == null || ensurePassword.isEmpty()){
                    JOptionPane.showMessageDialog(getContentPane(),"请确认密码");
                    found = false;
                    return;
                }
                if (!ensurePassword.equals(password)){
                    JOptionPane.showMessageDialog(getContentPane(),"密码不一致");
                    found = false;
                    return;
                }

                ArrayList<User> userList;
                userList=dataBase.getUser();
                //校验用户名是否存在
                for(User users :userList){

                    if (users.getId().equals(id)){
                        found = true;
                        break;
                    }
                }
                if (!found){
                    JOptionPane.showMessageDialog(getContentPane(),"未找到该用户");
                }
                if (found){
                    User user = new User();
                    user.setId(id);
                    user.setPassword(password);
                    dataBase.changePassword(user);
                    JOptionPane.showMessageDialog(getContentPane(),"修改成功");
                }

            }
        });


    }
}

1.界面设置：使用JFrame作为主窗口，通过setSize设置窗口大小，setTitle设置窗口标题，并通过setLocationRelativeTo(null)确保窗口在屏幕中央显示。

3.输入组件：为用户输入ID号、新密码和确认密码创建了三个标签和三个密码输入框。

4.确定按钮：创建了一个JButton，当用户点击时，会触发密码修改逻辑。

5.事件处理：为确定按钮添加了一个ActionListener，当按钮被点击时，会执行密码修改逻辑。密码修改逻辑包括：

从输入框中获取用户输入的ID号、新密码和确认密码。
验证输入的有效性，包括检查ID号、新密码和确认密码是否为空，以及确认密码是否与新密码一致。
校验用户名是否存在。
如果所有验证通过，调用dataBase.changePassword方法修改密码，并显示修改成功的消息。

6.数据库操作：通过DataBase类的实例dataBase来执行数据库操作，如验证用户是否存在和修改用户密码。

删除普通用户账号界面

package system;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;

public class DeleteUserJFrame extends JFrame {
    DataBase dataBase = new DataBase();
    public DeleteUserJFrame(){
        setTitle("删除用户");
        setSize(300, 200);
        setLocationRelativeTo(null); // 居中显示

        // 创建一个居中的面板
        JPanel centeredPanel = new JPanel();
        centeredPanel.setLayout(new FlowLayout(FlowLayout.CENTER, 10, 10)); // 使用FlowLayout布局并居中

        // 添加ID标签和输入框
        JLabel IdLabel = new JLabel("ID:");
        JTextField IdField = new JTextField(10);
        centeredPanel.add(IdLabel);
        centeredPanel.add(IdField);

        // 添加删除按钮
        JButton deleteButton = new JButton("删除");
        centeredPanel.add(deleteButton);

        // 设置内容面板的布局为BorderLayout，并将centeredPanel添加到CENTER位置
        Container contentPane = getContentPane();
        contentPane.setLayout(new BorderLayout());
        contentPane.add(centeredPanel, BorderLayout.CENTER);

        // 显示窗口
        setVisible(true);


        deleteButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String id = IdField.getText();
                if (!id.isEmpty()) {
                    // 检查ID是否存在
                    boolean IdExists = false;
                    ArrayList<User> userList = dataBase.getUser();
                    for (User user : userList) {
                        if (user.getId().equals(id)) {
                            IdExists = true;
                            break;
                        }
                    }
                    if (IdExists) {
                        // 如果ID存在，则执行删除操作
                        dataBase.deleteUser(id);
                        JOptionPane.showMessageDialog(getContentPane(), "删除成功");
                        IdField.setText("");
                    } else {
                        // 如果ID不存在，则提示用户
                        JOptionPane.showMessageDialog(getContentPane(), "账号不存在");
                    }
                } else {
                    // 如果ID为空，则提示用户输入书号
                    JOptionPane.showMessageDialog(getContentPane(), "请输入账号");
                }
            }
        });
    }
}

主函数

package system;

public class App {
    public static void main(String[] args) {
        LoginJFrame loginJFrame = new LoginJFrame();
    }
}

程序的入口点，创建并显示登录界面。

3.总结

这个图书管理系统包含了一些简单的界面布局和逻辑业务，并尝试使用国产达梦数据库作为数据支撑，其中的代码的一些解释在源代码中也有注析。作为一个Java初学者，这也是我的一个项目尝试，这个系统还存在着许多不足的地方，请合理借鉴参考，并欢迎大佬的指导。

2301_81290348

关注

52
点赞
踩
26

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫