Java图书管理系统
本文项目内容是Java图书管理系统（二）的另一版本，使用接口及其实现类，利用类的封装与实现，完成对图书的增删改查与借阅归还等。
一、项目需求
完成一个图书管理系统，实现：
1、查看所有书籍，展示所有书籍的类型 、书名、价格 、是否借出的情况
2、添加书籍（两种情况）
2.1 新添加的书籍类型在数据集合bookMap中已存在，那么就直接将新书添加到对应类型的书籍List集合中
2.2 新添加的书籍类型在数据集合bookMap中不存在，那么需要新建键值对完成bookMap中的元素添加
3、修改书籍信息
3.1 修改书籍类型
3.2 修改书籍名称及价格
4、删除书籍信息，删除书籍后需要判断该书所在List集合长度是否为0，为0则该键值对一起移除
5、退出系统
6、借阅书籍
7、归还书籍
二、项目结构
整体结构框架如图：
1、 dataBase层（数据层）
1.1 Database类
package myBookManage.cn.edu.just.dataBase;
import myBookManage.cn.edu.just.model.Book;
import java.util.ArrayList;
import java.util.HashMap;
public class Database {
public static HashMap<String, ArrayList<Book>> initBookMap() {
HashMap<String, ArrayList<Book>> bookMap = new HashMap<>();
//创建书籍对象
Book book1 = new Book("西游记", "名著", 69,false);
Book book2 = new Book("水浒传", "名著", 79,true);
Book book3 = new Book("红楼梦", "名著", 89,false);
Book book5 = new Book("py入门", "it", 77,true);
Book book6 = new Book("php入门", "it", 87,false);
Book book7 = new Book("jsp入门", "it", 68,false);
//创建书籍List集合
ArrayList<Book> bookList1 = new ArrayList<>();
ArrayList<Book> bookList2 = new ArrayList<>();
// List集合添加书籍
bookList1.add(book1);
bookList1.add(book2);
bookList1.add(book3);
bookList2.add(book5);
bookList2.add(book6);
bookList2.add(book7);
//HashMap添加键值对
bookMap.put(book1.getType(), bookList1);
bookMap.put(book6.getType(), bookList2);
return bookMap;
}
}
2、model层（或pojo层）
2.1 Book类
package myBookManage.cn.edu.just.model;
/**图书管理系统优化点
1 在修改书籍功能中 如果要修改的书籍类型或书名不存在的情况下 直接进行提示操作
2 在修改书籍功能中 增加修改已有书籍的类型的功能
3 在删除书籍功能中 如果删除的书籍类型和或书名不存在的情况下 直接进行提示操作
在优化完的基础上 新增两个功能
1 借书功能
2 还书功能
*/
public class Book {
//书名
private String name;
//类型
private String type;
//价格
private double price;
//是否借出
private boolean isBorrowed;
public Book() {
}
public Book(String name, String type, double price) {
this.name = name;
this.type = type;
this.price = price;
}
public Book(String name, String type, double price, boolean isBorrowed) {
this.name = name;
this.type = type;
this.price = price;
this.isBorrowed = isBorrowed;
}
public boolean isBorrowed() {
return isBorrowed ;
}
public void setBorrowed(boolean borrowed) {
isBorrowed = borrowed;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", type='" + type + '\'' +
", price=" + price +
", isBorrowed=" + (isBorrowed == true ? " 已借出 ":" 未借出 ") +
'}';
}
}
3、operation层（操作层）
一个操作接口（ IOpreation接口）：
对于每一个操作都有相近的一部分，刚好可以用接口，利用接口类型的数组来进行相关的操作。
七个操作实现类：
用于实现书籍增删改查以及借阅归还等操作。
用一个protected IOpreation[] iOpreations;即接口类型的数组，主要是在它的子类中，在构造函数中需要根据它们各自的功能实例化各个操作。IOpreation[] iOpreations数组实例化
3.1 AddBookInfoOperation类
添加书籍信息实现类
package myBookManage.cn.edu.just.operation;
import myBookManage.cn.edu.just.model.Book;
import myBookManage.cn.edu.just.service.MyBookManageService;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
public class AddBookInfoOperation implements IOpreation {
@Override
public void work(HashMap<String, ArrayList<Book>> bookMap) {
MyBookManageService user = new MyBookManageService();
Scanner scanner = new Scanner(System.in);
System.out.println("");
System.out.println("请输入您要添加的书籍类型:");
String bookType = scanner.next();
System.out.println("请输入您要添加的书名:");
String bookName = scanner.next();
System.out.println("请输入您要添加的书籍价格:");
double bookPrice = scanner.nextDouble();
//创建书籍对象
Book addBook = new Book (bookName, bookType, bookPrice);
//添加书籍存在两种情况
//1新添加的书籍类型在bookMap中已存在如果是这样那么就直接将新书添加到对应类型的书籍List集合中
//2新添加的书籍类型在bookMap中不存在如果这样需要新建键值对完成bookMap中的元素添加
//根据书籍类型查询是否有对应的书籍List集合
ArrayList<Book>bookArrayList = bookMap.get(bookType) ;
if (bookArrayList != null){
// 情况1
bookArrayList.add(addBook);
}else {
//情况2
//新建List集合并添加书籍
ArrayList<Book> bookList = new ArrayList<>();
bookList.add(addBook);
// bookMap新添加键值对
bookMap.put (bookType,bookList);
}
System.out.println("添加"+bookName+"成功!");
user.login( bookMap);
}
}
3.2 BorrowOperation类
借阅书籍实现类
package myBookManage.cn.edu.just.operation;
/**
* 借阅图书
* 对于借阅图书只需要将图书信息中的布尔型变量isBorrowed变量变为true即可，首先还是要遍历booklist找到该书。
*/
import myBookManage.cn.edu.just.model.Book;
import myBookManage.cn.edu.just.service.MyBookManageService;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
public class BorrowOperation implements IOpreation {
public void work( HashMap<String, ArrayList<Book>> bookMap){
MyBookManageService user = new MyBookManageService();
Scanner scan=new Scanner(System.in);
System.out.println("--------借阅图书-----------");
System.out.println("请输入要借阅的书籍类型：");
String borrowType=scan.next();
user.isExitByType(bookMap,borrowType);
System.out.println("请输入要借阅的书籍名称：");
String borrowBookName=scan.next();
user.isExitByName(bookMap,borrowType,borrowBookName);
ArrayList<Book> bookArrayList = bookMap.get(borrowType);
//判断是否借出
for (Book book : bookArrayList) {
String name = book.getName();
if (name.equals(borrowBookName)&&book.isBorrowed()==false) {
book.setBorrowed(true);
System.out.println("借阅成功");
System.out.println("该书籍的最新信息为：");
System.out.println(book.toString());
break;
}
if (name.equals(borrowBookName) && book.isBorrowed()==true){
System.out.println("该书已被借出");
break;
}
}
user.login( bookMap);
}
}
3.3 DeleteBookInfoOperation类
删除书籍信息实现类
package myBookManage.cn.edu.just.operation;
import myBookManage.cn.edu.just.model.Book;
import myBookManage.cn.edu.just.service.MyBookManageService;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
public class DeleteBookInfoOperation implements IOpreation {
@Override
public void work(HashMap<String, ArrayList<Book>> bookMap) {
MyBookManageService user = new MyBookManageService();
Scanner scanner=new Scanner(System.in);
System.out.println("");
System.out.println("请输入要删除的书籍类型");
String deleteBookType = scanner.next();
user.isExitByType(bookMap,deleteBookType);
System.out.println("请输入要删除的书名");
String deleteBookName = scanner.next();
user.isExitByName(bookMap,deleteBookType, deleteBookName);
ArrayList<Book> bookArrayList = bookMap.get(deleteBookType);
for (int i = 0; i < bookArrayList.size(); i++) {
Book book = bookArrayList.get(i);
String name = book.getName();
if (name.equals(deleteBookName)) {
//要删除的书名存在进行删除
bookArrayList.remove(i);
System.out.println("删除" + name + "成功!");
//删除书籍后需要判断该书所在List集合长度是否为0
if(bookArrayList.size() == 0) {
//移除该键值对
bookMap.remove(deleteBookType);
}
break;
}
}
user.login( bookMap);
}
}
3.4 ExitOperation类
退出系统实现类
package myBookManage.cn.edu.just.operation;
import myBookManage.cn.edu.just.model.Book;
import java.util.ArrayList;
import java.util.HashMap;
public class ExitOperation implements IOpreation {
@Override
public void work(HashMap<String, ArrayList<Book>> bookMap) {
//正在退出系统
System.out.println("正在退出系统");
System.exit(0);
}
}
3.5 GetBooksInfoOperation类
查看所有书籍实现类
也可直接在重写的toString函数中（toString函数在Object类中，它被认为是所有类的父类）用(isBorrowed == true ? " 已借出 “:” 未借出 ") 将true和false转换为文字。
package myBookManage.cn.edu.just.operation;
import myBookManage.cn.edu.just.model.Book;
import myBookManage.cn.edu.just.service.MyBookManageService;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class GetBooksInfoOperation implements IOpreation {
@Override
public void work(HashMap<String, ArrayList<Book>> bookMap) {
MyBookManageService user = new MyBookManageService();
System.out.println("类型 \t书名\t\t价格\t\t是否借出");
//对bookMap进行遍历并打印
Set<Map.Entry<String, ArrayList<Book>>> entries = bookMap.entrySet();
for (Map.Entry<String, ArrayList<Book>> book : entries) {
//获取bookMap中的key(书籍类型)
String bookType = book.getKey();
System.out.println(bookType);
//获取bookMap中的value（书籍List集合）
ArrayList<Book> bookList = book.getValue();
//对书籍List集合进行遍历
for (Book bookInfo : bookList) {
System.out.println("\t\t"+bookInfo.getName()+"\t\t"+bookInfo.getPrice()+"\t\t"+(bookInfo.isBorrowed()==true ? "已借出" : "未借出"));
}
}
user.login( bookMap);
}
}
3.6 IOpreation接口
操作接口（抽象）
对于每一个操作都有相近的一部分，刚好可以用接口，利用接口类型的数组来进行相关的操作。
package myBookManage.cn.edu.just.operation;
import myBookManage.cn.edu.just.dataBase.Database;
import myBookManage.cn.edu.just.model.Book;
import java.util.ArrayList;
import java.util.HashMap;
/**
* 操作接口
* 对于每一个操作都有相近的一部分，刚好可以用接口，在User（使用者）中利用接口类型的数组来进行相关的操作。
*/
public interface IOpreation {
void work( HashMap<String, ArrayList<Book>> bookMap);
}
3.7 ReturnOperation类
归还书籍实现类
package myBookManage.cn.edu.just.operation;
import myBookManage.cn.edu.just.model.Book;
import myBookManage.cn.edu.just.service.MyBookManageService;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
/**
* 归还书籍
* 和借阅图书进行对比可只，借阅图书是将isBorrowed变量由false变为true，那么归还图书就是将isBorrowed变量由true变为false.
*/
public class ReturnOperation implements IOpreation {
@Override
public void work( HashMap<String, ArrayList<Book>> bookMap) {
Scanner scan=new Scanner(System.in);
MyBookManageService user = new MyBookManageService();
System.out.println("-----------归还图书--------------");
System.out.println("请输入要归还的书籍类型：");
String returnBookType=scan.next();
user.isExitByType(bookMap,returnBookType);
System.out.println("请输入要归还的书籍名称：");
String returnBookName=scan.next();
user.isExitByName(bookMap,returnBookType,returnBookName);
ArrayList<Book> bookArrayList = bookMap.get(returnBookType);
for (Book book : bookArrayList) {
String name = book.getName();
if (name.equals(returnBookName)&&book.isBorrowed()==true ) {
book.setBorrowed(false);
System.out.println("归还成功");
System.out.println("该书籍的最新信息为：");
System.out.println(book.toString());
break;
}
if (name.equals(returnBookName)&&book.isBorrowed()==false){
System.out.println("该书已被归还");
}
}
user.login( bookMap);
}
}
3.8 UpdateBookInfoOperation类
修改书籍信息实现类
package myBookManage.cn.edu.just.operation;
import myBookManage.cn.edu.just.model.Book;
import myBookManage.cn.edu.just.service.MyBookManageService;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
public class UpdateBookInfoOperation implements IOpreation {
@Override
public void work(HashMap<String, ArrayList<Book>> bookMap) {
Scanner scan=new Scanner(System.in);
MyBookManageService user = new MyBookManageService();
System.out.println("");
System.out.println("请选择：");
System.out.println("1->修改书籍类型 2->修改书籍名称及价格 3->返回上一层");
int choose=scan.nextInt();
if(choose==1){
System.out.println("请输入该书籍原类型");
String originalBookType = scan.next();
user.isExitByType(bookMap, originalBookType);
System.out.println("请输入要修改的书名");
String modifyBookName = scan.next();
user.isExitByName(bookMap,originalBookType, modifyBookName);
System.out.println("请输入修改后的书籍类型");
String newBookType = scan.next();
double bookPrice=user.getBookPrice(bookMap,modifyBookName);
boolean bookIsBorrowed=user.getBookIsBorrowed(bookMap,modifyBookName);
Book addBook1 = new Book (modifyBookName, newBookType, bookPrice,bookIsBorrowed);
ArrayList<Book> bookArrayList = bookMap.get(newBookType);
if (bookArrayList != null){
bookArrayList.add(addBook1);
System.out.println("更改书籍类型"+modifyBookName+"成功!");
ArrayList<Book> bookArrayListRemove = bookMap.get(originalBookType);
for (int i = 0; i < bookArrayListRemove.size(); i++) {
Book book = bookArrayListRemove.get(i);
String name = book.getName();
if (name.equals(modifyBookName)) {
//要删除的书名存在进行删除
bookArrayListRemove.remove(i);
//删除书籍后需要判断该书所在ListJ集合长度是否为0
if (bookArrayListRemove.size() == 0) {
//移除该键值对
bookMap.remove(originalBookType);
}
}
}
}else {
ArrayList<Book> bookList = new ArrayList<>();
bookList.add(addBook1);
// bookMap新添加键值对
bookMap.put(newBookType, bookList);
System.out.println("更改书籍类型"+modifyBookName+"成功!");
ArrayList<Book> bookArrayListRemove = bookMap.get(originalBookType);
for (int i = 0; i < bookArrayListRemove.size(); i++) {
Book book = bookArrayListRemove.get(i);
String name = book.getName();
if (name.equals(modifyBookName)) {
//要删除的书名存在进行删除
bookArrayListRemove.remove(i);
// System.out.println("删除" + name + "成功!");
//删除书籍后需要判断该书所在ListJ集合长度是否为0
if (bookArrayListRemove.size() == 0) {
//移除该键值对
bookMap.remove(originalBookType);
}
}
}
}
}
if (choose==2){
System.out.println("请输入该书籍类型");
String bookType = scan.next();
user.isExitByType(bookMap, bookType);
System.out.println("请输入要修改的书名");
String oldBookName = scan.next();
user.isExitByName(bookMap,bookType, oldBookName);
System.out.println("请输入新的书名");
String newBookName = scan.next();
System.out.println("请输入新的价格");
double newBookPrice = scan.nextDouble();
ArrayList<Book> bookArrayList = bookMap.get(bookType);
for (Book book : bookArrayList) {
String name = book.getName();
if (name.equals(oldBookName)) {
book.setName(newBookName);
book.setPrice(newBookPrice);
System.out.println("书籍<<"+newBookName+">>的名称及价格修改完成!");
}
}
}
if (choose==3){
user.login(bookMap);
}
// else{
// System.out.println("输入有误，重新输入");
// Scanner scanner3= new Scanner(System.in);
// user.updateBookInfo(bookMap,scan);
// }
user.login( bookMap);
}
}
4、service层
4.1 MyBookManageService类
package myBookManage.cn.edu.just.service;
import myBookManage.cn.edu.just.model.Book;
import myBookManage.cn.edu.just.operation.*;
import java.util.*;
/**图书管理系统优化点
1 在修改书籍功能中 如果要修改的书籍类型或书名不存在的情况下 直接进行提示操作
2 在修改书籍功能中 增加修改已有书籍的类型的功能
3 在删除书籍功能中 如果删除的书籍类型和或书名不存在的情况下 直接进行提示操作
在优化完的基础上 新增两个功能
1 借书功能
2 还书功能
*/
public class MyBookManageService {
protected IOpreation[] iOpreations;
public void doOperation(int choice, HashMap<String, ArrayList<Book>> bookMap) {
this.iOpreations[choice].work(bookMap);
}
/**
* IOpreation[] iOpreations，在这里就实例化了
*/
public MyBookManageService() {
this.iOpreations = new IOpreation[]{
new GetBooksInfoOperation(),
new AddBookInfoOperation(),
new UpdateBookInfoOperation(),
new DeleteBookInfoOperation(),
new ExitOperation(),
new BorrowOperation(),
new ReturnOperation()
};
}
public void login(HashMap<String, ArrayList<Book>> bookMap){
//创建键盘录入对象
Scanner scanner = new Scanner(System.in);
int choice = menu(scanner,bookMap)-1;
doOperation(choice, bookMap);//对图书进行相关的操作
}
public int menu( Scanner scanner,HashMap<String, ArrayList<Book>> bookMap) {
System.out.println();
System.out.println("-------欢迎使用图书管理系统-------");
System.out.println("1.查看所有书籍");
System.out.println("2.添加书籍信息");
System.out.println("3.修改书籍信息");
System.out.println("4.删除书籍信息");
System.out.println("5.退出系统");
System.out.println("6.借阅书籍");
System.out.println("7.归还书籍");
System.out.println("请输入您的选择(输入1-7的数字):");
//获取键盘录入的数字
int chooseNum = scanner.nextInt();
if(chooseNum >7 ||chooseNum <1){
System.out.println("您的输入不合要求！");
login(bookMap);
}
return chooseNum;
}
/**
* 获取图书原价格
*
* @param bookMap
* @param bookName
* @return
*/
public static double getBookPrice(HashMap<String, ArrayList<Book>> bookMap, String bookName) {
Set<Map.Entry<String, ArrayList<Book>>> entries = bookMap.entrySet();
double price = 88;
for (Map.Entry<String, ArrayList<Book>> book : entries) {
ArrayList<Book> bookList = book.getValue();
//对书籍List集合进行遍历
for (Book bookInfo : bookList) {
if (bookInfo.getName().equals(bookName)) {
price = bookInfo.getPrice();
break;
}
}
}
return price;
}
/**
* 判断书籍是否借出
* @param bookMap
* @param bookName
* @return
*/
public static boolean getBookIsBorrowed(HashMap<String, ArrayList<Book>> bookMap, String bookName) {
Set<Map.Entry<String, ArrayList<Book>>> entries = bookMap.entrySet();
boolean isBorrowed=false;
for (Map.Entry<String, ArrayList<Book>> book : entries) {
ArrayList<Book> bookList = book.getValue();
//对书籍List集合进行遍历
for (Book bookInfo : bookList) {
if (bookInfo.getName().equals(bookName)) {
isBorrowed = bookInfo.isBorrowed();
break;
}
}
}
return isBorrowed;
}
/**
* 判断书籍类型是否存在
*
* @param bookMap
* @param bookType
*/
public void isExitByType(HashMap<String, ArrayList<Book>> bookMap, String bookType) {
ArrayList<Book> bookArrayList1 = bookMap.get(bookType);
if (bookArrayList1 == null || bookArrayList1.size() == 0) {
System.out.println("您要修改的书籍类型不存在");
// Scanner scanner = new Scanner(System.in);
login(bookMap);
}
// else {
// return;
// }
}
/**
* 判断书籍名称是否存在
*
* @param bookMap
* @param bookType
* @param bookName
*/
public void isExitByName(HashMap<String, ArrayList<Book>> bookMap, String bookType, String bookName) {
//根据书籍类型获取书籍List集合
ArrayList<Book> bookArrayList = bookMap.get(bookType);
//判读要修改的书籍是否存在
boolean isExist = false;
for (Book book : bookArrayList) {
String name = book.getName();
if (name.equals(bookName)) {
isExist = true;
break;
}
}
if (!isExist) {
System.out.println("您要修改的书名:" + bookName + "在系统里不存在");
Scanner scanner = new Scanner(System.in);
login(bookMap);
}
}
}
5、test层
5.1 Main类
package myBookManage.cn.edu.just.test;
import myBookManage.cn.edu.just.dataBase.Database;
import myBookManage.cn.edu.just.model.Book;
import myBookManage.cn.edu.just.service.MyBookManageService;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Database database = new Database();
MyBookManageService user = new MyBookManageService();
HashMap<String, ArrayList<Book>> bookMap = database.initBookMap();
//创建键盘录入对象
Scanner scanner = new Scanner(System.in);
int choice = user.menu(scanner,bookMap)-1;
user.doOperation(choice, bookMap);//对图书进行相关的操作
}
}
`
三、运行截图
1、查看所有书籍
2、添加书籍信息
情况一：新添加的书籍类型在数据集合bookMap中已存在，那么就直接将新书添加到对应类型的书籍List集合中
情況二：新添加的书籍类型在数据集合bookMap中不存在，那么需要新建键值对完成bookMap中的元素添加
3、修改书籍信息
如果要修改的书籍类型或书名不存在的情况下，直接进行提示操作
4、删除书籍信息
5、退出系统
6、借阅书籍
对于借阅图书只需要将图书信息中的布尔型变量isBorrowed变量变为true即可，首先还是要遍历ArrayList集合找到该书。
7、归还书籍
和借阅图书进行对比可知，借阅图书是将isBorrowed变量由false变为true，那么归还图书就是将isBorrowed变量由true变为false.
不使用接口及其实现类的另一版本：
Java图书管理系统（二）
扫一扫
408
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
