图书管理系统（装死版）

以下是要做的题目，本人只在java上初步实现这些操作，甚至没有检测和精修，只保证能跑。先发一下代码，纯装死

为图书管理人员编写一个图书管理系统，图书管理系统的设计主要是实现对图书的管理和相关操作，包括3个表：

管理员信息表——存储管理员的基本信息，包括管理员ID，管理员密码等。

图书信息表——存储图书的基本信息，包括书号、书名、作者、出版社、出版日期、存馆数量、定价等。

读者信息表——存储读者的基本信息，包括学号、姓名、学院、专业班级等。

图书借阅表——存储读者借书的相关信息，包括学号、姓名、书号、书名、借阅日期、应还日期、归还日期等。

用菜单选择方式完成下列功能：

1. 管理员登录功能：根据管理员ID和管理员密码登录操作界面。

2.  管理员注销功能：退出管理员操作界面。

3．图书信息添加功能：包括书号、书名、作者、出版社、存馆数量、定价等。

4．图书信息查询：分别按书名,按作者名,按出版社等进行查询。

5．图书信息排序：按书号、书名等按升序进行排序。

6．图书信息的修改、删除：按书号或书名进行图书的修改和删除。

7．读者信息添加功能：包括学号、姓名、学院、专业班级等。

8．读者信息查询：分别按学号、姓名、专业班级等进行查询。

9．读者信息排序：按学号、学院等按升序进行排序。

10．读者信息的修改、删除：按学号+姓名进行读者信息的修改和删除。

11．图书借阅：输入学号+书号，如果该书图书信息表中的存馆数量大于0，则可以借出，借出相应数量后修改图书信息表中的存馆数量，在图书借阅表添加该同学的借阅。

12．图书归还：输入学号+书号，修改图书信息表中的存馆数量，在图书借阅表中记录该同学的归还时间。

13．图书借阅查询：分别按学号、书名、学院等进行查询。

选做：查询功能用一种算法实现，如：二分查找等。

这是我代码的分类方式，四个大包，对应四个列表，大包中分为两个小包分别是列表和对列表的操作，小包中的类具体实现这些操作。还有一个user包，负责调用各操作，一个main类。 

 

admin包： 

Admin：

package library.admin.adminList;

public class Admin {
    private String ID;
    private String password;
    public Admin(String ID,String password){
        this.ID=ID;
        this.password=password;
    }
    public String getID(){
        return ID;
    }
    public String getPassword(){
        return password;
    }
}

 AdminList:

package library.admin.adminList;

public class AdminList {
    private Admin[] admin=new Admin[10];
    private  int usedsize=0;
    public AdminList()
    {
        admin[0]=new Admin("001","123456");
        admin[1]=new Admin("002","123456");
        admin[2]=new Admin("003","123456");
        usedsize=3;
    }
    public int getUsedSize(){
        return usedsize;
    }
    public Admin getAdmin(int pos){
        return this.admin[pos];
    }
}

ExitOperation 

package library.admin.adminOperation;
import library.admin.adminList.*;
public class ExitOperation {
    public void work(AdminList adminList){
        System.out.println("退出系统");
        System.exit(0);
    }
}

 LoginOperation

package library.admin.adminOperation;

import library.admin.adminList.Admin;
import library.admin.adminList.AdminList;
import library.book.bookList.BookList;
import library.reader.readerList.ReaderList;
import user.AdminUser;

import java.util.Scanner;

public class LoginOperation {
    public void work(AdminList adminList, BookList bookList, ReaderList readerList){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入用户名");
        String ID=sc.next();
        boolean flag=false;
        for (int i = 0; i < adminList.getUsedSize(); i++) {
            Admin admin=adminList.getAdmin(i);
            if(admin.getID().equals(ID)){
                flag=true;
                System.out.println("请输入密码");
                String password=sc.next();
                if(admin.getPassword().equals(password)){
                    System.out.println("密码正确");
                    AdminUser adminUser=new AdminUser(ID,bookList,readerList);
                }else{
                    System.out.println("此密码不正确");
                    break;
                }
            }
        }
        if(flag==false){
            System.out.println("用户名不正确");
        }
    }
}

book包：

Book

package library.book.bookList;

