1.1 系统需求
 图书作为学生学习的重要媒介，对于图书馆来说的话是很重要的资产。所以每个高校都建有自己的图书馆，专门用来管理馆藏图书信息，但随着高等教育的不断发展，在校学生数量越来越多，随着而来的就是学生借阅图书的需求量越来越大，现有的馆藏图书已经不能够满足学生们的需求，所以高校每个学期都会购买一些必要的图书信息，随着图书数量越来越多，管理起来也就越来越复杂，尤其是在借阅和归还这个环节，给教师和学生们的感觉是图书管理员的工作效率十分之低下，借阅图书的队伍永远都是长长的，借一本书需要排半个小时的队伍。但实际上是图书管理员在不停的努力工作中，每天服务教师和学生的时间都远远超过8个小时，但却得不到学生们的认可。造成这个原因的主要因素是图书馆的图书管理方式已经满足不了日常的学习需求。
 随着科学技术的不断发展，许多智能化的公办软件顺势而生，如指纹锁，自助售票机等，这些等自助服务软件的出现，在保证数据安全的前提下极大的方便了用户的使用，从而得到快速的推广。利用人工智能来开发出自助服务系统来进行图书的借阅与归还，对高等院校来说是很迫切的需求，因此许多高校都有购买配备一些自动化的自助借阅与归还图书系统来满足在校学生的借阅需求。但现有的自助借阅与归还系统操作起来比较复杂，且操作界面没有突出操作流程，更让学生们难以上手。
 1.2 系统软件功能需求
 本课题的图书馆自助借阅系统采用工作流程是通过RFID读取用户的磁卡信息，并将磁卡信息打包成SIP2接口协议数据包，然后通过socket传送到图书馆的系统服务器中，图书馆的系统服务器会检查这个磁卡用户的合法性，假如是合法身份图书馆系统服务器会返回磁卡所对应的用户身份信息，并将此信息通过Scoket传送到自助借阅图书的系统上，然后显示在界面上。等用户通过磁卡验证通过后，用户将图片防止在扫描区域，自助借阅图书系统扫描到图书的ISBN号码后，同样会将此条码信息通过Scoket传送到图书馆系统服务器中来查看此图书信息，并将查询得到图书信息通过Scoket返回给自助借阅图书系统，然后自助借阅系统会将这些信息显示在界面上，当用户点击借阅时，系统会将所有的信息打包发送到图书馆系统服务器上进行相应行为的操作，归还图书和借阅图书的数据流程基本上是一致的。因此系统的总体工作流程是通过RFID读取用户的磁卡信息，或者通过用户界面来获取用户的操作信息，然后将信息打包为SIP2协议通过SOCKET跟图书馆的数据库服务器进行通讯，然后将结果显示在界面上。本文重点介绍界面上需要实现哪些功能。
 主页功能需求
 1）有英汉双语可供选择：对于高校来说，在校的学生会包括来之全球各地的学生，并不是所有的学生都使用汉语，也会有同学使用其他的语言，除了汉语，多数留学生都会英语，所以为了尽可能的满足同学们的需求，需要主页上需要有汉英切换的功能，这样熟悉汉英的同学使用汉语进行操作，熟悉英语的同学使用英语进行操作。
 2）语音提示：对于对系统不是很熟悉的同学或者用户来说，界面上的操作提示可能没有那么详细，因为界面大小总是有限的，因此界面上的操作提示都是尽可能简洁，为了能够给学生和用户充分的操作引导提示，系统需要有操作提示语音，操作时有语音提示且提示比较全面。
 3）自动播放操作指南：当设备空闲时可播放操作指南，主界面也有操作演示可供读者选择GIF图片观看，因为对于从没有使用过此系统的用户来说，能有个操作指南是最好不过了，但又不能耽误其他用户的使用，所以系统在检查到无人使用的时候，可以自动播放操作指南，这样即不耽误用户的使用，又可以给用户一个操作指导。
 4）设备检查：设备有开机自检功能，若自检有问题会提示那一项有问题(SIP2服务器 一卡通连通性可以，硬件如何检测)
 5）自动连接：网络断开有提示并无法操作借还书，网络连接时能够自动连接SIP2并恢复正常功能
 6）保持操作日志：提供设备所有的操作日志，提供准确的工作统计，包括借还数量、成功与否等，主要还是数据统计这部分，比如这台机器借还书的列表以及借还总共多少册的统计，还有一些失败的原因等
 7）缴费：一卡通和图书管理系统的扣费功能，学生有超期归还会时会出现图书馆欠费，可以缴纳欠费并同时管理系统里将欠费消掉，但只能预留接口，具体扣费需要更换一卡通刷卡器和做软件，现在只能提示。
 8）打印功能：离校查询并打印盖章证明的功能，查询此用户是否还有在借图书，如没有可打印一张可粘贴的凭证证明没有在借图书，这样就可以实现学生离校时，自动办理图书清还操作。
 9）返回按钮：每个界面都有退回到主界面的按钮，方便用户返回操作。
 
借书界面需求
 1）身份认证：用户刷卡后是否需要输入密码需要可配置，密码形式是全键盘模式，刷卡处无法屏幕键盘输入。当用户刷卡后光标自动到密码输入框。当用户刷卡后需要将卡一直放在上面，若将卡取走即退出到主界面。
 2）定时控制：用户刷卡界面会有倒计时，时间可配置，倒计时结束退出到主界面，这样不至于界面一直停留在用户身份验证界面，因为系统需要检出是否空闲来判断是否需要自动播放操作指南。
 3）异常处理：当系统在用户使用过程中出现异常时，异常信息界面也有倒计时，时间可配置，倒计时结束退出到主界面，这样系统有时间来及时调整一些资源来满足用户的需求。
 4）用户信息显示：当用户刷卡验证后，假如验证成功后，从服务器中获取到用户的详细信息后，能够在借书界面有简单个人信息，包含名字，可借图书的本数以及已借图书本数。
 5）借书操作限时：借书界面也有倒计时，时间可配置，倒计时结束退出到主界面，每操作一本图书成功时间会重置，在用户操作借书过程中，系统扫描图书信息是有时间控制的，不然系统的摄像头一直处于工作状态的话，需要耗费大量的计算资源，这样用户操作界面就不会那么流畅。
 6）图书本数检查：只有当图书挡到主光电时才会开始借书，先判断是否有多本书，判断分两种，一种是物理判断，除了主光电以外任何一个光电也有信息时即判断为多本书；摄像头拍照判断是否是多本书，主要是判断是否有夹书；若判断有多本书时提示借阅者请重新放书，每次限放一本
 7）日志：当系统判断有多本书操作的情况时需要记录操作人员相关信息的日志，这样便于图书控制。
 8）扫描拍照：档用户挡住主光电时开始拍照，包括人脸和图书的拍照，并保存借阅人信息、日期和图书条码等，并在界面上做一定的提示。
 9）扫描图书：档系统判断只有单本书时开始打开条码枪扫描条码，并将图书信息显示到界面上。
 10）消磁：SIP2返回借书成功时开始消磁，并磁检查是否消磁成功，若消磁不成功需要提示到人工处操作，并在界面上提示。
 11）借书失败：SIP2返回借书失败时提示失败原因（需SIP2协议支持），需要在界面上提示借书失败。
 12）打印凭条：借阅完成后自由选择是否需要打印凭条，界面上需要显示打印凭条的操作按钮。
 13）系统配置：借书功能界面需要提供一个功能设置按钮，用来设置此功能可是否使用。
 14）借书操作指南：用户无需点击屏幕，先读卡，则启动借书流程，先扫图书信息，则启动判断图书状态流程等。在单本借阅情况下，首先识别图书状态（在馆，在借），如果在馆，则执行借阅流程，如果是在借，则首先将图书归还，在执行其它流程。
 
