用JAVA实现图书管理系统

流年

已于 2023-08-08 22:34:45 修改

阅读量8.7k

点赞数 51

文章标签： java 开发语言

于 2023-08-08 22:34:00 首次发布

本文链接：https://blog.csdn.net/2302_76924750/article/details/132120611

版权

3.3 operation包中的各个类以及接口

前言

我们在学习了封装，继承和多态，抽象类和接口等知识后，可以对知识做一个总结。通过近期所学内容，我们可以做一个简洁的图书管理系统来对近期知识加深了解。

一、设计背景及目的

我们在学习时，图书馆自然是我们一直以来的的“兵家必争之地”。同时，图书馆中存放的书籍如果没有系统的管理更会显得杂乱无章，使人困扰，因此一个能够系统管理书籍的图书管理系统就显的尤为重要了。

二、设计思路

我们在设计系统前要先理清自己的思绪，想明白需要创建的对象和需要实现的功能。

1. 首先，想清楚系统的界面。系统对于图书管理员来说是管理系统，对于普通用户来说是服务系统。所以我们针对管理员和普通用户所展示的界面是不同的。

2.书的属性有书名，作者，价格，类型。我们可以将书的属性进行封装，同时设置一个书架类，用于存放书籍。设置一个书的数组可以解决。

3.管理员界面上，我们可以添加书籍，查找书籍，删除书籍，显示书籍和退出系统。

4.普通用户界面上，我们可以查找书籍，借阅书籍，归还书籍和退出系统。

5.我们可以将这些操作全都封装起来，设计成一个单独的类。

草图如下：

三、代码的实现

3.1 Book类的实现

我们创建一个book的包，用于存放与书有关的类。根据上述思路，我们可以在Book包中创建一个Book的类和一个Booklist (书架) 的类。首先创建一个book类，在book中写入书的有关属性，书名 (name) ,作者 (author) ，价格 (price) ，类型 (type) 以及是否被借出。我们通过封装，将属性前的访问修饰符设置为private权限，然后通过编译器的快捷键提供相应的get方法和set方法以及一个不包含是否被借出的构造方法（我们将是否被借出属性的类型设置为boolean，Boolean类型默认为false，可以不初始化），然后通过快捷键提供相应的toString方法的重写。

代码如下：

package Book;

public class book {

    private String name;
    private String author;
    private int price;
    private String type;
    private boolean isBorrowed;


    public book(String name, String author, int price, String type) {
        this.name = name;
        this.author = author;
        this.price = price;
        this.type = type;
    }

    public String getName() {
        return name;
    }

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

    public String getAuthor() {
        return author;
    }

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

    public int getPrice() {
        return price;
    }

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

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public boolean isBorrowed() {
        return isBorrowed;
    }

    public void setBorrowed(boolean borrowed) {
        isBorrowed = borrowed;
    }

    @Override
    //重写toString 方法
    public String toString() {
        return "book{" +
                "书名='" + name + '\'' +
                ", 作者='" + author + '\'' +
                ", 价格=" + price +
                ", 类型='" + type + '\'' +
                ", 是否被借出=" + isBorrowed +
                '}';
    }
}

注意：上段代码大部分由编译器生成，只需输入书的属性，然后运用Getter and setter ，构造方法以及toString方法的快捷键，就能快速生成上述代码。

3.2 BookList类的实现

BookList类我们采用数组的方式对Book进行存储。

我们首先设置一个private权限的Book数组books，同时设置一个usedSize的变量，用于记录当前书架上存放了多少本书。我们先写一个BookList的构造方法，同时将数组的长度初始化为10，然后通过快捷键设置userSize的getter and setter方法。注意不要使用编译器生成的Book数组books的getter and setter 方法，那不是我们想要的。我们设置一个名为pos的数组下标参数，在getter方法中返回books的数组下标pos，在setter方法中，我们将 books数组的pos下标设置为一本书 。

代码如下：

package Book;

public class Booklist {

