使用 Java 实现简易图书管理系统

想听风雨

已于 2024-04-28 15:32:27 修改

阅读量474

点赞数

分类专栏： Java 文章标签： java

于 2023-09-20 10:37:07 首次发布

本文链接：https://blog.csdn.net/zzy734437202/article/details/132983316

版权

Java 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

一、书本及书本容器(书架)

1.图书管理系统必然有书，书的数量很多则必然需要书架归档整理，提取书及书架两个名词，编写为类；

2.明确书类中的属性，如书名，作者，价格等，并编写get/set方法；可以预见，书有可视化需求，需要打印输出属性，因此重写toString方法；

public class Book {
    //明确属性；
    private String title;
    private String author;
    private double price;
    private boolean isBorrow;

    //构造函数；
    public Book(String title, String author, double price) {
        this.title = title;
        this.author = author;
        this.price = price;
    }

    //get/set方法；
    public String getTitle() {
        return title;
    }
    public boolean getisBorrow() {
        return isBorrow;
    }
    public void setBorrow(boolean borrow) {
        isBorrow = borrow;
    }

    //重写toString方法；
    @Override
    public String toString() {
        return "Book{" +
                "title='" + title + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", isBorrow=" + (isBorrow?"已借出":"未借出") +
                '}';
    }
}

3.明确书架类中的属性，如书数组，书数量，书架容量等，并编写get/set方法；

public class BookShelf {
    //明确属性；
    private int BOOKS_CACPCITY = 10;
    private int bookCount;
    private Book[] books;

    //构造函数；
    public BookShelf() {
        this.bookCount = 0;
        this.books = new Book[this.BOOKS_CACPCITY];
    }

    //get/set方法；
    public int getBookCount() {
        return bookCount;
    }
    public void setBookCount(int bookCount) {
        this.bookCount = bookCount;
    }
    public void setBooks(Book book) {
        this.books[bookCount] = book;
    }
    public Book[] getBooks() {
        return books;
    }
}

二、登陆界面及用户

1.系统需要有登陆界面供使用者选择登录权限，根据使用者选择的登录权限，程序会打印不同的功能选择界面，展示给使用者；

2.登录权限包括管理员用户和普通用户，提取名词管理员用户和普通用户编写管理员用户类和普通用户类，并提取两个类中共通的部分，编写抽象用户类。

//抽象用户类；
public abstract class User {
    //用户名；
    String name;
    //功能接口实现类数组；
    IOperation[] iOperations;

    //构造函数；
    public User(String name) {
        this.name = name;
    }

    //抽象菜单方法；
    public abstract IOperation menu();
}

3.管理员用户类和普通用户类继承抽象用户类。

//管理员用户类；
public class AdminUser extends User{
    //构造方法；
    public AdminUser(String name) {
        super(name);
        //实例化功能数组，根据不同的选择实例化不同的功能；
        this.iOperations = new IOperation[]{
                new ExitOperation(),
                new SearchBook(),
                new AddBook(),
                new DeleteBook(),
                new ShowBooks(),
        };
    }

    //重写抽象菜单方法；
    @Override
    public IOperation menu() {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("----管理员用户----");
            System.out.println("1. 查找图书");
            System.out.println("2. 新增图书");
            System.out.println("3. 删除图书");
            System.out.println("4. 显示图书");
            System.out.println("0. 退出系统");
            System.out.println("------------------");
            int choice = sc.nextInt();
            if (choice >= 0 && choice <= 4) {
                return this.iOperations[choice];
            } else {
                System.out.println("选择错误，请重新选择！");
            }
        }
    }
}

//普通用户类；
public class NormalUser extends User{
    public NormalUser(String name) {
        super(name);
        //实例化功能数组，根据不同的选择实例化不同的功能；
        this.iOperations = new IOperation[]{
                new ExitOperation(),
                new SearchBook(),
                new BorrowBook(),
                new ReturnBook(),
                new ShowBooks(),
        };
    }

    //重写抽象菜单方法；
    @Override
    public IOperation menu() {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("----普通用户----");
            System.out.println("1. 查找图书");
            System.out.println("2. 借阅图书");
            System.out.println("3. 归还图书");
            System.out.println("4. 显示图书");
            System.out.println("0. 退出系统");
            System.out.println("---------------");
            int choice = sc.nextInt();
            if (choice >= 0 && choice <= 4) {
                return this.iOperations[choice];
            }else {
                System.out.println("选择错误，请重新选择！");
            }
        }
    }
}