public class Book {
    private String serialNumber;
    private String name;
    private String author;
    private String press;
    private String date;
    private int number;
    private int price;
    public Book(String serialNumber,String name,String author,String press,String date,int number,int price){
        this.serialNumber=serialNumber;
        this.name=name;
        this.author=author;
        this.press=press;
        this.date=date;
        this.number=number;
        this.price=price;
    }
    public Book(){}
    public void setSerialNumber(String serialNumber){
        this.serialNumber=serialNumber;
    }
    public void setName(String name){
        this.name=name;
    }
    public void setAuthor(String author){
        this.author=author;
    }
    public void setPress(String press){
        this.press=press;
    }
    public void setDate(String date){
        this.date=date;
    }
    public void setNumber(int number){
        this.number=number;
    }
    public void setPrice(int price){
        this.price=price;
    }
    public String getSerialNumber(){
        return this.serialNumber;
    }
    public String getName(){
        return this.name;
    }
    public String getAuthor(){
        return this.author;
    }
    public String getPress(){
        return this.press;
    }
    public int getNumber(){
        return this.number;
    }
    public void borrow(){
        this.number-=1;
    }
    public String toString(){
        return "Books.Book{"+
                "序号：'"+serialNumber+'\''+
                "书名：'"+name+'\''+
                "作者：'"+author+'\''+
                "出版社：'"+press+'\''+
                "日期：'"+date+'\''+
                "数量：'"+number+'\''+
                "价格：'"+price+'\''+
                '}';
    }

}

BookList

package library.book.bookList;

public class BookList {
    private Book[] books=new Book[100];
    private int usedSize=0;
    public  BookList(){
        books[0]=new Book("1001","136的3号铺最帅","136的3号铺","山农","2023.6.13",3,20);
        books[1]=new Book("1002","红楼梦","曹雪芹","未知","2018.1.1",3,36);
        usedSize=2;
    }
    public int getGetUsedSize(){
        return usedSize;
    }
    public Book getBook(int pos){
        return this.books[pos];
    }
    public void setUsedSize(){
        usedSize+=1;
    }
    public void setBooks(Book book){
        this.books[usedSize]=book;
        usedSize+=1;
    }
    public void remove(int pos){
        for (int i = pos; i < books.length; i++) {
            books[i]=books[i+1];
        }
        usedSize-=1;
    }
    public void borrow(int pos){
        books[pos].borrow();
    }
    public void SerialNumberSort(){
        int []sn=new int[books.length];
        for (int i = 0; i < books.length; i++) {
            sn[i]=0;
            int m=1;
            for (int i1 = books[i].getSerialNumber().length()-1; i1 >=0; i1--) {
                sn[i]+= books[i].getSerialNumber().charAt(i1) * m;
                m=m*10;
            }
        }
        for (int i = 0; i < books.length-1; i++) {
            for(int j=0;j<books.length-1-i;j++) {
                if (sn[i] > sn[i + 1]) {
                    int t = sn[i];
                    sn[i] = sn[i + 1];
                    sn[i + 1] = t;
                    Book tempBook = books[i];
                    books[i] = books[i + 1];
                    books[i + 1] = tempBook;
                }
            }
        }

    }
}

 AddOperation

package library.book.bookOperation;

import library.book.bookList.Book;
import library.book.bookList.BookList;

import java.util.Scanner;

public class AddOperation {
    public void work(BookList bookList){
        Scanner scanner=new Scanner(System.in);
        String serialNumber=null;
        boolean flag1=true;
        while (flag1) {
            System.out.println("请输入要添加的书号");
            serialNumber=scanner.next();
            flag1=false;
            for (int i = 0; i < bookList.getGetUsedSize(); i++) {
                Book book=bookList.getBook(i);
                if(book.getSerialNumber().equals(serialNumber)){
                    System.out.println("书号重复。请重新输入");
                    flag1=true;
                }
            }
        }
        System.out.println("请输入书名");
        String name=scanner.next();
        System.out.println("请输入作者");
        String author=scanner.next();
        System.out.println("请输入出版社");
        String press=scanner.next();
        System.out.println("请输入出版日期");
        String date=scanner.next();
        System.out.println("请输入存储数量");
        int number=scanner.nextInt();
        System.out.println("请输入定价");
        int price=scanner.nextInt();
        Book book=new Book(serialNumber,name,author,press,date,number,price);
        bookList.setBooks(book);
        System.out.println("图书添加成功");
    }
}

 DeleteOperation

package library.book.bookOperation;

import library.book.bookList.Book;
import library.book.bookList.BookList;

import java.util.Scanner;

public class DeleteOperation {
    public void work(BookList bookList){
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入要删除的书号或书名");
        String string=scanner.next();
        int count=0;
        for (int i = 0; i < bookList.getGetUsedSize(); i++) {
            Book book=bookList.getBook(i);
            if(book.getSerialNumber().equals(string)&&book.getName().equals(string)){
                bookList.remove(i);
                System.out.println(book.toString());
                System.out.println("图书删除成功");
                count+=1;
            }
        }
        if(count==0){
            System.out.println("未找到，要删除的图书");
        }

    }
}

 DisplayOperation

package library.book.bookOperation;

import library.book.bookList.BookList;