还书界面需求
 1）还书操作：还书界面有倒计时，时间可配置，倒计时结束(无错误时)退出到主界面，每操作一本图书成功时间会重置，在用户操作借书过程中，系统扫描图书信息是有时间控制的，不然系统的摄像头一直处于工作状态的话，需要耗费大量的计算资源，这样用户操作界面就不会那么流畅。并在界面上提示相关信息。
 2）扫描拍照：档用户挡住主光电时开始拍照，包括人脸和图书的拍照，并保存借阅人信息、日期和图书条码等，并在界面上做一定的提示。
 3）开始还书：图书挡到光电后开始充磁，还书不用判断多本书，检查是否充磁成功，充磁成功后即发送SIP2还书协议；若充磁不成功需要提示读者去人工处还书；若SIP2返回还书失败则提示原因并提示读者去人工处还书
 4）打印凭条：还书完成后自由选择是否需要打印凭条（人工选或自动打印参数配置），界面上需要显示打印凭条的操作按钮。
 5）系统配置：还书功能界面需要提供一个功能设置按钮，用来设置此功能可是否使用。
 
查询界面需求
 1） 身份认证：用户刷卡后是否需要输入密码需要可配置，密码形式是全键盘模式，刷卡处无法屏幕键盘输入。当用户刷卡后光标自动到密码输入框。当用户刷卡后需要将卡一直放在上面，若将卡取走即退出到主界面。
 2）定时控制：用户刷卡界面会有倒计时，时间可配置，倒计时结束退出到主界面，这样不至于界面一直停留在用户身份验证界面，因为系统需要检出是否空闲来判断是否需要自动播放操作指南。
 3）个人信息界面：个人信息界面也有倒计时，时间可配置，倒计时结束退出到主界面，用户通过RFID读取用户的磁卡信息，并将磁卡信息打包成SIP2接口协议数据包，然后通过socket传送到图书馆的系统服务器中，图书馆的系统服务器会检查这个磁卡用户的合法性，假如是合法身份图书馆系统服务器会返回磁卡所对应的用户身份信息，并将此信息通过Scoket传送到自助借阅图书的系统上，然后显示在界面上。
 4）系统配置：查询功能界面需要提供一个功能设置按钮，用来设置此功能可是否使用。
 
续借界面需求
 1）身份认证：用户刷卡后是否需要输入密码需要可配置，密码形式是全键盘模式，刷卡处无法屏幕键盘输入。当用户刷卡后光标自动到密码输入框。当用户刷卡后需要将卡一直放在上面，若将卡取走即退出到主界面。
 2）定时控制：用户刷卡界面会有倒计时，时间可配置，倒计时结束退出到主界面，这样不至于界面一直停留在用户身份验证界面，因为系统需要检出是否空闲来判断是否需要自动播放操作指南。
 3）个人信息查询：个人信息界面也有倒计时，时间可配置，倒计时结束退出到主界面。
 4）图书续借：在图书信息前面可以选择图书，可选择多本，点击续借后会显示续借成功，同时归还日期也会改变。若用户有异常信息比如超期等不允许续借的情况（需SIP2支持）则用红色提醒用户有哪些异常信息。
 5）系统配置：查询功能界面需要提供一个功能设置按钮，用来设置此功能可是否使用。

程序设计图书借阅管理系统
 
图书借阅管理是学校工作中的一项重要内容，学校图书馆，书目繁多，用户的信息冗杂，且信息数据在每天变化，如果采用人工方式进行管理控制，不仅工作量庞大，而且容易出错。浪费了许多的人力和物力，已不能适应时代的发展。在当今信息时代，这种传统的管理方法必然被以计算机为基础的信息管理系统所代替，图书管理系统可以有效的管理图书资源，控制图书增加，删除，修改，学生借阅和返还的流程，缩小开支，提高工作效率与准确率，能够节省时间，既方便了管理人员，又方便了学生，对图书馆的管理有很大的帮助，极大地提高了效率。
 功能：
 1、管理员功能
 （1）录入图书，录入数据格式：图书ID、书名、作者、书号、出版社、出版日期和单价：
 （2）修改图书信息，删除图书信息；；
 （3）查询图书，可按书名、作者、书号或出版社进行图书信息查询；
 （4）录入借阅用户信息，包括借阅用户ID、用户名、密码、录入时间；
 （5）查询借阅用户借书情况，至少包括借阅用户名、借阅图书、时间等。
 2、普通用户功能：
 （1）查询图书：可按书名、作者、书号或出版社进行图书信息的查询；
 （2）借阅图书：根据查询到图书，进行借阅，同时库存量要相应的减少，注意：超过借书数时不能借阅；
 （3）还书：还书成功后，相应的同时图书库存要增加。
 
界面展示（部分）
 
 
 
 
 
 
代码如下
 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#include<algorithm>
using namespace std; 
typedef struct book //图书
{
	char title[100];  //书名
	char isbn[100];  //书号
	char author[100];  //作者
	char publisher[100];  //出版社
	char publishtime[100];//出版日期 
	int value;  //单价 
	int cnt; //书籍数量
	struct book* next;  //下一本书籍
}Book;
Book* book_head;  //图书头指针
int book_amount;  //图书总数量
struct node //用户所借书籍
{
	int borrow_amount, max_amount; //所借书籍数量， 最大借书数
	double tax;  //超出时限收费比率
	time_t borrow_time[10], return_time[10];  //借、还时间
	Book borrow_book[10];  //每位最多借10本书籍
};

