本文档详述了一个Java实现的图书管理系统，涵盖了图书、读者、借阅信息的增删查改，使用了序列化、TreeSet进行排序，并通过自定义比较器实现了对象的比较。系统包括用户注册、登录、图书信息管理、读者信息管理和借阅信息管理等功能，涉及文件IO流、对象的序列化和反序列化以及异常处理。
目录
一、考察重点
二、功能概述
三、所遇问题及解决方案
四、代码块
五、总结与反思
一、考察重点：
1、熟练Java基础语法
2、理解面向对象的思想
3、理解封装、继承、多态，熟悉接口和异常
4、掌握集合和io流
二、功能概述
总分析：该项目的大体思想就是增、删、查、改，我认为主要难点在于io流的使用和各类直接的联系，怎么把它们串联起来。
1、图书信息管理：增、删、查、改。用户登录成功后，可以添加图书；可以通过ISBN（不重复，唯一的）、书名去查找图书，或者查看全部图书，可以按图书ISBN进行排序；可以根据图书的ISBN去删除图书，或去修改图书的信息。
2、读者信息管理：增、删、查、改。用户登录成功后，可以添加读者；可以通过ID（学号）、姓名去查找读者，或者查看全部图书，可以按读者ID进行排序；可以根据读者的学号（不重复，唯一的）去删除读者，或去修改读者的信息。
3、借阅信息管理：可以根据读者ID去查看该读者的借阅信息，通过读者ID去借书和还书。
4、用户信息管理：包括新用户注册和登录，查看用户信息，修改用户登录密码。
5、项目设计及分类：
三、所遇问题及解决方案
1、用io流读写文件的方式
我用的是序列化和反序列化。在操作过程中，我用到的都是集合，用序列化去写集合，反序列化读集合比较方便。把它写成一个方法，放在每个操作类里，方便调用。具体操作如下（以Book实体类为例）：
/**这里的输入输出是从内存的角度说的，把内存中的对象存到磁盘叫输出，反之从磁盘读入内存叫输入
*序列化： 把内存中的对象存到磁盘文件中去。用的的对象字节输出流（ObjectOutputStream)，它是一个高级管道，需要包一个低级管道（字节输出流）下面包的文件字节输出流。
* 用writeObject去序列化对象
*要序列化的对象需要实现Serializable接口
*/
//序列化
public static void serializable (ArrayList<Book> typeArrayList) {
try {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(typeArrayList);
//oos.flush();
oos.close(); //释放资源
} catch (Exception e) { //抛异常
e.printStackTrace();
}
}
/**
*反序列化：把磁盘中的对象数据恢复成内存中的对象。用对象字节输入流（ObjectInputStream）。
*用readObject
*/
//反序列化
//因为上面序列化的是对象集合，所以这里反序列化出来的也需要的对象集合。
public static ArrayList<Book> turnSerializable () {
ArrayList<Book> typeArrayList = new ArrayList<Book>();
try {
if (!file.exists()) {
file.createNewFile(); //先判断文件是否存在，如果不存在就先建一个
}
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
//这里直接强转集合
typeArrayList = (ArrayList<Book>) ois.readObject();
ois.close();
} catch (Exception e) {
System.out.println("文件首次创建成功");
}
return typeArrayList; //返回值是反序列化的集合
}2、各个类之间的联系：比如：借阅类中要有图书类的信息，图书的ISBN、书名。用户类中要有读者的ID、姓名。还有就是我的思路是先创建一个对象，比如图书对象，然后再调用函数把图书对象存起来，我认为这样操作起来比较简单，但是需要串联好各个类。
3、用TreeSet进行排序：
TreeSet集合特点和概述：
a：不重复、无索引、可排序。
b：可排序：按照元素的大小默认升序（由大到小）排序。对于数值类型：Integer、Doubl，官方默认按照大小进行升序排序。对于字符串类型：默认按照首字母的编号升序排序，若首字母相同，则看第二个，依次类推，若都相同，则看字符串长度。
c：TreeSet集合底层是基于红黑树的数据结构实现排序的，增删查改性能都很好。
注意：TreeSet集合是一定要排序的，可以将元素按照指定的规则进行排序。对于自定义的Student对象，TreeSet无法直接排序，要想使用，则需要制定排序规则，并且需要实现Comparable。如果TreeSet集合存储的对象有实现比较规则，集合也自带比较器，默认使用集合自带的比较排序。例如：
//学生类实现Comparable接口，TreeSet就可以对学生进行自然排序
public class Student implements Comparable<Student>{
private String name;
private int age;
//实现元素排序的规则
/*
根据返回值排序
返回的负数，认为当前要存入的元素比较小，存左边
返回的正数，认为当前要存入的元素比较大，存右边
返回的0，认为当前要存入的元素已经存在，不存入
*/
@Override
public int compareTo(Student o) {
//按照年龄升序排序 (从小到大)
return this.age - o.age;
//按照年龄降序排序（从大到小）
//return o.age - this.age;
}测试类：
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet<Student> ts = new TreeSet<>();
ts.add(new Student("lisi",21));
ts.add(new Student("zhangsan",28));
ts.add(new Student("zhaoliu",25));
Iterator<Student> it = ts.iterator();
while(it.hasNext()){
Student s = it.next();
System.out.println(s.getName()+"："+s.getAge());
}
}
}输出结果：
lisi：21
zhaoliu：25
张三：28四、代码块
我的思路是先建立实体类，然后再对它们进行增删查改等基本的操作，再考虑怎么把它们联系起来。
实体类：
Book类：
package Entity_Class;
import java.io.Serializable;
//要序列化的对象需要实现Serializable接口
public class Book implements Serializable ,Comparable<Book>{
//书号、书名、作者、出版社、出版日期、存馆数量、定价
private String ISBN;
private String name;
private String author;
private String publish;//出版社
private String publishData;//出版日期
private int number;
private double price;
//get、set以及构造方法
//重写toString
@Override
public String toString() {
return
ISBN+"\t\t"+name+"\t\t"+author+"\t\t"+publish+"\t\t"+publishData+"\t\t"+number+"\t\t"+price;
}
//自定义比较器
@Override
public int compareTo(Book o) {
return this.getISBN().compareTo(o.getISBN());
}
}
Book操作类：
public class BookOp {
//用来储存book
//书号ISBN、书名name、作者author、出版社publish、出版日期publishData、存馆数量number、定价price
private static File file = new File("management/src/Information/Book.txt");
//Scanner sc=new Scanner(System.in);
//添加图书，我这里是直接传入图书对象，这样存起来比较简单
public static void AddBook(Book book) {
//因为我们序列化和反序列化的都是对象集合，所以建立对象集合是必要的
ArrayList<Book> arrayListBook = new ArrayList<>();
boolean flag = true;
if (file.exists() && file.length() == 0) { //如果文件存在并且为空，可以直接添加，不需要判断ISBN的重复
arrayListBook.add(book);
serializable(arrayListBook);//直接把集合存起来
System.out.println("图书：" + book.getName() + "添加成功");
} else {
//文件存在，且有数据的情况，需要判断ISBN是否重复，先读取文件内容
arrayListBook = turnSerializable();
for (Book book1 : arrayListBook) {//增强for循环
//判断ISBN是否重复
if (book.getISBN().equals(book1.getISBN())) {
System.out.println("该图书已存在！");
flag = false;
break;
}
}
//ISBN不重复
if (flag) {
arrayListBook.add(book);
serializable(arrayListBook);
System.out.println("图书：" + book.getName() + "添加成功");
}
}
}
//输出全部图书
public static void printAllBook() {
//先判断文件是否存在或有没有内容
if (file.exists() == false) {
System.out.println("文件不存在，请先创建文件！");
} else if (file.length() == 0) {
System.out.println("文件中还没添加图书，请先添加！");
} else {
ArrayList<Book> arrayListBook = new ArrayList<>();//必要的
arrayListBook = turnSerializable();//读出来
Iterator<Book> it = arrayListBook.iterator();//建立迭代器
System.out.println("图书编号ISBN" + "\t\t图书名称" + "\t\t作者" + "\t\t出版社" + "\t\t出版日期" + "\t\t单价");
while (it.hasNext()) {//先判断是否有元素，再取元素
Book b = it.next();//it向后移
System.out.println(b.toString());//输出
}
}
}
//查找指定图书（按书名查找）
public static void getNameBook(String name) {
//思路还是先判断文件
if (file.exists() == false) {
System.out.println("文件不存在，请先创建文件！");
} else if (file.length() == 0) {
System.out.println("文件中还没添加图书，请先添加！");
} else {
ArrayList<Book> bookArrayList = new ArrayList<>();
bookArrayList = turnSerializable();
Iterator<Book> it = bookArrayList.iterator();
for (Book list : bookArrayList) { //查找书名相同的情况
if (list.getName().equals(name)) {
System.out.println("恭喜您！找到了！");
System.out.println(list.toString());
return;
}
}
System.out.println("您查找的图书不存在！");
}
}
//删除图书（按ISBN）
public static void deleteBook(String ISBN) {
//同上
if (file.exists() == false) {
System.out.println("文件不存在，请先创建文件！");
} else if (file.length() == 0) {
System.out.println("文件中还没添加图书，请先添加！");
} else {
ArrayList<Book> bookArrayList = new ArrayList<>();
bookArrayList = turnSerializable();
Iterator<Book> it = bookArrayList.iterator();
while (it.hasNext()) {
Book b = it.next();
if (b.getISBN().equals(ISBN)) {
it.remove(); //这里用迭代器取删除
System.out.println("删除成功！");
serializable(bookArrayList);
return;
}
}
System.out.println("您输入的IBSN错误或不存在！");
}
return;
}
//根据ISBN修改图书信息
public static void modifyBookInfo(String ISBN) {
if (file.exists() == false) {
System.out.println("文件不存在，请先创建文件！");
} else if (file.length() == 0) {
System.out.println("文件中还没添加图书，请先添加！");
} else {
ArrayList<Book> bookArrayList = new ArrayList<>();
bookArrayList = turnSerializable(); //先读文件
Iterator<Book> it = bookArrayList.iterator();
while (it.hasNext()) { //再判断
Book b = it.next();
if (b.getISBN().equals(ISBN)){
System.out.println("您要修改图书的原信息为：");
System.out.println(b.toString());
System.out.println("注意：如果不要修改此项信息，可直接回车跳过！");
System.out.println("请输入图书新的ISBN：");
String newISBN= Utility.modifyString(8,b.getISBN());
b.setISBN(newISBN);
System.out.println("请输入图书新的价格：");
String price = Utility.modifyString(10,String.valueOf(b.getPrice()));
b.setPrice(Double.parseDouble(price));
System.out.println("请输入图书新的数量：");
String number = Utility.modifyString(10,String.valueOf(b.getNumber()));
b.setNumber(Integer.parseInt(number));
//bookArrayList.remove(b);
//bookArrayList.add(new Book(newISBN,b.getName(),b.getAuthor(),b.getPublish(),b.getPublishData(),Integer.parseInt(number),Double.parseDouble(price)));
//bookArrayList.remove(b);
serializable(bookArrayList); //最后写入文件
System.out.println("修改成功！");
}
}
}
}
//根据ISBN查找，并返回Book对象，因为再后面会用到，思路和上面的查找一样
public static Book getISBNBook(String ISBN){
if (file.exists() == false) {
System.out.println("文件不存在，请先创建文件！");
} else if (file.length() == 0) {
System.out.println("文件中还没添加图书，请先添加！");
} else {
ArrayList<Book> bookArrayList = turnSerializable();
Iterator<Book> it = bookArrayList.iterator();
while (it.hasNext()) {
Book b = it.next();
if(b.getISBN().equals(ISBN)){
return b;
}
}
}
return null;
}
//更新指定ISBN图书的数量，在后面也会用到
public static void updateBookNumber(String ISBN,int number){
ArrayList<Book> arrayList = turnSerializable();
Iterator<Book> it = arrayList.iterator();
while (it.hasNext()){
Book book = it.next();
if(book.getISBN().equals(ISBN)){
book.setNumber(number);
}
serializable(arrayList);
}
}
}Rearer类：
public class Reader implements Serializable ,Comparable<Reader> {
//学号、姓名、学院、专业班级
private String id;
private String name;
private String faculty;//院系
private String major;//专业
public Reader(){
}
public Reader(String id, String name, String faculty, String major) {
this.id = id;
this.name = name;
this.faculty = faculty;
this.major = major;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getFaculty() {
return faculty;
}
public void setFaculty(String faculty) {
this.faculty = faculty;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
@Override
public String toString() {
return id +"\t\t"+name + "\t\t" + faculty + "\t\t" + major;
}
@Override
public int compareTo(Reader r) {
return this.getId().compareTo(r.getId());
//return Integer.parseInt(this.getId()) - Integer.parseInt(r.getId());
}
}
BorrowBook类：
public class BorrowBook implements Serializable {
//学号、姓名、书号、书名、借阅日期、应还日期、归还日期
private String readerId;
private String readerName;
private String ISBN;
private String borrowData;//借阅日期
private String returnData;//归还日期
private String answerData;//应还日期
public BorrowBook(){
}
public BorrowBook(String readerId, String readerName, String ISBN, String borrowData, String returnData, String answerData) {
this.readerId = readerId;
this.readerName = readerName;
this.ISBN = ISBN;
this.borrowData = borrowData;
this.returnData = returnData;
this.answerData = answerData;
}
public String getReaderId() {
return readerId;
}
public void setReaderId(String readerId) {
this.readerId = readerId;
}
public String getReaderName() {
return readerName;
}
public void setReaderName(String readerName) {
this.readerName = readerName;
}
public String getISBN() {
return ISBN;
}
public void setISBN(String ISBN) {
this.ISBN = ISBN;
}
public String getBorrowData() {
return borrowData;
}
public void setBorrowData(String borrowData) {
this.borrowData = borrowData;
}
public String getReturnData() {
return returnData;
}
public void setReturnData(String returnData) {
this.returnData = returnData;
}
public String getAnswerData() {
return answerData;
}
public void setAnswerData(String answerData) {
this.answerData = answerData;
}
@Override
public String toString() {
return readerId+"\t\t"+readerName+"\t\t"+ISBN+"\t\t"+borrowData+"\t\t"+returnData+"\t\t"+answerData;
}
}注意：这里的有些变量是一样的，就比如借阅类，包含图书的书名、书号，和读者类，图书类等就能联系起来！！
以上的操作类，大体思路一致，不在赘述，详情请见代码。
这里，我创建了一个工具类，方便后来调用。
public class Utility {
//工具类，用于存放不同的方法，方便调用
private static Scanner sc=new Scanner(System.in);
//限制参数长度
public static String readKeyBoard1(int limit,boolean blankReturn){
String line="";
while (sc.hasNextLine()){ //读取一行，以回车结束，可以为空
line= sc.nextLine();
if (line.length() == 0) {
if (blankReturn) return line; //当blankReturn为true时，返回空
else continue;
}
if(line.length()<1||line.length()>limit){
System.out.println("您输入长度有误"+"(不大于"+limit+")"+"请重新输入:");
continue;
}
break;
}
return line;
}
//固定参数长度
public static String readKeyBoard2(int limit,boolean blankReturn){
String line="";
while (sc.hasNextLine()){
line= sc.nextLine();
if (line.length() == 0) {
if (blankReturn) return line;
else continue;
}
if(line.length()!=limit){
System.out.println("您输入长度错误，请重新输入:"+"长度为"+limit);
continue;
}
break;
}
return line;
}
//用于菜单选择，同时利用了readKeyBoard2函数
public static char readSelect(){
char select;
while (true){
String s=readKeyBoard1(1,false);
select=s.charAt(0);//因为需要的是字符型，而且只需要返回1个长度的字符串，所以此处合理；
if(select<'1'||select>'6'){
System.out.println("输入有误，请重新输入(1-6)：");
}
else {
break;
}
}
return select;
}
//用于用户修改ISBN
public static String modifyString(int limit,String string){
String newString=readKeyBoard1(limit,true);
return newString.equals("")?string:newString; //三元运算符，如果newString等于空，返回string，否则返回newString
}
//用于进行下一步操作
public static void readReturn() {
System.out.print("按回车键继续...");
readKeyBoard1(100, true);
}
//用于退出系统（Y/N）
public static char select(){
char s;
while (true){
String se= readKeyBoard1(1,false);
//这里需要先判断用户输入是否为空，否则会抛异常
if(se==null){
System.out.println("请输入（Y或N）！");
continue;
}else {
s = se.charAt(0);
if (s != 'Y' && s != 'N') {
System.out.println("输入有误，请重新输入！！！！");
} else {
break;
}
}
}
return s;
}
}
以上是对下面操作的基础，下面将展示如何把这些内容联系起来。
BorrowService类：
public class BorrowView {
//先导入文件
private static File BookFile = new File("management\\src\\Information\\Book.txt");
private static File ReaderFile = new File("management\\src\\Information\\Reader.txt");
private static File BorrowBookFile = new File("management\\src\\Information\\BorrowBook.txt");
public static void borrowBookView() {
while (true) {
System.out.println("========================欢迎来到图书借阅系统========================");
System.out.println("1、查看指定读者的借阅信息！");
//System.out.println("2、添加指定读者的借阅信息！");
System.out.println("2、借书系统！");
System.out.println("3、还书系统！");
System.out.println("4、退出借阅系统！");
System.out.println("请输入您的选择：");
char command = Utility.readSelect();
switch (command) {
case '1':
System.out.println("目前所有的读者信息如下：");
ReaderOp.printAllReader();
System.out.println("请输入您要查询的读者的ID：");
String id = Utility.readKeyBoard1(10, true);
BorrowBookOp.printIDBorrowBook(id);
break;
case '2':
borrowBookSystem();
Utility.readReturn();
break;
case '3':
returnBookSystem();
Utility.readReturn();
break;
case '4':
System.out.println("请您输入指令（N或Y）：");
char select = Utility.select();
if (select == 'Y') {
return;
// break;
} else {
System.out.println("欢迎继续使用本系统！");
Utility.readReturn();
}
default:
System.out.println("您输入的指令有误，请重新输入！！！！");
}
}
}
//借书系统
public static void borrowBookSystem() {
Scanner sc = new Scanner(System.in);
System.out.println("======================欢迎来到借书系统========================");
System.out.println("当前所有读者的如下：");
ReaderOp.printAllReader();
System.out.println("请输入您的读者ID：");
String id = Utility.readKeyBoard1(10, true);
Reader reader = ReaderOp.getIdReader(id);
try {
//System.out.println("您的借阅信息如下：");
//BorrowBookOp.printIDBorrowBook(id);
Utility.readReturn();
} catch (NullPointerException n) { //空指针异常，如过查询不到所输入的id，也就是返回值为null时将退出系统
System.out.println("您输入的ID有误，请重进系统！");
return;
}
System.out.println("目前有如下图书：");
BookOp.printAllBook();
System.out.println("请输入您要借阅图书的ISBN：");
String ISBN = Utility.readKeyBoard1(10, true);
Book book = BookOp.getISBNBook(ISBN);
try {
System.out.println("您要借阅的图书是《" + book.getName() + "》");
} catch (NullPointerException n) {
System.out.println("您输入图书的ISBN有误，请重进系统！");
return;
}
System.out.println("您要借阅图书的全部信息是：");
System.out.println(book.toString());
if (book.getNumber() == 0) {
System.out.println("您所借阅的图书已全部被接出！");
System.out.println("请重新登录系统！");
return;
} else {
System.out.println("请输入借阅日期：（格式：yyyy-MM-dd）");
String borrowData=Utility.readKeyBoard1(10,true);//借阅日期
System.out.println("请您输入应还日期（格式：yyyy-MM-dd，借阅时长为一个月！）：");
String answerData=Utility.readKeyBoard1(10,true);//应还日期
BorrowBook borrowBook = new BorrowBook(id, book.getName(), book.getISBN(), borrowData, null, answerData);
BorrowBookOp.addIDBorrowBook(borrowBook);
int number=book.getNumber(); //借书成功后，该书的数量要加一
BookOp.updateBookNumber(book.getISBN(),number-1);
System.out.println("借书成功！！");
return;
}
}
//还书系统
public static void returnBookSystem() {
Scanner sc = new Scanner(System.in);
System.out.println("======================欢迎来到借阅系统========================");
System.out.println("当前有读者：");
ReaderOp.printAllReader();
Utility.readReturn();
System.out.println("请您输入读者的ID：");
String id = Utility.readKeyBoard2(10, false);
Reader reader = ReaderOp.getIdReader(id);
System.out.println(reader);
try {
System.out.println("您的借阅信息如下：");
System.out.println("读者ID" + "\t\t书名" + "\t\t图书编号ISBN" + "\t\t借阅日期" + "\t\t归还日期" + "\t\t应还日期");
ArrayList<BorrowBook> bookArrayList = new ArrayList<>();
bookArrayList = BorrowBookOp.getReaderIdBorrowBook(id);
Iterator<BorrowBook> it=bookArrayList.iterator();
while (it.hasNext()) {
BorrowBook borrowBook = it.next();
System.out.println(borrowBook);
}
Utility.readReturn();
System.out.println("请输入要还图书的ISBN：");
String ISBN = Utility.readKeyBoard1(8, false);
Book b = BookOp.getISBNBook(ISBN);
ArrayList<BorrowBook> borrowBooks = BorrowBookOp.getISBNBorrowBook(ISBN);
if(borrowBooks==null){
System.out.println("您还没借书呢，怎么还书！！！！！");
}
Iterator iterator = borrowBooks.iterator();
while (iterator.hasNext()) {
BorrowBook book = (BorrowBook) iterator.next();
if (book.getReaderId().equals(id)) {
System.out.println("请您输入还书日期(格式：yyyy-MM-dd):");
String returnData=Utility.readKeyBoard2(10,false);
book.setReturnData(returnData);
BorrowBookOp.updateBorrowBook(book);
int number=b.getNumber(); //还书成功后，该书的数量需要加一
BookOp.updateBookNumber(b.getISBN(),number+1);
System.out.println("还书成功~~~");
}
}
} catch (NullPointerException n) {
System.out.println("读者ID输入错误，请重进系统！");
return;
}
}
public static Date answerData(Date date) {
boolean flag = true;
int year = date.getYear();
int month = date.getMonth();
int days = date.getDays();
//(x%400==0)||(x%400!=0)&&(x%4==0)&&(x%100!=0);
if (year % 400 == 0 || (year % 4 == 0) && (year % 100 != 0)) {//闰年的判断
flag = false;
if (month == 2) {
days = days + 30 - 29;
month = month + 1;
date.setDays(days);
date.setMonth(month);
return date;
}
}
if (month == 2 && flag) {
days = days + 30 - 28;
month = month + 1;
date.setDays(days);
date.setMonth(month);
return date;
} else if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
int days1 = days + 30 > 31 ? days + 30 - 31 : days + 30;
int month1 = days + 30 > 31 ? month == 12 ? 1 : month + 1 : month;
int year1 = month == 12 ? days > 1 ? year + 1 : year : year;
date.setDays(days1);
date.setMonth(month1);
date.setYear(year1);
return date;
} else if (month == 4 || month == 6 || month == 9 || month == 11) {
month += 1;
date.setMonth(month);
return date;
}
return null;
}Service类：
public class ServiceView {
public static void Service() {
while (true) {
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("请输入您的选择(1-6)：");
char command = Utility.readSelect();
switch (command) {
case '1':
bookSystem();
break;
case '2':
readerSystem();
break;
case '3':
BorrowView.borrowBookView();
break;
case '4':
userSystem();
break;
case '5':
break;
case '6':
System.out.println("您是否要退出系统（Y/N）");
char c1 = Utility.select();
if (c1 == 'Y') {
System.out.println("成功退出！！");
return;
} else {
System.out.println("欢迎继续使用本系统~~");
Utility.readReturn();
}
break;
default:
System.out.println("您输入的指令有误！！");
}
}
}
//图书信息管理系统
public static void bookSystem() {
//书号、书名、作者、出版社、出版日期、存馆数量、定价
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("==========================欢迎进入图书信息管理系统========================");
System.out.println("=================================1、添加图书=============================");
System.out.println("================================2、查询图书=============================");
System.out.println("================================3、修改指定ISBN的图书============================");
System.out.println("================================4、根据ISBN删除图书===============================");
System.out.println("=================================5、退出子系统=================================");
System.out.println("请输入您的选择(1-5)：");
char c = Utility.readSelect();
switch (c) {
case '1':
System.out.println("请您输入图书的ISBN（五位数字）：");
String ISBN = Utility.readKeyBoard2(5, false);
System.out.println("请您输入书名：");
String name = Utility.readKeyBoard1(10, false);
System.out.println("请您输入作者：");
String author = Utility.readKeyBoard1(10, false);
System.out.println("请您输入出版社：");
String publish = Utility.readKeyBoard1(10, false);
System.out.println("请输入出版日期（格式：yyyy-mm-dd）：");
String publishDay = Utility.readKeyBoard1(10, false);
System.out.println("请您输入存入的数量：");
int number = sc.nextInt();
System.out.println("请您输入图书的定价：");
double price = sc.nextDouble();
Book book = new Book(ISBN, name, author, publish, publishDay, number, price);
BookOp.AddBook(book);
Utility.readReturn();
break;
case '2':
findBookSystem();
break;
case '3':
System.out.println("请您输入所要修改图书的ISBN：");
String ISBN1 = Utility.readKeyBoard2(5, false);
BookOp.modifyBookInfo(ISBN1);
Utility.readReturn();
break;
case '4':
System.out.println("请您输入所要删除图书的ISBN：");
String ISBN2 = Utility.readKeyBoard2(5, false);
BookOp.deleteBook(ISBN2);
Utility.readReturn();
break;
case '5':
System.out.println("您是否要退出系统（Y/N）");
char c1 = Utility.select();
if (c1 == 'Y') {
System.out.println("成功退出！！");
return;
} else {
System.out.println("欢迎继续使用本系统~~");
Utility.readReturn();
}
break;
default:
System.out.println("您输入的指令有误，请重新输入！！");
Utility.readReturn();
}
}
}
//图书查询系统
public static void findBookSystem() {
while (true) {
System.out.println("=====================欢迎进入图书查询系统！======================");
System.out.println("=====================1、按书名查询=======================");
System.out.println("=====================2、按书号ISBN查询=======================");
System.out.println("=====================3、查询全部图书=======================");
System.out.println("=====================4、按图书ISBN进行排序=======================");
System.out.println("=====================5、退出子系统=======================");
System.out.println("请您输入指令(1-5)：");
char command = Utility.readSelect();
switch (command) {
case '1':
System.out.println("请输入所要查询图书的名字：");
String name = Utility.readKeyBoard1(10, true);
BookOp.getNameBook(name);
Utility.readReturn();
break;
case '2':
System.out.println("请输入所要查询图书的ISBN：");
String ISBN = Utility.readKeyBoard2(5, true);
Book book = BookOp.getISBNBook(ISBN);
System.out.println(book.toString());
break;
case '3':
BookOp.printAllBook();
break;
case '4':
BookOp.cmpISBN();
Utility.readReturn();
break;
case '5':
System.out.println("您是否要退出系统（Y/N）");
char c1 = Utility.select();
if (c1 == 'Y') {
System.out.println("成功退出！！");
return;
} else {
System.out.println("欢迎继续使用本系统~~");
Utility.readReturn();
}
break;
default:
System.out.println("您输入的指令有误，请重新输入！");
}
}
}
//读者信息管理
public static void readerSystem() {
//学号、姓名、学院、专业班级
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("============================欢迎来到读者信息管理系统============================");
System.out.println("==============================1、读者添加===========================");
System.out.println("==============================2、读者查询==============================");
System.out.println("==============================3、读者删除（按读者ID）=====================================");
System.out.println("==============================4、读者信息修改==================================");
System.out.println("==============================5、退出子系统======================================");
System.out.println("请输入您的指令(1-5)：");
char command = Utility.readSelect();
学号、姓名、学院、专业班级
switch (command) {
case '1':
System.out.println("请您输入要添加读者的学号：");
String id = Utility.readKeyBoard2(10, false);
System.out.println("请您输入要添加读者的姓名：");
String name = Utility.readKeyBoard1(5, false);
System.out.println("请您输入要添加读者的学院：");
String f = Utility.readKeyBoard1(8, false);
System.out.println("请您输入要添加读者的专业班级：");
String m = Utility.readKeyBoard1(10, false);
Reader reader = new Reader(id, name, f, m);
ReaderOp.addReader(reader);
Utility.readReturn();
break;
case '2':
findReader();
break;
case '3':
System.out.println("请您输入要删除读者的ID：");
String ID = Utility.readKeyBoard2(10, false);
ReaderOp.deleteReader(ID);
Utility.readReturn();
break;
case '4':
System.out.println("请您输入要修改读者的ID：");
String Id = Utility.readKeyBoard2(10, false);
ReaderOp.modifyReader(Id);
Utility.readReturn();
break;
case '5':
System.out.println("您是否要退出系统（Y/N）");
char c1 = Utility.select();
if (c1 == 'Y') {
System.out.println("成功退出！！");
return;
} else {
System.out.println("欢迎继续使用本系统~~");
Utility.readReturn();
}
break;
default:
System.out.println("您输入的信息有误，请重新输入！");
}
}
}
public static void findReader() {
while (true) {
System.out.println("===========================欢迎进入读者查询系统==========================");
System.out.println("=====================1、按读者姓名查询=======================");
System.out.println("=====================2、按读者ID查询=======================");
System.out.println("=====================3、查询全部读者=======================");
System.out.println("=====================4、按读者ID进行排序=======================");
System.out.println("=====================5、退出子系统=======================");
System.out.println("请您输入指令(1-5)：");
char command = Utility.readSelect();
switch (command) {
case '1':
System.out.println("请输入所要查询读者的姓名：");
String name = Utility.readKeyBoard1(5, false);
ReaderOp.getNameReader(name);
Utility.readReturn();
break;
case '2':
System.out.println("请输入所要查询读者的ID：");
String ID = Utility.readKeyBoard1(10, false);
Reader reader = ReaderOp.getIdReader(ID);
try {
System.out.println(reader.toString());
}catch (NullPointerException n){
System.out.println("您查询的读者不存在或您输入的ID有误！！");
}
Utility.readReturn();
break;
case '3':
ReaderOp.printAllReader();
Utility.readReturn();
break;
case '4':
ReaderOp.cmpID();
Utility.readReturn();
break;
case '5':
System.out.println("您是否要退出系统（Y/N）");
char c1 = Utility.select();
if (c1 == 'Y') {
System.out.println("成功退出！！");
return;
} else {
System.out.println("欢迎继续使用本系统~~");
Utility.readReturn();
}
break;
default:
System.out.println("您输入的信息有误，请重新输入！");
}
}
}
//用户信息管理
public static void userSystem() {
while (true) {
System.out.println("=========================欢迎来到用户管理系统===========================");
System.out.println("==========================1、用户信息删除=============================");
System.out.println("==========================2、用户信息查询=============================");
System.out.println("==========================3、用户信息修改==============================");
System.out.println("==========================4、退出子系统===============================");
System.out.println("========================请输入您的指令（1-4）：");
char command = Utility.readSelect();
switch (command) {
case '1':
System.out.println("请输入所要删除用户的ID：");
String id = Utility.readKeyBoard2(10, false);
/*System.out.println("请输入所要添加用户的姓名：");
String name = Utility.readKeyBoard1(5,false);
System.out.println("请输入所要添加用户的密码：");
String password = Utility.readKeyBoard1(15,false);
User user = new User(id,name ,password);
UserOp.registerUser(user);*/
UserOp.deleteUser(id);
Utility.readReturn();
break;
case '2':
findUser();
break;
case '3':
System.out.println("请输入所要修改用户的ID:");
String ID = Utility.readKeyBoard2(10, false);
UserOp.modifyUser(ID);
Utility.readReturn();
return;
case '4':
System.out.println("您是否要退出系统（Y/N）");
char c1 = Utility.select();
if (c1 == 'Y') {
System.out.println("成功退出！！");
return;
} else {
System.out.println("欢迎继续使用本系统~~");
Utility.readReturn();
}
break;
default:
System.out.println("您输入的指令有误，请重新输入！");
}
}
}
//用户信息的查找
public static void findUser() {
while (true) {
System.out.println("=======================欢迎进入用户查询系统=======================");
System.out.println("========================1、查询所有用户==========================");
System.out.println("========================2、按用户ID查询======================");
System.out.println("========================3、退出子系统========================");
System.out.println("请输入您的指令（1-3）：");
char command = Utility.readSelect();
switch (command) {
case '1':
UserOp.printUser();
Utility.readReturn();
break;
case '2':
System.out.println("请输入所要查询用户的姓名：");
String id = Utility.readKeyBoard1(10, false);
UserOp.getIdUser(id);
Utility.readReturn();
break;
case '3':
System.out.println("您是否要退出系统（Y/N）");
char c1 = Utility.select();
if (c1 == 'Y') {
System.out.println("成功退出！！");
return;
} else {
System.out.println("欢迎继续使用本系统~~");
Utility.readReturn();
}
break;
default:
System.out.println("您输入的指令有误，请重新输入！");
}
}
}
//基础信息维护
public static void informationSystem() {
while (true) {
System.out.println("=======================欢迎来到基础信息维护系统===========================");
System.out.println("===========================1、读者信息维护======================");
System.out.println("===========================2、图书信息维护========================");
System.out.println("===========================3、退出子系统============================");
System.out.println("请输入您的指令（1-3）：");
char command = Utility.readSelect();
switch (command) {
case '1':
readerSystem();
Utility.readReturn();
break;
case '2':
bookSystem();
Utility.readReturn();
break;
case '3':
System.out.println("您是否要退出系统（Y/N）");
char c1 = Utility.select();
if (c1 == 'Y') {
System.out.println("成功退出！！");
return;
} else {
System.out.println("欢迎继续使用本系统~~");
Utility.readReturn();
}
break;
default:
System.out.println("您输入的指令有误，请重新输入！");
}
}
}
}最后是Main类：
public class MainView {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("==============================欢迎使用图书管理系统！！！！===================================");
while (true){
System.out.println("=================1、用户登录=======================");
System.out.println("=================2、用户注册=======================");
System.out.println("=================3、退出系统=======================");
System.out.println("请输入您的选择(1-3)：");
char command = Utility.readSelect();
switch (command){
case '1':
System.out.println("欢迎来到用户登录系统：");
System.out.println("请输入您的姓名：");
String userName = Utility.readKeyBoard1(5,false);
System.out.println("请输入您的密码：");
String password = Utility.readKeyBoard1(12,false);
boolean login = UserOp.login(userName, password);
if (login) {
System.out.println("您已登录成功！");
Utility.readReturn();
//登录成功后下一个界面
ServiceView.Service();
} else {
System.out.println("登录失败，密码错误或未注册账号");
}
break;
case '2':
System.out.println("请输入您的学号：");
String id = Utility.readKeyBoard2(10,false);
System.out.println("请输入您的姓名：");
String name =Utility.readKeyBoard1(5,false);
System.out.println("请输入您的密码：");
String password1=Utility.readKeyBoard1(12,false);
System.out.println("请再次确认密码：");
String password2=Utility.readKeyBoard1(12,false);
if (password2.equals(password1)){
User user =new User(id,name ,password1);
UserOp.registerUser(user);
System.out.println("用户注册成功！！");
Utility.readReturn();
}
else {
System.out.println("两次密码不一致，请重新注册！");
}
break;
case '3':
System.out.println("您确认要退出吗？（Y/N）:");
char select = Utility.select();
if (select=='Y') {
System.out.println("退出成功！");
Utility.readReturn();
return;
} else {
System.out.println("欢迎继续使用本系统");
Utility.readReturn();
}
break;
default:
System.out.println("您输入的指令有误，请重新输入！");
}
}
}
}
这里需要注意的时，每当使用某一操作，致使数据变化时，一定要重新把它们存起来，不要单纯的在内存中做操作。
五、总结：
因为在上学期学习了C++，有一定的基础，入门比较容易，但是在这一个月以前没接触过java，只是自学了这一个月。
在做项目的时候，也发现自己的基础不是很牢，还需要继续加强学习；在前期开始的时候，不能做好各个包功能的划分。
这里建议大家，不要光看，要自己去实践，去做，不要怕出错，遇到不会就去百度或者查阅资料再或者问问身边的大佬，这样效率更高。
若发现bug，敬请指出，本人表示感谢！
99
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