public class DisplayOperation {
    public void work(BookList bookList){
        System.out.println("显示书籍");
        for (int i = 0; i < bookList.getGetUsedSize(); i++) {
            System.out.println(bookList.getBook(i));
        }
    }
}

 FindOperation

package library.book.bookOperation;
import library.book.bookList.Book;
import library.book.bookList.BookList;

import java.util.Scanner;

public class FindOperation {
    Scanner scanner=new Scanner(System.in);
    public void work(BookList bookList){
        System.out.println("请输入查询方式");
        System.out.println("1.按书号查询");
        System.out.println("2.按书名查询");
        System.out.println("3.按作者查询");
        System.out.println("4.按出版社查询");
        String choice=scanner.next();
        switch (choice){
            case "1"-> SerialNumber(bookList);
            case "2"-> Name(bookList);
            case "3"-> Author(bookList);
            case "4"-> Press(bookList);
            default -> System.out.println("没有您输入的选项");
        }
    }

    public void SerialNumber(BookList bookList) {
        System.out.println("请输入书号");
        String serialNumber=scanner.next();
        for (int i = 0; i < bookList.getGetUsedSize(); i++) {
            Book book=bookList.getBook(i);
            if(book.getSerialNumber().equals(serialNumber)){
                System.out.println(bookList.getBook(i).toString());
            }
        }
    }
    public void Name(BookList bookList) {
        System.out.println("请输入书名");
        String name=scanner.next();
        for (int i = 0; i < bookList.getGetUsedSize(); i++) {
            Book book=bookList.getBook(i);
            if(book.getName().equals(name)){
                System.out.println(book.toString());
            }
        }
    }
    public void Author(BookList bookList) {
        System.out.println("请输入作者");
        String author=scanner.next();
        for (int i = 0; i < bookList.getGetUsedSize(); i++) {
            Book book=bookList.getBook(i);
            if(book.getName().equals(author)){
                System.out.println(book.toString());
            }
        }
    }
    public void Press(BookList bookList) {
        System.out.println("请输入出版社");
        String press=scanner.next();
        for (int i = 0; i < bookList.getGetUsedSize(); i++) {
            Book book=bookList.getBook(i);
            if(book.getName().equals(press)){
                System.out.println(book.toString());
            }
        }
    }
}

 ReviseOperation

package library.book.bookOperation;

import library.book.bookList.Book;
import library.book.bookList.BookList;

import java.util.Scanner;

public class ReviseOperation {
    public void work(BookList bookList){
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入要修改的书号");
        String serialNumber=scanner.next();
        int index=getIndex(bookList,serialNumber);
        if(index==-1){
            System.out.println("要修改的书号不存在");
            return;
        }
        Book book=bookList.getBook(index);
        System.out.println("请输入要修改的书名");
        String newName=scanner.next();
        book.setName(newName);
        System.out.println("请输入要修改的作者");
        String newAuthor=scanner.next();
        book.setAuthor(newAuthor);
        System.out.println("请输入要修改的出版社");
        String newPress=scanner.next();
        book.setPress(newPress);
        System.out.println("请输入要修改的出版日期");
        String newDate=scanner.next();
        book.setDate(newDate);
        System.out.println("请输入要修改的存储数量");
        int newNumber=scanner.nextInt();
        book.setNumber(newNumber);
        System.out.println("请输入要修改的定价");
        int newPrice=scanner.nextInt();
        book.setPrice(newPrice);
        System.out.println("图书修改成功");
    }
    public int getIndex(BookList bookList,String serialNumber){
        for (int i = 0; i < bookList.getGetUsedSize(); i++) {
            Book book=bookList.getBook(i);
            String string=book.getSerialNumber();
            if(string.equals(serialNumber)){
                return i;
            }
        }
        return -1;
    }
}

SortOperation

package library.book.bookOperation;

import library.book.bookList.BookList;

import java.util.Scanner;

public class SortOperation {
    public void work(BookList bookList){
        bookList.SerialNumberSort();
        System.out.println("按书号排序，结果如下");
        for (int i = 0; i < bookList.getGetUsedSize(); i++) {
            System.out.println(bookList.getBook(i));
        }
    }
}

borrow包

Borrow

package library.borrow.borrowList;