typedef struct user //用户
{
	char user_name[30];  //用户名
	char password[30];  //密码
	char ID[30]; //有效证件号码
	int admin;  //是否管理员
	struct node user_book;  //用户所借书籍
	struct user* next;  //下一位用户
}User;
User* user_head;  //用户头指针
User* yongheng;  //超级管理员账号
int user_amount;  //用户总数量
void welcome_page();  //欢迎页面
void manual();  //使用手册
void main_menu();  //主菜单
void user_register();  //用户注册
void user_login();  //用户登录
void admin_login();  //管理员登陆
void user_menu(User*);  //用户菜单
void user_change(User*);  //更改用户信息
int delete_user(User*);  //删除账号
void borrow_book(User*);  //借阅管理
void return_book(User*);  //还书管理
void history(User*);  //历史借阅浏览
void admin_initi();  //超级管理员账号初始化
User* serch_username(char*);  //查找用户名
void admin_menu(User*);  //管理员菜单
void query_user();  //用户信息查询
void admin_user();  //管理用户信息
void all_history(); //查看用户图书借阅归还情况
User* serch_user();  //按序号搜索用户
void set_admin(User*);  //设置管理员
void add_book();  //增加图书信息
void change_book() ; //修改图书信息
void delete_book();  //删除图书信息
void browse_book();  //图书浏览
void search_book(); 
void search_title();   //按书名查找 
void search_author();       // 按作者查找 
void search_isbn();         //按书号查找 
void search_publisher();     //按出版社查找
void creat_user_list(char*, char*, char*);  //创建用户链表
void creat_book_list(char*, char*, char*, char*, int);  //创建图书链表
void user_initi(User*);  //用户图书管理初始化
void load();  //从文件中加载数据
void save();  //保存数据到文件
int main()
{
	welcome_page();
	printf("退出系统成功，祝您生活愉快！\n");
	//system("pause"); 
	system("cls");
	return 0;
}
void welcome_page()  //欢迎页面
{
	load();
	while (1)
	{	printf("***********************               **   * \n");
		printf("**    **             **               **    *    \n");
		printf("**   ************    **         ***************  \n");
		printf("**  ** **    **      **               **     **		\n");
		printf("** **     **         **               **     **   \n");
		printf("**      **   **      **               **     **  \n");
		printf("**    **       **    **      **********************  \n");
		printf("**  **    **     **  **               **         **	\n");
		printf("**         **        **               **         **	\n");
 		printf("**                   **               **         **	\n");
		printf("**        **         **               **      ** **  \n");
		printf("**         **        **               **         **	\n");
		printf("***********************               **	             \n");
		printf("**************************************************\n");
		printf("*               欢迎使用本图书管理系统!          *\n");
		printf("*            请输入选项前的数字以确认操作！      *\n");
		printf("*                 1、进入系统                    *\n");
		printf("*                 2、查看使用手册                *\n");
		printf("*                 0、退出系统                    *\n");
		printf("**************************************************\n");
		int op; scanf("%d", &op); system("cls");
		switch (op)
		{
		case 1: main_menu(); break;
		case 2: manual(); system("pause"); system("cls"); break;
		case 0: return ;
		default: printf("错误的指令，请重新输入！\n"); 
		system("cls"); break;
		}
	}
}
void manual() //使用手册
{
	printf("*******************************************************************************\n");
	printf("用户须知:\n\n初始管理员账户：yongheng\t密码：666\t证件号：1903\n\n");
	printf("该系统为图书借阅管理，用户和管理员具有不同的权限，\n ");
	printf("一、图书管理员功能（需要输入用户名、密码正确后才能使用如下功能\n");
	printf("     1,录入图书，录入数据格式：图书ID、书名、作者、书号、出版社、出版日期和单价 \n");
	printf("     2,修改图书信息，删除图书信息");
	printf("     3,查询图书，可按书名、作者、书号或出版社进行图书信息查询；\n");
	printf("     4,录入借阅用户信息，包括借阅用户ID、用户名、密码、录入时间；\n");
	printf("     5,查询借阅用户借书情况，至少包括借阅用户名、借阅图书、时间等。\n");
	printf("二、借阅用户功能（需要输入用户名、密码正确后才能使用如下功能）\n");
	printf("     1,查询图书 可按书名、作者、书号或出版社进行图书信息的查询；\n");
	printf("     2,借阅图书 ，根据查询到图书，进行借阅，同时库存量要想要的减少，注意：超过借书数时不能借阅；\n");
	printf("     3,还书，还书成功后，相应的同时图书库存要增加。\n");
	printf("*******************************************************************************\n");
}
void main_menu()  //主菜单
{
	while (1)
	{
		printf("+---------------------------------------------+\n");
		printf("*            欢迎进入本图书管理系统!          *\n");
		printf("*         请输入选项前的数字以确认操作！      *\n");
		printf("*               1、用户注册                   *\n");
		printf("*               2、用户登陆                   *\n");
		printf("*               3、管理员登陆                 *\n");
		printf("*               0、返回欢迎页面               *\n");
		printf("+---------------------------------------------+\n");
		int op; scanf("%d", &op); system("cls");
		switch (op)
		{
		case 1: user_register(); break;
		case 2: user_login();  break;
		case 3: admin_login();  break;
		case 0: return;
		default: printf("错误的指令，请重新输入！\n"); 
		system("cls"); break;
		}
	}
}
void user_register()  //用户注册
{
	char name[30];
	printf("请输入您需要注册的用户名(不超过25个字母)：\n");
	scanf("%s", name);
	User* account;
	while (account = serch_username(name), account != NULL)
	{
		printf("该用户名已存在，请重新输入！\n");
		scanf("%s", name);
	}
	printf("请输入您的账号密码(不超过25个字母)：\n");
	char password[30];
	scanf("%s", password);
	printf("请输入您的有效证件号码(不超过25个数字)：\n");
	char ID[30];
	scanf("%s", ID);
	creat_user_list(name, password, ID);
	printf("恭喜您注册成功！\n");
	++user_amount;
	system("cls");
}

void user_login()  //用户登录
{
	char name[30];
	printf("请输入您的用户名(不超过25个字母)：\n");
	scanf("%s", name);
	User* account;
	while (account = serch_username(name), account == NULL)
	{
		system("cls");
		printf("该用户名不存在，请注册或重新登陆账号！\n");
		printf("       返回系统输入 1 \n"); 
		printf("请输入；");
		scanf("%s", name);
		if(strcmp(name,"1")==0)
		{
			system("cls");
			return ;
		}
	}
	printf("请输入您的账号密码(不超过25个字母)：\n");
	scanf("%s", name);
	if (strcmp(account->password, name))
	{
		printf("密码错误，请确认后重新登陆！\n");
	}
	printf("恭喜您登录成功,即将跳转用户界面...\n");
	system("cls");
	user_menu(account);
}

void admin_login()  //管理员登陆
{
	char name[30];
	printf("尊敬的管理员：\n");
	printf("请输入您的管理账号(不超过25个字母)：\n");
	scanf("%s", name);
	User* account;
	while (account = serch_username(name), account == NULL)
	{
		system("cls");
		printf("该用户名不存在，请重新登陆账号！\n");
		printf("       返回系统输入 1 \n"); 
		printf("请输入；");
		scanf("%s", name);
		if(strcmp(name,"1")==0)
		{
			system("cls");
			return ;
		}
	}
	if (!account->admin)
	{
		printf("该账号暂无管理权限，请联系相关管理人员！\n");
		system("cls"); return;
	}
	printf("请输入该管理账号的密码(不超过25个字母)：\n");
	scanf("%s", name);
	if (strcmp(account->password, name))
	{
		printf("密码错误，请确认后重新登陆！\n");
		system("cls"); return;
	}
	printf("恭喜您登录成功,即将跳转管理界面...\n");
	system("cls");
	admin_menu(account);
}
void creat_user_list(char* name, char* password, char* ID)  //创建用户链表
{
	User* np = (User*)malloc(sizeof(User));
	np = user_head;
	while (np->next) np = np->next;
	User* tp = (User*)malloc(sizeof(User));
	strcpy(tp->user_name, name);
	strcpy(tp->password, password);
	strcpy(tp->ID, ID);
	tp->admin = 0;
	tp->next = NULL;
	user_initi(tp);
	np->next = tp;
	save();
}

void creat_book_list(char* title, char* isbn, char* author, char* publisher,char* publishtime,int value, int cnt)  //创建图书链表
{
	Book* np = (Book*)malloc(sizeof(Book));
	np = book_head;
	while (np->next) np = np->next;
	Book* tb = (Book*)malloc(sizeof(Book));
	strcpy(tb->title, title);
	strcpy(tb->isbn, isbn);
	strcpy(tb->author, author);
	strcpy(tb->publisher, publisher);
	strcpy(tb->publishtime, publishtime);
	tb->value = value;
	tb->cnt = cnt;
	tb->next = NULL;
	np->next = tb;
	save();
}
void user_initi(User* account)  //用户图书管理初始化
{
	account->user_book.borrow_amount = 0;
	account->user_book.max_amount = 10;
	account->user_book.tax = 1.0;
	memset(account->user_book.borrow_time, 0, sizeof(account->user_book.borrow_time));
	memset(account->user_book.return_time, 0, sizeof(account->user_book.return_time));
	memset(account->user_book.borrow_book, 0, sizeof(account->user_book.borrow_book));
}

void load()  //从文件中加载数据
{
	book_head = (Book*)malloc(sizeof(Book));
	book_head->next = NULL;
	book_amount = 0;

	FILE* fp2;
	fp2 = fopen("book.bin", "rb");
	if (fp2 == NULL)
	{
		fp2 = fopen("book.bin", "wb");
		if (fp2 == NULL)
		{
			printf("图书存储失败！\n"); exit(0);
		}
		fclose(fp2);
	}
	else
	{
		Book* bp = (Book*)malloc(sizeof(Book));
		bp = book_head;
		Book* tp = (Book*)malloc(sizeof(Book));
		while (fread(tp, sizeof(Book), 1, fp2))
		{
			bp->next = tp;
			++book_amount;
			tp = tp->next;
			tp = (Book*)malloc(sizeof(Book));
			bp = bp->next;
		}
		fclose(fp2);
	}

	user_head = (User*)malloc(sizeof(User));
	user_head->next = NULL;
	user_amount = 0;

	FILE* fp1;
	fp1 = fopen("user.bin", "rb");
	if (fp1 == NULL)
	{
		admin_initi(); return;
	}
	User* np = (User*)malloc(sizeof(User));
	np = user_head;
	User* temp = (User*)malloc(sizeof(User));
	while (fread(temp, sizeof(User), 1, fp1))
	{
		np->next = temp;
		++user_amount;
		temp = temp->next;
		temp = (User*)malloc(sizeof(User));
		np = np->next;
	}
	yongheng = user_head->next;
	fclose(fp1);
}