    private Book[] books;
    private int usedSize;  //记录当前书架上实际存放了多少本书，默认为 0

    public Booklist() {
        this.books = new Book[10];
    }

    public int getUsedSize() {
        return usedSize;
    }

    public void setUsedSize(int usedSize) {
        this.usedSize = usedSize;
    }

    public Book getBook(int pos) {
        return books[pos];
    }

    // pos 为数组下标
    public void setBook(int pos,Book book) {
        books[pos] = book;  //将 books数组的 pos下标设置为一本书
    }
}

3.3 operation包中的各个类以及接口

我们通过草图，能够得出结论，图书管理系统共有七个需要实现的功能，我们将这些功能分别写成一个类放在operation这个组织包中。因为无论是管理员还是普通用户，我们需要实现的所有功能都属于对书的操作，都是在BookList类的数组books中操作的，所以我们可以提供一个IOperation的接口，用来实现对数组的操作。

package operation;

import book.Booklist;

public interface IOperation {
    void work(Booklist booklist);
}

我们创建完多个类后，如图所示：

然后我们可以对这些类引用接口，然后重写work方法，比如删除图书：

package operation;

import book.Booklist;

public class DelOperation implements IOperation{
    @Override
    public void work(Booklist booklist) {
        System.out.println("删除图书");
    }
}

3.4 关于用户的操作

我们创建一个user的包，用于存放与用户相关的类。我们这里就要对普通用户和管理员分开处理了，先创建一个User的类，对于管理员和用户来说，它们都是用户。在User类中，创建一个成员变量，来表示用户，因为我们想让这个变量在一个包中使用，所以我们使用关键字protected。利用快捷键创建一个构造方法对其初始化。

package user;

public class User {

    protected String name;

    public User(String name) {
        this.name = name;
    }
}

将子类NormalUser继承父类User，此时会显示报错，这是因为子类在构造前要先对父类进行构造，同理，AdminUser也一样。

package user;

public class NormalUser extends User{
    public NormalUser(String name) {
        super(name);
    }
   
}

接下来打印菜单，我们不能让管理员的菜单和普通用户的一样，所以我们要对菜单方法进行重写，根据两种用户各自所需的功能进行打印。

管理员菜单：

package user;

public class AdminUser extends User{

    public AdminUser(String name) {
        super(name);
    }

    public void menu() {
        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("*****************");
    }
}

普通用户菜单：

package user;

public class NormalUser extends User{
    public NormalUser(String name) {
        super(name);
    }
    public void menu() {
        System.out.println("*****************");
        System.out.println("2.查找书籍");
        System.out.println("3.借阅书籍");
        System.out.println("4.归还书籍");
        System.out.println("0.退出系统");
        System.out.println("*****************");
    }
}

3.5 Main方法的实现

用户和菜单都有了，此时我们需要一个类把他们全都整合起来。

接下来我们就需要登录了，我们写一个main方法，在main方法中写一个login方法，先写一个判断判定你是管理员还是普通用户。代码如下：

 public static User login() {
        System.out.println("请输入你的名字：");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        System.out.println("请输入您的身份：-> 1.管理员  2.普通用户");
        int choice = scanner.nextInt();
        if(choice ==1) {
            return new AdminUser(name);
        }else {
            return new NormalUser(name);
        }

    }

此时，我们需要接收这个判断的返回值AdminUser 或 NormalUser，把返回类型改为 User ，这样不论 if 返回AdminUser 还是 NormalUser ， User作为父类都可以接收，这个过程就发生了向上转型。

然后在main方法中引用 login 方法，就可以实现选择登陆了。在使用login方法时，我们会发现，使用user加 . ， . 不出来menu菜单，这是因为父类User没有menu方法，你需要在User中声明一下menu方法，我们在声明时编译器还是会显示报错，将User设置成抽象类问题解决。

最终抽象类User代码：

package user;

public abstract class User {

    protected String name;

    public User(String name) {
        this.name = name;
    }
    public abstract void menu();
}

