【Java】IO流实现图书管理系统

我认为这些功能应分为读者操作和管理员操作。

其中，读者操作界面：

管理员操作界面：

因此，应该同时设计首页，包含登录和注册功能，用来判断身份， 进入相应界面：

调用相应方法实现这些功能，并且在方法体中应以 return; 的方式结束当前方法（退出当前页面） 

对基本信息的设计如下：

设计完这些基本信息和操作后，在LibraryTest完成 。

把集合定义在main方法外，用public static修饰，整个类都可以使用；

对于需要排序的集合，直接定义成TreeMap类自动排序，在类中重写排序方法；

IO流在main方法中使用，定义一对序列化IO流输入和输出管道（一定只能是一对，否则会错）。

依次指向不同文件进行对象信息的输入输出；

LibraryTest类：

package wryyyyy;

import java.io.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

public class LibraryTest
{
    //存储用户对象
    public static Set ALL_USERS = new HashSet<>();
    //存储读者和借书信息
    public static Map> READERS_BOOKS = new TreeMap<>();
    //存储图书借阅信息
    public static Set ALL_IN_LEND = new HashSet<>();
    //存储图书信息
    public static Map ALL_BOOKS = new TreeMap<>();
    //定义扫描器
    public static final Scanner SYS_SC = new Scanner(System.in);
    //记录一个登录对象
    public static User loginUser;
    //日期格式化
    public static SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
    //准备测试数据
    static
    {
//        public Reader(String name,String number,String password,String academic, String subject, String gradeAndClass)
        Reader c1 = new Reader();
        c1.setName("wryyyyy");
        c1.setNumber("2022523");
        c1.setPassWord("123456");
        c1.setAcademic("信息学院");
        c1.setSubject("计算机");
        c1.setGradeAndClass("21-01");
        ALL_USERS.add(c1);
        Set lends1 = new HashSet<>();
        READERS_BOOKS.put(c1,lends1);

        Manager b1 = new Manager();
        b1.setName("wry");
        b1.setNumber("2021285");
        b1.setPassWord("098765");
        ALL_USERS.add(b1);

//        public Book(String name, String number, String author, String press, String data, double price)
        Book a1 = new Book();
        a1.setName("大学物理");
        a1.setNumber("B-123");
        a1.setAuthor("作者1");
        a1.setPress("人民出版社");
        a1.setData("2021/10");
        a1.setContain(50);
        a1.setPrice(59.8);
        ALL_BOOKS.put(a1,100);
    }


    public static void main(String[] args) throws IOException, ClassNotFoundException
    {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src/wryyyyy/ALL_BOOKS.txt"));
        Object o1 = ois.readObject();
        ALL_BOOKS = (TreeMap)o1;

        ois = new ObjectInputStream(new FileInputStream("src/wryyyyy/ALL_USERS"));
        Object o2 = ois.readObject();
        ALL_USERS = (Set)o2;

        ois = new ObjectInputStream(new FileInputStream("src/wryyyyy/ALL_IN_LEND"));
        Object o3 = ois.readObject();
        ALL_IN_LEND = (Set) o3;

        ois = new ObjectInputStream(new FileInputStream("src/wryyyyy/READERS_BOOKS"));
        Object o4 = ois.readObject();
        READERS_BOOKS = (TreeMap>)o4;
        Set readers = READERS_BOOKS.keySet();

        showMain();

        System.out.println("-----------------");

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src/wryyyyy/ALL_BOOKS.txt"));
        oos.writeObject(ALL_BOOKS);
        oos = new ObjectOutputStream(new FileOutputStream("src/wryyyyy/ALL_USERS"));
        oos.writeObject(ALL_USERS);
        oos = new ObjectOutputStream(new FileOutputStream("src/wryyyyy/ALL_IN_LEND"));
        oos.writeObject(ALL_IN_LEND);
        oos = new ObjectOutputStream(new FileOutputStream("src/wryyyyy/READERS_BOOKS"));
        oos.writeObject(READERS_BOOKS);

        System.out.println("-------------------");
    }

    private static void showMain()//主页面
    {
        while (true)
        {
            System.out.println("=================进入首页================");
            System.out.println("1.登录");
            System.out.println("2.读者注册");
            System.out.println("3.管理员注册");
            System.out.println("4.退出系统");
            System.out.println("请输入操作命令");
            String command = SYS_SC.nextLine();
            switch (command)
            {
                case "1":
                    login();
                    break;//break之后回到首页
                case "2":
                    addReader();
                    break;
                case "3":
                    addManager();
                    break;
                case "4":
                    return;
                default:
                    System.out.println("命令有误！请确认");
            }
        }
    }