void save()  //保存数据到文件
{
	FILE* fp = fopen("user.bin", "wb");
	User* temp = user_head->next;
	while (temp)
	{
		fwrite(temp, sizeof(User), 1, fp);
		temp = temp->next;
	}
	fclose(fp);

	fp = fopen("book.bin", "wb");
	Book* tb = book_head->next;
	while (tb)
	{
		fwrite(tb, sizeof(Book), 1, fp);
		tb = tb->next;
	}
	fclose(fp);
}

void user_menu(User* account)  //用户菜单
{
	while (1)
	{
		printf("+---------------------------------------------+\n");
		printf("*  用户：%12s   欢迎您!               *\n", account->user_name);
		printf("*  请输入选项前的数字以确认操作！             *\n");
		printf("*  1、图书浏览                                *\n");
		printf("*  2、图书查找                                *\n");
		printf("*  3、历史借阅浏览                            *\n");
		printf("*  4、借阅管理                                *\n");
		printf("*  5、还书管理                                *\n");
		printf("*  6、修改账号信息                            *\n");
		printf("*  7、删除账号                                *\n");
		printf("*  0、退出登陆                                *\n");
		printf("+---------------------------------------------+\n");
		int op; scanf("%d", &op); system("cls");
		switch (op)
		{
		case 1: browse_book(); system("pause"); system("cls"); break;
		case 2: search_book(); system("pause"); system("cls"); break;
		case 3: history(account); system("pause"); system("cls"); break;
		case 4: borrow_book(account); break;
		case 5: return_book(account); break;
		case 6: user_change(account);  break;
		case 7: if (delete_user(account))
		{
			printf("该账号已被删除，请重新登陆！\n");
			system("cls");
			return;
		}
		else break;
		case 0: printf("账号登出成功!\n"); 
		system("cls"); return;
		default: printf("错误的指令，请重新输入！\n");
		system("cls"); break;
		}
	}
}

void user_change(User* account)  //更改用户信息
{
	printf("待修改用户：%s\t 您现在可以更改您的个人信息!\n", account->user_name);
	char Name[30];
	printf("请输入新的用户名(不超过25个字母)：\n");
	scanf("%s", Name);
	strcpy(account->user_name, Name);
	printf("请重新输入您的密码(不超过25个字母)：\n");
	char password[30];
	scanf("%s", password);
	strcpy(account->password, password);
	printf("用户%s\t账号密码已修改！\n", account->user_name);
	printf("请重新输入您的有效证件号码(不超过25个字母)：\n");
	char ID[30];
	scanf("%s", ID);
	strcpy(account->ID, ID);
	printf("用户%s\t有效证件号码已修改！\n", account->user_name);
	save();
	printf("用户%s\t个人信息修改成功，正在返回上一界面...\n", account->user_name);
	system("cls");
}

int delete_user(User* account)  //删除账号
{
	printf("********************************************\n");
	if (!strcmp(account->user_name, yongheng->user_name))
	{
		printf("用户%s拥有最高权限，不可被删除！！！\n", yongheng->user_name);
		system("cls"); return 0;
	}
	printf("是否需要删除账号%s？\n", account->user_name);
	printf("请输入相应数字以继续操作！\n");
	printf("1、是\t0、否\n");
	int op;  scanf("%d", &op);
	if (op == 1)
	{
		if (account->user_book.borrow_amount)
		{
			printf("删除失败！该用户有%d本图书未归还！请先归还所借阅图书！\n", account->user_book.borrow_amount);
		}
		else
		{
			User* tp = (User*)malloc(sizeof(User));
			tp = user_head;
			User* np = (User*)malloc(sizeof(User));
			np = user_head->next;
			while (np)
			{
				if (!strcmp(np->user_name, account->user_name))
				{
					tp->next = np->next;
					free(np); --user_amount;
					save();
					printf("账号已删除成功！\n");
					system("pause"); system("cls");
					return 1;
				}
				tp = np;
				np = np->next;
			}
		}
	}
	else if (!op) printf("已取消本次操作！\n");
	else printf("输入选项错误，请重新输入！正在返回上一层...\n");
	system("pause"); system("cls"); return 0;
}

void borrow_book(User* account)  //借阅管理
{
	printf("用户%s：请输入您的有效身份证件号码(不超过25位)以继续！\n", account->user_name);
	char ID[30]; scanf("%s", ID); system("cls");
	while (strcmp(account->ID, ID))
	{
		system("cls");
		printf("身份证件号码与账号不匹配，请检查后重新输入！\n");
		scanf("%s", ID);
	}
	while (1)
	{
		int ans = account->user_book.borrow_amount, Max = account->user_book.max_amount;
		if (ans == Max)
		{
			printf("用户%s：借阅图书数量 %d 本，已达上限 %d 本，请先归还部分图书！\n", account->user_name, ans, Max);
			system("pause"); system("cls"); return;
		}
		browse_book();
		printf("请输入您需要借阅的书籍序号(输入 0 退出删除操作)：\n");
		int cnt; scanf("%d", &cnt);
		if (cnt == 0)
		{
			printf("已成功退出借阅系统！\n"); system("pause"); system("cls");
			return;
		}
		else if (cnt > book_amount || cnt < 0)
		{
			printf("请正确输入上图中已有的图书序号！\n");
		}
		else
		{
			printf("请设置您需要借阅的时间(不超过90天)：\n");
			int day; scanf("%d", &day);
			if (day > 90 || day <= 0)
				printf("输入借阅时间不被允许，请重新输入！\n");
			else
			{
				Book* tb = (Book*)malloc(sizeof(Book));
				tb = book_head->next;
				for (int i = 1; i < cnt; ++i)
					tb = tb->next;
				tb->cnt--;	
				account->user_book.borrow_book[ans] = *tb;
				account->user_book.borrow_time[ans] = time(NULL);
				account->user_book.return_time[ans] = time(NULL) + day * 3600 * 24;
				++account->user_book.borrow_amount;
				save();
				printf("用户%s：借阅图书《%s》成功！\n", account->user_name, tb->title);
			}
		}
		system("pause"); system("cls");
	}
}

void return_book(User * account)  //还书管理
{

	while (1)
	{
		history(account);
		if (!account->user_book.borrow_amount)
		{
			system("pause"); system("cls"); return;
		}
		printf("请输入您需要归还的书籍序号（输入-1以退出还书系统）！\n");
		int cnt = 0; scanf("%d", &cnt); system("cls");
		if (cnt == -1)
		{
			printf("正在退出还阅系统，请稍后...\n");
			system("pause"); system("cls"); return;
		}
		if (cnt > account->user_book.borrow_amount || cnt < 0)
		{
			printf("请正确输入上述书籍序号！\n");
		}
		else
		{
			int i = 0;
			for (--cnt; i < cnt; ++i);
			Book* tb = (Book*)malloc(sizeof(Book));
				tb = book_head->next;
				for (int i = 1; i < cnt; ++i)
					tb = tb->next;
			tb->cnt++;
			char title[100];
			strcpy(title, account->user_book.borrow_book[i].title);
			time_t t = time(NULL);
			printf("*************************************************\n");
			printf("规定还书时间：%s", ctime(&account->user_book.return_time[i]));
			printf("当前时间：%s", ctime(&t));
			t -= account->user_book.return_time[i];
			if (t > 0)
			{
				double cost = t / 3600.0 / 24 * account->user_book.tax;
				printf("由于您未在指定日期内归还《%s》,您需要支付违约金%.2lf元\n", title, cost);
			}
			else printf("书籍《%s》借阅未超出时间，无需支付违约金！\n", title);
			for (; i < account->user_book.borrow_amount; ++i)
			{
				account->user_book.borrow_book[i] = account->user_book.borrow_book[i + 1];
				account->user_book.borrow_time[i] = account->user_book.borrow_time[i + 1];
				account->user_book.return_time[i] = account->user_book.return_time[i + 1];
			}
			--account->user_book.borrow_amount;
			save();
			printf("书籍《%s》归还成功！\n", title);
		}
		system("pause"); system("cls");
	}
}

