• 图书管理系统(Java实现）[附完整代码]

    作者：爱塔居的博客_CSDN博客-JavaSE领域博主

    专栏：JavaSE

    作者专栏：大三学生，希望跟大家一起进步！

    wx:csy1330748830

    需要可以加，免费给。我是女孩子，别叫我哥，呜呜。

    一、图书管理系统菜单

    🍓管理员菜单

    1.查找图书

    2.新增图书

    3.删除图书

    4.显示图书

    0.退出系统

    ---------------------------------------------------------------------------------------------------------------------------------

    🌼用户菜单

    1.查找图书

    2.借阅图书

    3.归还图书

    0.退出系统

    二、实现基本框架

    先建立一个新的文件，命名为TestBook,在文件内建立两个包，分别命名为user(用户)、book（图书）。

     先写book相关的代码。于是，我们先在book包中新建一个java类，名为：Book。

    显示图书时，我们希望它能显示出所有图书的名称、作者、价格、类型和图书目前是否借出。

    1.   private String name;//书名
    2.     private String author;//作者
    3.     private int price;//价格
    4.     private String type;//类型
    5.     private boolean isBorrowed;//是否被借出,初始值是false,在构造方法中不用写

     右击鼠标，选择Generate，选择Getter and Setter 选项，点击shift，点最后一个，就能全选：

    自动生成：

    1.  
    2.     public String getName() {
    3.         return name;
    4.     }
    5.  
    6.     public void setName(String name) {
    7.         this.name = name;
    8.     }
    9.  
    10.     public String getAuthor() {
    11.         return author;
    12.     }
    13.  
    14.     public void setAuthor(String author) {
    15.         this.author = author;
    16.     }
    17.  
    18.     public int getPrice() {
    19.         return price;
    20.     }
    21.  
    22.     public void setPrice(int price) {
    23.         this.price = price;
    24.     }
    25.  
    26.     public String getType() {
    27.         return type;
    28.     }
    29.  
    30.     public void setType(String type) {
    31.         this.type = type;
    32.     }
    33.  
    34.     public boolean isBorrowed() {
    35.         return isBorrowed;
    36.     }

    再写它们的构造方法：

    当我们新增一本图书时，它默认就是未被借出的，所以不用构造方法。

    快捷键：alt+insert。按ctrl，可以多选，直接生成下面代码块：

    1.  
    2.     public Book(String name, String author, int price, String type) {//构造方法
    3.         this.name = name;
    4.         this.author = author;
    5.         this.price = price;
    6.         this.type = type;
    7.     }

     我们再右键选择Generate，选择ToString,全选，点OK，自动生成：

    1.   @Override
    2.     public String toString() {
    3.         return "Book{" +
    4.                 "name='" + name + '\'' +
    5.                 ", author='" + author + '\'' +
    6.                 ", price=" + price +
    7.                 ", type='" + type + '\'' +
    8.                 ", isBorrowed=" + isBorrowed +
    9.                 '}';
    10.     }

    此时，在book包中新建一个类：BookList（书架）:

    在这个书架中，我们希望能在里面固定的位置放书，并且能知道放了几本书：

    1.     private  Book[] books=new  Book[10];//这个书架可以放十本书
    2.     private int usedSize;//记录下当前book数组中有几本书

    然后依旧是右键Generate ,getter and setter，自动生成：

     当前界面：

    我们还记得在C语言中，我们用到的 define，用define语句来定义一个常量，同理，我们这边也可以定义一个能放多少本书的常量：

    1.   private static final int DEFAULT_SIZE=10;
    2.   private  Book[] books=new  Book[DEFAULT_SIZE];

    我们这边就是先按思路慢慢写，慢慢补充。在后面，我会放完整的代码。

    book包已经告一段落了，现在来写user包。

    我们在user包中新建三个类：AdminUser（管理员）、NormalUser(用户)、User。

    NormalUser、AdminUser，这也就是我们图书管理系统面对的两个对象了，管理员和用户，他们具有一些相同的属性。我们就可以写一个User类，让两个类去继承，来省一些代码了。

    🥗我们先写User类叭~

    1. package user;
    2.  
    3. public class User {
    4.     protected String name;//名字.这边的protect代表的是名字的权限。如果是private,它只能在同一个包的同一类使用。就不能让AdminUser类继承了。
    5.     //写public的话，权限太大了，不是很好。
    6.     public User(String name) {//构造方法
    7.         this.name = name;
    8.     }
    9. }

    所以在AdminUser类中：

    1. package user;
    2.  
    3. public class AdminUser extends User{
    4.     public AdminUser(String name) {
    5.         super(name);
    6.     }
    7. }

    可以直接用快捷键，alt+insert，直接生成构造方法。

    同理，NormalUser类中：

    1. package user;
    2.  
    3. public class NormalUser extends User{
    4.     public NormalUser(String name) {
    5.         super(name);
    6.     }
    7. }
    8.

    我们书的属性和用户属性的包和类已经写了大概。我们现在回归到我前面列的功能上：

     

     然后，我们就会发现我们想要实现的功能和操作基本上是针对图书的。所以，这边，我们可以选择直接在图书book包中写方法，也可以选择另外再创建一个包。

    我这边是新建了一个包，命名为：opera，再创建一个接口命名为IOPeration。

    创建接口：点oper，右击，点击java Class：

     然后页面为：

     创建接口：

    1. package opera;
    2.  
    3. import book.BookList;
    4.  
    5. public interface IOPeration {//创建接口
    6.     void work(BookList bookList);//抽象方法
    7.     //功能主要是针对图书的，也就是针对书架。
    8. }

     我们在opera（实现功能的包）中，创建两个类，AddOperation、FindOperation，这两个类。

    我们会发现这两个类的实现也都要依靠BookList(书架)来实现。所以，在这两个类中，实现接口：

    FindOperation类中：

    1. package opera;
    2.  
    3. import book.BookList;
    4. public class FindOperation implements IOPeration{//继承
    5.     @Override
    6.     public void work(BookList bookList) {//重写IOPeration类中的work方法
    7.         System.out.println("查找图书！");
    8.     }
    9. }

    AddOperation类中：

    1. package opera;
    2.  
    3. import book.BookList;
    4.  
    5. public class AddOperation implements IOPeration {
    6.     public void work(BookList bookList){
    7.         System.out.println("新增图书！");
    8.     }
    9. }

     同理，新建类DelOperation（删除图书）:

    1. package opera;
    2.  
    3. import book.BookList;
    4.  
    5. public class DelOperation implements IOPeration{
    6.     @Override
    7.     public void work(BookList bookList) {
    8.         System.out.println("删除图书！");
    9.     }
    10. }

     新建一个类：ShowOperation(显示图书):

    1. package opera;
    2.  
    3. import book.BookList;
    4.  
    5. public class ShowOperation implements IOPeration{
    6.     @Override
    7.     public void work(BookList bookList) {
    8.         System.out.println("打印所有图书！");
    9.     }
    10. }

     再新建一个类：ExitOperation(退出系统）：

    1. package opera;
    2.  
    3. import book.BookList;
    4.  
    5. public class ExitOperation implements IOPeration{
    6.     @Override
    7.     public void work(BookList bookList) {
    8.         System.out.println("退出系统！");
    9.     }
    10. }

    新建一个BrrowOperation类（借阅图书）：

    1. package opera;
    2.  
    3. import book.BookList;
    4.  
    5. public class BrrowOperation implements IOPeration{
    6.     @Override
    7.     public void work(BookList bookList) {
    8.         System.out.println("借阅图书！");
    9.     }
    10. }

     再新建一个类：ReturnOperation(借阅图书):

    1. package opera;
    2.  
    3. import book.BookList;
    4.  
    5. public class ReturnOperation implements IOPeration{
    6.     @Override
    7.     public void work(BookList bookList) {
    8.         System.out.println("归还图书！");
    9.     }
    10. }

    接着，我们来细化我们的类。

    🍅我们还没有给user添加菜单。

    我们先给管理员添加菜单：

    1.     public void menu(){
    2.         System.out.println("____________________________________");
    3.         System.out.println("1.查找图书");
    4.         System.out.println("2.新增图书");
    5.         System.out.println("3.删除图书");
    6.         System.out.println("4.显示图书");
    7.         System.out.println("0.退出系统");
    8.     }

    再给用户添加菜单：

    1. public void manu(){
    2.     System.out.println("_________________");
    3.     System.out.println("hello,"+name+"~");
    4.     System.out.println("1.查找图书！");
    5.     System.out.println("2.借阅图书！");
    6.     System.out.println("3.归还图书！");
    7.     System.out.println("0.退出系统！");
    8. }

    现在，我们写main方法。在src下新建一个类：Main：

    1. import user.AdminUser;
    2. import user.NormalUser;
    3. import user.User;
    4.  
    5. import java.util.Scanner;
    6.  
    7. public class Main {
    8.     //登录
    9.         public static User login(){
    10.             System.out.println("请输入你的姓名：");
    11.             Scanner scanner=new Scanner(System.in);
    12.             String name=scanner.nextLine();
    13.             System.out.println("请选择你的身份：1->管理员 0->普通用户");
    14.             int choice =scanner.nextInt();
    15.             if(choice==1){
    16.                 //说明是管理员
    17.                 //由于有返回值,所以我们的方法返回值就不能写void了。但是我们也无法确定返回值是什么,可能是管理员,可能是用户。所以,用向上转型,写User.
    18.                 return new AdminUser(name);//返回实例化一个管理员对象
    19.             }else {
    20.                 return new NormalUser(name);//返回实例化一个用户对象
    21.             }
    22.         }
    23.     public static void main(String[] args) {
    24.   User user=login();//执行上面的login方法
    25.         user.menu();//实现打印菜单
    26.     }
    27. }

    执行login方法时，我们是还不知道new的对象是管理员还是用户的。所以，在打印菜单时，我们也不能直接使用我们在AdminUser类和NormalUser类中写的menu()方法。

    ✨🎉所以在写user.menu();这个语句时，不行！

    所以，我们想到了重写。

    我们把User类改成抽象类，在抽象类中写一个menu的抽象方法。

    1. package user;
    2. public abstract class User {//抽象类
    3.     protected String name;//名字.这边的protect代表的是名字的权限。如果是private,它只能在同一个包的同一类使用。就不能让AdminUser类继承了。写public的话
    4.     //权限太大了，不是很好。
    5.     public User(String name) {//构造方法
    6.         this.name = name;
    7.     }
    8.     public abstract void menu();//抽象方法,打印菜单
    9. }

    那么， 在AdminUser类和NormalUser类中，也应该有相应的改动，把里面的menu()写成重写的形式。

    这也仅仅是实现了打印菜单：

     这个过程还是有一些弯弯绕绕的。我们可以通过调试，来捋清我们的思路：

    调试的话:

     然后，编译器就会带我们一步步地看它是怎么执行的。

    接着，我们继续完善我们的代码。光打印一个菜单，不执行我们想要的功能，可不行。

    所以，我们在我们的menu菜单中，需要输入我们的功能选择：

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

    输入功能选择，我们就要通过这个选择就实现：

    首先，我们要根据对象（管理员或用户），选择引用哪一个菜单方法：

    NormalUser类中：

    1.  public NormalUser(String name) {
    2.         super(name);
    3.         this.ioPerations=new IOPeration[]{//引用,这边用super也可以，因为这里没有同名的，不需要做区分。用this最好
    4.                 new FindOperation(),
    5.                 new BrrowOperation(),
    6.                 new ReturnOperation(),
    7.                 new ExitOperation()//以动态方式申请内存。拿到变量后，我们就给他们分配内存
    8.         };

     AdminUser类中：

    1.   public AdminUser(String name) {
    2.         super(name);
    3.         this.ioPerations=new IOPeration[]{
    4.                 new ExitOperation(),
    5.                 new FindOperation(),
    6.                 new AddOperation(),
    7.                 new DelOperation(),
    8.                 new ShowOperation()
    9.         };
    10.     }

     当我们在构造方法中，写了这些，也就为它们分配了内存。当main类中login()方法下，new一个对象时，就会执行相应的构造方法，在这里就是开辟内存：

     在User类中：

    我们加上这样一段代码：

    1.  public void doWork(int choice, BookList bookList){//通过选择的操作，去选择执行数组下的哪个操作
    2.         this.ioPerations[choice].work(bookList);
    3.     }

    this.ioPerations[choice]其实就是new了一个对象。后面的.work（bookList）是调用图书中对应的work方法。

    由此一来，我们就可以根据我们一步步的选择，调用book包中对应的work方法。

    为了让代码在输入0的时候退出系统，我们用while语句（在Main方法中修改）：

    1.    while (true){
    2.             int choice=user.menu();//实现打印菜单
    3.             user.doWork(choice,bookList);
    4.         }

     

    这下子基本框架就构造好了。

    先看一下测试结果：

     三、实现业务

    3.1 打印所有图书

     我们先在BookList类，也就是书架中先添加图书：

    1. public BookList(){//构造方法
    2.         books[0]=new Book("《三国演义》","罗贯中",40,"小说");
    3.         books[1]=new Book("《西游记》","吴承恩",60,"小说");
    4.         books[2]=new Book("《红楼梦》","曹雪芹",45,"小说");
    5.         this.usedSize=3;
    6.     }
    7.    //通过这个方法，实现ShowOperation中的通过下标打印数组元素
    8.     public Book getBook(int pos){
    9.         return this.books[pos];
    10.     }

    然后，我们实现打印所有图书这个业务 。

    🍍在ShowOperation类中，添加打印所有图书的程序，利用for循环。

     在ShowOperation类中：

    1. package opera;
    2.  
    3. import book.BookList;
    4.  
    5. public class ShowOperation implements IOPeration{
    6.     @Override
    7.     public void work(BookList bookList) {
    8.         System.out.println("显示图书！");
    9.         int currentSize= bookList.getUsedSize();
    10.         for (int i=0;i
    11.             System.out.println(bookList.getBook(i));
    12.         }
    13.     }
    14. }

    实现的结果：

     我们会发现一些小瑕疵，比如这边输出的false。我们想把它改成已借出，未借出。

    这时，我们要用到三目运算符。条件？符合输出：不符合输出

    在book类中修改：

    1.   public String toString() {
    2.         return "Book{" +
    3.                 "name='" + name + '\'' +
    4.                 ", author='" + author + '\'' +
    5.                 ", price=" + price +
    6.                 ", type='" + type + '\'' +
    7.                 ", isBorrowed=" +(isBorrowed==true?"    已借出":"    未借出") +
    8.                 '}';
    9.     }

     3.2 退出系统

    退出系统很简单，只需要加上👇语句即可。0代表正常退出。

    System.exit(0);

     实现结果：

     3.3 查找图书

    查找图书是跟刚才打印图书差不多的思路。通过for循环，利用equal()进行比对，输出图书信息。

    在FindOperation类中补充代码：

    1. public class FindOperation implements IOPeration{//继承
    2.     @Override
    3.     public void work(BookList bookList) {//重写IOPeration类中的work方法
    4.         System.out.println("查找图书！");
    5.         System.out.println("请输入要查找的图书名字");
    6.         Scanner scanner=new Scanner(System.in);
    7.        String name=scanner.nextLine();
    8.        int currentSize= bookList.getUsedSize();
    9.        for (int i=0;i
    10.            Book book=bookList.getBook(i);
    11.            if(book.getName().equals(name)){//判断查找图书名字是否相同
    12.                System.out.println("查到了：");
    13.                System.out.println(book);//输出图书信息
    14.            }else {
    15.                System.out.println("没有这本书");
    16.            }
    17.        }
    18.     }
    19.  
    20. }

     3.4 增加图书

    我们要先输入新增图书信息，new一个对象，判断这本图书是否已经存在，如果不存在，则存入书架中。

    AddOperation类：

    1. package opera;
    2.  
    3. import book.Book;
    4. import book.BookList;
    5.  
    6. import java.util.Scanner;
    7.  
    8. public class AddOperation implements IOPeration {
    9.     public void work(BookList bookList){
    10.         System.out.println("新增图书！");
    11.         Scanner scanner=new Scanner(System.in);
    12.         System.out.println("请输入新增图书名字：");
    13.         String name= scanner.nextLine();
    14.         System.out.println("请输入新增图书作者：");
    15.         String author=scanner.nextLine();
    16.         System.out.println("请输入价格");
    17.        int price=scanner.nextInt();
    18.         Scanner scanner2=new Scanner(System.in);
    19.         System.out.println("请输入小说类型:");
    20.         String type=scanner2.nextLine();
    21.         Book book=new Book(name,author,price,type);
    22.         int currentSize= bookList.getUsedSize();
    23.         for (int i=0;i
    24.             Book temp=bookList.getBook(i);
    25.             if(temp.getName().equals(name)){//判断查找图书名字是否相同
    26.                 System.out.println("已经有这本书了");
    27.                 return;
    28.             }
    29.         }
    30.      bookList.setBooks(book);
    31.         System.out.println("新增图书成功！");
    32.         //修改图书数量
    33.         bookList.setUsedSize(currentSize+1);
    34.     }
    35. }

     bookList.setBooks(book);这个语句，我们需要在书架那个类加上setBooks()方法：

    1.   public void setBooks(Book book){
    2.         this.books[usedSize]=book;
    3.     }

     🍓注意！！！

    在增加图书的时候，我遇到了困难。

    我在价格的地方，设置的是int类型。 int price=scanner.nextInt();这个语句执行完，它就不会执行后面的输入语句了。这是我疏忽的一个点。

    有三种解决方案。

    1.像我上面的代码一样，多写一个  Scanner scanner2=new Scanner(System.in); 这是改动最小的方法了。

    2.就是把图书的价格和类型的顺序调换一下，就是要几个文件都改一小下，其实也很快。这样子int price=scanner.nextInt();，最后输这个输入命令的话，就能保证输入命令全部执行

    3.这个方法也比较简单，就是把图书的价格类型改成String，那样子，就没有影响了。

    3.5 删除图书 

    🍆删除图书，我们要注意，不仅仅是把那本书删除就好了，还需要把后面的书往前挪。

    DelOperation类：

    1.    public void work(BookList bookList) {
    2.         System.out.println("删除图书！");
    3.         System.out.println("请输入要删除图书的名称");
    4.         Scanner scanner=new Scanner(System.in);
    5.         String name=scanner.nextLine();
    6.         int currentSize= bookList.getUsedSize();
    7.         int index=-1;
    8.         for (int i=0;i
    9.             Book temp=bookList.getBook(i);
    10.             if(temp.getName().equals(name)){//判断查找图书名字是否相同
    11.                 index=i;
    12.                 break;
    13.             }
    14.         }
    15.         //删除图书，把后面的图书往前面挪
    16.         for (int j=index;j1;j++){
    17.             Book book=bookList.getBook(j+1);//拿到j下标后面的书
    18.             bookList.setBooks(j,book);//放到j下标的位置
    19.         }
    20.         bookList.setUsedSize(currentSize-1);//修改size值
    21.         bookList.setBooks(currentSize-1,null);//因为删除的是对象,所以把地址置为null，就没有人引用了
    22.     }

    BookList类：

    1.   public void setBooks(int pos,Book book){
    2.         this.books[pos]=book;
    3.     }

    我们可以注意到在BookList新添加的这个方法跟刚才在写增加图书时放置图书的方法相似。不过，我们可以注意到，增加图书，就是在最后面放一本书，就好了。而这里，是把后面的书一本本往前挪一个书位。

    3.6 借阅图书

    思路：判断图书是否在书库中存在，判断图书是否已经被借出。满足条件，执行

    temp.setBorrowed(true);

    3.7 归还图书 

    思路：判断图书是否在书库中存在，判断书是否已被借出。

    满足条件：

    temp.setBorrowed(false);

    总代码

    Book:

    1. package book;
    2.  
    3. public class Book {
    4.     private String name;//书名
    5.     private String author;//作者
    6.     private int price;//价格
    7.     private String type;//类型
    8.     private boolean isBorrowed;//是否被借出,初始值是false,在构造方法中不用写
    9.  
    10.     public Book(String name, String author, int price, String type) {//构造方法
    11.         this.name = name;
    12.         this.author = author;
    13.         this.price = price;
    14.         this.type = type;
    15.     }
    16.  
    17.     public String getName() {
    18.         return name;
    19.     }
    20.  
    21.     public void setName(String name) {
    22.         this.name = name;
    23.     }
    24.  
    25.     public String getAuthor() {
    26.         return author;
    27.     }
    28.  
    29.     public void setAuthor(String author) {
    30.         this.author = author;
    31.     }
    32.  
    33.     public int getPrice() {
    34.         return price;
    35.     }
    36.  
    37.     public void setPrice(int price) {
    38.         this.price = price;
    39.     }
    40.  
    41.     public String getType() {
    42.         return type;
    43.     }
    44.  
    45.     public void setType(String type) {
    46.         this.type = type;
    47.     }
    48.  
    49.     public boolean isBorrowed() {
    50.         return isBorrowed;
    51.     }
    52.  
    53.     @Override
    54.     public String toString() {
    55.         return "Book{" +
    56.                 "name='" + name + '\'' +
    57.                 ", author='" + author + '\'' +
    58.                 ", price=" + price +
    59.                 ", type='" + type + '\'' +
    60.                 ", isBorrowed=" +(isBorrowed==true?"    已借出":"    未借出") +
    61.                 '}';
    62.     }
    63.  
    64.     public void setBorrowed(boolean borrowed) {
    65.         isBorrowed = borrowed;
    66.     }
    67. }

     BookList

    1. package book;
    2. //书架
    3. public class BookList {
    4.     private static final int DEFAULT_SIZE=10;
    5.     private  Book[] books=new  Book[DEFAULT_SIZE];//这个书架可以放十本书
    6.     public BookList(){//构造方法
    7.         books[0]=new Book("《三国演义》","罗贯中",40,"小说");
    8.         books[1]=new Book("《西游记》","吴承恩",60,"小说");
    9.         books[2]=new Book("《红楼梦》","曹雪芹",45,"小说");
    10.         this.usedSize=3;
    11.     }
    12.     //通过这个方法，实现ShowOperation中的通过下标打印数组元素
    13.     public Book getBook(int pos){
    14.         return this.books[pos];
    15.     }
    16.     public void setBooks(Book book){
    17.         this.books[usedSize]=book;
    18.     }
    19.     public void setBooks(int pos,Book book){
    20.         this.books[pos]=book;
    21.     }
    22.     private int usedSize;//记录下当前book数组中有几本书
    23.     public int getUsedSize() {
    24.         return usedSize;
    25.     }
    26.     public void setUsedSize(int usedSize) {
    27.         this.usedSize = usedSize;
    28.     }
    29. }

    AddOperation

    1. package opera;
    2.  
    3. import book.Book;
    4. import book.BookList;
    5.  
    6. import java.util.Scanner;
    7.  
    8. public class AddOperation implements IOPeration {
    9.     public void work(BookList bookList){
    10.         System.out.println("新增图书！");
    11.         Scanner scanner=new Scanner(System.in);
    12.         System.out.println("请输入新增图书名字：");
    13.         String name= scanner.nextLine();
    14.         System.out.println("请输入新增图书作者：");
    15.         String author=scanner.nextLine();
    16.         System.out.println("请输入价格");
    17.        int price=scanner.nextInt();
    18.         Scanner scanner2=new Scanner(System.in);
    19.         System.out.println("请输入小说类型:");
    20.         String type=scanner2.nextLine();
    21.         Book book=new Book(name,author,price,type);
    22.         int currentSize= bookList.getUsedSize();
    23.         for (int i=0;i
    24.             Book temp=bookList.getBook(i);
    25.             if(temp.getName().equals(name)){//判断查找图书名字是否相同
    26.                 System.out.println("已经有这本书了");
    27.                 return;
    28.             }
    29.         }
    30.      bookList.setBooks(book);
    31.         System.out.println("新增图书成功！");
    32.         //修改图书数量
    33.         bookList.setUsedSize(currentSize+1);
    34.     }
    35. }

    BorrwOperation:

    1. package opera;
    2.  
    3. import book.Book;
    4. import book.BookList;
    5.  
    6. import java.util.Scanner;
    7.  
    8. public class BrrowOperation implements IOPeration{
    9.     @Override
    10.     public void work(BookList bookList) {
    11.         System.out.println("借阅图书！");
    12.         System.out.println("请输入要借阅的图书名字:");
    13.         Scanner scanner=new Scanner(System.in);
    14.         String name=scanner.nextLine();
    15.         int curentSize= bookList.getUsedSize();
    16.         int x=1;
    17.         for(int i=0;i
    18.             Book temp=bookList.getBook(i);
    19.             if((temp.getName().equals(name))&&!temp.isBorrowed()){
    20.                {
    21.  
    22.                     temp.setBorrowed(true);
    23.                     x=0;
    24.                    System.out.println("借阅成功！");
    25.                    return;
    26.                 }
    27.             }
    28.         }
    29.         if(x==1){
    30.             System.out.println("没有该图书");
    31.         }
    32.     }
    33. }

    DelOperation:

    1. package opera;
    2.  
    3. import book.Book;
    4. import book.BookList;
    5.  
    6. import java.util.Scanner;
    7.  
    8. public class DelOperation implements IOPeration{
    9.     @Override
    10.     public void work(BookList bookList) {
    11.         System.out.println("删除图书！");
    12.         System.out.println("请输入要删除图书的名称");
    13.         Scanner scanner=new Scanner(System.in);
    14.         String name=scanner.nextLine();
    15.         int currentSize= bookList.getUsedSize();
    16.         int index=-1;
    17.         int z=0;
    18.         for (int i=0;i
    19.             Book temp=bookList.getBook(i);
    20.             if(temp.getName().equals(name)){//判断查找图书名字是否相同
    21.                 index=i;
    22.                 z=1;
    23.                 break;
    24.             }
    25.         }
    26.         if(z==0){
    27.             System.out.println("没有这本书！");
    28.             return;
    29.         }
    30.         //删除图书，把后面的图书往前面挪
    31.         for (int j=index;j1;j++){
    32.             Book book=bookList.getBook(j+1);//拿到j下标后面的书
    33.             bookList.setBooks(j,book);//放到j下标的位置
    34.         }
    35.         bookList.setUsedSize(currentSize-1);//修改size值
    36.         bookList.setBooks(currentSize-1,null);//因为删除的是对象,所以把地址置为null，就没有人引用了
    37.         System.out.println("删除成功！");
    38.     }
    39.  
    40. }

    ExitOperation:

    1. package opera;
    2.  
    3. import book.BookList;
    4.  
    5. public class ExitOperation implements IOPeration{
    6.     @Override
    7.     public void work(BookList bookList) {
    8.         System.out.println("退出系统！");
    9.         System.exit(0);//退出系统。0代表正常退出
    10.     }
    11. }

     FindOperation:

    1. package opera;
    2.  
    3. import book.Book;
    4. import book.BookList;
    5.  
    6. import java.util.Scanner;
    7.  
    8. public class FindOperation implements IOPeration{//继承
    9.     @Override
    10.     public void work(BookList bookList) {//重写IOPeration类中的work方法
    11.         System.out.println("查找图书！");
    12.         System.out.println("请输入要查找的图书名字");
    13.         Scanner scanner=new Scanner(System.in);
    14.        String name=scanner.nextLine();
    15.        int currentSize= bookList.getUsedSize();
    16.        for (int i=0;i
    17.            Book book=bookList.getBook(i);
    18.            if(book.getName().equals(name)){//判断查找图书名字是否相同
    19.                System.out.println("查到了：");
    20.                System.out.println(book);//输出图书信息
    21.                return;
    22.            }
    23.        }
    24.         System.out.println("没有这本书！");
    25.     }
    26.  
    27. }

    IOPeration: 

    1. package opera;
    2.  
    3. import book.BookList;
    4.  
    5. public interface IOPeration {//创建接口
    6.     void work(BookList bookList);//抽象方法
    7.     //功能主要是针对图书的，也就是针对书架。
    8. }

     ReturnOperation:

    1. package opera;
    2.  
    3. import book.Book;
    4. import book.BookList;
    5.  
    6. import java.util.Scanner;
    7.  
    8. public class ReturnOperation implements IOPeration{
    9.     @Override
    10.     public void work(BookList bookList) {
    11.         System.out.println("归还图书！");
    12.         System.out.println("请输入要归还的图书名字:");
    13.         Scanner scanner=new Scanner(System.in);
    14.         String name=scanner.nextLine();
    15.         int curentSize= bookList.getUsedSize();
    16.         for(int i=0;i
    17.             Book temp=bookList.getBook(i);
    18.             if((temp.getName().equals(name))&&temp.isBorrowed()){
    19.                 {
    20.                     temp.setBorrowed(false);
    21.                     System.out.println("归还成功！");
    22.                     return;
    23.                 }
    24.             }
    25.         }
    26.     }
    27.     }

    ShowOperation:

    1. package opera;
    2.  
    3. import book.BookList;
    4.  
    5. public class ShowOperation implements IOPeration{
    6.     @Override
    7.     public void work(BookList bookList) {
    8.         System.out.println("显示图书！");
    9.         int currentSize= bookList.getUsedSize();
    10.         for (int i=0;i
    11.             System.out.println(bookList.getBook(i));
    12.         }
    13.     }
    14. }

    Main

    1. import book.BookList;
    2. import user.AdminUser;
    3. import user.NormalUser;
    4. import user.User;
    5.  
    6. import java.util.Scanner;
    7.  
    8. public class Main {
    9.     //登录
    10.     public static User login() {
    11.         System.out.println("请输入你的姓名：");
    12.         Scanner scanner = new Scanner(System.in);
    13.         String name = scanner.nextLine();
    14.         System.out.println("请选择你的身份：1->管理员 0->普通用户");
    15.         int choice = scanner.nextInt();
    16.         if (choice == 1) {
    17.             //说明是管理员
    18.             //由于有返回值,所以我们的方法返回值就不能写void了。但是我们也无法确定返回值是什么,可能是管理员,可能是用户。所以,用向上转型,写User.
    19.             return new AdminUser(name);//返回实例化一个管理员对象
    20.         } else {
    21.             return new NormalUser(name);//返回实例化一个用户对象
    22.         }
    23.     }
    24.  
    25.     public static void main(String[] args) {
    26.         User user = login();//执行上面的login方法
    27.         BookList bookList = new BookList();
    28.         while (true) {
    29.             int choice = user.menu();//实现打印菜单
    30.             user.doWork(choice, bookList);
    31.         }
    32.     }
    33. }

    测试的话，运行Main：

    user代码

    AdminUer

    1. package user;
    2.  
    3. import opera.*;
    4.  
    5. import java.util.Scanner;
    6.  
    7. public class AdminUser extends User{
    8.     public AdminUser(String name) {
    9.         super(name);
    10.         this.ioPerations=new IOPeration[]{
    11.                 new ExitOperation(),
    12.                 new FindOperation(),
    13.                 new AddOperation(),
    14.                 new DelOperation(),
    15.                 new ShowOperation()
    16.         };
    17.     }
    18.     @Override
    19.     public int menu() {//因为返回值choice是int类型的
    20.         System.out.println("____________________________________");
    21.         System.out.println("1.查找图书");
    22.         System.out.println("2.新增图书");
    23.         System.out.println("3.删除图书");
    24.         System.out.println("4.显示图书");
    25.         System.out.println("0.退出系统");
    26.         System.out.println("请选择你需要的功能：");
    27.         Scanner scanner=new Scanner(System.in);
    28.         int choice=scanner.nextInt();
    29.         return choice;
    30.     }
    31.  
    32. }

    NormalUser

    1. package user;
    2.  
    3. import opera.*;
    4.  
    5. import java.util.Scanner;
    6.  
    7. public class NormalUser extends User{
    8.     public NormalUser(String name) {
    9.         super(name);
    10.         this.ioPerations=new IOPeration[]{//引用,这边用super也可以，因为这里没有同名的，不需要做区分。用this最好
    11.                 new ExitOperation(),
    12.                 new FindOperation(),
    13.                 new BrrowOperation(),
    14.                 new ReturnOperation()
    15.                 //以动态方式申请内存。拿到变量后，我们就给他们分配内存
    16.         };
    17.     }
    18.  
    19.     @Override
    20.     public int menu() {
    21.         System.out.println("_________________");
    22.         System.out.println("hello,"+name+"~");
    23.         System.out.println("1.查找图书！");
    24.         System.out.println("2.借阅图书！");
    25.         System.out.println("3.归还图书！");
    26.         System.out.println("0.退出系统！");
    27.         Scanner scanner=new Scanner(System.in);
    28.         int choice=scanner.nextInt();
    29.         return choice;
    30.     }

    User

    1. package user;
    2.  
    3. import book.BookList;
    4. import opera.IOPeration;
    5.  
    6. public abstract class User {//抽象类
    7.     protected String name;//名字.这边的protect代表的是名字的权限。如果是private,它只能在同一个包的同一类使用。就不能让AdminUser类继承了。写public的话
    8.     //权限太大了，不是很好。
    9.     protected IOPeration[] ioPerations;
    10.     public User(String name) {//构造方法
    11.         this.name = name;
    12.     }
    13.     public abstract int menu();//抽象方法,打印菜单,因为有了choice返回值int类型，所以void改成int
    14.     public void doWork(int choice, BookList bookList){//通过选择的操作，去选择执行数组下的哪个操作
    15.         this.ioPerations[choice].work(bookList);
    16.     }
    17. }

  • 相关阅读:
    java基础08
    HTML+CSS:实现心动的感觉！
    【准研一学习】狂肝15小时整理的Verilog语言入门知识
    C++启航跟沸羊羊有关系吗？
    C中的基本函数
    数据结构与算法之Hash&BitMap
    能添加任意贴图超级复布局的初级智能文本提示器
    半个小时！！！ 项目轻松部署到Linux
    vue.js scss ＞＞＞ 失效的问题
    hdfs集群的扩容和缩容
  • 原文地址：https://blog.csdn.net/m0_65683419/article/details/127936230