图书管理系统基本框架
- 1.核心类介绍
- 2. book包详解
- 2.1 Book 类
- 2.1.2 代码展示
- 2.1.2 代码解析
- 2.2 BookList 类
- 2.2.2 代码展示
- 2.2.2 代码解析
- 2.3Book类和BookList类的联系
- 3. 用户角色与管理
- 3.1 User 类
- 3.1.1 代码展示
- 3.1.2 代码解析
- 3.2 adminUser 类
- 3.2.1 代码展示
- 3.2.2代码解析
- 3.3 normalUser 类
- 3.3.1 代码展示
- 3.3.2 代码解析
- 3.4三者之间的联系
- 4. 操作类详解
- 4.1 IOperation 接口
- 4.1.1 代码展示
- 4.1.2接口和各实现类之间的关系
- 4.2 AddOperation 类
- 4.2.1 代码展示
- 4.2.2 代码解析
- 4.3 BorrowOperation 类
- 4.3.1 代码展示
- 4.2.2 代码解析
- 4.4 DelOperation 类
- 4.4.1 代码展示
- 4.2.2 代码解析
- 4.5 ExitOperation 类
- 4.5.1 代码展示
- 4.2.2 代码解析
- 4.6 FindOperation 类
- 4.6.1 代码展示
- 4.2.2 代码解析
- 4.7 ReturnOperation 类
- 4.7.1 代码展示
- 4.2.2 代码解析
- 4.8 ShowOperation 类
- 4.8.1 代码展示
- 4.2.2 代码解析
- 5. 系统整合与实践
- 5.1 类之间的交互与整合
- 5.1.1 package book
- 5.1.2 package ioperations
- 5.1.2 package user
- 5.2 类和类之间的整体联系
- 5.3 功能拓展
1.核心类介绍
本项目的核心类包括Book、User（及其子类adminUser和normalUser）、以及多个操作类（AddOperation、BorrowOperation等）。Book类代表图书信息，User类及其子类处理用户身份与权限，而操作类则封装了图书管理的各项功能，共同支撑起整个系统的运作。
图片预览：
2. book包详解
2.1 Book 类
2.1.2 代码展示
package book;
public class Book {
private String name;//书名
private String author;//作者
private int price;//价格
private String type;//书的类型
private boolean isBorrowed;//书的状态（是否借出）
public Book(String name, String author, int price, String type) {
this.name = name;
this.author = author;
this.price = price;
this.type = type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public boolean isBorrowed() {
return isBorrowed;
}
public void setBorrowed(boolean borrowed) {
isBorrowed = borrowed;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price='" + price + '\'' +
", type='" + type + '\'' +
//", isBorrowed=" + isBorrowed +
((isBorrowed == true) ? "已借出" : "未借出") +
'}';
}
}
2.1.2 代码解析
这个Book类定义了书籍的基本属性和行为。
-
属性：
name：书名author：作者price：价格type：书的类型isBorrowed：表示书是否被借出，是一个布尔值。
-
构造方法：
当创建一个新的Book对象时，需要传入书名、作者、价格和类型，这些值将被用来初始化对象的相应属性。 -
Getter 和 Setter 方法：
对于每个属性，都有对应的获取（getter）和设置（setter）方法，允许外部代码读取或修改这些属性的值。 -
toString 方法：
这个方法用于返回书籍信息的字符串表示。它拼接了书名、作者、价格和类型，并根据isBorrowed属性的值添加书籍的借出状态（“已借出"或"未借出”）。
逻辑关系分析：
Book类封装了书籍的基本信息。- 构造方法确保在创建书籍对象时，必须提供必要的信息（书名、作者、价格、类型）。
- Getter 方法允许外部访问书籍的属性，但不允许直接修改。
- Setter 方法允许外部修改书籍的属性，提供了对属性值的保护和控制。
toString方法提供了一种标准化的方式来展示书籍的详细信息，包括其是否被借出的状态。
整体而言，这个类通过封装、数据隐藏和提供接口，实现了对书籍信息的有效管理和保护。
2.2 BookList 类
2.2.2 代码展示
package book;
public class BookList {
//把书作为对象：
private Book[] books = new Book[10];//书架
private int usedSize;//书本的有效个数
//书架
public BookList() {
this.books[0] = new Book("三国演义", "罗贯中", 10, "小说");
this.books[1] = new Book("西游记", "吴承恩", 20, "小说");
this.books[2] = new Book("红楼梦", "曹雪芹", 30, "小说");
this.usedSize = 3;
}
public Book getBook(int pos) {
return this.books[pos];
}
public Book[] getBooks() {
return books;
}
public void setBook(int pos, Book book) {
this.books[pos] = book;
}
public int getUsedSize() {
return usedSize;
}
public void setUsedSize(int usedSize) {
this.usedSize = usedSize;
}
}
2.2.2 代码解析
这个BookList类代表了一个书架，它管理一个包含书籍（Book对象）的数组。
-
属性：
books：一个Book对象数组，代表书架上的书，最多可以容纳10本书。usedSize：表示书架上当前已经放置的书籍数量。
-
构造方法：
在创建BookList对象时，构造方法会初始化书架，并在书架上放置三本初始的书籍，同时设置usedSize为3，表示书架上有3本书。 -
Getter 和 Setter 方法：
getBook(int pos)：根据位置获取书架上的某本书。getBooks()：获取整个书籍数组。setBook(int pos, Book book)：在指定位置放置一本书。getUsedSize()和setUsedSize(int usedSize)：分别用于获取和设置书架上当前使用的空间（即书本的数量）。
逻辑关系分析：
BookList类模拟了一个书架，可以存放最多10本书。- 构造方法初始化了书架，并在其上放置了三本预定义的书籍。
- 通过getter方法可以查看书架上的书籍信息，包括获取特定位置的书籍或整个书籍数组。
- 通过setter方法可以在书架上放置或替换书籍。
usedSize属性跟踪书架上当前有多少本书，这有助于避免访问空位置或超出数组界限。
总的来说，这个类通过封装一个Book对象数组和相关的操作方法，提供了一个管理和访问书架上书籍的接口。
2.3Book类和BookList类的联系
-
Book 类:
- 描述了书的基本属性，如书名、作者、价格、类型和借阅状态。
- 提供了构造函数用于初始化这些属性。
- 提供了getter和setter方法来访问和修改这些属性。
- 重写了
toString方法，用于以字符串形式展示书的信息，特别是借阅状态被转换为了中文描述。
-
BookList 类:
- 表示一个书架，可以存放多本书。
- 使用了一个
Book类型的数组books来存储书，并设置了一个上限为10本书。 usedSize变量用于跟踪书架上实际存放的书的数量。- 构造函数中初始化了书架，放置了三本书，并设置了
usedSize为3。 - 提供了方法来获取和设置书架上特定位置的书，以及获取整个书架的书和
usedSize的值。
逻辑关系:
Book类定义了书的属性和行为。BookList类使用Book对象来构建一个书架，可以管理和操作书架上的书。- 在
BookList的构造函数中，创建了三个Book对象并放置在书架上。
简而言之，Book类代表单本书，而BookList类代表一个可以存储多本书的书架，并提供了管理和访问这些书的方法。
3. 用户角色与管理
3.1 User 类
3.1.1 代码展示
package user;
import book.BookList;
import ioperations.IOperation;
public abstract class User {
//用户通过接口数组和名字来操作图书系统的
protected String name;
IOperation[] iOperations;
public User(String name) {
this.name = name;
}
public abstract int menu();
public void doIoperation(int choice, BookList bookList) {
iOperations[choice].work(bookList);//真正操作图书系统
}
}
3.1.2 代码解析
User是一个抽象类，它代表了一个使用图书系统的用户。以下是User类逻辑关系的简短分析：
-
属性：
name：存储用户的名字。iOperations：是一个IOperation接口类型的数组，用于存储用户可以执行的各种操作。
-
构造方法：
- 构造方法接受一个字符串参数，用于设置用户的名字。
-
抽象方法：
menu()：这是一个抽象方法，需要在User的子类中实现。这个方法预计会返回一个整数，可能代表用户选择的操作编号。
-
普通方法：
doIoperation(int choice, BookList bookList)：这个方法接受一个操作编号（choice）和一个BookList对象。根据操作编号，它会调用iOperations数组中相应位置的IOperation对象的work方法，对bookList执行具体的操作。这是用户与图书系统交互的桥梁，通过这个方法，用户可以执行添加、查找、归还或展示书籍等操作。
简而言之，User类定义了一个使用图书系统的用户的基本属性和行为。它使用了一个IOperation接口数组来代表用户可以执行的各种操作，并通过doIoperation方法来实际执行用户选择的操作。这个类是一个抽象类，意味着它不能直接实例化，而是需要具体的子类来实现menu方法，并可能提供额外的功能或属性。
3.2 adminUser 类
3.2.1 代码展示
package user;
import ioperations.*;
import java.util.Scanner;
public class AdminUser extends User {
public AdminUser(String name) {
super(name);
this.iOperations = new IOperation[] {
new ExitOperation(),
new FindOperation(),
new AddOperation(),
new DelOperation(),
new ShowOperation()
};
}
@Override
public int menu() {
System.out.println("欢迎" + this.name + "来到图书系统");
System.out.println("*******管理员菜单*******");
System.out.println("1. 查找图书");
System.out.println("2. 新增图书");
System.out.println("3. 删除图书");
System.out.println("4. 显示图书");
System.out.println("0. 退出系统");
System.out.println("**********************");
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的操作：");
int choice = scanner.nextInt();
return choice;
}
}
3.2.2代码解析
AdminUser类是User类的子类，代表图书系统的管理员用户。以下是AdminUser类逻辑关系的简短分析：
-
继承关系：
AdminUser继承了User类，这意味着它继承了User的所有属性和方法，并且可以添加或覆盖父类的方法以实现特定的管理员功能。
-
构造方法：
- 构造方法接收管理员的名字作为参数，并通过调用父类的构造方法来设置该名字。
- 在构造方法中，初始化了
iOperations数组，该数组包含了管理员可以执行的操作。这些操作包括退出、查找、添加、删除和显示图书。
-
覆盖的
menu方法：menu方法被覆盖以提供管理员特定的菜单选项。- 方法首先输出欢迎信息和管理员菜单，然后提示用户输入操作选择。
- 使用
Scanner类从用户那里接收输入，表示用户选择的操作编号。 - 返回用户选择的操作编号，这个编号将用于后续调用
doIoperation方法来执行相应的操作。
简而言之，AdminUser类通过继承User类并覆盖其menu方法，为管理员用户提供了特定的功能和操作菜单。管理员可以执行查找、新增、删除和显示图书等操作，这些都是通过iOperations数组中存储的相应操作类来实现的。
3.3 normalUser 类
3.3.1 代码展示
package user;
import ioperations.*;
import java.util.Scanner;
public class NormalUser extends User {
public NormalUser(String name) {
super(name);
this.iOperations = new IOperation[] {
new ExitOperation(),
new FindOperation(),
new BorrowOperation(),
new ReturnOperation()
};
}
@Override
public int menu() {
System.out.println("欢迎" + this.name + "来到图书系统");
System.out.println("*******普通用户菜单*******");
System.out.println("1. 查找图书");
System.out.println("2. 借阅图书");
System.out.println("3. 归还图书");
System.out.println("0. 退出系统");
System.out.println("**********************");
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的操作：");
int choice = scanner.nextInt();
return choice;
}
}
3.3.2 代码解析
NormalUser类是User类的另一个子类，代表图书系统的普通用户。以下是NormalUser类逻辑关系的简短分析：
-
继承关系：
NormalUser继承了User类，因此它继承了父类的所有属性和方法，并可以根据需要覆盖或添加新的方法。
-
构造方法：
- 构造方法接受普通用户的名字作为参数，并通过调用父类的构造方法来初始化该名字。
- 在构造方法中，还初始化了
iOperations数组，这个数组包含了普通用户可以执行的操作。这些操作包括退出系统、查找图书、借阅图书和归还图书。
-
覆盖的
menu方法：menu方法在NormalUser类中被覆盖，以提供普通用户特定的菜单选项。- 方法首先打印欢迎信息和普通用户菜单，然后提示用户输入他们的操作选择。
- 使用
Scanner类从控制台接收用户的输入，该输入代表用户想要执行的操作编号。 - 返回用户选择的操作编号，此编号稍后将用于调用
doIoperation方法，以执行用户选择的操作。
简而言之，NormalUser类通过继承User类并定制其menu方法，为普通用户提供了特定的操作菜单和功能。普通用户可以执行查找、借阅和归还图书等操作，这些操作是通过iOperations数组中相应位置的操作类来实现的。这个类与AdminUser类相似，但提供的操作和功能是根据普通用户的需求来定制的。
3.4三者之间的联系
父类User定义了用户的通用属性和行为，包括用户名字和一系列操作。它设置了一个框架，使得不同的用户类型可以执行不同的操作。
子类AdminUser和NormalUser分别继承了User类，代表两种不同类型的用户：管理员和普通用户。这两个子类都拥有父类的属性和方法，但各自定制了可执行的操作集合iOperations和菜单选项menu()。
AdminUser提供了管理员特有的功能，如添加、删除图书等，而NormalUser则提供了普通用户需要的功能，如借阅和归还图书。
通过这种继承关系，代码实现了用户角色的多态性，即不同类型的用户可以以不同的方式使用系统，但都基于相同的用户基础结构。
4. 操作类详解
4.1 IOperation 接口
4.1.1 代码展示
public interface IOperation {
void work(BookList bookList);
}
4.1.2接口和各实现类之间的关系
IOperation 是一个接口，它定义了一个 work 方法，该方法接受一个 BookList 类型的参数。这个接口的作用是规定一种操作契约，即任何实现了 IOperation 接口的类都必须提供 work 方法的具体实现，并且这个方法需要能够对一个 BookList 对象执行某种操作。
现在，让我们来分析 IOperation 接口与 AddOperation、BorrowOperation、DelOperation、ExitOperation、FindOperation、ReturnOperation、ShowOperation 等类之间的逻辑关系：
-
IOperation 接口：
- 定义了操作的通用接口，即
work方法。 - 它是所有具体操作的抽象表示。
- 定义了操作的通用接口，即
-
具体实现类（如 AddOperation）：
- 这些类是
IOperation接口的具体实现。 - 每个类都必须实现
work方法，以定义该类对应的特定操作。 - 例如，
AddOperation的work方法可能会实现向BookList中添加书籍的逻辑。
- 这些类是
逻辑关系：
IOperation是所有操作类的基类（接口），它定义了操作的通用方法。AddOperation、BorrowOperation、DelOperation、ExitOperation、FindOperation、ReturnOperation、ShowOperation等类是IOperation的具体实现，每个类都负责实现一种特定的图书管理操作。- 这些实现类通过覆盖（实现）
work方法，提供了对BookList对象执行特定操作的具体逻辑。
这种设计允许系统以一种统一和灵活的方式处理不同的图书管理操作，因为所有的操作都遵循相同的接口规范。同时，这种结构也便于扩展和维护，因为可以轻松地添加新的操作类，只要它们实现了 IOperation 接口。
4.2 AddOperation 类
4.2.1 代码展示
package ioperations;
import book.Book;
import book.BookList;
import java.util.Scanner;
public class AddOperation implements IOperation {
@Override
public void work(BookList bookList) {
System.out.print("添加书籍：");
//1. 判满
int currentSize = bookList.getUsedSize();
if (currentSize == bookList.getBooks().length) {
System.out.println("书架满了 不能放了.....");
return;
}
//2. 构建对象
Scanner scanner = new Scanner(System.in);
System.out.println("请输入书名：");
String name = scanner.nextLine();
System.out.println("请输入作者：");
String author = scanner.nextLine();
System.out.println("请输入书的类型：");
String type = scanner.nextLine();
System.out.println("请输入价格：");
int price = scanner.nextInt();
Book newBook = new Book(name, author, price, type);
//3. 判断书架有没有这本书
for (int i = 0; i < currentSize; i++) {
Book book = bookList.getBook(i);
if (book.getName().equals(name)) {
System.out.println("有这本书不能插入！");
return;
}
}
//4.插入这本书
bookList.setBook(currentSize, newBook);
bookList.setUsedSize(currentSize + 1);
System.out.println("新增图书成功！！！");
}
}
4.2.2 代码解析
这个AddOperation类实现了IOperation接口，并提供了work方法用于向BookList中添加新的书籍。以下是该方法的逻辑关系分析：
-
检查书架是否已满：
- 首先，获取书架当前的使用大小（
currentSize）和书架的总容量。 - 如果书架已满（
currentSize等于书架总容量），则输出提示信息并结束方法。
- 首先，获取书架当前的使用大小（
-
构建新书籍对象：
- 使用
Scanner类从用户那里获取新书籍的信息（书名、作者、类型和价格）。 - 利用这些信息创建一个新的
Book对象。
- 使用
-
检查书籍是否已存在：
- 遍历书架上的所有书籍。
- 如果找到与新书籍同名的书籍，则输出提示信息并结束方法。
-
添加新书籍到书架：
- 将新创建的
Book对象添加到书架的下一个可用位置（即currentSize所指示的位置）。 - 更新书架的使用大小（
usedSize），将其增加1。 - 输出成功添加新书籍的信息。
- 将新创建的
简而言之，这个类的work方法实现了向书架中添加新书籍的功能，同时确保了书架不会超出容量，并且避免了重复添加相同的书籍。
4.3 BorrowOperation 类
4.3.1 代码展示
package ioperations;
import book.Book;
import book.BookList;
import java.util.Scanner;
public class BorrowOperation implements IOperation {
@Override
public void work(BookList bookList) {
System.out.println("借阅书籍：");
Scanner scanner = new Scanner(System.in);
System.out.printf("请输入你借阅的书名：");
String name = scanner.nextLine();
int currentSize = bookList.getUsedSize();
for (int i = 0; i < currentSize; i++) {
Book book = bookList.getBook(i);
if (book.getName().equals(name)) {
if (book.isBorrowed()) {
System.out.println("这本书已经被借出了！");
return;
}
book.setBorrowed(true);
System.out.println("借阅成功！");
return;
}
}
System.out.println("没有你要借阅的这本书....");
}
}
4.2.2 代码解析
这个BorrowOperation类实现了IOperation接口，并提供了work方法用于处理书籍借阅的逻辑。以下是该方法逻辑关系的简短分析：
-
提示用户并接收输入：
- 输出提示信息，告知用户正在进行借阅操作。
- 使用
Scanner类接收用户输入的要借阅的书名。
-
遍历书架上的书籍：
- 获取书架当前的使用大小（
currentSize）。 - 遍历书架上的每一本书，检查书名是否与用户输入的书名匹配。
- 获取书架当前的使用大小（
-
检查书籍状态并执行借阅：
- 如果找到匹配的书名，首先检查该书是否已经被借出。
- 如果书已经被借出，则输出提示信息并结束方法。
- 如果书未被借出，将其借阅状态设置为已借出，输出借阅成功的提示信息，并结束方法。
-
处理未找到书籍的情况：
- 如果遍历完书架上的所有书籍都没有找到匹配的书名，则输出提示信息表示没有用户要借阅的这本书。
简而言之，这个类的work方法实现了书籍借阅的功能，通过用户输入的书名来查找并尝试借阅书籍，同时确保了同一本书不会被重复借出，并在未找到书籍或书籍已被借出时给出相应的提示。
4.4 DelOperation 类
4.4.1 代码展示
package ioperations;
import book.Book;
import book.BookList;
import java.util.Scanner;
/**
* Created with IntelliJ IDEA.
* Description:
* User: 姚东名
* Date: 2024-06-22
* Time: 9:56
*/
public class DelOperation implements IOperation {
@Override
public void work(BookList bookList) {
System.out.println("删除书籍：");
Scanner scanner = new Scanner(System.in);
System.out.print("请输入你删除的书名：");
String name = scanner.nextLine();
int currentSize = bookList.getUsedSize();
int pos = -1;
//找到这本书
int i = 0;
for (; i < currentSize; i++) {
Book book = bookList.getBook(i);
if (book.getName().equals(name)) {
pos = i;
break;
}
}
if (i == currentSize) {
System.out.println("没有你要删除的书！");
return;
}
//这里开始删除
for (int j = pos; j < currentSize - 1; j++) {
//bookList[j] = bookList[j+1];
Book book = bookList.getBook(j + 1);
bookList.setBook(j, book);
}
bookList.setBook(currentSize - 1, null);
bookList.setUsedSize(currentSize - 1);
System.out.println("删除成功！！！！");
}
}
4.2.2 代码解析
这个DelOperation类实现了IOperation接口，并提供了work方法用于从BookList中删除指定的书籍。以下是该方法逻辑关系的简短分析：
-
提示用户并接收输入：
- 输出提示信息，告知用户正在进行删除书籍操作。
- 使用
Scanner类接收用户输入的要删除的书名。
-
查找要删除的书籍：
- 遍历书架上的书籍，查找与用户输入书名相匹配的书籍，并记录其位置
pos。 - 如果未找到匹配的书籍，则输出提示信息并结束方法。
- 遍历书架上的书籍，查找与用户输入书名相匹配的书籍，并记录其位置
-
执行删除操作：
- 如果找到了要删除的书籍，从该书的位置开始，将后面的每一本书向前移动一个位置，覆盖掉要删除的书籍。
- 将书架的最后一个位置设置为
null，因为已经有一本书被“移除”了。 - 更新书架的使用大小（
usedSize），将其减少1。 - 输出删除成功的提示信息。
简而言之，这个类的work方法实现了从书架中删除指定书籍的功能，通过用户输入的书名来查找并删除书籍，同时在未找到书籍时给出相应的提示。删除操作是通过将后面的书籍向前移动来覆盖要删除的书籍，并更新书架的使用大小。
4.5 ExitOperation 类
4.5.1 代码展示
package ioperations;
import book.BookList;
public class ExitOperation implements IOperation {
@Override
public void work(BookList bookList) {
System.out.println("退出系统：");
System.exit(0);
}
}
4.2.2 代码解析
这个ExitOperation类实现了IOperation接口，并提供了work方法用于退出系统。其逻辑关系非常简单：
-
输出提示信息：首先，输出一条信息提示用户系统正在退出。
-
退出程序：然后，调用
System.exit(0)方法立即终止Java虚拟机，从而结束整个程序。这里的0是退出状态码，表示程序正常退出。
简而言之，这个类的work方法实现了退出系统的功能，通过调用System.exit(0)来结束程序运行。
4.6 FindOperation 类
4.6.1 代码展示
package ioperations;
import book.Book;
import book.BookList;
import java.util.Scanner;
public class FindOperation implements IOperation {
@Override
public void work(BookList bookList) {
System.out.println("查找书籍：");
Scanner scanner = new Scanner(System.in);
System.out.printf("请输入你的书名：");
String name = scanner.nextLine();
int currentSize = bookList.getUsedSize();
for (int i = 0; i < currentSize; i++) {
Book book = bookList.getBook(i);
if (book.getName().equals(name)) {
System.out.println("找到了这本书：");
System.out.println(book);
return;
}
}
System.out.println("没有你要找的这本书....");
}
}
4.2.2 代码解析
这个FindOperation类实现了IOperation接口，并提供了work方法用于在BookList中查找指定的书籍。以下是该方法逻辑关系的简短分析：
-
提示用户并接收输入：
- 输出提示信息，告知用户正在进行书籍查找操作。
- 使用
Scanner类接收用户输入的要查找的书名。
-
遍历书架上的书籍：
- 获取书架当前的使用大小（
currentSize）。 - 遍历书架上的每一本书，检查书名是否与用户输入的书名匹配。
- 获取书架当前的使用大小（
-
查找并输出结果：
- 如果找到匹配的书名，输出找到的书籍信息，并结束方法。
- 如果遍历完所有书籍都没有找到匹配的书名，则输出提示信息表示没有用户要查找的这本书。
简而言之，这个类的work方法实现了书籍查找的功能，通过用户输入的书名来在书架中查找书籍，找到则输出书籍信息，未找到则给出相应的提示。
4.7 ReturnOperation 类
4.7.1 代码展示
package ioperations;
import book.Book;
import book.BookList;
import java.util.Scanner;
public class ReturnOperation implements IOperation {
@Override
public void work(BookList bookList) {
System.out.println("归还书籍：");
Scanner scanner = new Scanner(System.in);
System.out.printf("请输入你归还的书名：");
String name = scanner.nextLine();
int currentSize = bookList.getUsedSize();
for (int i = 0; i < currentSize; i++) {
Book book = bookList.getBook(i);
if (book.getName().equals(name)) {
if (book.isBorrowed()) {
book.setBorrowed(false);
System.out.println("归还成功！");
return;
}
}
}
System.out.println("没有你要归还的图书！！！");
}
}
4.2.2 代码解析
这个ReturnOperation类实现了IOperation接口，并提供了work方法用于处理书籍归还的逻辑。以下是该方法逻辑关系的简短分析：
-
提示用户并接收输入：
- 输出提示信息，告知用户正在进行书籍归还操作。
- 使用
Scanner类接收用户输入的要归还的书名。
-
遍历书架上的书籍：
- 获取书架当前的使用大小（
currentSize）。 - 遍历书架上的每一本书，检查书名是否与用户输入的书名匹配。
- 获取书架当前的使用大小（
-
检查书籍状态并执行归还：
- 如果找到匹配的书名，首先检查该书是否处于被借出状态。
- 如果书已经被借出，则将其借阅状态设置为未借出，输出归还成功的提示信息，并结束方法。
-
处理未找到书籍或书籍未被借出的情况：
- 如果遍历完书架上的所有书籍都没有找到匹配的书名，或者书籍本身就未被借出，则输出提示信息表示没有用户要归还的图书。
简而言之，这个类的work方法实现了书籍归还的功能，通过用户输入的书名来查找并尝试归还书籍，同时确保了只有被借出的书籍才能被归还，并在未找到书籍或书籍未被借出时给出相应的提示。
4.8 ShowOperation 类
4.8.1 代码展示
package ioperations;
import book.Book;
import book.BookList;
public class ShowOperation implements IOperation {
@Override
public void work(BookList bookList) {
System.out.println("展示书籍：");
int currentSize = bookList.getUsedSize();//3
for (int i = 0; i < currentSize; i++) {
Book book = bookList.getBook(i);
System.out.println(book);
//Book book1 = bookList[i];
}
}
}
4.2.2 代码解析
这个ShowOperation类实现了IOperation接口，并提供了work方法用于展示书架上的所有书籍。以下是该方法逻辑关系的简短分析：
-
输出提示信息：首先，输出一条信息提示用户接下来将展示书籍。
-
获取书架使用大小：通过调用
bookList.getUsedSize()方法来获取书架上当前书籍的数量。 -
遍历并展示书籍：使用一个for循环遍历书架上的每一本书。在每次循环中，通过
bookList.getBook(i)方法获取指定索引位置的书籍对象，并将其信息打印到控制台。
简而言之，这个类的work方法实现了展示书架上所有书籍的功能，通过遍历书架并逐一打印每本书的信息来完成这一操作。
5. 系统整合与实践
5.1 类之间的交互与整合
5.1.1 package book
//book.java
package book;
public class Book {
private String name;//书名
private String author;//作者
private int price;//价格
private String type;//书的类型
private boolean isBorrowed;//书的状态（是否借出）
public Book(String name, String author, int price, String type) {
this.name = name;
this.author = author;
this.price = price;
this.type = type;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public boolean isBorrowed() {
return isBorrowed;
}
public void setBorrowed(boolean borrowed) {
isBorrowed = borrowed;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price='" + price + '\'' +
", type='" + type + '\'' +
//", isBorrowed=" + isBorrowed +
((isBorrowed == true) ? "已借出" : "未借出") +
'}';
}
}
//BookList.java
package book;
public class BookList {
//把书作为对象：
private Book[] books = new Book[10];//书架
private int usedSize;//书本的有效个数
//书架
public BookList() {
this.books[0] = new Book("三国演义", "罗贯中", 10, "小说");
this.books[1] = new Book("西游记", "吴承恩", 20, "小说");
this.books[2] = new Book("红楼梦", "曹雪芹", 30, "小说");
this.usedSize = 3;
}
public Book getBook(int pos) {
return this.books[pos];
}
public Book[] getBooks() {
return books;
}
public void setBook(int pos, Book book) {
this.books[pos] = book;
}
public int getUsedSize() {
return usedSize;
}
public void setUsedSize(int usedSize) {
this.usedSize = usedSize;
}
}
5.1.2 package ioperations
接口
//IOperation.java
package ioperations;
import book.BookList;
public interface IOperation {
void work(BookList bookList);
}
基于接口实现的类
//AddOperation.java
package ioperations;
import book.Book;
import book.BookList;
import java.util.Scanner;
public class AddOperation implements IOperation {
@Override
public void work(BookList bookList) {
System.out.print("添加书籍：");
//1. 判满
int currentSize = bookList.getUsedSize();
if (currentSize == bookList.getBooks().length) {
System.out.println("书架满了 不能放了.....");
return;
}
//2. 构建对象
Scanner scanner = new Scanner(System.in);
System.out.println("请输入书名：");
String name = scanner.nextLine();
System.out.println("请输入作者：");
String author = scanner.nextLine();
System.out.println("请输入书的类型：");
String type = scanner.nextLine();
System.out.println("请输入价格：");
int price = scanner.nextInt();
Book newBook = new Book(name, author, price, type);
//3. 判断书架有没有这本书
for (int i = 0; i < currentSize; i++) {
Book book = bookList.getBook(i);
if (book.getName().equals(name)) {
System.out.println("有这本书不能插入！");
return;
}
}
//4.插入这本书
bookList.setBook(currentSize, newBook);
bookList.setUsedSize(currentSize + 1);
System.out.println("新增图书成功！！！");
}
}
//BorrowOperation.java
package ioperations;
import book.Book;
import book.BookList;
import java.util.Scanner;
public class BorrowOperation implements IOperation {
@Override
public void work(BookList bookList) {
System.out.println("借阅书籍：");
Scanner scanner = new Scanner(System.in);
System.out.printf("请输入你借阅的书名：");
String name = scanner.nextLine();
int currentSize = bookList.getUsedSize();
for (int i = 0; i < currentSize; i++) {
Book book = bookList.getBook(i);
if (book.getName().equals(name)) {
if (book.isBorrowed()) {
System.out.println("这本书已经被借出了！");
return;
}
book.setBorrowed(true);
System.out.println("借阅成功！");
return;
}
}
System.out.println("没有你要借阅的这本书....");
}
}
//DelOperation.java
package ioperations;
import book.Book;
import book.BookList;
import java.util.Scanner;
public class DelOperation implements IOperation {
@Override
public void work(BookList bookList) {
System.out.println("删除书籍：");
Scanner scanner = new Scanner(System.in);
System.out.print("请输入你删除的书名：");
String name = scanner.nextLine();
int currentSize = bookList.getUsedSize();
int pos = -1;
//找到这本书
int i = 0;
for (; i < currentSize; i++) {
Book book = bookList.getBook(i);
if (book.getName().equals(name)) {
pos = i;
break;
}
}
if (i == currentSize) {
System.out.println("没有你要删除的书！");
return;
}
//这里开始删除
for (int j = pos; j < currentSize - 1; j++) {
//bookList[j] = bookList[j+1];
Book book = bookList.getBook(j + 1);
bookList.setBook(j, book);
}
bookList.setBook(currentSize - 1, null);
bookList.setUsedSize(currentSize - 1);
System.out.println("删除成功！！！！");
}
}
//ExitOperation.java
package ioperations;
import book.BookList;
public class ExitOperation implements IOperation {
@Override
public void work(BookList bookList) {
System.out.println("退出系统：");
System.exit(0);
}
}
//FindOperation.java
package ioperations;
import book.Book;
import book.BookList;
import java.util.Scanner;
public class FindOperation implements IOperation {
@Override
public void work(BookList bookList) {
System.out.println("查找书籍：");
Scanner scanner = new Scanner(System.in);
System.out.printf("请输入你的书名：");
String name = scanner.nextLine();
int currentSize = bookList.getUsedSize();
for (int i = 0; i < currentSize; i++) {
Book book = bookList.getBook(i);
if (book.getName().equals(name)) {
System.out.println("找到了这本书：");
System.out.println(book);
return;
}
}
System.out.println("没有你要找的这本书....");
}
}
//ReturnOperation.java
package ioperations;
import book.Book;
import book.BookList;
import java.util.Scanner;
public class ReturnOperation implements IOperation {
@Override
public void work(BookList bookList) {
System.out.println("归还书籍：");
Scanner scanner = new Scanner(System.in);
System.out.printf("请输入你归还的书名：");
String name = scanner.nextLine();
int currentSize = bookList.getUsedSize();
for (int i = 0; i < currentSize; i++) {
Book book = bookList.getBook(i);
if (book.getName().equals(name)) {
if (book.isBorrowed()) {
book.setBorrowed(false);
System.out.println("归还成功！");
return;
}
}
}
System.out.println("没有你要归还的图书！！！");
}
}
//ShowOperation.java
package ioperations;
import book.Book;
import book.BookList;
public class ShowOperation implements IOperation {
@Override
public void work(BookList bookList) {
System.out.println("展示书籍：");
int currentSize = bookList.getUsedSize();//3
for (int i = 0; i < currentSize; i++) {
Book book = bookList.getBook(i);
System.out.println(book);
//Book book1 = bookList[i];
}
}
}
5.1.2 package user
父类
//User.java
package user;
import book.BookList;
import ioperations.IOperation;
public abstract class User {
//用户通过接口数组和名字来操作图书系统的
protected String name;
IOperation[] iOperations;
public User(String name) {
this.name = name;
}
public abstract int menu();
public void doIoperation(int choice, BookList bookList) {
iOperations[choice].work(bookList);//真正操作图书系统
}
}
基于父类的子类
//AdminUser.java
package user;
import ioperations.*;
import java.util.Scanner;
public class AdminUser extends User {
public AdminUser(String name) {
super(name);
this.iOperations = new IOperation[] {
new ExitOperation(),
new FindOperation(),
new AddOperation(),
new DelOperation(),
new ShowOperation()
};
}
@Override
public int menu() {
System.out.println("欢迎" + this.name + "来到图书系统");
System.out.println("*******管理员菜单*******");
System.out.println("1. 查找图书");
System.out.println("2. 新增图书");
System.out.println("3. 删除图书");
System.out.println("4. 显示图书");
System.out.println("0. 退出系统");
System.out.println("**********************");
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的操作：");
int choice = scanner.nextInt();
return choice;
}
}
//NormalUser.java
package user;
import ioperations.*;
import java.util.Scanner;
public class NormalUser extends User {
public NormalUser(String name) {
super(name);
this.iOperations = new IOperation[] {
new ExitOperation(),
new FindOperation(),
new BorrowOperation(),
new ReturnOperation()
};
}
@Override
public int menu() {
System.out.println("欢迎" + this.name + "来到图书系统");
System.out.println("*******普通用户菜单*******");
System.out.println("1. 查找图书");
System.out.println("2. 借阅图书");
System.out.println("3. 归还图书");
System.out.println("0. 退出系统");
System.out.println("**********************");
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的操作：");
int choice = scanner.nextInt();
return choice;
}
}
5.2 类和类之间的整体联系
-
基础结构：系统的基础是
User类，它定义了用户的通用属性和行为，包括用户名和一系列操作。这个类为不同类型的用户提供了一个统一的框架。 -
用户角色：系统通过继承
User类来定义两种不同类型的用户角色——AdminUser（管理员用户）和NormalUser（普通用户）。这两种用户角色都继承了父类的基本属性和方法，但根据各自的需求定制了特定的功能和操作。 -
操作集合：每个用户角色都有一个操作集合（
iOperations数组），其中包含了该角色可以执行的操作。这些操作通常封装在实现了某个接口（如IOperation）的对象中，允许系统以统一的方式调用不同的操作。 -
菜单系统：每个用户角色都有一个定制的菜单系统（通过
menu()方法实现），用于向用户展示可用的操作选项，并接收用户的选择。这个菜单系统根据用户的角色（管理员或普通用户）提供不同的选项。 -
操作执行：当用户通过菜单选择一个操作后，系统会根据用户的选择调用相应的操作（通过
doIoperation()方法）。这个调用是基于操作集合中的接口对象，实现了多态性，使得系统可以灵活地处理不同类型的操作。 -
扩展性：通过接口和继承的使用，系统具有良好的扩展性。如果需要添加新的用户角色或操作，只需创建新的类或实现新的接口，而无需对现有代码进行大量修改。
综上所述，这个图书系统通过面向对象的设计原则（如继承、多态和接口）构建了一个灵活且可扩展的逻辑结构，能够支持不同类型的用户执行各自特定的操作。
5.3 功能拓展
-
增加用户认证与权限管理：目前系统虽然通过不同的用户类（AdminUser和NormalUser）区分了用户角色，但可以进一步增加用户认证机制，如用户名和密码登录，以及更细粒度的权限管理，确保用户只能访问其权限范围内的功能。
-
引入数据库支持：为了提升系统的数据持久化和检索能力，可以集成数据库来存储图书信息、用户信息和借阅记录等。这将使得数据管理更加高效和可靠。
-
优化用户界面：当前的菜单系统是基于控制台的简单文本输出，可以考虑开发一个图形用户界面（GUI）或网页界面，提升用户体验和交互性。
-
增加图书推荐功能：通过分析用户的借阅历史和偏好，可以为用户提供个性化的图书推荐，增强用户粘性和满意度。
-
实现图书预约与续借功能：为了满足用户更多的需求，可以增加图书预约和续借功能，使得用户能够更加方便地管理自己的借阅行为。
-
集成在线支付系统：如果图书系统涉及费用（如逾期罚款、图书购买等），可以集成在线支付系统，为用户提供便捷的支付方式。
-
提供API接口：为了与其他系统进行集成，可以提供API接口，允许第三方开发者或系统调用图书系统的功能，如查询图书信息、进行借阅操作等。
总结：通过增加用户认证与权限管理、引入数据库支持、优化用户界面、增加图书推荐功能、实现图书预约与续借功能、集成在线支付系统以及提供API接口等改进措施，可以进一步提升图书系统的安全性、可用性、用户体验和扩展性。这些改善将有助于图书系统更好地服务于用户，满足用户多样化的需求。