void history(User * account)  //历史借阅浏览
{
	int n = account->user_book.borrow_amount;
	printf("*************************************************************\n");
	printf("用户%s：\n", account->user_name);
	if (!n)
	{
		printf("暂无书籍在借阅记录！\n"); return;
	}
	printf("借阅书籍序号：\n");
	for (int i = 0; i < n; ++i)
	{
		struct node t = account->user_book;
		time_t nt = time(NULL) - t.return_time[i];
		double cost = 0.0;
		if (nt > 0) cost = t.tax * (nt / 3600.0 / 24);
		printf("%d：\n", i + 1);
		printf("  书名：《%s》\n", t.borrow_book[i].title);
		printf("  借阅日期：%s", ctime(&t.borrow_time[i]));
		printf("  规定还书日期：%s", ctime(&t.return_time[i]));
		if (nt > 0) printf("  是否超时：是\n");
		else printf("  是否超时：否\n");
		printf("  借阅费用：%.2lf\n", cost);
	}
}

void admin_initi()  //超级管理员账号初始化
{
	FILE* fp = fopen("user.bin", "wb");
	if (fp == NULL)
	{
		printf("管理员权限初始化失败！\n"); exit(0);
	}
	yongheng = (User*)malloc(sizeof(User));
	strcpy(yongheng->user_name, "yongheng");
	strcpy(yongheng->password, "666");
	strcpy(yongheng->ID, "1903");
	yongheng->admin = 1;
	yongheng->next = NULL;
	user_initi(yongheng);
	user_head->next = yongheng;
	user_amount = 1;
	save();
	fclose(fp);
}

User* serch_username(char* name)  //查找用户名
{
	User* np = user_head->next;
	while (np)
	{
		if (!strcmp(np->user_name, name)) return np;
		np = np->next;
	}
	return NULL;
}

void admin_menu(User * account)  //管理员菜单
{
	while (1)
	{
		printf("*************************************************\n");
		printf("*   用户：%12s   欢迎您!                *\n", account->user_name);
		printf("*   请输入选项前的数字以确认操作！              *\n");
		printf("*     1、增加图书信息                           *\n");
		printf("*     2、修改图书信息                           *\n");
		printf("*     3、删除图书信息                           *\n");
		printf("*     4、图书浏览                               *\n");
		printf("*     5、图书查找                               *\n");
		printf("*     6、管理用户信息                           *\n");
		printf("*     0、退出登陆                               *\n");
		printf("*************************************************\n");
		int op; scanf("%d", &op); system("cls");
		switch (op)
		{
		case 1: add_book(); break;
		case 2: change_book(); break;
		case 3: delete_book(); break;
		case 4: browse_book(); system("pause"); system("cls"); break;
		case 5: search_book(); break;
		case 6: admin_user(); break;
		case 0: printf("退出管理账号成功!\n"); system("pause"); system("cls"); return;
		default: printf("错误的指令，请重新输入！\n"); system("pause"); system("cls"); break;
		}
	}
}

void query_user()  //用户信息查询
{
	int cnt = 1;
	User* np = (User*)malloc(sizeof(User));
	np = user_head->next;
	printf("序号  用户名\t\t密码\t\t证件号码\t\t是否管理员\n");
	while (np)
	{
		printf("%d、 %-20s %-20s %-20s", cnt, np->user_name, np->password, np->ID);
		if (np->admin) printf(" 是\n");
		else printf(" 否\n");
		np = np->next;
		++cnt;
	}
}

void admin_user()  //管理用户信息
{
	while (1)
	{
		printf("*************************************************\n");
		printf("*       欢迎进入用户管理界面！                  *\n");
		printf("*       请输入选项前的数字以确认操作！          *\n");
		printf("*       1、查看用户个人信息                     *\n");
		printf("*       2、修改用户个人信息                     *\n");
		printf("*       3、删除用户账号                         *\n");
		printf("*       4、查看用户图书借阅归还情况             *\n");
		printf("*       5、设置管理员权限                       *\n");
		printf("*       0、返回总管理界面                       *\n");
		printf("*************************************************\n");
		User* np = (User*)malloc(sizeof(User));
		int op; scanf("%d", &op); system("cls");
		switch (op)
		{
		case 1: query_user(); system("pause"); system("cls"); break;
		case 2: if (np = serch_user(), np != NULL) user_change(np);
				else
		{
			system("cls");
		}
				break;
		case 3:if (np = serch_user(), np != NULL)
		{
			int admin = np->admin;
			if (delete_user(np) && admin)
				printf("该账号已被删除，请重新登陆！\n");
			system("pause"); system("cls");
			return;
		}
			   else
		{
			system("pause"); system("cls");
		}
			   break;
		case 4: all_history(); break;
		case 5: if (np = serch_user(), np != NULL) set_admin(np);
				else
		{
			system("cls");
		}
				break;
		case 0: printf("退出用户管理界面成功!\n"); system("pause"); system("cls"); return;
		default: printf("错误的指令，请重新输入！\n"); system("pause"); system("cls"); break;
		}
	}
}

void all_history() //查看用户图书借阅归还情况
{
	while (1)
	{
		printf("###########################################################\n");
		printf("欢迎使用用户图书借阅归还查询系统！\n");
		User* account = (User*)malloc(sizeof(User));
		account = serch_user();
		if (account)
		{
			history(account);
			printf("查阅成功！正在返回上一层...\n");
			system("pause"); system("cls"); return;
		}
		system("cls");
	}
}

User* serch_user()  //按序号搜索用户
{
	query_user();
	printf("请输入待操作的用户序号：\n");
	int cnt; scanf("%d", &cnt); system("cls");
	if (cnt > user_amount || cnt <= 0)
		printf("请正确输入上图中待操作的用户序号！\n");
	else
	{
		User* tb = (User*)malloc(sizeof(User));
		tb = user_head->next;
		for (int i = 1; i < cnt; ++i)
			tb = tb->next;
		return tb;
	}
	return NULL;
}

void set_admin(User * account)  //设置管理员
{
	printf("*******************************************************************\n");
	if (!strcmp(account->user_name, yongheng->user_name))
	{
		printf("用户%s拥有最高管理权限，不可被修改！！！正在返回上一层...\n", yongheng->user_name);
		system("cls"); return;
	}
	printf("是否确认将用户%s设置为管理员？\n", account->user_name);
	printf("请输入相应数字以继续操作！\n");
	printf("1、设置为管理员\t0、取消管理员权限\n");
	int op; scanf("%d", &op);
	if (op == 1)
	{
		account->admin = op;
		printf("用户%s\t管理员权限设置成功！\n", account->user_name);
	}
	else if (op == 0)
	{
		account->admin = op;
		printf("用户%s\t管理员权限已被取消！\n", account->user_name);
	}
	else
	{
		printf("设置管理员权限失败，请按要求输入！\n");
	}
	printf("*******************************************************************\n");
	save();
	system("cls");
}

