【Java 基础篇】Java 图书管理系统详解

这篇具有很好参考价值的文章主要介绍了【Java 基础篇】Java 图书管理系统详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

图书管理系统java,Java 进击高手之路,java,开发语言,数据库,python,windows,数据结构,eclipse

介绍

图书管理系统是一种用于管理图书信息、借阅记录、用户信息等的软件系统。它可以帮助图书馆、书店或个人管理和组织图书资源,提供了方便的借阅和查询功能。在这篇博客中,我们将详细介绍如何使用Java编程语言创建一个简单的图书管理系统。

功能需求

在设计图书管理系统之前,我们首先需要明确系统应该具备的功能需求。以下是一个简单的功能列表:

  1. 添加图书:管理员可以添加新的图书信息,包括书名、作者、出版社、ISBN号等。
  2. 删除图书:管理员可以删除已有的图书信息。
  3. 查询图书:用户可以通过关键字搜索图书,系统将返回匹配的图书列表。
  4. 借阅图书:用户可以借阅图书,并记录借阅时间。
  5. 归还图书:用户可以归还已借阅的图书,并记录归还时间。
  6. 查看借阅记录:用户可以查看自己的借阅记录,包括借阅时间、归还时间等。
  7. 用户管理:管理员可以管理用户信息,包括添加、删除用户。
  8. 权限管理:管理员可以设置用户的权限,例如普通用户和管理员用户。

数据模型

在设计图书管理系统时,首先需要考虑数据模型,即如何存储和管理图书信息、用户信息、借阅记录等数据。以下是一个简化的数据模型示意图:

Book
- ID
- Title
- Author
- Publisher
- ISBN
- Status (Available, Checked Out)
- Borrower ID (if checked out)
- Due Date (if checked out)

User
- ID
- Name
- Email
- Password
- Role (Admin, User)

BorrowRecord
- ID
- Book ID
- User ID
- Borrow Date
- Return Date

数据模型包括三个主要实体:图书(Book)、用户(User)和借阅记录(BorrowRecord)。图书实体包括图书的基本信息和当前状态,用户实体包括用户的基本信息和角色,借阅记录实体用于记录图书的借阅和归还情况。

架构设计

在开始编写代码之前,我们需要考虑系统的架构设计。通常,一个图书管理系统可以分为以下几个模块:

  1. 用户管理模块:负责用户的注册、登录和权限管理。
  2. 图书管理模块:负责图书的添加、删除、查询和状态管理。
  3. 借阅管理模块:负责借阅和归还图书,以及记录借阅记录。
  4. 数据存储模块:负责将数据存储到数据库或文件中,以及从数据库或文件中检索数据。

接下来,我们将逐步实现这些模块。

开发环境和工具

在开始编写代码之前,确保您已经准备好了以下开发环境和工具:

  • Java开发工具(例如Eclipse、IntelliJ IDEA或VS Code)
  • 数据库(可以选择关系型数据库如MySQL或SQLite,也可以选择文件存储)
  • Java数据库连接库(例如JDBC)
  • 项目构建工具(例如Maven或Gradle)

用户管理模块

用户实体类

首先,让我们创建一个用户实体类,用于表示系统中的用户信息。用户实体包括ID、用户名、密码、邮箱和角色。

public class User {
    private int id;
    private String username;
    private String password;
    private String email;
    private UserRole role;

    // 构造函数、getter和setter方法
}

UserRole是一个枚举类型,表示用户的角色,可以定义为管理员和普通用户。

public enum UserRole {
    ADMIN,
    USER
}

用户数据访问对象(DAO)

接下来,创建一个用户数据访问对象(DAO),用于与数据库或文件进行用户的数据交互。我们将使用JDBC(Java Database Connectivity)来连接数据库并执行数据库操作。

首先,我们需要建立数据库连接。假设我们选择MySQL数据库,以下是建立数据库连接的示例代码:

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

public class DatabaseConnection {
    private static final String URL = "jdbc:mysql://localhost:3306/library";
    private static final String USERNAME = "root";
    private static final String PASSWORD = "password";

    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(URL, USERNAME, PASSWORD);
    }
}