public class Borrow {
    private String stuId;
    private String stuName;
    private String bookSerialNumber;
    private String bookName;
    private int borrowDateYear;
    private int borrowDateMonth;
    private int borrowDateDay;
    private int payableDateYear;
    private int payableDateMonth;
    private int payableDateDay;
    private int returnDateYear;
    private int returnDateMonth;
    private int returnDateDay;
    private boolean isReturn;
    public Borrow(){

    }
    public void setStuId(String stuId){
        this.stuId=stuId;
    }
    public void setStuName(String stuName){
        this.stuName=stuName;
    }
    public void setBookSerialNumber(String bookSerialNumber){
        this.bookSerialNumber=bookSerialNumber;
    }
    public void setBookName(String bookName){
        this.bookName=bookName;
    }
    public void setBorrowDate(int borrowDateYear,int borrowDateMonth,int borrowDateDay){
        this.borrowDateYear=borrowDateYear;
        this.borrowDateMonth=borrowDateMonth;
        this.borrowDateDay=borrowDateDay;
    }
    public void setReturnDate(int returnDateYear,int returnDateMonth,int returnDateDay){
        this.returnDateYear=returnDateYear;
        this.borrowDateMonth=returnDateMonth;
        this.borrowDateDay=returnDateDay;
    }
    public String getBookName(){
        return this.bookName;
    }
    public String getBookSerialNumber(){
        return this.bookSerialNumber;
    }
    public String getStuId(){
        return this.stuId;
    }

    public Borrow(String stuId,String stuName,String bookSerialNumber,String bookName,int borrowDateYear,int borrowDateMonth,int borrowDateDay){
        this.stuId=stuId;
        this.stuName=stuName;
        this.bookSerialNumber=bookSerialNumber;
        this.bookName=bookName;
        this.borrowDateYear=borrowDateYear;
        this.borrowDateMonth=borrowDateMonth;
        this.borrowDateDay=borrowDateDay;
        this.isReturn=false;
        this.payableDateDay=borrowDateDay;
        this.payableDateMonth=borrowDateMonth;
        this.payableDateYear=borrowDateYear+1;
        this.returnDateYear=0;
        this.returnDateMonth=0;
        this.returnDateDay=0;
    }
    public void returnBorrow(int returnDateYear,int returnDateMonth,int returnDateDay){
        this.isReturn=true;
        this.returnDateYear=returnDateYear;
        this.returnDateMonth=returnDateMonth;
        this.returnDateDay=returnDateDay;
    }
}

BorrowList

package library.borrow.borrowList;
import library.book.bookList.Book;
import library.book.bookList.BookList;

public class BorrowList {
    private Borrow[] borrows=new Borrow[100];
    int usedSize=0;
    public BorrowList(){

    }
    public void addBorrow(String stuID,String stuName,String bookSerialNumber,String bookName,int borrowDateYear,int borrowDateMonth,int borrowDateDay){
        borrows[usedSize] = new Borrow(stuID,stuName,bookSerialNumber,bookName,borrowDateYear,borrowDateMonth,borrowDateDay);
        usedSize+=1;
    }
    public int getUsedSize(){
        return usedSize;
    }
    public Borrow getBorrow(int pos){
        return borrows[pos];
    }
    public void returnBorrow(int index,int returnDateYear,int returnDateMonth,int returnDateDay){
        borrows[index].returnBorrow(returnDateYear,returnDateMonth,returnDateDay);
    }
}

BorrowOperation

package library.borrow.borrowOperation;

import library.book.bookList.Book;
import library.book.bookList.BookList;
import library.borrow.borrowList.BorrowList;
import library.reader.readerList.Reader;
import library.reader.readerList.ReaderList;

import java.util.Scanner;

public class BorrowOperation {
    public void work(BookList bookList, ReaderList readerList, BorrowList borrowList){
        System.out.println("请输入您的学号");
        Scanner scanner=new Scanner(System.in);
        String stuId=scanner.next();
        int index1=-1;
        int index2=-1;
        for (int i = 0; i < readerList.getUsedSize(); i++) {
            Reader reader=readerList.getReader(i);
            if(reader.getId().equals(stuId)){
                index1=i;
            }
        }
        System.out.println("请输入您要借阅的图书书号");
        String bookSerialNumber=scanner.next();
        for (int i = 0; i < bookList.getGetUsedSize(); i++) {
            Book book=bookList.getBook(i);
            if(book.getSerialNumber().equals(bookSerialNumber)){
                index2=i;
            }
        }
        if(index1==-1){
            System.out.println("抱歉，未找到您输入的学号");
            return;
        }
        if(index2==-1){
            System.out.println("抱歉，未找到您输入的书号");
            return;
        }
        if(bookList.getBook(index2).getNumber()>=1){
            System.out.println("抱歉，您要借阅的图书已被全部借出");
            return;
        }
        bookList.borrow(index2);
        System.out.println("请输入借书日期：");
        System.out.println("年：");
        int borrowDateYear=scanner.nextInt();
        System.out.println("月：");
        int borrowDateMonth = scanner.nextInt();
        System.out.println("日；");
        int borrowDateDay=scanner.nextInt();
        borrowList.addBorrow(stuId,readerList.getReader(index1).getName(),bookSerialNumber,bookList.getBook(index2).getName(),
                borrowDateYear,borrowDateMonth,borrowDateDay);
        System.out.println("图书借阅成功");
    }
}