void add_book()  //增加图书信息
{
	char title[100], isbn[100], author[100], publisher[100], publishtime[100];
	int value,cnt;
	printf("请输入需要添加的书籍名称：\n");
	scanf("%s", title);
	printf("请输入需要添加的书籍书号：\n");
	scanf("%s", isbn);
	printf("请输入需要添加的书籍作者：\n");
	scanf("%s", author);
	printf("请输入需要添加的书出版社：\n");
	scanf("%s", publisher);
	printf("请输入需要添加的书出版日期：\n");
	scanf("%s", publishtime);
	printf("请输入需要添加的图书单价：\n");
	scanf("%d", &value);
	printf("请输入需要添加的书籍数量：\n");
	scanf("%d", &cnt);
	++book_amount;
	creat_book_list(title, isbn, author, publisher, publishtime, value, cnt);
	printf("添加书籍《%s》成功！\n", title);
	system("pause"); system("cls");
}
void change_book()  //修改图书信息
{
	while(1)
	{
		browse_book();
		printf("请输入待修改的书籍序号(输入 0 退出修改操作)：\n");
		int cnt; scanf("%d", &cnt);
		if (cnt == 0)
		{
			printf("已成功退出修改系统！\n"); system("pause"); system("cls");
			return;
		}
		else if (cnt > book_amount || cnt < 0)
		{
			printf("请正确输入上图中待修改的图书序号！\n");
		}
		else
		{
			Book* tb = (Book*)malloc(sizeof(Book));
			tb = book_head->next;
			int dd=1;
			while (tb)
			{
				if(dd==cnt)
				{
					char title[100], isbn[100], author[100], publisher[100],publishtime[100];
					int value,cnt;
					printf("请输入修改后的书籍名称：\n");
					scanf("%s", title);
					printf("请输入修改后的籍书号：\n");
					scanf("%s", isbn);
					printf("请输入修改后的书籍作者：\n");
					scanf("%s", author);
					printf("请输入修改后的出版社：\n");
					scanf("%s", publisher);
					printf("请输入修改后的出版日期：\n");
					scanf("%s", publishtime);
					printf("请输入修改后的图书单价：\n");
					scanf("%d", &value);
					printf("请输入修改后的书籍数量：\n");
					scanf("%d", &cnt);
					strcpy(tb->title,title);
					strcpy(tb->isbn,isbn);
					strcpy(tb->author,author);
					strcpy(tb->publisher,publisher);
					strcpy(tb->publishtime,publishtime);
					tb->value=value;
					tb->cnt=cnt;
					break;
				}
				tb = tb->next; ++dd;
			}	
		} 
		system("pause"); system("cls");
	}
} 
void delete_book()  //删除图书信息
{
	while (1)
	{
		browse_book();
		printf("请输入待删除的书籍序号(输入 0 退出删除操作)：\n");
		int cnt; scanf("%d", &cnt);
		if (cnt == 0)
		{
			printf("已成功退出删除系统！\n"); system("pause"); system("cls");
			return;
		}
		else if (cnt > book_amount || cnt < 0)
		{
			printf("请正确输入上图中待删除的图书序号！\n");
		}
		else
		{
			Book* tb = (Book*)malloc(sizeof(Book));
			Book* np = (Book*)malloc(sizeof(Book));
			np = book_head;
			tb = book_head->next;
			for (int i = 1; i < cnt; ++i)
			{
				np = tb;
				tb = tb->next;
			}
			np->next = tb->next;
			free(tb); --book_amount;
			save();
			printf("该图书已从馆内删除成功！\n");
		}
		system("pause"); system("cls");
	}
}

void browse_book()  //图书浏览
{
	int cnt = 1;
	if (!book_amount)
	{
		printf("馆内暂无图书资料，请联系管理员添加书籍！\n");
		return;
	}
	Book* tb = (Book*)malloc(sizeof(Book));
	tb = book_head->next;
	printf("馆内图书详情如下：\n");
	printf("+--------------------------------------------------------------------------------+\n");
    printf("|序号|    书名    |    书号    |    作者    |   出版社   |   出版日期  |单价|数量|\n");
    printf("+--------------------------------------------------------------------------------+\n");
	while (tb)
	{
		printf("|%4d|%12s|%12s|%12s|%12s|%12s|%4d|%4d|\n", cnt, tb->title, tb->isbn,
			tb->author, tb->publisher,tb->publishtime,tb->value, tb->cnt);
		tb = tb->next; ++cnt;
	}
}
void search_book()//tu 
{   while(1) 
	{  
        printf("+------------------------------------+\n");
        printf("*    请输入选项前的数字以确认操作    *\n");
		printf("*          1、按书名查找             *\n");
		printf("*          2、按作者查找             *\n");
		printf("*          3、按书号查找             *\n");
		printf("*          4、按出版社查找           *\n");
		printf("*          0、返回欢迎页面           *\n");
		printf("+------------------------------------+\n");
		int op; scanf("%d", &op); system("cls");
		switch (op)
		{
			case 1: search_title(); system("pause"); system("cls"); break;
			case 2: search_author(); system("pause"); system("cls"); break;
			case 3: search_isbn();  system("pause"); system("cls"); break;
			case 4: search_publisher(); system("pause"); system("cls"); break;
			case 0: system("pause"); system("cls"); return ;
			default: printf("错误的指令，请重新输入！\n"); 
			system("cls"); break;
		}
	}
}
void search_title()   //按书名查找 
{
	
	Book* tb = (Book*)malloc(sizeof(Book));
	tb = book_head->next;
	printf("请输入查找书名\n");
	char name[100];
	scanf("%s",name);
	printf("+--------------------------------------------------------------------------+\n");
    printf("|    书名    |    书号    |    作者    |   出版社   |  出版日期  |单价|数量|\n");
    printf("+--------------------------------------------------------------------------+\n");
	while (tb)
	{
		if(strcmp(tb->title,name)==0)
		{
			printf("|%12s|%12s|%12s|%12s|%12s|%4d|%4d|\n", tb->title, tb->isbn,
			tb->author, tb->publisher,tb->publishtime,tb->value, tb->cnt);
		}
		
		tb = tb->next;
	}
}
void search_author()       // 按作者查找 
{
	Book* tb = (Book*)malloc(sizeof(Book));
	tb = book_head->next;
	printf("请输入图书作者\n");
	char name[100];
	scanf("%s",name);
	printf("+--------------------------------------------------------------------------+\n");
    printf("|    书名    |    书号    |    作者    |   出版社   |  出版日期  |单价|数量|\n");
    printf("+--------------------------------------------------------------------------+\n");
	while (tb)
	{
		if(strcmp(tb->author,name)==0)
		{
			printf("|%12s|%12s|%12s|%12s|%12s|%4d|%4d|\n", tb->title, tb->isbn,
			tb->author, tb->publisher,tb->publishtime,tb->value, tb->cnt);
		}
		tb = tb->next;
	}

}
void search_isbn()         //按书号查找 
{
	Book* tb = (Book*)malloc(sizeof(Book));
	tb = book_head->next;
	printf("请输入查找书号\n");
	char name[100];
	scanf("%s",name);
    printf("+--------------------------------------------------------------------------+\n");
    printf("|    书名    |    书号    |    作者    |   出版社   |  出版日期  |单价|数量|\n");
    printf("+--------------------------------------------------------------------------+\n");
	while (tb)
	{
		if(strcmp(tb->isbn,name)==0)
		{
			printf("|%12s|%12s|%12s|%12s|%12s|%4d|%4d|\n", tb->title, tb->isbn,
			tb->author, tb->publisher,tb->publishtime,tb->value, tb->cnt);
		}
		tb = tb->next;
	}
}
void search_publisher()     //按出版社查找 
{
	Book* tb = (Book*)malloc(sizeof(Book));
	tb = book_head->next;
	printf("请输入出版社名称\n");
	char name[100];
	scanf("%s",name);
	printf("+--------------------------------------------------------------------------+\n");
    printf("|    书名    |    书号    |    作者    |   出版社   |  出版日期  |单价|数量|\n");
    printf("+--------------------------------------------------------------------------+\n");
	while (tb)
	{
		if(strcmp(tb->publisher,name)==0)
		{
			printf("|%12s|%12s|%12s|%12s|%12s|%4d|%4d|\n", tb->title, tb->isbn,
			tb->author, tb->publisher,tb->publishtime,tb->value, tb->cnt);
		}
		
		tb = tb->next;
	}
}

**
 
项目需求：
 
**
 为图书阅览室开发一个图书借阅系统，最多可存50本书，实现图书的管理。图书借阅系统具备以下功能：
 1.查看图书信息
 菜单选择查看功能，展示当前所有图书的相关信息，效果如下。
 
 