4.登陆界面可以编写登录界面类，但项目中不实现太多功能，因此简单在测试类中编写静态 login 方法(带有main方法的类)替代。

//用户登录方法；
    public static User login(){
        /*根据用户名，及选择的登录权限创建用户对象，
         * 并将用户对象返回*/
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入用户名：");
        String name = sc.nextLine();
        while (true){
            System.out.print("请选择登陆权限：1.管理员用户 2.普通用户 ->");
            int choice = sc.nextInt();
            if(choice==1){
                return new AdminUser(name); //实例化管理员用户；
            }else if (choice==2){
                return new NormalUser(name); //实例化普通用户；
            }else {
                System.out.println("选择错误，请重新选择！");
            }
        }
    }

三、各个实际功能的实现

1、管理员用户权限

管理员用户权限需要实现以下功能：

新增图书
删除图书
查找图书
展示图书
退出系统

1.新增图书

思路：选择该功能后，新实例化一个书类，由使用者输入图书各项属性，并将该新实例化的书类放置到书架的书本数组中；

public class AddBook implements IOperation{
    @Override
    public void word(BookShelf bookShelf) {
        Scanner sc = new Scanner(System.in);
        int bookCount = bookShelf.getBookCount(); //取得当前书本数量；

        String title = null;
        boolean flag = true;
        while (flag){
            System.out.print("请输入需要添加的书籍的名称：");
            title = sc.nextLine();
            int i = 0;
            for (i = 0;i<bookCount;i++){
                if(title.equals(bookShelf.getBooks()[i].getTitle())){ //将最新输入的书名和books数组中的第i本书的书名进行比较；
                    System.out.println("书架中已存在同名书籍，请重新输入！");
                    break; //找到同名书籍则退出，此时退出必定不满足flag改变条件，则循环继续；
                }
            }
            if(i==bookCount){
                flag = false;
            }
        }

        System.out.print("请输入需要添加的书本的作者：");
        String author = sc.nextLine();
        System.out.print("请输入需要添加的书本的价格：");
        double price = sc.nextDouble();
        Book book = new Book(title,author,price);
        bookShelf.setBooks(book); //将书本设置到书架books数组中；

        bookShelf.setBookCount(++bookCount); //设置书本数量+1；
    }
}

2.删除图书

思路：由使用者输入需要删除的书本名称，程序在书架的书本数组中查找书本名称，找到同名则将该数组元素置空，并由该元素之后的数组元素(如有)覆盖，找不到则提示无此书；

public class DeleteBook implements IOperation{
    @Override
    public void word(BookShelf bookShelf) {
        Scanner sc = new Scanner(System.in);
        int bookCount = bookShelf.getBookCount(); //取得当前书本数量；

        System.out.print("请输入需要删除的书籍的名称：");
        String title = sc.nextLine();
        int i = 0;
        for (i = 0;i<bookCount;i++){
            if(title.equals(bookShelf.getBooks()[i].getTitle())){ //将最新输入的书名和books数组中的第i本书的书名进行比较；
                for (int j=i;j<bookCount-1;j++){
                    bookShelf.getBooks()[j] = bookShelf.getBooks()[j+1]; //从后向前覆盖；
                    break;
                }
                bookShelf.setBookCount(--bookCount); //设置书本数量-1；
            }
        }
        if(i==bookCount){
            System.out.println("找不到该书籍");
        }
    }
}

3.查找图书

思路：由使用者输入输入需要查找的书本名称，遍历书本数组，找到同名则将该数组元素打印，找不到则提示无此书；

public class SearchBook implements IOperation{
    @Override
    public void word(BookShelf bookShelf) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入需要查找的书籍的名称：");
        String title = sc.nextLine();
        int bookCount = bookShelf.getBookCount(); //取得当前书本数量；
        int i = 0;
        for (i = 0;i<bookCount;i++){
            if(title.equals(bookShelf.getBooks()[i].getTitle())){ //将最新输入的书名和books数组中的第i本书的书名进行比较；
                System.out.println("找到书籍 "+title);
                System.out.println(bookShelf.getBooks()[i].toString()); //打印books数组的第i个元素的内容；
                break;
            }
        }
        if(i==bookCount){
            System.out.println("未找到该书籍！");
        }
    }
}