    private static void login()//登录
    {
        while (true)
        {
            System.out.println("请输入登录名称：");
            String loginName = SYS_SC.nextLine();
            System.out.println("请输入登录密码（6位数字）：");
            String passWord = SYS_SC.nextLine();

            User u = getUserByLoginName(loginName);

            if(u!=null)
            {
                if(u.getPassWord().equals(passWord))
                {
                    loginUser = u;
                    if(u instanceof Manager)
                    {
                        showManagerMain();
                    }
                    else
                    {
                        showReaderMain();
                    }
                }
                else
                {
                    System.out.println("密码错误");
                }
            }
            else
            {
                System.out.println("登录名称错误，请确认！");
            }
            return;//方法执行完之后，结束login回到首页（Switch那里）
        }
    }

    private static void showReaderMain()//展示读者界面
    {
        System.out.println("============读者页面=============");
        System.out.println("欢迎"+loginUser.getName()+"进入");
        System.out.println("1.展示读者详情");//读者信息查询
        System.out.println("2.浏览图书馆所有图书");
        System.out.println("3.查询图书");
        System.out.println("4.借书");
        System.out.println("5.还书");
        System.out.println("6.退出");

        while (true)
        {
            System.out.println("请输入命令：");
            String command = SYS_SC.nextLine();
            switch (command)
            {
                case "1":
                    showReaderDetail();//ok
                    break;
                case "2":
                    scanBook();//ok
                    break;
                case "3":
                    inquireBook();//ok
                    break;
                case "4":
                    borrowBook();
                    break;
                case "5":
                    returnBook();
                    break;
                case "6":
                    return;//干掉这个方法
                default:
                    System.out.println("不存在该命令！");
                    break;
            }
        }
    }

    private static void showManagerMain()//管理员界面
    {
        System.out.println("==============管理员界面==============");
        //浏览全部信息
        System.out.println("1.浏览图书馆所有图书");
        System.out.println("2.浏览图书借阅表");
        System.out.println("3.浏览读者信息表");
        //图书操作
        System.out.println("4.添加图书");
        System.out.println("5.查询图书");//ok
        System.out.println("6.图书下架");
        System.out.println("7.图书修改");//ok
        System.out.println("8.图书排序");
        //读者操作
        System.out.println("9.添加读者信息");
        System.out.println("10.注销读者账号");
        System.out.println("11.读者信息修改");//ok
        System.out.println("12.读者信息排序");
        System.out.println("13.读者信息查询");//ok
        //退出
        System.out.println("14.退出");

        while (true)
        {
            System.out.println("请输入命令：");
            String command = SYS_SC.nextLine();
            switch (command)
            {
                case "1":
                    scanBook();//ok
                    break;
                case "2":
                    bookLendInformation();//ok
                    break;
                case "3":
                    readerInformation();//ok
                    break;
                case "4":
                    addBook();//ok
                    break;
                case "5":
                    inquireBook();//ok
                    break;
                case "6":
                    Book book = new Book();//ok
                    Set books = ALL_BOOKS.keySet();
                    deleteBook();
                    break;
                case "7":
                    updateBook();//ok
                    break;
                case "8":
                    sortBook();//ok
                    break;
                case "9":
                    addReader();//ok
                    break;
                case "10":
                    Reader reader = new Reader();//ok
                    Set readers = READERS_BOOKS.keySet();
                    deleteReader();
                    break;
                case "11":
                    updateReader();//ok
                    break;
                case "12":
                    sortReader();//ok
                    break;
                case "13":
                    inquirerReader();//ok
                    break;
                case "14":
                    return;//ok
                default:
                    System.out.println("不存在该命令！");
                    break;
            }
        }
    }