DisplayOperation

package library.borrow.borrowOperation;

import library.borrow.borrowList.Borrow;
import library.borrow.borrowList.BorrowList;
import library.reader.readerList.ReaderList;

import java.util.Scanner;

public class DisplayOperation {
    Scanner scanner=new Scanner(System.in);
    public void work(BorrowList borrowList, ReaderList readerList){
        System.out.println("请选择查询方式");
        System.out.println("1.按学号查询");
        System.out.println("2.按书名查询");
        System.out.println("3.按学院查询");

        String choice=scanner.next();
        switch (choice){
            case "1": choiceByStdId(borrowList);
            case "2": choiceByBookName(borrowList);
            case "3": choiceByStuCollege(borrowList,readerList);
            default:System.out.println("您输入的选择不存在");
        }
    }

    private void choiceByStdId(BorrowList borrowList) {
        System.out.println("请输入您要查询的学号");
        String stuId= scanner.next();
        int[]index=new int[borrowList.getUsedSize()];
        int m=-1;
        for (int i = 0; i < borrowList.getUsedSize(); i++) {
            Borrow borrow=borrowList.getBorrow(i);
            if(borrow.getStuId().equals(stuId)){
                m+=1;
                index[m]=i;
            }
        }
        if(m==-1){
            System.out.println("您要查询的学号不存在");
            return;
        }
        for (int i = 0; i < m; i++) {
            System.out.println(borrowList.getBorrow(index[m]).toString());
        }
    }

    private void choiceByBookName(BorrowList borrowList) {
        System.out.println("请输入您要查询的书名");
        String bookName = scanner.next();
        int count = 0;
        for (int i = 0; i < borrowList.getUsedSize(); i++) {
            Borrow borrow=borrowList.getBorrow(i);
            if(borrow.getBookName().equals(bookName)){
                System.out.println(borrow.toString());
                count+=1;
            }
        }
        if(count==0){
            System.out.println("该图书未被借阅");
        }
    }

    private void choiceByStuCollege(BorrowList borrowList,ReaderList readerList) {
        System.out.println("请输入您要查询的学院");
        String stuCollege=scanner.next();
        int count1 = -1;
        String []stuId=new String[readerList.getUsedSize()];
        for (int i = 0; i < readerList.getUsedSize(); i++) {
            if(readerList.getReader(i).getCollege().equals(stuCollege)){
                count1++;
                stuId[count1]=readerList.getReader(i).getId();
            }
        }
        if(count1==-1){
            System.out.println("您要查询的学院不存在");
            return;
        }
        int count2=-1;
        for (int i = 0; i < count1; i++) {
            for (int i1 = 0; i1 < borrowList.getUsedSize(); i1++) {
                if(borrowList.getBorrow(i1).equals(stuId[i])){
                    System.out.println(borrowList.getBorrow(i1).toString());
                    count2++;
                }
            }
        }
        if(count2==-1){
            System.out.println("借阅表中没有您要查询的学院");
            return;
        }
    }
}

RetuenOperation

package library.borrow.borrowOperation;

import library.book.bookList.*;
import library.borrow.borrowList.*;
import library.reader.readerList.*;

import java.util.Scanner;

public class ReturnOperation {
    public void work(BorrowList borrowList) {
        System.out.println("请输入您的学号");
        Scanner scanner = new Scanner(System.in);
        String stuId = scanner.next();
        int index1 = -1;
        for (int i = 0; i < borrowList.getUsedSize(); i++) {
            Borrow borrow = borrowList.getBorrow(i);
            if (borrow.getStuId().equals(stuId)) {
                index1 = i;
            }
        }
        if (index1 == -1) {
            System.out.println("您输入的学号在借阅表中不存在");
            return;
        }
        System.out.println("请输入您要归还的图书书号");
        String bookSerialNumber = scanner.next();
        int index2 = -1;
        for (int i = 0; i < borrowList.getUsedSize(); i++) {
            Borrow borrow = borrowList.getBorrow(i);
            if (borrow.getBookName().equals(bookSerialNumber)) {
                index2 = i;
            }
        }
        if (index2 == -1) {
            System.out.println("您要找的图书在您的借阅表中不存在");
            return;
        }
        System.out.println("请输入归还时间");
        System.out.println("年：");
        int returnDateYear = scanner.nextInt();
        System.out.println("月：");
        int returnDateMonth = scanner.nextInt();
        System.out.println("日：");
        int returnDateDay = scanner.nextInt();
        System.out.println("是否归还（Y/N)");
        String choice = scanner.next();
        if (choice.equals("N") && choice.equals("n")) {
            System.out.println("归还失败");
            return;
        } else if (choice.equals("Y") && choice.equals("y")) {
            int index = -1;
            for (int i = 0; i < borrowList.getUsedSize(); i++) {
                Borrow borrow = borrowList.getBorrow(i);
                if (borrow.getStuId().equals(stuId) && borrow.getBookSerialNumber().equals(bookSerialNumber)) {
                    index = i;
                    break;
                }
            }
            if (index == -1) {
                System.out.println("您输入的学号或书号有误");
                return;
            }
            borrowList.returnBorrow(index, returnDateYear, returnDateMonth, returnDateDay);
        } else {
            System.out.println("请输入正确选项");
            return;
        }
    }
}