4.展示图书

思路：遍历书本数组并打印；

public class ShowBooks implements IOperation{
    @Override
    public void word(BookShelf bookShelf) {
        int bookCount = bookShelf.getBookCount(); //取得当前书本数量；
        for (int i=0;i<bookCount;i++){
            System.out.println(bookShelf.getBooks()[i].toString()); //打印books数组的第i个元素的内容；
        }
    }
}

5.退出系统

思路：直接调用停止虚拟机运行方法；

public class ExitOperation implements IOperation{
    @Override
    public void word(BookShelf bookShelf) {
        System.out.println("退出图书管理系统！");
        System.exit(0);
    }
}

2、普通用户权限

普通用户权限需要实现以下功能：

查找图书
借阅图书
归还图书
展示图书
退出系统

查找图书、展示图书、退出系统功能已经实现过了，不再重复；

1.借阅图书

思路：在书本类的书本属性中添加(如没有，有则跳过步骤)，布尔类型的属性，用以表达书本是否已经被借阅，属性值为true表示已经借出，无法借阅，属性值为false表示可以借阅；

由使用者输入需要借阅的书籍，遍历书本数组查找，找不到则提示无此书，找到则借阅成功并将是否被借阅属性值改为true；

public class BorrowBook implements IOperation{
    @Override
    public void word(BookShelf bookShelf) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入需要借阅的书籍的名称：");
        String title = sc.nextLine();
        int bookCount = bookShelf.getBookCount(); //取得当前书本数量；
        int i = 0;
        for (i = 0;i<bookCount;i++){
            if(title.equals(bookShelf.getBooks()[i].getTitle())){ //将最新输入的书名和books数组中的第i本书的书名进行比较；
                if(bookShelf.getBooks()[i].getisBorrow()==false){
                    bookShelf.getBooks()[i].setBorrow(true);
                    System.out.println("借阅书籍 "+title);
                }else {
                    System.out.println("书籍已被借阅，无法再次借阅！");
                }
                break;
            }
        }
        if(i==bookCount){
            System.out.println("未找到该书籍！");
        }
    }
}

2.归还图书

思路：由使用者输入需要借阅的书籍，遍历书本数组查找，找不到则提示无此书，找到则归还成

功并将是否被借阅属性值改为false；

public class ReturnBook implements IOperation{
    @Override
    public void word(BookShelf bookShelf) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入需要归还的书籍的名称：");
        String title = sc.nextLine();
        int bookCount = bookShelf.getBookCount(); //取得当前书本数量；
        int i = 0;
        for (i = 0;i<bookCount;i++){
            if(title.equals(bookShelf.getBooks()[i].getTitle())){ //将最新输入的书名和books数组中的第i本书的书名进行比较；
                if(bookShelf.getBooks()[i].getisBorrow()==true){
                    bookShelf.getBooks()[i].setBorrow(false);
                    System.out.println("归还书籍 "+title);
                }else {
                    System.out.println("书籍未被借阅，无需归还！");
                }
                break;
            }
        }
        if(i==bookCount){
            System.out.println("未找到该书籍！");
        }
    }
}

四、功能接口

为了方便各个功能类代码的调用，将每个功能类的功能实现方法同一命名，新建功能接口，将方法提取至功能接口中，并将方法设置为抽象方法；在各功能类中实现该接口，实现多态；

public interface IOperation {
    public void word(BookShelf bookShelf);
}

五、程序启动代码(main方法)

思路：将各个类的代码在main方法中完整串联；

1.确定用户权限，根据选择的权限实例化用户类，同时实例化书架类；

2.根据实例化的用户类，选择需要使用的功能，实例化功能类；

3.根据实例化的功能类，多态的调用对应方法；

public static void main(String[] args) {
        //确定用户权限；
        User user = login();
        //实例化书架；
        BookShelf bookShelf = new BookShelf();
        while (true){
            user.menu().word(bookShelf); //确定使用功能，并调用；
        }
    }

main方法和静态 login 方法编写在同一个类中。程序！启动！

（哈哈哈~~ 文章结束！）

（看到这里，如果有为各位帅哥美女提供一点点灵感，请点一个小小的赞哦，比心💖💖💖 ）