    private static void borrowBook()//借出图书
    {
        //现存数量大于0可以借出（get value值）ok
        //借出后修改图书信息表中现存数量（修改value值）ok
        //名字添加到图书借阅表，个人信息表也写上->lend对象 ok
        while (true)
        {
            System.out.println("==================图书借阅==================");
            System.out.println("请输入书号/书名：");
            String input = SYS_SC.nextLine();
            Book book = getBookByInput(input);
            System.out.println(book);
            if(book!=null)
            {
                if(ALL_BOOKS.get(book)>0)
                {
                    System.out.println("是否确认借出y/n");
                    String choice = SYS_SC.nextLine();
                    if (Objects.equals(choice,"y"))
                    {
                        ALL_BOOKS.put(book,ALL_BOOKS.get(book)-1);
                        Date d = new Date();
                        long time = d.getTime();
                        String TimeFrom = sdf.format(time);
                        Lend lend = new Lend(book,(Reader) loginUser,TimeFrom,null);
                        READERS_BOOKS.get((Reader)loginUser).add(lend);
                        READERS_BOOKS.put((Reader) loginUser,READERS_BOOKS.get((Reader)loginUser));
//                        ALL_IN_LEND.addAll(READERS_BOOKS.get((Reader)loginUser));
                        ALL_IN_LEND.add(lend);
                        System.out.println("借阅成功！");
//                        System.out.println(ALL_BOOKS.get(book));
//                        System.out.println(READERS_BOOKS.get(loginUser));
                    }
                }
                else
                {
                    System.out.println("该图书以被借空，请一段时间后再来。");
                }
            }
            else
            {
                System.out.println("馆内没有该图书！");
            }
            System.out.println("请问是否继续?y/n");
            String command = SYS_SC.nextLine();
            switch (command)
            {
                case "y":
                    break;
                default:
                    System.out.println("好的！");
                    return;
            }
        }
    }
    private static void returnBook()//归还图书
    {
        while (true)
        {
            System.out.println("==================图书归还==================");
            System.out.println("请输入书号/书名：");
            String input = SYS_SC.nextLine();
            Book book = getBookByInput(input);
            System.out.println(book);
            Lend lend = getLendInformationByBook(book);
            if (lend!=null)
            {
                System.out.println("是否确认归还y/n");
                String choice = SYS_SC.nextLine();
                if (Objects.equals(choice,"y"))
                {
                    ALL_BOOKS.put(book,ALL_BOOKS.get(book)+1);
                    Date d = new Date();
                    long time = d.getTime();
                    String TimeTo = sdf.format(time);
                    lend.setTime_to(TimeTo);
                    ALL_BOOKS.put(book,ALL_BOOKS.get(book));

                    Lend lend1 = getLendInformationByBook1(book);
                    ALL_IN_LEND.add(lend);
//                    ALL_IN_LEND.remove(lend1);
                }
            }
            else
            {
                System.out.println("您没有借阅该书！");
            }
            System.out.println("请问是否继续?y/n");
            String command = SYS_SC.nextLine();
            switch (command) {
                case "y":
                    break;
                default:
                    System.out.println("好的！");
                    return;
            }
        }
    }

    private static void addBook()//上架图书
    {
        while (true)
        {
            System.out.println("===============添加图书================");
            System.out.println("请输入书名：");
            String name = SYS_SC.nextLine();
            System.out.println("请输入书号（例如：A-023）：");
            String number = SYS_SC.nextLine();
            System.out.println("请输入作者：");
            String author = SYS_SC.nextLine();
            System.out.println("请输入出版社：");
            String press = SYS_SC.nextLine();
            System.out.println("请输入出版时间（例如2021/12）：");
            String date = SYS_SC.nextLine();
            System.out.println("请输增加后的馆存数量：");
            String add_contain = SYS_SC.nextLine();
            System.out.println("请输入价格：");
            String price = SYS_SC.nextLine();
//            public Book(String name, String number, String author, String press, String data, int contain, double price)
            Book book = new Book(name,number,author,press,date,Integer.valueOf(add_contain),Double.valueOf(price));
            ALL_BOOKS.put(book,Integer.valueOf(add_contain));
            System.out.println(book);
            System.out.println("上架成功：《"+book.getName()+"》");
            System.out.println("请问是否继续?y/n");
            String command = SYS_SC.nextLine();
            switch (command)
            {
                case "y":
                    break;
                default:
                    System.out.println("好的！");
                    return;
            }
        }
    }
    private static void addReader()//添加读者
    {
        while (true)
        {
            System.out.println("===============添加读者================");
            System.out.println("请输入读者名：");
            String name = SYS_SC.nextLine();
            System.out.println("请输入读者学号（7位数字）：");
            String number = SYS_SC.nextLine();
            System.out.println("请设置读者登录密码（6位数子）：");
            String password = SYS_SC.nextLine();
            System.out.println("请输入学院（信息学院,机械电子学院,经管学院,林学院,外国语学院,动科学院,资环学院：");
            String academic = SYS_SC.nextLine();
            System.out.println("请输入专业：");
            String subject = SYS_SC.nextLine();
            System.out.println("请输入年级和班级（如21-10）：");
            String GradeAndClass = SYS_SC.nextLine();
            Reader reader = new Reader(name,number,password,academic,subject,GradeAndClass);
            Set personal_lend = new HashSet<>();
            ALL_USERS.add(reader);
            READERS_BOOKS.put(reader,personal_lend);
            System.out.println("添加成功："+reader.getName());
            System.out.println("请问是否继续?y/n");
            String command = SYS_SC.nextLine();
            switch (command)
            {
                case "y":
                    break;
                default:
                    System.out.println("好的！");
                    return;
            }
        }
    }