管理员登录界面：

普通用户登录界面：

显示界面后，下一步我们应该根据用户的选择来选择进入哪个功能。我们先设置一个变量choice，用于接收用户输入的指令。返回choice，所以我们将 void 改为 int ，整个过程用到了向上转型和动态绑定。例如管理员界面：

public int menu() {
        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("********************");

        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;

在 Main 方法中接收 choice ，然后输出：

public static void main(String[] args) {

        //user指向那个对象，就看返回值是什么
       User user = login();
       int choice = user.menu();
        System.out.println("choice = "+choice);
    }

最终可以得到 choice 成功接收指令：

现在，我们下一步可以根据 choice 的选择来决定调用哪个方法。那接下来如何实现呢，整理一下思路。

1. 看 user 指向哪个对象。

2. 可以打印指定的菜单，并且看 choice 是多少。

3.然后调用 user 指向对象的操作方法。

就是说，看 user 指向哪个对象，指向普通用户就打印普通用户菜单，指向管理员用户就打印管理员用户菜单，同时看choice 是多少。比如user指向普通用户，choice是 1 调用普通用户界面的的添加书籍功能。

接下来就是代码的具体实现。我们在父类 User 定义一个成员变量 IOperation数组 ，然后在 User 的子类 Adminiopeartion 和 Normalioperation 上分别对他进行实例化(实例化顺序按照草图来哈，别搞错了顺序。还要注意一点，因为咱们定义的是数组，我们是要打算按 0 退出系统的，所以退出功能的数组下标得是0，所以把退出功能放到最前面)。

User 添加：

 protected IOperation[] iOperations;

Adminiopeartion 对他进行实例化：

public AdminUser(String name) {
        super(name);
        this.iOperations = new IOperation[] {
                new ExitOperation(),
                new FindOperation(),
                new AddOperation(),
                new DelOperation(),
                new ShowOperation()
                };
    }

Normalioperation 对他进行实例化：

public NormalUser(String name) {
        super(name);
        this.iOperations = new IOperation[] {
                new ExitOperation(),
                new FindOperation(),
                new BorrowOperation(),
                new ReturnOperation()
                };
    }

接下来就是 choice 如何返回对应方法的问题了。我们可以创建一个doIoperation方法，然后把 choice 给他，当user 调用这个方法时，这个方法就可以调用你所选对象的某一个方法了。在User创建doIoperation 方法，将 choice 给到他作为参数，同时将booklist作为另一个参数，因为我们要让他调用某一个对象对应的方法，而方法在各个功能类的work 中，work 是以 booklist 作为参数的。这个方法总结下来就是调用这个方法的 choice 下标所对应的work方法。

public void doIoperation (int choice, Booklist booklist) {
        iOperations[choice].work(booklist);
    }

在Main方法中，实例化Booklist类，使user能够调用doioperation方法，给到 choice 和 booklist 参数。在用户登陆功能后给到一个循环，使程序能够重复打印菜单。

public static void main(String[] args) {
        Booklist booklist = new Booklist();
        //user指向那个对象，就看返回值是什么
        User user = login();
        while (true) {
            int choice = user.menu();
            System.out.println("choice = " + choice);

            //根据choice的选择来决定，调用的是哪个方法
            user.doIoperation(choice, booklist);
        }
    }

最后功能实现：

这样我们整个程序的基本框架就写好了，下边的事情只是丰富各个功能了。

3.6 实现各个功能

1. 显示图书功能实现

我们在运行程序初始化书架时，先往书架上放几本书，然后用 userSize 记录当前书架上书的数量。

public Booklist() {

        this.books = new Book[10];

        //放好书！
        this.books[0] = new Book("西游记","罗贯中",15,"小说");
        this.books[1] = new Book("水浒传","施耐庵",25,"小说");
        this.books[2] = new Book("红楼梦","曹雪芹",35,"小说");

        this.usedSize = 3;
    }

显示所有图书相当于遍历书架上所有书。打开Showioperation 类，创建一个变量currentSize，让currentSize拿到 userSize 的值。写一个for循环，让 i 小于currentSize，遍历 booklist 数组中所有下标的值，然后输出，就能拿到所有书。

public void work(Booklist booklist) {
        System.out.println("显示图书");
        int currentSize = booklist.getUsedSize();
        for (int i = 0;i < currentSize;i++) {
            Book book = booklist.getBook(i);
            System.out.println(book);
        }
    }

输出时，因为我们已经重写了 toString 方法，所以他会输出重写后的 toString 方法，但重写的toString方法中isBorrowed与对象没有交互，所以看的会有点奇怪。我们重新写一下isBorrowed，当 isBorrowed 为 true 时，输出已经被借出，为 false 时，输出未被借出。

public String toString() {
        return "book{" +
                "书名='" + name + '\'' +
                ", 作者='" + author + '\'' +
                ", 价格=" + price +
                ", 类型='" + type + '\'' +
                ((isBorrowed == true) ? " 已经借出" : " 未被借出")+
               // ", 是否被借出=" + isBorrowed +
                '}';
    }

2. 查找图书功能实现

查找功能和遍历类似，只要利用equals关键字比较字符串输出就可以了。在Findioperation 类中，先输入要查找的书名，遍历所有的书，比较书名，书名一样输出即可。

public void work(Booklist booklist) {
        System.out.println("查找图书");

        System.out.println("请输入你要查找的图书：");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        int currentSize = booklist.getUsedSize();
        for (int i = 0;i < currentSize;i++) {
            Book book = booklist.getBook(i);

            if(book.getName().equals(name)) {
                System.out.println("找到了这本书，信息如下：");
                System.out.println(book);
                return;
            }
        }
        System.out.println("没有找到这本书！");
    }

3. 添加图书功能实现

思路：首先利用扫描器正常输入书的属性(此处为书名，作者，价格，类型)。但要注意一点，将int 类型放到最后，如果int 类型放到 String 类型前，那输入 int 类型后的回车会被接下来的 String 类型吸收，导致下边的 String 类型无法输入。将输入好的数据放到 book 中。检查 booklist 数组中有没有新增的数据，如果有就不再添加，如果没有检查书架是否溢出，如果没有，添加成功。

在 Booklist 中写一个getbooks 方法，用于接收书架容量。

 public Book[] getBooks() {
        return books;
    }

看看当前书的数目有没有超过书架容量，没有超过添加成功，同时 currentSize 加 1 。

public void work(Booklist booklist) {
        System.out.println("添加图书");

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入书名：");
        String name = scanner.nextLine();

        System.out.println("请输入作者：");
        String author = scanner.nextLine();

        System.out.println("请输入类型：");
        String type = scanner.nextLine();

        System.out.println("请输入价格：");
        int price = scanner.nextInt();

        Book book = new Book(name,author,price,type);

        //检查数组当中有没有这本书
        int currentSize = booklist.getUsedSize();
        for (int i = 0;i < currentSize;i++) {
            Book book1 = booklist.getBook(i);
            if(book1.getName().equals(name)) {
                System.out.println("书架中有这本书了，不在进行存放！");
                return;
            }
        }
        if(currentSize == booklist.getBooks().length) {
            System.out.println("书架满了，不能操作");
        }else {
            System.out.println("添加成功！");
            booklist.setBook(currentSize,book);
            booklist.setUsedSize(currentSize+1);
        }

    }

4. 退出系统功能实现

最简单的一集！一句 System.exit(0); 直接退出系统。

public void work(Booklist booklist) {
        System.out.println("退出系统");
        System.exit(0);
    }

5. 删除图书功能实现

思路：首先找到有没有这本书，然后数组后边的数据从后往前直接覆盖掉想要删除的数据，然后将最后一个数据置空就可以了。

说是覆盖，其实是把需要删除的元素地址指向下一个元素就可以了，同时最后一个元素不需要再指向下一个元素，要不然就数组越界了，所以在循环时，i 要小于currentSize - 1。

public void work(Booklist booklist) {
        System.out.println("删除图书");

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入想要删除的书名：");
        String name = scanner.nextLine();

        int pos = -1;
        int currentSize = booklist.getUsedSize();
        int i = 0;
        for (; i < currentSize; i++) {
            //说明有删除的书，进行标记
            Book book = booklist.getBook(i);
            if(book.getName().equals(name)){
                pos = i;
                break;
            }
        }
        if (i == currentSize) {
            System.out.println("没有要删除的图书");
            return;
        }
        //开始删除
        int j = pos;
        for (; j < currentSize - 1; j++) {
            Book book = booklist.getBook(j+1);
            booklist.setBooks(j,book);
        }
        //将数组最后一个元素置为空
        booklist.setBook(j,null);
        //删除元素，更新 userSize
        booklist.setUsedSize(currentSize - 1);
    }

6. 借阅图书功能实现

借阅图书实现起来相对比较容易，输入要借阅的书名，如果有这本书，将这本书的
setBorrowed 置为 true 就可以了。

public void work(Booklist booklist) {
        System.out.println("借阅图书");
        /**
         * 1.你要借阅那本书
         * 2.借阅的书有没有
         * 3.借阅的方式是什么
         */
        Scanner scanner = new Scanner(System.in);
        System.out.println("你要借阅哪本书：");
        String name = scanner.nextLine();

        int i = 0;
        int currentSize = booklist.getUsedSize();
        for (i = 0;i < currentSize;i++) {
            Book book = booklist.getBook(i);
            if (book.getName().equals(name)) {
                book.setBorrowed(true);
                System.out.println("借阅成功！");
                System.out.println(book);
                return;
            }
        }
        System.out.println("你借阅的图书不存在！");

    }

7. 归还图书功能实现

和借阅图书功能完全一样！

public void work(Booklist booklist) {
        System.out.println("归还图书");
            /**
             * 1.你要归还那本书
             * 2.归还的书有没有
             * 3.归还的方式是什么
             */
            Scanner scanner = new Scanner(System.in);
            System.out.println("你要归还哪本书：");
            String name = scanner.nextLine();

            int i = 0;
            int currentSize = booklist.getUsedSize();
            for (i = 0;i < currentSize;i++) {
                Book book = booklist.getBook(i);
                if (book.getName().equals(name)) {
                    book.setBorrowed(false);
                    System.out.println("归还成功！");
                    System.out.println(book);
                    return;
                }
            }
            System.out.println("你归还的图书不存在！");

        }

到了这里，整个图书管理系统就全部完成了。

四、完整代码

book 包中的 book ：

package book;

public class Book {

    private String name;
    private String author;
    private int price;
    private String type;
    private boolean isBorrowed;


    public Book(String name, String author, int price, String type) {
        this.name = name;
        this.author = author;
        this.price = price;
        this.type = type;
    }

    public String getName() {
        return name;
    }

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

    public String getAuthor() {
        return author;
    }

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

    public int getPrice() {
        return price;
    }

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

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public boolean isBorrowed() {
        return isBorrowed;
    }

    public void setBorrowed(boolean borrowed) {
        isBorrowed = borrowed;
    }

    @Override
    //重写toString 方法
    public String toString() {
        return "book{" +
                "书名='" + name + '\'' +
                ", 作者='" + author + '\'' +
                ", 价格=" + price +
                ", 类型='" + type + '\'' +
                ((isBorrowed == true) ? " 已经借出" : " 未被借出")+
               // ", 是否被借出=" + isBorrowed +
                '}';
    }
}

booklist ：

package book;

public class Booklist {

    private Book[] books;
    private int usedSize;  //记录当前书架上实际存放了多少本书，默认为 0

    public Booklist() {

        this.books = new Book[10];

        //放好书！
        this.books[0] = new Book("西游记","罗贯中",15,"小说");
        this.books[1] = new Book("水浒传","施耐庵",25,"小说");
        this.books[2] = new Book("红楼梦","曹雪芹",35,"小说");

        this.usedSize = 3;
    }

    public int getUsedSize() {
        return usedSize;
    }

    public void setUsedSize(int usedSize) {
        this.usedSize = usedSize;
    }

    public Book getBook(int pos) {
        return books[pos];
    }

    // pos 为数组下标
    public void setBook(int pos,Book book) {
        books[pos] = book;  //将 books数组的 pos下标设置为一本书
    }
    public Book[] getBooks() {
        return books;
    }

    public void setBooks(int pos,Book book) {
        books[pos] = book;
    }
}

IOpeartion 包中的 Addioperation ：

package operation;

import book.Book;
import book.Booklist;

import java.util.Scanner;

public class AddOperation implements IOperation{
    @Override
    public void work(Booklist booklist) {
        System.out.println("添加图书");

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入书名：");
        String name = scanner.nextLine();

        System.out.println("请输入作者：");
        String author = scanner.nextLine();

        System.out.println("请输入类型：");
        String type = scanner.nextLine();

        System.out.println("请输入价格：");
        int price = scanner.nextInt();

        Book book = new Book(name,author,price,type);

        //检查数组当中有没有这本书
        int currentSize = booklist.getUsedSize();
        for (int i = 0;i < currentSize;i++) {
            Book book1 = booklist.getBook(i);
            if(book1.getName().equals(name)) {
                System.out.println("书架中有这本书了，不在进行存放！");
                return;
            }
        }
        if(currentSize == booklist.getBooks().length) {
            System.out.println("书架满了，不能操作");
        }else {
            System.out.println("添加成功！");
            booklist.setBook(currentSize,book);
            booklist.setUsedSize(currentSize+1);
        }

    }
}

Borrowedioperation：

package operation;

import book.Book;
import book.Booklist;

import java.util.Scanner;

public class BorrowOperation implements IOperation{
    @Override
    public void work(Booklist booklist) {
        System.out.println("借阅图书");
        /**
         * 1.你要借阅那本书
         * 2.借阅的书有没有
         * 3.借阅的方式是什么
         */
        Scanner scanner = new Scanner(System.in);
        System.out.println("你要借阅哪本书：");
        String name = scanner.nextLine();

        int i = 0;
        int currentSize = booklist.getUsedSize();
        for (i = 0;i < currentSize;i++) {
            Book book = booklist.getBook(i);
            if (book.getName().equals(name)) {
                book.setBorrowed(true);
                System.out.println("借阅成功！");
                System.out.println(book);
                return;
            }
        }
        System.out.println("你借阅的图书不存在！");

    }
}

Delioperation ：

package operation;

import book.Book;
import book.Booklist;

import java.util.Scanner;

public class DelOperation implements IOperation{
    @Override
    public void work(Booklist booklist) {
        System.out.println("删除图书");

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入想要删除的书名：");
        String name = scanner.nextLine();

        int pos = -1;
        int currentSize = booklist.getUsedSize();
        int i = 0;
        for (; i < currentSize; i++) {
            //说明有删除的书，进行标记
            Book book = booklist.getBook(i);
            if(book.getName().equals(name)){
                pos = i;
                break;
            }
        }
        if (i == currentSize) {
            System.out.println("没有要删除的图书");
            return;
        }
        //开始删除
        int j = pos;
        for (; j < currentSize - 1; j++) {
            Book book = booklist.getBook(j+1);
            booklist.setBooks(j,book);
        }
        //将数组最后一个元素置为空
        booklist.setBook(j,null);
        //删除元素，更新 userSize
        booklist.setUsedSize(currentSize - 1);
    }

}

Exitioperation ：

package operation;

import book.Booklist;

public class ExitOperation implements IOperation{
    @Override
    public void work(Booklist booklist) {
        System.out.println("退出系统");
        System.exit(0);
    }
}

Findioperation ：

package operation;

import book.Book;
import book.Booklist;

import java.util.Scanner;

public class FindOperation implements IOperation{
    @Override
    public void work(Booklist booklist) {
        System.out.println("查找图书");

        System.out.println("请输入你要查找的图书：");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        int currentSize = booklist.getUsedSize();
        for (int i = 0;i < currentSize;i++) {
            Book book = booklist.getBook(i);

            if(book.getName().equals(name)) {
                System.out.println("找到了这本书，信息如下：");
                System.out.println(book);
                return;
            }
        }
        System.out.println("没有找到这本书！");
    }
}

Returnioperation ：

package operation;

import book.Book;
import book.Booklist;

import java.util.Scanner;

public class ReturnOperation implements IOperation{
    @Override
    public void work(Booklist booklist) {
        System.out.println("归还图书");
            /**
             * 1.你要归还那本书
             * 2.归还的书有没有
             * 3.归还的方式是什么
             */
            Scanner scanner = new Scanner(System.in);
            System.out.println("你要归还哪本书：");
            String name = scanner.nextLine();

            int i = 0;
            int currentSize = booklist.getUsedSize();
            for (i = 0;i < currentSize;i++) {
                Book book = booklist.getBook(i);
                if (book.getName().equals(name)) {
                    book.setBorrowed(false);
                    System.out.println("归还成功！");
                    System.out.println(book);
                    return;
                }
            }
            System.out.println("你归还的图书不存在！");

        }
    }

Showioperation ：

package operation;

import book.Book;
import book.Booklist;

public class ShowOperation implements IOperation{
    @Override
    public void work(Booklist booklist) {
        System.out.println("显示图书");
        int currentSize = booklist.getUsedSize();
        for (int i = 0;i < currentSize;i++) {
            Book book = booklist.getBook(i);
            System.out.println(book);
        }
    }
}

user 包中的 User ：

package user;

import book.Booklist;
import operation.IOperation;

public abstract class User {

    protected String name;

    protected IOperation[] iOperations;

    public User(String name) {

        this.name = name;

    }
    public abstract int menu();

    //
    public void doIoperation (int choice, Booklist booklist) {
        
        iOperations[choice].work(booklist);
    }
}

AdminUser：

package user;

import operation.*;

import java.util.Scanner;

public class AdminUser extends User{

    public AdminUser(String name) {
        super(name);
        this.iOperations = new IOperation[] {
                new ExitOperation(),
                new AddOperation(),
                new FindOperation(),
                new DelOperation(),
                new ShowOperation()
                };
    }

    public int menu() {
        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("********************");

        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;
    }
}

NormalUser：

package user;

import operation.*;

import java.util.Scanner;

public class NormalUser extends User{
    public NormalUser(String name) {
        super(name);
        this.iOperations = new IOperation[] {
                new ExitOperation(),
                new FindOperation(),
                new BorrowOperation(),
                new ReturnOperation()
                };
    }
    public int menu() {
        System.out.println("***** 普通用户 *****");
        System.out.println("1.查找书籍");
        System.out.println("2.借阅书籍");
        System.out.println("3.归还书籍");
        System.out.println("0.退出系统");
        System.out.println("*******************");

        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;
    }
}

Main 方法：

import book.Booklist;
import user.AdminUser;
import user.NormalUser;
import user.User;

import java.util.Scanner;

public class Main {

    public static User login() {
        System.out.println("请输入你的名字：");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        System.out.println("请输入您的身份：-> 1.管理员  2.普通用户");
        int choice = scanner.nextInt();
        if (choice == 1) {
            return new AdminUser(name);
        } else {
            return new NormalUser(name);
        }

    }

    public static void main(String[] args) {
        Booklist booklist = new Booklist();
        //user指向那个对象，就看返回值是什么
        User user = login();
        while (true) {
            int choice = user.menu();

            //根据choice的选择来决定，调用的是哪个方法
            user.doIoperation(choice, booklist);
        }
    }
}