reader包

 Reader

package library.reader.readerList;

public class Reader {
    private String id;
    private String name;
    private String studentClass;
    private String college;
    public Reader(){
    }
    public Reader(String id,String name,String studentClass,String college){
        this.id=id;
        this.name=name;
        this.studentClass=studentClass;
        this.college=college;
    }
    public void setId(String id){
        this.id=id;
    }
    public void setName(String name){
        this.name=name;
    }
    public void setStudentClass(String studentClass){
        this.studentClass=studentClass;
    }
    public void setCollege(String college){
        this.college=college;
    }
    public String getId(){
        return this.id;
    }
    public String getName(){
        return this.name;
    }
    public String getCollege(){
        return this.college;
    }
    public String toString(){
        return "Reader.reader{"+
                "学号：'"+id+'\''+
                "姓名：'"+name+'\''+
                "班级：'"+studentClass+'\''+
                "学院：'"+college+'\''+
                '}';
    }
}

ReaderList

package library.reader.readerList;

import library.book.bookList.Book;

public class ReaderList {
    private Reader[] readers=new Reader[100];
    private int usedSize=0;
    public ReaderList(){
        readers[0]=new Reader("001","wj","10","信息学院");
        readers[1]=new Reader("002","ww","11","经管学院");
        usedSize=2;
    }
    public int getUsedSize(){
        return usedSize;
    }
    public Reader getReader(int pos) {
        return readers[pos];
    }

    public void setReader(Reader reader) {
        this.readers[usedSize]=reader;
        usedSize+=1;
    }
    public void remove(int pos){
        for (int i = pos; i < readers.length; i++) {
            readers[pos]=readers[pos+1];
            usedSize-=1;
        }
    }

    public void idSort() {
        int[] is = new int[readers.length];
        for (int i = 0; i < readers.length; i++) {
            is[i] = 0;
            int m = 1;
            for (int i1 = readers[i].getId().length(); i1 >= 0; i1--) {
                is[i] += readers[i].getId().charAt(i1) * m;
                m = m * 10;
            }
        }
        for (int i = 0; i < readers.length - 1; i++) {
            for (int j = 0; j < readers.length - 1 - i; j++) {
                if (is[i] > is[i + 1]) {
                    int t = is[i];
                    is[i] = is[i + 1];
                    is[i + 1] = t;
                    Reader tempReader = readers[i];
                    readers[i] = readers[i + 1];
                    readers[i + 1] = tempReader;
                }
            }
        }
    }

}

AddOperation

package library.reader.readerOperation;

import library.reader.readerList.Reader;
import library.reader.readerList.ReaderList;

import java.util.Scanner;

public class AddOperation {
    public void work(ReaderList readerList){
        boolean flag1=true;
        Scanner scanner=new Scanner(System.in);
        String id=null;
        while (flag1) {
            flag1=false;
            System.out.println("请输入要添加的学号");
            id=scanner.next();
            for (int i = 0; i < readerList.getUsedSize(); i++) {
                if(readerList.getReader(i).equals(id)){
                    System.out.println("学号重复请重新输入");
                    flag1=true;
                }
            }
        }
        System.out.println("请输入学生姓名");
        String name=scanner.next();
        System.out.println("请输入学生班级");
        String studentClass=scanner.next();
        System.out.println("请输入学生学院");
        String college=scanner.next();
        Reader reader=new Reader(id,name,studentClass,college);
        readerList.setReader(reader);
    }
}

DeleteOperation

package library.reader.readerOperation;

import library.reader.readerList.Reader;
import library.reader.readerList.ReaderList;

import java.util.Scanner;

public class DeleteOperation {
    public void work(ReaderList readerList){
        System.out.println("请输入要删除的学生学号");
        Scanner scanner=new Scanner(System.in);
        String id=scanner.next();
        int index=-1;
        for (int i = 0; i < readerList.getUsedSize(); i++) {
            Reader reader=readerList.getReader(i);
            if(reader.getId().equals(id)){
                index=getIndex(i);
                break;
            }
        }
        if(index==-1){
            System.out.println("未找到要删除的学生学号");
            return;
        }
        readerList.remove(index);
    }
    public int getIndex(int i){
        int index=i;
        return index;
    }
}