    private static void addManager()//添加管理员
    {
        System.out.println("===============添加管理员================");
        System.out.println("请输入姓名：");
        String name = SYS_SC.nextLine();
        System.out.println("请输入工号（7）：");
        String number = SYS_SC.nextLine();
        System.out.println("请设置登录密码（6位数）：");
        String password = SYS_SC.nextLine();
        Manager manager = new Manager(name,number,password);
        ALL_USERS.add(manager);
        System.out.println("添加成功："+manager.getName());
    }
    private static void inquireBook()//图书查询
    {
        System.out.println("===================查询图书信息==================");
        while (true)
        {
            System.out.println("请输入书名/书号/作者/出版社");
            String search = SYS_SC.nextLine();
            Set books = ALL_BOOKS.keySet();
            for (Book book : books)
            {
                if (book.getName().contains(search)||book.getNumber().contains(search)
                        ||book.getAuthor().contains(search)||book.getPress().contains(search))
                {
                    System.out.println(book);
                }
            }
            System.out.println("查询完毕");
            System.out.println("请问是否继续?y/n");
            String command = SYS_SC.nextLine();
            switch (command)
            {
                case "y":
                    break;
                default:
                    System.out.println("好的！");
                    return;
            }
        }
    }
    private static void inquirerReader()//更改读者信息
    {
        System.out.println("===================查询读者信息==================");
        while (true)
        {
            System.out.println("请输入姓名/学号/专业");
            String search = SYS_SC.nextLine();
            Set readers = READERS_BOOKS.keySet();
            for (Reader reader : readers)
            {
                if (reader.getName().contains(search)||reader.getNumber().contains(search)
                        ||reader.getSubject().contains(search))
                {
                    System.out.println(reader);
                }
            }
            System.out.println("查询完毕");
            System.out.println("请问是否继续?y/n");
            String command = SYS_SC.nextLine();
            switch (command)
            {
                case "y":
                    break;
                default:
                    System.out.println("好的！");
                    return;
            }
        }
    }
    private static void deleteBook()//下架图书
    {
        while (true)
        {
            System.out.println("===============下架图书================");
            if (ALL_BOOKS.size() == 0)
            {
                System.out.println("当前无图书可下架");
            }
            System.out.println("请输入需要下架图书的名称/书号：");
            String input = SYS_SC.nextLine();
            Book x2 = getBookByInput(input);
            if(x2 != null)
            {
                ALL_BOOKS.remove(x2);
                System.out.println("您已成功删除了" + x2.getName());
            }
            else
            {
                System.out.println("馆内没有该图书");
            }
            System.out.println("请问是否继续?y/n");
            String command = SYS_SC.nextLine();
            switch (command)
            {
                case "y":
                    break;
                default:
                    System.out.println("好的！");
                    return;
            }
        }
    }

    private static void deleteReader()//注销读者账号
    {
        while (true)
        {
            System.out.println("===============删除读者信息================");
            if (READERS_BOOKS.size() == 0)
            {
                System.out.println("当前无读者信息可删除");
            }
            System.out.println("请输入需要删除读者的名称：");
            String name = SYS_SC.nextLine();
            Reader x1 = (Reader) getUserByLoginName(name);
            if(x1 != null)
            {
                READERS_BOOKS.remove(x1);
                System.out.println("您已成功删除了" + x1.getName());
                System.out.println(READERS_BOOKS);
            }
            else
            {
                System.out.println("没有该读者的信息");
            }
            System.out.println("请问是否继续?y/n");
            String command = SYS_SC.nextLine();
            switch (command)
            {
                case "y":
                    break;
                default:
                    System.out.println("好的！");
                    return;
            }
        }
    }