case 2:
				System.out.println("--->查看图书");
				System.out.println("序号\t状态\t名称\t\t借出日期");
				for(int i = 0;names[i] != null;i ++){
					String situation = (states[i] == 0)?"已借出":"可借";
					System.out.print((i+1) + "\t" + situation + "\t《" + names[i] + "》\t");
					if(states[i] == 0){
						System.out.println(dates[i]);
					}else{
						System.out.println();
					}
				}
				System.out.println("*************************");
				break;
 
2.新增图书信息
 菜单选择新增功能，根据提示输入新增的图书信息，添加到库存：效果如下。如果图书货架已满，即达到50本图书，则提示增加失败的信息。
 
 
 
case 1:
				System.out.println("--->新增图书");
				int a = 0;
				for(;a < names.length;a ++){
					if(names[a] == null){
					System.out.print("请输入图书名称：");
				    names[a]= input.next();//录入书名
					System.out.println("\n" + "新增《" +names[a] +"》成功！");
					
					//将图书信息存入数组中
					states[a] = 1;
					times[a] = 0;
					dates[a] = null;
					break;
					}
				}
				if(a == 50){
					System.out.println("货架已满，增加失败");
				}
				System.out.println("*************************");
				break;
 
3.删除图书信息
 执行“删除”命令，输入要删除的图书名称后进行删除，效果如下。如果图书为借出状态，不允许删除。如果没有在图书列表中找到该图书信息，则提示：“没有找到匹配信息！”
 
 
 
 
case 3:
				System.out.println("--->删除图书");
				System.out.println("请输入图书名称");
				String book = input.next();
				boolean check1 = false;//判断是否找到需要删除的书目，false为未找到
				for(int b = 0;names[b] != null;b ++){
					if(names[b].equals(book)){
						check1 = true;
						if(states[b] == 1){//图书未借出，可以删除
							System.out.println("删除《" +book + "》成功！");
							int i = b;
							for(;i <names.length-1;i ++){
								states[i] = states[i+1];//第三本书未借出
								names[i] = names[i+1];
								dates[i] = dates[i+1];
								times[i] = times[i+1];
							}//将数组内容前移
							
							//将最后一本书的位置进行初始化
							states[i] = 1;//第三本书未借出
							names[i] = null;
							dates[i] = null;
							times[i] = 0;
							break;
						}else{
							System.out.println("图书已借出，无法删除！");
							break;
						}
				    }
				}
				if(check1 == false){
					System.out.println("没有找到匹配信息！");
				}
				System.out.println("*************************");
				break;
 
4.借出图书
 执行“借出”命令，实现图书的借出，效果如下。如果该图书已被借出，则系统提示“XXX已被借出”。如果没有找到该图书信息，则系统提示：“没有找到匹配信息！”借出日期是以（年-月-日）的格式进行输入的。
 
 
 
case 4:
				System.out.println("--->借出图书");
				System.out.println("请输入图书名称：");
				String lend = input.next();
				boolean check2 = false;//判断想要借出的书是否能找到，false为未找到，true为找到
				for(int b = 0;names[b] != null;b ++){
					if(names[b].equals(lend)){//如果该书存在
						check2 = true;//想要借的书能被找到
						if(states[b] == 1){//如果图书未借出
							System.out.println("请输入借出日期（年-月-日）:");
							dates[b] = input.next();
							while(judge(dates[b]) == false){
								System.out.println("日期非法，请重新输入！");
								dates[b] = input.next();
							}
							states[b] = 0;//将当前图书的状态转化为借出
							times[b] ++;//当前图书的借出次数加一
						}else{//如果图书已经借出
							System.out.println(names[b] + "已被借出！");						
						}
						break;
					}
				}
				if(check2 == false){
					System.out.println("没有找到匹配信息！");
				}
				System.out.println("*************************");
				break;
 
5.归还图书
 执行“归还”命令，实现归还图书，并计算租金（1元/天），效果如下。如果归还的图书未被借出，则系统提示：“该图书没有被借出！无法进行归还操作。”如果归还的图书与列表中的图书不匹配，则系统提示：“没有找到匹配信息！”
 
 
 
case 5:
				System.out.println("--->归还图书");
				System.out.println("请输入图书名称:");
				String back = input.next();
				boolean check3 = false;//判断想要归还的书是否能找到，false为未找到，true为找到
				for(int b = 0;names[b] != null;b ++){
					if(names[b].equals(back)){//如果该书存在
						check3 = true;//想要借的书能被找到
						if(states[b] == 0){//如果图书已经借出
							System.out.println("请输入归还日期（年-月-日）:");
							String returnDate = input.next();
							while(judge(returnDate) == false){
								System.out.println("日期非法，请重新输入！");
								returnDate = input.next();
							}
							System.out.println("归还《" + back + "》成功！");
							System.out.println("借出日期：" + dates[b]);
							System.out.println("归还日期：" + returnDate);
							int money = 0;
							try {
								money = daysBetween(dates[b],returnDate);
							} catch (ParseException e) {
								e.printStackTrace();
							}
							System.out.println("应付租金（元）：" + money );
							states[b] = 1;//将当前图书的状态转化为未借出							
						}else{//如果图书未借出
							System.out.println("该书没有被借出，无法进行归还操作！");						
						}
						break;
					}
				}
				if(check3 == false){
					System.out.println("没有找到匹配信息！");
				}
				System.out.println("*************************");
				break;
 