DisplayOperation

package library.reader.readerOperation;

import library.reader.readerList.ReaderList;
import library.reader.readerList.Reader;
public class DisplayOperation {
    public void work(ReaderList readerList){
        System.out.println("显示学生信息");
        for (int i = 0; i < readerList.getUsedSize(); i++) {
            Reader reader=readerList.getReader(i);
            reader.toString();
        }
    }
}

 FindOperation

package library.reader.readerOperation;

import library.reader.readerList.ReaderList;
import library.reader.readerList.Reader;
import java.util.Scanner;

public class FindOperation {
    public void work(ReaderList readerList){
        System.out.println("请输入要查询的学生学号");
        Scanner scanner=new Scanner(System.in);
        String id=scanner.next();
        int index=-1;
        for (int i = 0; i < readerList.getUsedSize(); i++) {
            Reader reader=readerList.getReader(i);
            if(reader.getId().equals(id)){
                index=i;
                break;
            }
        }
        if(index==-1){
            System.out.println("您要找的学生学号不存在");
            return;
        }
        System.out.println("你要找的学生信息如下：");
        readerList.getReader(index).toString();
    }
}

ReviveOperation

package library.reader.readerOperation;

import library.reader.readerList.ReaderList;
import library.reader.readerList.Reader;
import java.util.Scanner;

public class ReviveOperation {
    public void work(ReaderList readerList){
        System.out.println("请输入要修改的学生学号");
        Scanner scanner=new Scanner(System.in);
        String id=scanner.next();
        System.out.println("请输入要修改的学生姓名");
        String name=scanner.next();
        int index=-1;
        for (int i = 0; i < readerList.getUsedSize(); i++) {
            Reader reader=readerList.getReader(i);
            if(reader.getId().equals(id)){
                index=i;
            }
        }
        if(!readerList.getReader(index).getName().equals(name)){
            index=-2;
        }
        if(index==-1){
            System.out.println("您要修改的学生学号不存在");
            return;
        }
        if (index == -2) {
            System.out.println("您输入的学生学号与学生姓名不匹配");
            return;
        }
        System.out.println("请输入要修改的学生学号");
        String newId=scanner.next();
        readerList.getReader(index).setId(newId);
        System.out.println("请输入要修改的学生姓名");
        String newName=scanner.next();
        readerList.getReader(index).setId(newName);
        System.out.println("请输入要修改的学生班级");
        String newStudentClass=scanner.next();
        readerList.getReader(index).setId(newStudentClass);
        System.out.println("请输入要修改的学生学院");
        String newCollege=scanner.next();
        readerList.getReader(index).setId(newCollege);
        System.out.println("学生信息修改成功");
    }
}

SortOperation

package library.reader.readerOperation;

import library.reader.readerList.Reader;
import library.reader.readerList.ReaderList;

public class SortOperation {
    public void work(ReaderList readerList){
        readerList.idSort();
        System.out.println("按学号排序后，结果如下：");
        for (int i = 0; i < readerList.getUsedSize(); i++) {
            System.out.println(readerList.getReader(i).toString());
        }
    }
}

user包

AdminUser

package user;

import library.book.bookList.BookList;
import library.book.bookOperation.*;
import library.reader.readerList.ReaderList;
import library.reader.readerOperation.ReviveOperation;

import java.util.Scanner;