    private static void updateBook()//修改图书信息
    {
        System.out.println("===============修改图书================");
        if (ALL_BOOKS.size() == 0)
        {
            System.out.println("当前无作品可修改");
            return;
        }
        while (true)
        {
            System.out.println("请输入需要修改的图书名称/书号：");
            String input = SYS_SC.nextLine();

            Book book = getBookByInput(input);
            if (book != null)
            {
                System.out.println("请输入修改后书名：");
                String name = SYS_SC.nextLine();
                System.out.println("请输入修改后书号（例如：A-023）：");
                String number = SYS_SC.nextLine();
                System.out.println("请输入修改后作者：");
                String author = SYS_SC.nextLine();
                System.out.println("请输入修改后出版社：");
                String press = SYS_SC.nextLine();
                System.out.println("请输入修改后出版时间（例如2021/12）：");
                String date = SYS_SC.nextLine();
//                System.out.println("请输入该图书总馆存数量：");
//                int contain = SYS_SC.nextInt();
                System.out.println("请输入修改后价格：");
                String price = SYS_SC.nextLine();
                Book book1 = new Book(name,number,author,press,date, book.getContain(), Double.valueOf(price));
                ALL_BOOKS.put(book1,ALL_BOOKS.get(book));
                System.out.println("修改成功!");
                ALL_BOOKS.remove(book);
            }
            else
            {
                System.out.println("馆内没有该图书");
            }
            System.out.println("请问是否继续?y/n");
            String command = SYS_SC.nextLine();
            switch (command)
            {
                case "y":
                    break;
                default:
                    System.out.println("好的！");
                    return;
            }
        }
    }
    private static void updateReader()//修改读者信息
    {
        System.out.println("===============修改读者信息================");
        if (ALL_BOOKS.size() == 0)
        {
            System.out.println("当前无读者可修改");
            return;
        }
        while (true)
        {
            System.out.println("请输入需要修改的读者名称：");
            String readerName = SYS_SC.nextLine();

            Reader reader = (Reader) getUserByLoginName(readerName);
            ALL_USERS.remove(reader);

            if (reader != null)
            {
                System.out.println("请输入修改后读者名：");
                String name = SYS_SC.nextLine();
                System.out.println("请输入修改后读者学号（7位数字）：");
                String number = SYS_SC.nextLine();
                System.out.println("请重新设置读者登录密码（6位数字）：");
                String password = SYS_SC.nextLine();
                System.out.println("请输入修改后学院：");
                String academic = SYS_SC.nextLine();
                System.out.println("请输入修改后专业：");
                String subject = SYS_SC.nextLine();
                System.out.println("请输入修改后年级和班级（如21-04）：");
                String GradeAndClass = SYS_SC.nextLine();
                Reader reader1 = new Reader(name,number,password,academic,subject,GradeAndClass);
                ALL_USERS.add(reader1);
                READERS_BOOKS.put(reader1,READERS_BOOKS.get(reader));
                READERS_BOOKS.remove(reader);
            }
            else
            {
                System.out.println("没有该读者相关信息");
            }
            System.out.println("请问是否继续?y/n");
            String command = SYS_SC.nextLine();
            switch (command)
            {
                case "y":
                    break;
                default:
                    System.out.println("好的！");
                    return;
            }
        }
    }
    private static void sortReader()//TreeMap集合会自动排序，以重写排序规则
    {
        System.out.println("读者信息排序完成！");
    }
    private static void sortBook()//TreeMap集合会自动排序，以重写排序规则
    {
        System.out.println("完成排序！");
    }
    private static void readerInformation()//全部读者信息
    {
        System.out.println("======================读者信息表===================");
        Set readers = READERS_BOOKS.keySet();
        for (Reader reader : readers)
        {
            System.out.println(reader);
        }
    }
    private static void bookLendInformation()//全部图书借阅信息
    {
        System.out.println("======================图书借阅表===================");
        for (Lend lend : ALL_IN_LEND)
        {
            System.out.println(lend);
        }
    }
    private static void scanBook()//浏览全部图书
    {
        System.out.println("===================图书信息表===================");
        //提取键值
        Set books = ALL_BOOKS.keySet();
        for (Book book : books)
        {
             System.out.println(book+"  现有数量："+ALL_BOOKS.get(book));
        }

    }