public class bookLending {
	//定义函数，用于判断日期是否合法
	static boolean judge (String str) {
		SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd");//括号内为日期格式，y代表年份，M代表年份中的月份（为避免与小时中的分钟数m冲突，此处用M），d代表月份中的天数
		try {
			sd.setLenient(false);//此处指定日期/时间解析是否不严格，在true是不严格，false时为严格
			sd.parse(str);//从给定字符串的开始解析文本，以生成一个日期
		}
		catch (Exception e) {
			return false;
		}
		return true;
	}
 
public static int daysBetween(String smdate,String bdate) throws ParseException{
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
			Calendar cal = Calendar.getInstance();
			cal.setTime(sdf.parse(smdate));
			long time1 = cal.getTimeInMillis();
			cal.setTime(sdf.parse(bdate));
			long time2 = cal.getTimeInMillis();
			long between_days=(time2-time1)/(1000*3600*24);
		return Integer.parseInt(String.valueOf(between_days));
		}
 
6.借出排行榜
 将所有数目按照借出次数从大到小进行排序
 
 
	public static void printBook(String[] names, int[] times, int[] sortBook, int number){
		int[] another = times.clone();//复制数组
		int i = 0;
		int max = another[0];//求出借出次数的最大值，用于设置循环条件
		for(int p = 0;p <= max;p ++){//从0至借出次数最大值，依次查询借出次数对应的书的下标，并存储在sortBook数组中
			for(int q = 0;q < number;q ++){//遍历次数数组，将符合条件的数组值的下标存储在sortBook数组中
				if(times[q] == p){
					sortBook[i++] = q;
				}
			}
		}
		System.out.println("序号\t" + "书名\t\t" + "借出次数");
		for(int x = (number-1);x >= 0;x --){//打印借出次数排行榜
			System.out.println((number-x) + "\t" + names[sortBook[x]] + "\t\t" + times[sortBook[x]]);
		}
		System.out.println("*************************");
	}
 
case 0:
				int number = 0;//初始化书目总数未0
				for(;names[number] != null;number ++){}//求出当前书目总数
				int[] sortBook = new int[number];
	            printBook(names,times,sortBook, number);//调用函数导出借出排行榜
				break;
 
7.退出
 当用户执行“退出”命令时，结束本程序；
 
以下为总代码：
 
package bookLending;

import java.util.Scanner;
import java.text.SimpleDateFormat;
import java.util.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class bookLending {
	//定义函数，用于判断日期是否合法
	static boolean judge (String str) {
		SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd");//括号内为日期格式，y代表年份，M代表年份中的月份（为避免与小时中的分钟数m冲突，此处用M），d代表月份中的天数
		try {
			sd.setLenient(false);//此处指定日期/时间解析是否不严格，在true是不严格，false时为严格
			sd.parse(str);//从给定字符串的开始解析文本，以生成一个日期
		}
		catch (Exception e) {
			return false;
		}
		return true;
	}
	public static void printBook(String[] names, int[] times, int[] sortBook, int number){
		int[] another = times.clone();//复制数组
		int i = 0;
		int max = another[0];//求出借出次数的最大值，用于设置循环条件
		for(int p = 0;p <= max;p ++){//从0至借出次数最大值，依次查询借出次数对应的书的下标，并存储在sortBook数组中
			for(int q = 0;q < number;q ++){//遍历次数数组，将符合条件的数组值的下标存储在sortBook数组中
				if(times[q] == p){
					sortBook[i++] = q;
				}
			}
		}
		System.out.println("序号\t" + "书名\t\t" + "借出次数");
		for(int x = (number-1);x >= 0;x --){//打印借出次数排行榜
			System.out.println((number-x) + "\t" + names[sortBook[x]] + "\t\t" + times[sortBook[x]]);
		}
		System.out.println("*************************");
	}
	public static int daysBetween(String smdate,String bdate) throws ParseException{
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
			Calendar cal = Calendar.getInstance();
			cal.setTime(sdf.parse(smdate));
			long time1 = cal.getTimeInMillis();
			cal.setTime(sdf.parse(bdate));
			long time2 = cal.getTimeInMillis();
			long between_days=(time2-time1)/(1000*3600*24);
		return Integer.parseInt(String.valueOf(between_days));
		}

	public static void main(String[] args) {
		//定义数据主体：图书
		int[] states = new int[50];//状态,0：已借出，1：可借
		String[] names = new String[50];//名称
		String[] dates = new String[50];//借出日期,二维数组将年月日分别存储，便于计算日期
		int[] times = new int[50];//借出次数

		//初始化四个数据
		states[0] = 0;//第一本书已借出
		names[0] = "数据结构";
		dates[0] = "2018-7-1";//第一本书于2018年7月1日借出
		times[0] = 1;//第一本书已借出一次
		
		states[1] = 1;//第二本书未借出
		names[1] = "数据库";
		dates[1] = null;
		times[1] = 0;//第二本书还未借出过
		
		states[2] = 1;//第三本书未借出
		names[2] = "离散数学";
		dates[2] = null;
		times[2] = 0;//第三本书还未借出过
		
		states[3] = 1;//第四本书未借出
		names[3] = "编译原理";
		dates[3] = null;
		times[3] = 0;//第四本书还未借出过
		
		//搭建程序流程框架
		Scanner input = new Scanner(System.in);
		int num = -1;//用户输入0时返回主菜单，num在借阅操作后进行重新赋值
		boolean flag = false;//记录用户是否退出系统，true为退出，false为不退出
		System.out.println("欢迎使用图书借阅系统");
		
		do{
			System.out.println("---------------------");
			System.out.println("0.借出排行榜");
			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("---------------------");
			System.out.println("请选择：");
			int choose = input.nextInt();
			switch(choose){
			case 0:
				int number = 0;//初始化书目总数未0
				for(;names[number] != null;number ++){}//求出当前书目总数
				int[] sortBook = new int[number];
	            printBook(names,times,sortBook, number);//调用函数导出借出排行榜
				break;
			case 1:
				System.out.println("--->新增图书");
				int a = 0;
				for(;a < names.length;a ++){
					if(names[a] == null){
					System.out.print("请输入图书名称：");
				    names[a]= input.next();//录入书名
					System.out.println("\n" + "新增《" +names[a] +"》成功！");
					
					//将图书信息存入数组中
					states[a] = 1;
					times[a] = 0;
					dates[a] = null;
					break;
					}
				}
				if(a == 50){
					System.out.println("货架已满，增加失败");
				}
				System.out.println("*************************");
				break;
			case 2:
				System.out.println("--->查看图书");
				System.out.println("序号\t状态\t名称\t\t借出日期");
				for(int i = 0;names[i] != null;i ++){
					String situation = (states[i] == 0)?"已借出":"可借";
					System.out.print((i+1) + "\t" + situation + "\t《" + names[i] + "》\t");
					if(states[i] == 0){
						System.out.println(dates[i]);
					}else{
						System.out.println();
					}
				}
				System.out.println("*************************");
				break;
			case 3:
				System.out.println("--->删除图书");
				System.out.println("请输入图书名称");
				String book = input.next();
				boolean check1 = false;//判断是否找到需要删除的书目，false为未找到
				for(int b = 0;names[b] != null;b ++){
					if(names[b].equals(book)){
						check1 = true;
						if(states[b] == 1){//图书未借出，可以删除
							System.out.println("删除《" +book + "》成功！");
							int i = b;
							for(;i <names.length-1;i ++){
								states[i] = states[i+1];//第三本书未借出
								names[i] = names[i+1];
								dates[i] = dates[i+1];
								times[i] = times[i+1];
							}//将数组内容前移
							
							//将最后一本书的位置进行初始化
							states[i] = 1;//第三本书未借出
							names[i] = null;
							dates[i] = null;
							times[i] = 0;
							break;
						}else{
							System.out.println("图书已借出，无法删除！");
							break;
						}
				    }
				}
				if(check1 == false){
					System.out.println("没有找到匹配信息！");
				}
				System.out.println("*************************");
				break;
			case 4:
				System.out.println("--->借出图书");
				System.out.println("请输入图书名称：");
				String lend = input.next();
				boolean check2 = false;//判断想要借出的书是否能找到，false为未找到，true为找到
				for(int b = 0;names[b] != null;b ++){
					if(names[b].equals(lend)){//如果该书存在
						check2 = true;//想要借的书能被找到
						if(states[b] == 1){//如果图书未借出
							System.out.println("请输入借出日期（年-月-日）:");
							dates[b] = input.next();
							while(judge(dates[b]) == false){
								System.out.println("日期非法，请重新输入！");
								dates[b] = input.next();
							}
							states[b] = 0;//将当前图书的状态转化为借出
							times[b] ++;//当前图书的借出次数加一
						}else{//如果图书已经借出
							System.out.println(names[b] + "已被借出！");						
						}
						break;
					}
				}
				if(check2 == false){
					System.out.println("没有找到匹配信息！");
				}
				System.out.println("*************************");
				break;
			case 5:
				System.out.println("--->归还图书");
				System.out.println("请输入图书名称:");
				String back = input.next();
				boolean check3 = false;//判断想要归还的书是否能找到，false为未找到，true为找到
				for(int b = 0;names[b] != null;b ++){
					if(names[b].equals(back)){//如果该书存在
						check3 = true;//想要借的书能被找到
						if(states[b] == 0){//如果图书已经借出
							System.out.println("请输入归还日期（年-月-日）:");
							String returnDate = input.next();
							while(judge(returnDate) == false){
								System.out.println("日期非法，请重新输入！");
								returnDate = input.next();
							}
							System.out.println("归还《" + back + "》成功！");
							System.out.println("借出日期：" + dates[b]);
							System.out.println("归还日期：" + returnDate);
							int money = 0;
							try {
								money = daysBetween(dates[b],returnDate);
							} catch (ParseException e) {
								e.printStackTrace();
							}
							System.out.println("应付租金（元）：" + money );
							states[b] = 1;//将当前图书的状态转化为未借出							
						}else{//如果图书未借出
							System.out.println("该书没有被借出，无法进行归还操作！");						
						}
						break;
					}
				}
				if(check3 == false){
					System.out.println("没有找到匹配信息！");
				}
				System.out.println("*************************");
				break;
			case 6:
				flag = true;
				break;
			default:
				flag = true;
				break;
		
			}
			if(flag == true){
				break;
			}else{
				System.out.println("输入0返回");
				num = input.nextInt();
			}
		}while(num == 0);
		System.out.println("谢谢使用！");
	}
}