public class AdminUser {
    public AdminUser(String ID, BookList bookList, ReaderList readerList) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("管理员" + ID + "欢迎使用图书管理系统");
        boolean flag=true;
        while (flag) {
            System.out.println("请选择您要执行的操作");
            System.out.println("1.添加图书");
            System.out.println("2.删除图书");
            System.out.println("3.修改图书");
            System.out.println("4.查找图书");
            System.out.println("5.阅览图书信息");
            System.out.println("6.图书排序");
            System.out.println("7.添加读者");
            System.out.println("8.删除读者");
            System.out.println("9.修改读者");
            System.out.println("10.查找读者");
            System.out.println("11.阅览读者信息");
            System.out.println("12.读者排序");
            System.out.println("0.退出");
            String choice = scanner.next();
            switch (choice) {
                case "1" -> {
                    AddOperation addOperation = new AddOperation();
                    addOperation.work(bookList);
                }
                case "2" -> {
                    DeleteOperation deleteOperation = new DeleteOperation();
                    deleteOperation.work(bookList);
                }
                case "3" -> {
                    ReviseOperation reviseOperation = new ReviseOperation();
                    reviseOperation.work(bookList);
                }
                case "4" -> {
                    FindOperation findOperation = new FindOperation();
                    findOperation.work(bookList);
                }
                case "5" -> {
                    DisplayOperation displayOperation = new DisplayOperation();
                    displayOperation.work(bookList);
                }
                case "6" -> {
                    SortOperation sortOperation = new SortOperation();
                    sortOperation.work(bookList);
                }
                case "7" -> {
                    library.reader.readerOperation.AddOperation addOperation = new library.reader.readerOperation.AddOperation();
                    addOperation.work(readerList);
                }
                case "8" -> {
                    library.reader.readerOperation.DeleteOperation deleteOperation = new library.reader.readerOperation.DeleteOperation();
                    deleteOperation.work(readerList);
                }
                case "9" -> {
                    ReviveOperation reviveOperation = new ReviveOperation();
                    reviveOperation.work(readerList);
                }
                case "10" -> {
                    library.reader.readerOperation.FindOperation findOperation = new library.reader.readerOperation.FindOperation();
                    findOperation.work(readerList);
                }
                case "11" -> {
                    library.reader.readerOperation.DisplayOperation displayOperation = new library.reader.readerOperation.DisplayOperation();
                    displayOperation.work(readerList);
                }
                case "12" -> {
                    library.reader.readerOperation.SortOperation sortOperation = new library.reader.readerOperation.SortOperation();
                    sortOperation.work(readerList);
                }
                case "0" -> flag=false;
                default -> System.out.println("没有您输入的选项");
            }
        }
    }
}

BorrowAndRetuenMenu

package user;

import library.book.bookList.BookList;
import library.book.bookOperation.SortOperation;
import library.borrow.borrowList.BorrowList;
import library.borrow.borrowOperation.BorrowOperation;
import library.borrow.borrowOperation.DisplayOperation;
import library.borrow.borrowOperation.ReturnOperation;
import library.reader.readerList.ReaderList;

import java.util.Scanner;

public class BorrowAndReturnMenu {
    public void work(BookList bookList, BorrowList borrowList, ReaderList readerList) {
        System.out.println("请选择您要执行的操作");
        Scanner scanner = new Scanner(System.in);
        System.out.println("1.借阅图书");
        System.out.println("2.归还图书");
        System.out.println("3.图书借阅查询");
        System.out.println("4.阅览图书信息");
        System.out.println("5.图书排序");
        System.out.println("0.退出");
        String choice = scanner.next();
        switch (choice) {
            case "1" -> {
                BorrowOperation borrowOperation = new BorrowOperation();
                borrowOperation.work(bookList, readerList, borrowList);
            }
            case "2" -> {
                ReturnOperation returnOperation = new ReturnOperation();
                returnOperation.work(borrowList);
            }
            case "3" -> {
                DisplayOperation displayOperation = new DisplayOperation();
                displayOperation.work(borrowList, readerList);
            }
            case "4" -> {
                library.book.bookOperation.DisplayOperation displayOperation = new library.book.bookOperation.DisplayOperation();
                displayOperation.work(bookList);
            }
            case "5" -> {
                SortOperation sortOperation = new SortOperation();
                sortOperation.work(bookList);
            }
            case "0" -> System.exit(0);
            default -> {
                System.out.println("没有您输入的选项");
                System.exit(0);
            }
        }
    }
}

main

import library.admin.adminList.AdminList;
import library.admin.adminOperation.LoginOperation;
import library.book.bookList.BookList;
import library.borrow.borrowList.BorrowList;
import library.reader.readerList.ReaderList;
import user.BorrowAndReturnMenu;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        while (true) {
            System.out.println("========================");
            System.out.println("欢迎来到图书管理系统");
            System.out.println("请输入您的选择");
            System.out.println("1.管理员登录");
            System.out.println("2.图书借阅与归还");
            System.out.println("0.退出程序");
            System.out.println("========================");
            String choice=scanner.next();
            AdminList adminList=new AdminList();
            BookList bookList=new BookList();
            BorrowList borrowList=new BorrowList();
            ReaderList readerList=new ReaderList();
            switch (choice){
                case "1"->{adminLogin(adminList,bookList,readerList);}
                case "2"->{borrowAndReturn(bookList,borrowList,readerList);}
                case "0"->{System.exit(0);}
                default->System.out.println("请输入正确选项");
            }
        }
    }

    private static void adminLogin(AdminList adminList,BookList bookList,ReaderList readerList) {
        LoginOperation loginOperation = new LoginOperation();
        loginOperation.work(adminList,bookList,readerList);
    }
    private static void borrowAndReturn(BookList bookList,BorrowList borrowList,ReaderList readerList) {
        BorrowAndReturnMenu borrowAndReturnMenu=new BorrowAndReturnMenu();
        borrowAndReturnMenu.work(bookList,borrowList,readerList);
    }
}