    public static User getUserByLoginName(String loginName)//根据用户姓名确定对象
    {
        for (User allUser : ALL_USERS)
        {
            if (Objects.equals(allUser.getName(),loginName))
            {
                return allUser;
            }
        }
        return null;
    }

    public static void showReaderDetail()//展示读者个人详情
    {
        System.out.println("=============="+loginUser.getName()+"的个人主页"+"==============");
        Reader reader = (Reader) loginUser;
        System.out.println(reader.getName()+"tt"+reader.getNumber());
        Set lends = READERS_BOOKS.get(loginUser);
        if (lends.size()>0)
        {
            System.out.println("书名ttt书号tt借出时间tt归还时间");
            for (Lend lend : lends)
            {
                System.out.println(lend.getBook_in_lend().getName()+"ttt"+lend.getBook_in_lend().getNumber()+"ttt"
                        +lend.getTime_from()+"ttt"+lend.getTime_to());
            }
        }
        else
        {
            System.out.println("当前没有记录");
        }
    }

    public static Lend getLendInformationByBook(Book book)//获取个人借书信息
    {
        Set lends = READERS_BOOKS.get(loginUser);
        if (lends.size()>0)
        {
            for (Lend lend : lends)
            {
                if (Objects.equals(book.getName(),lend.getBook_in_lend().getName()))
                {return lend;}
            }
        }
        return null;
    }
    public static Lend getLendInformationByBook1(Book book)
    {
        for (Lend lend : ALL_IN_LEND)
        {
            if (lend.getBook_in_lend().getName().contains(book.getName()))
            {
                return lend;
            }
        }
        return null;
    }
    public static Book getBookByInput(String InPut)//通过书名/书号获取图书对象
    {
        Set books = ALL_BOOKS.keySet();
        for (Book book : books)
        {
            if (book.getName().contains(InPut)||book.getNumber().contains(InPut))
                return book;
        }
        return null;
    }
}

基本元素类（作为父类被继承）： 

package wryyyyy;

import java.io.Serializable;

public class Element implements Serializable
{
    private String name;
    private String number;

    public Element(String name, String number) {
        this.name = name;
        this.number = number;
    }

    public Element() {
    }

    public String getName() {
        return name;
    }

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

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }
}

 图书信息类：

package wryyyyy;

import java.io.Serializable;
import java.util.*;

public class Book extends Element implements Comparable, Serializable
{
    private String author;
    private String press;
    private String data;
    private int contain;
    private double price;

    public Book(String name, String number, String author, String press, String data, int contain, double price) {
        super(name, number);
        this.author = author;
        this.press = press;
        this.data = data;
        this.contain = contain;
        this.price = price;
    }

    public Book() {
    }

    public String getAuthor() {
        return author;
    }

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

    public String getPress() {
        return press;
    }

    public void setPress(String press) {
        this.press = press;
    }

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }

    public int getContain() {
        return contain;
    }

    public void setContain(int contain) {
        this.contain = contain;
    }

    public double getPrice() {
        return price;
    }

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

    @Override
    public String toString() {
        return "书名："+this.getName()+"  书号："+this.getNumber()+"  作者："+author+"  出版社："+press+
                "  出版时间："+data+"  馆存数量："+contain+"  价格："+price;
    }

    //重写hashCode?


    @Override
    public int compareTo(Book o)
    {
        for (int i = 0; i < 5; i++)
        {
            if (Objects.equals((int)o.getNumber().charAt(i),(int)this.getNumber().charAt(i)))
            {
                continue;
            }
            else
            {
                return (int)o.getNumber().charAt(i)-(int)this.getNumber().charAt(i)>0?-1:1;
            }
        }
        return 0;
    }

    @Override
    public boolean equals(Object o)
    {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Book book = (Book) o;
        return getName()==book.getName()&&getNumber()==book.getNumber();
    }
    @Override
    public int hashCode() {
        return Objects.hash(getName(),getNumber(),author, press, data, contain, price);
    }
}

用户类（继承Element类，同时作为读者类和管理员类的父类）： 

package wryyyyy;

import java.io.Serializable;

public class User extends Element implements Serializable
{
    private String passWord;

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    public User(String name, String number, String passWord) {
        super(name, number);
        this.passWord = passWord;
    }

    public User() {
    }
}

读者类： 

package wryyyyy;

import java.io.Serializable;
import java.util.*;