在上面的示例中,我们使用JDBC连接了名为"library"的MySQL数据库,使用用户名"root"和密码"password"。请根据您的实际数据库配置进行更改。

接下来,创建一个用户DAO类,用于执行用户相关的数据库操作,包括用户的添加、删除、查询和权限管理。以下是一个简单的用户DAO示例:

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class UserDao {
    private Connection connection;

    public UserDao() {
        try {
            connection = DatabaseConnection.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 添加用户
    public void addUser(User user) {
        String sql = "INSERT INTO users (username, password, email, role) VALUES (?, ?, ?, ?)";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setString(1, user.getUsername());
            preparedStatement.setString(2, user.getPassword());
            preparedStatement.setString(3, user.getEmail());
            preparedStatement.setString(4, user.getRole().toString());

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

    // 删除用户
    public void deleteUser(int userId) {
        String sql = "DELETE FROM users WHERE id = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setInt(1, userId);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 根据用户名查询用户
    public User getUserByUsername(String username) {
        String sql = "SELECT * FROM users WHERE username = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setString(1, username);
            ResultSet resultSet = preparedStatement.executeQuery();

            if (resultSet.next()) {
                return extractUserFromResultSet(resultSet);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    // 查询所有用户
    public List<User> getAllUsers() {
        List<User> userList = new ArrayList<>();
        String sql = "SELECT * FROM users";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            ResultSet resultSet = preparedStatement.executeQuery();

            while (resultSet.next()) {
                userList.add(extractUserFromResultSet(resultSet));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return userList;
    }

    // 从ResultSet提取用户信息
    private User extractUserFromResultSet(ResultSet resultSet) throws SQLException {
        User user = new User();
        user.setId(resultSet.getInt("id"));
        user.setUsername(resultSet.getString("username"));
        user.setPassword(resultSet.getString("password"));
        user.setEmail(resultSet.getString("email"));
        user.setRole(UserRole.valueOf(resultSet.getString("role")));
        return user;
    }
}

上述示例中,我们创建了一个UserDao类,该类包含了添加用户、删除用户、查询用户和查询所有用户的方法。这些方法使用了预备语句(PreparedStatement)来执行SQL查询和更新操作,并将查询结果映射到User对象。

用户服务类

用户服务类用于处理用户管理模块的业务逻辑。它可以调用用户DAO来执行数据库操作,例如添加用户、删除用户、查询用户等。

以下是一个简单的用户服务类示例:

public class UserService {
    private UserDao userDao;

    public UserService() {
        userDao = new UserDao();
    }

    // 注册用户
    public void registerUser(String username, String password, String email, UserRole role) {
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);
        user.setEmail(email);
        user.setRole(role);

        userDao.addUser(user);
    }

    // 删除用户
    public void deleteUser(int userId) {
        userDao.deleteUser(userId);
    }

    // 根据用户名查询用户
    public User getUserByUsername(String username) {
        return userDao.getUserByUsername(username);
    }

    // 查询所有用户
    public List<User> getAllUsers() {
        return userDao.getAllUsers();
    }
}

在上面的示例中,UserService类提供了注册用户、删除用户、查询用户和查询所有用户的方法,它通过调用UserDao来实现这些功能。

图书管理模块

接下来,让我们创建图书管理模块,包括图书实体、图书DAO和图书服务类。

图书实体类

首先,创建一个图书实体类,用于表示系统中的图书信息。图书实体包括ID、书名、作者、出版社、ISBN号、状态、借阅人ID和归还日期等属性。

public class Book {
    private int id;
    private String title;
    private String author;
    private String publisher;
    private String isbn;
    private BookStatus status;
    private int borrowerId;
    private LocalDate dueDate;

    // 构造函数、getter和setter方法
}

BookStatus是一个枚举类型,表示图书的状态,可以定义为“可借阅”和“已借出”。

public enum BookStatus {
    AVAILABLE,
    CHECKED_OUT
}

图书数据访问对象(DAO)

接下来,创建一个图书数据访问对象(DAO),用于执行图书相关的数据库操作,包括添加图书、删除图书、查询图书和更新图书状态。

以下是一个简单的图书DAO示例:

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class BookDao {
    private Connection connection;

    public BookDao() {
        try {
            connection = DatabaseConnection.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 添加图书
    public void addBook(Book book) {
        String sql = "INSERT INTO books (title, author, publisher, isbn, status, borrower_id, due_date) " +
                     "VALUES (?, ?, ?, ?, ?, ?, ?)";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setString(1, book.getTitle());
            preparedStatement.setString(2, book.getAuthor());
            preparedStatement.setString(3, book.getPublisher());
            preparedStatement.setString(4, book.getIsbn());
            preparedStatement.setString(5, book.getStatus().toString());
            preparedStatement.setInt(6, book.getBorrowerId());
            preparedStatement.setDate(7, Date.valueOf(book.getDueDate()));

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

    // 删除图书
    public void deleteBook(int bookId) {
        String sql = "DELETE FROM books WHERE id = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setInt(1, bookId);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 根据ID查询图书
    public Book getBookById(int bookId) {
        String sql = "SELECT * FROM books WHERE id = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setInt(1, bookId);
            ResultSet resultSet = preparedStatement.executeQuery();

            if (resultSet.next()) {
                return extractBookFromResultSet(resultSet);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    // 查询所有图书
    public List<Book> getAllBooks() {
        List<Book> bookList = new ArrayList<>();
        String sql = "SELECT * FROM books";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            ResultSet resultSet = preparedStatement.executeQuery();

            while (resultSet.next()) {
                bookList.add(extractBookFromResultSet(resultSet));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return bookList;
    }

    // 更新图书状态
    public void updateBookStatus(int bookId, BookStatus status, int borrowerId, LocalDate dueDate) {
        String sql = "UPDATE books SET status = ?, borrower_id = ?, due_date = ? WHERE id = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setString(1, status.toString());
            preparedStatement.setInt(2, borrowerId);
            preparedStatement.setDate(3, Date.valueOf(dueDate));
            preparedStatement.setInt(4, bookId);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 从ResultSet提取图书信息
    private Book extractBookFromResultSet(ResultSet resultSet) throws SQLException {
        Book book = new Book();
        book.setId(resultSet.getInt("id"));
        book.setTitle(resultSet.getString("title"));
        book.setAuthor(resultSet.getString("author"));
        book.setPublisher(resultSet.getString("publisher"));
        book.setIsbn(resultSet.getString("isbn"));
        book.setStatus(BookStatus.valueOf(resultSet.getString("status")));
        book.setBorrowerId(resultSet.getInt("borrower_id"));
        book.setDueDate(resultSet.getDate("due_date").toLocalDate());
        return book;
    }
}

上述示例中,我们创建了一个BookDao类,该类包含了添加图书、删除图书、查询图书、更新图书状态和查询所有图书的方法。这些方法使用了预备语句(PreparedStatement)来执行SQL查询和更新操作,并将查询结果映射到Book对象。

图书服务类

图书服务类用于处理图书管理模块的业务逻辑。它可以调用图书DAO来执行数据库操作,例如添加图书、删除图书、查询图书等。

以下是一个简单的图书服务类示例:

import java.util.List;

public class BookService {
    private BookDao bookDao;

    public BookService() {
        bookDao = new BookDao();
    }

    // 添加图书
    public void addBook(String title, String author, String publisher, String isbn) {
        Book book = new Book();
        book.setTitle(title);
        book.setAuthor(author);
        book.setPublisher(publisher);
        book.setIsbn(isbn);
        book.setStatus(BookStatus.AVAILABLE); // 默认设置为可借阅状态

        bookDao.addBook(book);
    }

    // 删除图书
    public void deleteBook(int bookId) {
        bookDao.deleteBook(bookId);
    }

    // 根据ID查询图书
    public Book getBookById(int bookId) {
        return bookDao.getBookById(bookId);
    }

    // 查询所有图书
    public List<Book> getAllBooks() {
        return bookDao.getAllBooks();
    }

    // 借阅图书
    public void borrowBook(int bookId, int userId, LocalDate dueDate) {
        Book book = bookDao.getBookById(bookId);
        if (book.getStatus() == BookStatus.AVAILABLE) {
            book.setStatus(BookStatus.CHECKED_OUT);
            book.setBorrowerId(userId);
            book.setDueDate(dueDate);
            bookDao.updateBookStatus(bookId, book.getStatus(), book.getBorrowerId(), book.getDueDate());
        }
    }

    // 归还图书
    public void returnBook(int bookId) {
        Book book = bookDao.getBookById(bookId);
        if (book.getStatus() == BookStatus.CHECKED_OUT) {
            book.setStatus(BookStatus.AVAILABLE);
            book.setBorrowerId(0);
            book.setDueDate(null);
            bookDao.updateBookStatus(bookId, book.getStatus(), book.getBorrowerId(), book.getDueDate());
        }
    }
}

在上面的示例中,BookService类提供了添加图书、删除图书、查询图书、借阅图书和归还图书的方法,它通过调用BookDao来实现这些功能。

借阅管理模块

借阅管理模块负责处理用户借阅和归还图书的操作,并记录借阅记录。

借阅记录实体类

首先,创建一个借阅记录实体类,用于表示用户的借阅记录。借阅记录实体包括ID、图书ID、用户ID、借阅日期和归还日期。

public class BorrowRecord {
    private int id;
    private int bookId;
    private int userId;
    private LocalDate borrowDate;
    private LocalDate returnDate;

    // 构造函数、getter和setter方法
}

借阅记录数据访问对象(DAO)

接下来,创建一个借阅记录数据访问对象(DAO),用于执行借阅记录相关的数据库操作,包括记录借阅和归还图书。

以下是一个简单的借阅记录DAO示例:

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class BorrowRecordDao {
    private Connection connection;

    public BorrowRecordDao() {
        try {
            connection = DatabaseConnection.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 记录借阅
    public void borrowBook(int bookId, int userId, LocalDate borrowDate) {
        String sql = "INSERT INTO borrow_records (book_id, user_id, borrow_date) VALUES (?, ?, ?)";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setInt(1, bookId);
            preparedStatement.setInt(2, userId);
            preparedStatement.setDate(3, Date.valueOf(borrowDate));

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

    // 记录归还
    public void returnBook(int bookId, LocalDate returnDate) {
        String sql = "UPDATE borrow_records SET return_date = ? WHERE book_id = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setDate(1, Date.valueOf(returnDate));
            preparedStatement.setInt(2, bookId);

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

    // 查询用户的借阅记录
    public List<BorrowRecord> getBorrowRecordsByUserId(int userId) {
        List<BorrowRecord> recordList = new ArrayList<>();
        String sql = "SELECT * FROM borrow_records WHERE user_id = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setInt(1, userId);
            ResultSet resultSet = preparedStatement.executeQuery();

            while (resultSet.next()) {
                recordList.add(extractBorrowRecordFromResultSet(resultSet));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return recordList;
    }

    // 查询图书的借阅记录
    public List<BorrowRecord> getBorrowRecordsByBookId(int bookId) {
        List<BorrowRecord> recordList = new ArrayList<>();
        String sql = "SELECT * FROM borrow_records WHERE book_id = ?";
        try (PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setInt(1, bookId);
            ResultSet resultSet = preparedStatement.executeQuery();

            while (resultSet.next()) {
                recordList.add(extractBorrowRecordFromResultSet(resultSet));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return recordList;
    }

    // 从ResultSet提取借阅记录信息
    private BorrowRecord extractBorrowRecordFromResultSet(ResultSet resultSet) throws SQLException {
        BorrowRecord record = new BorrowRecord();
        record.setId(resultSet.getInt("id"));
        record.setBookId(resultSet.getInt("book_id"));
        record.setUserId(resultSet.getInt("user_id"));
        record.setBorrowDate(resultSet.getDate("borrow_date").toLocalDate());
        if (resultSet.getDate("return_date") != null) {
            record.setReturnDate(resultSet.getDate("return_date").toLocalDate());
        }
        return record;
    }
}

上述示例中,我们创建了一个BorrowRecordDao类,该类包含了记录借阅和归还图书、查询用户的借阅记录以及查询图书的借阅记录等方法。这些方法使用了预备语句(PreparedStatement)来执行SQL查询和更新操作,并将查询结果映射到BorrowRecord对象。

借阅记录服务类

借阅记录服务类用于处理借阅管理模块的业务逻辑。它可以调用借阅记录DAO来执行数据库操作,例如记录借阅和归还图书、查询用户的借阅记录以及查询图书的借阅记录。

以下是一个简单的借阅记录服务类示例:

import java.util.List;

public class BorrowRecordService {
    private BorrowRecordDao borrowRecordDao;

    public BorrowRecordService() {
        borrowRecordDao = new BorrowRecordDao();
    }

    // 记录借阅
    public void borrowBook(int bookId, int userId, LocalDate borrowDate) {
        borrowRecordDao.borrowBook(bookId, userId, borrowDate);
    }

    // 记录归还
    public void returnBook(int bookId, LocalDate returnDate) {
        borrowRecordDao.returnBook(bookId, returnDate);
    }

    // 查询用户的借阅记录
    public List<BorrowRecord> getBorrowRecordsByUserId(int userId) {
        return borrowRecordDao.getBorrowRecordsByUserId(userId);
    }

    // 查询图书的借阅记录
    public List<BorrowRecord> getBorrowRecordsByBookId(int bookId) {
        return borrowRecordDao.getBorrowRecordsByBookId(bookId);
    }
}

在上面的示例中,BorrowRecordService类提供了记录借阅和归还图书、查询用户的借阅记录以及查询图书的借阅记录的方法,它通过调用BorrowRecordDao来实现这些功能。

数据存储模块

数据存储模块负责将数据存储到数据库或文件中,以及从数据库或文件中检索数据。在本示例中,我们使用了数据库作为数据存储的方式。您可以根据需要选择适当的数据存储方式。

用户界面

最后,我们需要创建一个用户界面,允许用户与图书管理系统进行交互。用户界面可以是命令行界面、图形界面或Web界面,具体实现方式取决于您的需求和技术栈。用户界面需要调用用户服务类、图书服务类和借阅记录服务类来实现用户注册、登录、添加图书、借阅图书、归还图书等功能。

以下是一个简单的命令行用户界面示例:

import java.time.LocalDate;
import java.util.List;
import java.util.Scanner;

public class LibraryManagementSystem {
    private UserService userService;
    private BookService bookService;
    private BorrowRecordService borrowRecordService;
    private User currentUser;

    public LibraryManagementSystem() {
        userService = new UserService();
        bookService = new BookService();
        borrowRecordService = new BorrowRecordService();
    }

    public void run() {
        Scanner scanner = new Scanner(System.in);

        while (true) {
            if (currentUser == null) {
                System.out.println("Welcome to the Library Management System!");
                System.out.println("1. Register");
                System.out.println("2. Login");
                System.out.println("3. Exit");
                System.out.print("Please select an option: ");

                int choice = scanner.nextInt();
                scanner.nextLine(); // Consume newline

                switch (choice) {
                    case 1:
                        registerUser(scanner);
                        break;
                    case 2:
                        loginUser(scanner);
                        break;
                    case 3:
                        System.out.println("Goodbye!");
                        return;
                    default:
                        System.out.println("Invalid option. Please try again.");
                        break;
                }
            } else {
                System.out.println("Welcome, " + currentUser.getUsername() + "!");
                System.out.println("1. Add Book");
                System.out.println("2. Borrow Book");
                System.out.println("3. Return Book");
                System.out.println("4. View Borrowed Books");
                System.out.println("5. Logout");
                System.out.print("Please select an option: ");

                int choice = scanner.nextInt();
                scanner.nextLine(); // Consume newline

                switch (choice) {
                    case 1:
                        addBook(scanner);
                        break;
                    case 2:
                        borrowBook(scanner);
                        break;
                    case 3:
                        returnBook(scanner);
                        break;
                    case 4:
                        viewBorrowedBooks();
                        break;
                    case 5:
                        currentUser = null;
                        System.out.println("Logged out successfully.");
                        break;
                    default:
                        System.out.println("Invalid option. Please try again.");
                        break;
                }
            }
        }
    }

    private void registerUser(Scanner scanner) {
        System.out.print("Enter username: ");
        String username = scanner.nextLine();
        System.out.print("Enter password: ");
        String password = scanner.nextLine();
        System.out.print("Enter email: ");
        String email = scanner.nextLine();
        // Assume default role is USER
        UserRole role = UserRole.USER;

        userService.registerUser(username, password, email, role);
        System.out.println("Registration successful. You can now log in.");
    }

    private void loginUser(Scanner scanner) {
        System.out.print("Enter username: ");
        String username = scanner.nextLine();
        System.out.print("Enter password: ");
        String password = scanner.nextLine();

        currentUser = userService.getUserByUsername(username);

        if (currentUser != null && currentUser.getPassword().equals(password)) {
            System.out.println("Login successful. Welcome, " + currentUser.getUsername() + "!");
        } else {
            currentUser = null;
            System.out.println("Login failed. Please check your username and password.");
        }
    }

    private void addBook(Scanner scanner) {
        System.out.print("Enter book title: ");
        String title = scanner.nextLine();
        System.out.print("Enter author: ");
        String author = scanner.nextLine();
        System.out.print("Enter publisher: ");
        String publisher = scanner.nextLine();
        System.out.print("Enter ISBN: ");
        String isbn = scanner.nextLine();

        bookService.addBook(title, author, publisher, isbn);
        System.out.println("Book added successfully.");
    }

    private void borrowBook(Scanner scanner) {
        System.out.print("Enter book ID to borrow: ");
        int bookId = scanner.nextInt();
        scanner.nextLine(); // Consume newline
        LocalDate dueDate = LocalDate.now().plusWeeks(2); // Borrow period of 2 weeks

        bookService.borrowBook(bookId, currentUser.getId(), dueDate);
        System.out.println("Book borrowed successfully.");
    }

    private void returnBook(Scanner scanner) {
        System.out.print("Enter book ID to return: ");
        int bookId = scanner.nextInt();
        scanner.nextLine(); // Consume newline

        bookService.returnBook(bookId);
        System.out.println("Book returned successfully.");
    }

    private void viewBorrowedBooks() {
        List<BorrowRecord> borrowRecords = borrowRecordService.getBorrowRecordsByUserId(currentUser.getId());
        if (borrowRecords.isEmpty()) {
            System.out.println("You have not borrowed any books.");
        } else {
            System.out.println("Your borrowed books:");
            for (BorrowRecord record : borrowRecords) {
                Book book = bookService.getBookById(record.getBookId());
                System.out.println("Book Title: " + book.getTitle());
                System.out.println("Borrow Date: " + record.getBorrowDate
() + "   Due Date: " + record.getDueDate());
                System.out.println("------------------------------------------------");
            }
        }
    }

    public static void main(String[] args) {
        LibraryManagementSystem libraryManagementSystem = new LibraryManagementSystem();
        libraryManagementSystem.run();
    }
}

在上述示例中,我们创建了一个简单的命令行用户界面,允许用户注册、登录、添加图书、借阅图书、归还图书以及查看已借阅的图书。界面根据用户的登录状态显示不同的选项。

总结

通过本博客,我们详细介绍了如何使用Java编程语言创建一个简单的图书管理系统。系统包括用户管理模块、图书管理模块和借阅管理模块,以及相应的数据模型、数据访问对象和服务类。此外,我们还提供了一个简单的命令行用户界面,允许用户与系统进行交互。

要构建完整的图书管理系统,您可能需要进一步扩展和优化代码,包括添加异常处理、安全性、性能优化等方面的功能。希望本博客能够帮助初学者了解如何使用Java创建一个基本的图书管理系统,并为后续学习和开发提供参考。文章来源地址https://www.toymoban.com/news/detail-752413.html

作者信息

作者 : 繁依Fanyi
CSDN: https://techfanyi.blog.csdn.net
掘金:https://juejin.cn/user/4154386571867191

到了这里,关于【Java 基础篇】Java 图书管理系统详解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 图书管理系统【java】

    目录 🥇1.设计背景 🔎2.设计思路 🔑3.book包 📗3.1 Book类的实现 📕3.2 BookList类的实现(书架) 🔑4.user包 📙4.1 User类的实现 📒4.2 AdminUser(管理员) 📘4.3 Normal(普通用户) 👜5.opera包 1️⃣5.1 IOperation接口的实现 2️⃣AddOperation(添加操作) 3️⃣FindOperation(查找操作) 4️⃣

    2024年02月03日
    浏览(54)
  • 【Java】实现图书管理系统

    随着社会的发展和科技的进步,图书馆的规模和藏书量都在不断扩大,图书的管理和维护变得越来越复杂。传统的图书管理方式已经无法满足现代图书馆的需求,因此需要开发一种高效、便捷的图书管理系统来提高图书管理效率和读者的借阅体验。 在这种背景下,我们设计了

    2024年02月20日
    浏览(58)
  • 【JAVA】用Java实现简易图书管理系统

    图书馆作为每个大学或者城市必不可少的部分,其存放的海量书籍与文献使得其管理显得尤为困难,此时图书管理系统就起 到了一个重大的作用。 一种是面向管理员开启的菜单和功能,一种是面向所有普通用户来提供的菜单和功能。这些功能包括对于图书的借阅,归 还,增

    2024年02月03日
    浏览(52)
  • 图书管理系统(借还图书)--Java实现(附源码)

    目录 图书管理系统权限 图书管理系统程序框图 图书管理系统架构 管理员执行流程 学生执行流程 详细代码 源码获取 毕设专栏 图书管理系统权限 管理员:具有  1、查找图书 2、增加图书 3、删除图书 4、显示图书 等功能 学生:具有  1、查找图书 2、借阅图书 3、归还图书

    2024年02月08日
    浏览(74)
  • 基于JAVA的图书管理系统

                                                                    摘要         网络技术给生活带来了十分的便利。所以把图书管理与现在网络相结合。在图书馆发展的整个过程中,图书担负着最重要的角色。为满足如今日益复杂的管理需求,各类管理系统程序也

    2024年02月12日
    浏览(37)
  • 《Java》图书管理系统(已升级)

    目录 前言 效果展示  功能模块 书架 定义书的类  创建书架  用户 User用户类 AdminUser管理员 NormalUser普通用户   功能 接口 FindOperation 查找图书  AddOperation添加图书  DelOperation删除图书 BorrowOperation借阅图书  DisOperation 打印图书   RetOperation归还图书  ExitOperation退出系统  整

    2024年01月21日
    浏览(39)
  • JAVA图书管理系统详细代码

    代码主要分为四个大部分,主函数,图书相关函数,操作,以及使用者。分为三个包:book、operation、user和一个单独的主函数。 操作接口 对于每一个操作都有相近的一部分,刚好可以用接口,在User(使用者)中利用接口类型的数组来进行相关的操作。在下面的User中会具体说

    2024年02月09日
    浏览(53)
  • Java 实现图书馆管理系统

    目录 一:创建对象 1.学生类对象Student : 2.图书类对象book : 3.管理员类对象OP: 二.创建主要交互界面MainMenu,并实现主界面功能 1.创建交互界面: 2.实现主界面功能: 三:创建OP管理界面: 1.创建主要交互界面及实现\\\"管理学生\\\"功能OPmenu: (1).交互界面: (2):实现\\\"管理学生\\\"功能: 2.实现\\\"管理

    2024年02月12日
    浏览(45)
  • 【开源】基于JAVA的图书管理系统

    图书管理系统是一个用于管理图书馆资源的软件系统,该系统包括图书馆模块、图书类型模块、图书模块、图书借阅模块和公告模块。 图书馆模块 是系统的核心模块,用于管理图书馆的基本信息,包括图书馆名称、地址、联系方式等。管理员可以通过该模块进行图书馆信息

    2024年02月21日
    浏览(45)
  • 【Java课程设计】基于Java Swing 的图书管理系统

    🎁 作者简介 :在校大学生一枚,Java领域新星创作者,Java、Python正在学习中。 💗 个人主页: 我是一棵卷心菜的个人主页 🍂 日常学习网站: 牛客网,可以用来刷算法题、工作内推、面经复习、练习SQL等等,很不错的多功能网站。点击注册学习刷题吧! 📕 自我提醒: 多

    2024年02月07日
    浏览(72)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包