public class Reader extends User implements Comparable, Serializable
{
    private String academic;
    private String subject;
    private String GradeAndClass;

    public Reader(String name,String number,String password,String academic, String subject, String gradeAndClass)
    {
        super(name,number,password);
        this.academic = academic;
        this.subject = subject;
        GradeAndClass = gradeAndClass;
    }

    public Reader() {
    }

    public String getAcademic() {
        return academic;
    }

    public void setAcademic(String academic) {
        this.academic = academic;
    }

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    public String getGradeAndClass() {
        return GradeAndClass;
    }

    public void setGradeAndClass(String gradeAndClass) {
        GradeAndClass = gradeAndClass;
    }

    @Override
    public String toString() {
        return  "姓名："+this.getName()+"  学号："+this.getNumber()+"  登录密码："+this.getPassWord()
                +"  学院："+academic+"  专业："+subject+"  班级："+GradeAndClass;
    }

    @Override
    public int compareTo(Reader o)
    {
        List sizes = new ArrayList<>();
        Collections.addAll(sizes,"信息学院","机械电子学院","经管学院","林学院","外国语学院","动科学院","资环学院");
        if (Objects.equals(o.getAcademic(),this.getAcademic())==false)
        {
            return sizes.indexOf(o.getAcademic())-sizes.indexOf(this.getAcademic())>0?-1:1;
        }
        else if(Objects.equals(o.getNumber(),this.getNumber())==false)
        {
            return Integer.valueOf(o.getNumber())-Integer.valueOf(this.getNumber())>0?-1:1;
        }
        else
        {
            return 0;
        }
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Reader reader = (Reader) o;
        return Objects.equals(academic, reader.academic) && Objects.equals(subject, reader.subject) && Objects.equals(GradeAndClass, reader.GradeAndClass);
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(),getNumber(),getPassWord(),academic, subject, GradeAndClass);
    }
}

管理员类： 

package wryyyyy;

import java.io.Serializable;

public class Manager extends User implements Serializable
{
    public Manager(String name, String number, String passWord) {
        super(name, number, passWord);
    }

    public Manager() {
    }

    @Override
    public String toString()
    {
        return "姓名："+this.getName()+"  工号："+this.getNumber()+"  登录密码："+this.getPassWord();
    }
}

借阅信息类： 

package wryyyyy;

import java.io.Serializable;
import java.util.Objects;

public class Lend implements Serializable
{
    private Book book_in_lend;
    private Reader reader_in_lend;//如果出现问题就把这个改成字符串
    private String time_from;//改成存储字符串，数据格式化放在借书那里
    private String time_to;

    public Lend(Book book_in_lend, Reader reader_in_lend, String time_from, String time_to)
    {
        this.book_in_lend = book_in_lend;
        this.reader_in_lend = reader_in_lend;
        this.time_from = time_from;
        this.time_to = time_to;
    }

    public Lend() {
    }

    public Book getBook_in_lend() {
        return book_in_lend;
    }

    public void setBook_in_lend(Book book_in_lend) {
        this.book_in_lend = book_in_lend;
    }

    public Reader getReader_in_lend() {
        return reader_in_lend;
    }

    public void setReader_in_lend(Reader reader_in_lend) {
        this.reader_in_lend = reader_in_lend;
    }

    public String getTime_from() {
        return time_from;
    }

    public void setTime_from(String time_from) {
        this.time_from = time_from;
    }

    public String getTime_to() {
        return time_to;
    }

    public void setTime_to(String time_to) {
        this.time_to = time_to;
    }

    @Override
    public String toString() {
        return "---" +
                "在借图书：" + book_in_lend.getName() +"("+book_in_lend.getNumber()+
                ")  读者姓名：" + reader_in_lend.getName() +"  读者学号：" + reader_in_lend.getNumber()+
                "  借出时间：" + (time_from) +
                "  归还时间：" + time_to ;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Lend lend = (Lend) o;
        return  Objects.equals(book_in_lend, lend.book_in_lend) && Objects.equals(reader_in_lend, lend.reader_in_lend);
    }

    @Override
    public int hashCode() {
        return Objects.hash(book_in_lend, reader_in_lend);
    }
}

以Element作为图书类，读者类，管理员类的父类的目的是一开始因为这三者都有删除，查询等相同功能，打算定义泛型方法让他们都可以用，但是由于这样没有节省很多代码，所以没有定义泛型方法。