用JAVA实现图书管理系统
目录
前言
一、设计背景及目的
二、设计思路
三、代码的实现
3.1 Book类的实现
3.2 BookList类的实现
3.3 operation包中的各个类以及接口
3.4 关于用户的操作
3.5 Main方法的实现
3.6 实现各个功能
1. 显示图书功能实现
2. 查找图书功能实现
3. 添加图书功能实现
4. 退出系统功能实现
5. 删除图书功能实现
6. 借阅图书功能实现
7. 归还图书功能实现
四、完整代码
前言
我们在学习了封装，继承和多态，抽象类和接口等知识后，可以对知识做一个总结。通过近期所学内容，我们可以做一个简洁的图书管理系统来对近期知识加深了解。
一、设计背景及目的
我们在学习时，图书馆自然是我们一直以来的的“兵家必争之地”。同时，图书馆中存放的书籍如果没有系统的管理更会显得杂乱无章，使人困扰，因此一个能够系统管理书籍的图书管理系统就显的尤为重要了。
二、设计思路
我们在设计系统前要先理清自己的思绪，想明白需要创建的对象和需要实现的功能。
1. 首先，想清楚系统的界面。系统对于图书管理员来说是管理系统，对于普通用户来说是服务系统。所以我们针对管理员和普通用户所展示的界面是不同的。
2.书的属性有书名，作者，价格，类型。我们可以将书的属性进行封装，同时设置一个书架类，用于存放书籍。设置一个书的数组可以解决。
3.管理员界面上，我们可以添加书籍，查找书籍，删除书籍，显示书籍和退出系统。
4.普通用户界面上，我们可以查找书籍，借阅书籍，归还书籍和退出系统。
5.我们可以将这些操作全都封装起来，设计成一个单独的类。
草图如下：
三、代码的实现
3.1 Book类的实现
我们创建一个book的包，用于存放与书有关的类。根据上述思路，我们可以在Book包中创建一个Book的类和一个Booklist (书架) 的类。首先创建一个book类，在book中写入书的有关属性，书名 (name) ,作者 (author) ， 价格 (price) ，类型 (type) 以及是否被借出。我们通过封装，将属性前的访问修饰符设置为private权限，然后通过编译器的快捷键提供相应的get方法和set方法以及一个不包含是否被借出的构造方法（我们将是否被借出属性的类型设置为boolean，Boolean类型默认为false，可以不初始化），然后通过快捷键提供相应的toString方法的重写。
代码如下：
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
//重写toString 方法
public String toString() {
return "book{" +
"书名='" + name + '\'' +
", 作者='" + author + '\'' +
", 价格=" + price +
", 类型='" + type + '\'' +
", 是否被借出=" + isBorrowed +
'}';
}
}
注意：上段代码大部分由编译器生成，只需输入书的属性，然后运用Getter and setter ，构造方法 以及toString方法的快捷键，就能快速生成上述代码。
3.2 BookList类的实现
BookList类我们采用数组的方式对Book进行存储。
我们首先设置一个private权限的Book数组books，同时设置一个usedSize的变量，用于记录当前书架上存放了多少本书。我们先写一个BookList的构造方法，同时将数组的长度初始化为10，然后通过快捷键设置userSize的getter and setter方法。注意不要使用编译器生成的Book数组books的getter and setter 方法，那不是我们想要的。我们设置一个名为pos的数组下标参数，在getter方法中返回books的数组下标pos，在setter方法中，我们将 books数组的pos下标设置为一本书 。
代码如下：
package Book;
public class Booklist {
private Book[] books;
private int usedSize; //记录当前书架上实际存放了多少本书，默认为 0
public Booklist() {
this.books = new Book[10];
}
public int getUsedSize() {
return usedSize;
}
public void setUsedSize(int usedSize) {
this.usedSize = usedSize;
}
public Book getBook(int pos) {
return books[pos];
}
// pos 为数组下标
public void setBook(int pos,Book book) {
books[pos] = book; //将 books数组的 pos下标设置为一本书
}
}
3.3 operation包中的各个类以及接口
我们通过草图，能够得出结论，图书管理系统共有七个需要实现的功能，我们将这些功能分别写成一个类放在operation这个组织包中。因为无论是管理员还是普通用户，我们需要实现的所有功能都属于对书的操作，都是在BookList类的数组books中操作的，所以我们可以提供一个IOperation的接口，用来实现对数组的操作。
package operation;
import book.Booklist;
public interface IOperation {
void work(Booklist booklist);
}
我们创建完多个类后，如图所示：
然后我们可以对这些类引用接口，然后重写work方法，比如删除图书：
package operation;
import book.Booklist;
public class DelOperation implements IOperation{
@Override
public void work(Booklist booklist) {
System.out.println("删除图书");
}
}
3.4 关于用户的操作
我们创建一个user的包，用于存放与用户相关的类。我们这里就要对普通用户和管理员分开处理了，先创建一个User的类，对于管理员和用户来说，它们都是用户。在User类中，创建一个成员变量，来表示用户，因为我们想让这个变量在一个包中使用，所以我们使用关键字protected。利用快捷键创建一个构造方法对其初始化。
package user;
public class User {
protected String name;
public User(String name) {
this.name = name;
}
}
将子类NormalUser继承父类User，此时会显示报错，这是因为子类在构造前要先对父类进行构造，同理，AdminUser也一样。
package user;
public class NormalUser extends User{
public NormalUser(String name) {
super(name);
}
}接下来打印菜单，我们不能让管理员的菜单和普通用户的一样，所以我们要对菜单方法进行重写，根据两种用户各自所需的功能进行打印。
管理员菜单：
package user;
public class AdminUser extends User{
public AdminUser(String name) {
super(name);
}
public void menu() {
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("*****************");
}
}
普通用户菜单：
package user;
public class NormalUser extends User{
public NormalUser(String name) {
super(name);
}
public void menu() {
System.out.println("*****************");
System.out.println("2.查找书籍");
System.out.println("3.借阅书籍");
System.out.println("4.归还书籍");
System.out.println("0.退出系统");
System.out.println("*****************");
}
}
3.5 Main方法的实现
用户和菜单都有了，此时我们需要一个类把他们全都整合起来。
接下来我们就需要登录了，我们写一个main方法，在main方法中写一个login方法，先写一个判断判定你是管理员还是普通用户。代码如下：
public static User login() {
System.out.println("请输入你的名字：");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
System.out.println("请输入您的身份：-> 1.管理员 2.普通用户");
int choice = scanner.nextInt();
if(choice ==1) {
return new AdminUser(name);
}else {
return new NormalUser(name);
}
}
此时，我们需要接收这个判断的返回值AdminUser 或 NormalUser，把返回类型改为 User ，这样不论 if 返回AdminUser 还是 NormalUser ， User作为父类都可以接收，这个过程就发生了向上转型。
然后在main方法中引用 login 方法，就可以实现选择登陆了。在使用login方法时，我们会发现，使用user加 . ， . 不出来menu菜单，这是因为父类User没有menu方法，你需要在User中声明一下menu方法，我们在声明时编译器还是会显示报错，将User设置成抽象类问题解决。
最终抽象类User代码：
package user;
public abstract class User {
protected String name;
public User(String name) {
this.name = name;
}
public abstract void menu();
}
管理员登录界面：
普通用户登录界面：
显示界面后，下一步我们应该根据用户的选择来选择进入哪个功能。我们先设置一个变量choice，用于接收用户输入的指令。返回choice，所以我们将 void 改为 int ，整个过程用到了向上转型和动态绑定。例如管理员界面：
public int menu() {
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);
int choice = scanner.nextInt();
return choice;在 Main 方法中接收 choice ，然后输出：
public static void main(String[] args) {
//user指向那个对象，就看返回值是什么
User user = login();
int choice = user.menu();
System.out.println("choice = "+choice);
}最终可以得到 choice 成功接收指令：
现在，我们下一步可以根据 choice 的选择来决定调用哪个方法。那接下来如何实现呢，整理一下思路。
1. 看 user 指向哪个对象。
2. 可以打印指定的菜单，并且看 choice 是多少。
3.然后调用 user 指向对象的操作方法。
就是说，看 user 指向哪个对象，指向普通用户就打印普通用户菜单，指向管理员用户就打印管理员用户菜单，同时看choice 是多少。比如user指向普通用户，choice是 1 调用普通用户界面的的添加书籍功能。
接下来就是代码的具体实现。我们在父类 User 定义一个成员变量 IOperation数组 ，然后在 User 的子类 Adminiopeartion 和 Normalioperation 上分别对他进行实例化(实例化顺序按照草图来哈，别搞错了顺序。还要注意一点，因为咱们定义的是数组，我们是要打算按 0 退出系统的，所以退出功能的数组下标得是0，所以把退出功能放到最前面)。
User 添加 ：
protected IOperation[] iOperations;Adminiopeartion 对他进行实例化：
public AdminUser(String name) {
super(name);
this.iOperations = new IOperation[] {
new ExitOperation(),
new FindOperation(),
new AddOperation(),
new DelOperation(),
new ShowOperation()
};
}Normalioperation 对他进行实例化：
public NormalUser(String name) {
super(name);
this.iOperations = new IOperation[] {
new ExitOperation(),
new FindOperation(),
new BorrowOperation(),
new ReturnOperation()
};
}接下来就是 choice 如何返回对应方法的问题了。我们可以创建一个doIoperation方法，然后把 choice 给他，当user 调用这个方法时，这个方法就可以调用你所选对象的某一个方法了。在User创建doIoperation 方法，将 choice 给到他作为参数，同时将booklist作为另一个参数，因为我们要让他调用某一个对象对应的方法，而方法在各个功能类的work 中，work 是以 booklist 作为参数的。这个方法总结下来就是调用这个方法的 choice 下标 所对应的work方法。
public void doIoperation (int choice, Booklist booklist) {
iOperations[choice].work(booklist);
}在Main方法中，实例化Booklist类，使user能够调用doioperation方法，给到 choice 和 booklist 参数。在用户登陆功能后给到一个循环，使程序能够重复打印菜单。
public static void main(String[] args) {
Booklist booklist = new Booklist();
//user指向那个对象，就看返回值是什么
User user = login();
while (true) {
int choice = user.menu();
System.out.println("choice = " + choice);
//根据choice的选择来决定，调用的是哪个方法
user.doIoperation(choice, booklist);
}
}最后功能实现：
这样我们整个程序的基本框架就写好了，下边的事情只是丰富各个功能了。
3.6 实现各个功能
1. 显示图书功能实现
我们在运行程序初始化书架时，先往书架上放几本书，然后用 userSize 记录当前书架上书的数量。
public Booklist() {
this.books = new Book[10];
//放好书！
this.books[0] = new Book("西游记","罗贯中",15,"小说");
this.books[1] = new Book("水浒传","施耐庵",25,"小说");
this.books[2] = new Book("红楼梦","曹雪芹",35,"小说");
this.usedSize = 3;
}显示所有图书相当于遍历书架上所有书。打开Showioperation 类，创建一个变量currentSize，让currentSize拿到 userSize 的值。写一个for循环，让 i 小于currentSize，遍历 booklist 数组中所有下标的值，然后输出，就能拿到所有书。
public void work(Booklist booklist) {
System.out.println("显示图书");
int currentSize = booklist.getUsedSize();
for (int i = 0;i < currentSize;i++) {
Book book = booklist.getBook(i);
System.out.println(book);
}
}
输出时，因为我们已经重写了 toString 方法，所以他会输出重写后的 toString 方法，但重写的toString方法中isBorrowed与对象没有交互，所以看的会有点奇怪。我们重新写一下isBorrowed，当 isBorrowed 为 true 时，输出已经被借出，为 false 时，输出未被借出。
public String toString() {
return "book{" +
"书名='" + name + '\'' +
", 作者='" + author + '\'' +
", 价格=" + price +
", 类型='" + type + '\'' +
((isBorrowed == true) ? " 已经借出" : " 未被借出")+
// ", 是否被借出=" + isBorrowed +
'}';
}2. 查找图书功能实现
查找功能和遍历类似，只要利用equals关键字比较字符串输出就可以了。 在Findioperation 类中，先输入要查找的书名，遍历所有的书，比较书名，书名一样输出即可。
public void work(Booklist booklist) {
System.out.println("查找图书");
System.out.println("请输入你要查找的图书：");
Scanner scanner = new Scanner(System.in);
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("没有找到这本书！");
}3. 添加图书功能实现
思路：首先利用扫描器正常输入书的属性(此处为书名，作者，价格，类型)。但要注意一点，将int 类型放到最后，如果int 类型放到 String 类型前，那输入 int 类型后的回车会被接下来的 String 类型吸收，导致下边的 String 类型无法输入。将输入好的数据放到 book 中。 检查 booklist 数组中有没有新增的数据，如果有就不再添加，如果没有检查书架是否溢出，如果没有，添加成功。
在 Booklist 中写一个getbooks 方法，用于接收书架容量。
public Book[] getBooks() {
return books;
}看看当前书的数目有没有超过书架容量，没有超过添加成功，同时 currentSize 加 1 。
public void work(Booklist booklist) {
System.out.println("添加图书");
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 book = new Book(name,author,price,type);
//检查数组当中有没有这本书
int currentSize = booklist.getUsedSize();
for (int i = 0;i < currentSize;i++) {
Book book1 = booklist.getBook(i);
if(book1.getName().equals(name)) {
System.out.println("书架中有这本书了，不在进行存放！");
return;
}
}
if(currentSize == booklist.getBooks().length) {
System.out.println("书架满了，不能操作");
}else {
System.out.println("添加成功！");
booklist.setBook(currentSize,book);
booklist.setUsedSize(currentSize+1);
}
}4. 退出系统功能实现
最简单的一集！一句 System.exit(0); 直接退出系统。
public void work(Booklist booklist) {
System.out.println("退出系统");
System.exit(0);
}5. 删除图书功能实现
思路：首先找到有没有这本书，然后数组后边的数据从后往前直接覆盖掉想要删除的数据，然后将最后一个数据置空就可以了。
说是覆盖，其实是把需要删除的元素地址指向下一个元素就可以了，同时最后一个元素不需要再指向下一个元素，要不然就数组越界了，所以在循环时，i 要小于currentSize - 1。
public void work(Booklist booklist) {
System.out.println("删除图书");
Scanner scanner = new Scanner(System.in);
System.out.println("请输入想要删除的书名：");
String name = scanner.nextLine();
int pos = -1;
int currentSize = booklist.getUsedSize();
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;
}
//开始删除
int j = pos;
for (; j < currentSize - 1; j++) {
Book book = booklist.getBook(j+1);
booklist.setBooks(j,book);
}
//将数组最后一个元素置为空
booklist.setBook(j,null);
//删除元素，更新 userSize
booklist.setUsedSize(currentSize - 1);
}6. 借阅图书功能实现
借阅图书实现起来相对比较容易，输入要借阅的书名，如果有这本书，将这本书的
setBorrowed 置为 true 就可以了。
public void work(Booklist booklist) {
System.out.println("借阅图书");
/**
* 1.你要借阅那本书
* 2.借阅的书有没有
* 3.借阅的方式是什么
*/
Scanner scanner = new Scanner(System.in);
System.out.println("你要借阅哪本书：");
String name = scanner.nextLine();
int i = 0;
int currentSize = booklist.getUsedSize();
for (i = 0;i < currentSize;i++) {
Book book = booklist.getBook(i);
if (book.getName().equals(name)) {
book.setBorrowed(true);
System.out.println("借阅成功！");
System.out.println(book);
return;
}
}
System.out.println("你借阅的图书不存在！");
}7. 归还图书功能实现
和借阅图书功能完全一样！
public void work(Booklist booklist) {
System.out.println("归还图书");
/**
* 1.你要归还那本书
* 2.归还的书有没有
* 3.归还的方式是什么
*/
Scanner scanner = new Scanner(System.in);
System.out.println("你要归还哪本书：");
String name = scanner.nextLine();
int i = 0;
int currentSize = booklist.getUsedSize();
for (i = 0;i < currentSize;i++) {
Book book = booklist.getBook(i);
if (book.getName().equals(name)) {
book.setBorrowed(false);
System.out.println("归还成功！");
System.out.println(book);
return;
}
}
System.out.println("你归还的图书不存在！");
}到了这里，整个图书管理系统就全部完成了。
四、完整代码
book 包中的 book ：
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
//重写toString 方法
public String toString() {
return "book{" +
"书名='" + name + '\'' +
", 作者='" + author + '\'' +
", 价格=" + price +
", 类型='" + type + '\'' +
((isBorrowed == true) ? " 已经借出" : " 未被借出")+
// ", 是否被借出=" + isBorrowed +
'}';
}
}
booklist ：
package book;
public class Booklist {
private Book[] books;
private int usedSize; //记录当前书架上实际存放了多少本书，默认为 0
public Booklist() {
this.books = new Book[10];
//放好书！
this.books[0] = new Book("西游记","罗贯中",15,"小说");
this.books[1] = new Book("水浒传","施耐庵",25,"小说");
this.books[2] = new Book("红楼梦","曹雪芹",35,"小说");
this.usedSize = 3;
}
public int getUsedSize() {
return usedSize;
}
public void setUsedSize(int usedSize) {
this.usedSize = usedSize;
}
public Book getBook(int pos) {
return books[pos];
}
// pos 为数组下标
public void setBook(int pos,Book book) {
books[pos] = book; //将 books数组的 pos下标设置为一本书
}
public Book[] getBooks() {
return books;
}
public void setBooks(int pos,Book book) {
books[pos] = book;
}
}
IOpeartion 包中的 Addioperation ：
package operation;
import book.Book;
import book.Booklist;
import java.util.Scanner;
public class AddOperation implements IOperation{
@Override
public void work(Booklist booklist) {
System.out.println("添加图书");
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 book = new Book(name,author,price,type);
//检查数组当中有没有这本书
int currentSize = booklist.getUsedSize();
for (int i = 0;i < currentSize;i++) {
Book book1 = booklist.getBook(i);
if(book1.getName().equals(name)) {
System.out.println("书架中有这本书了，不在进行存放！");
return;
}
}
if(currentSize == booklist.getBooks().length) {
System.out.println("书架满了，不能操作");
}else {
System.out.println("添加成功！");
booklist.setBook(currentSize,book);
booklist.setUsedSize(currentSize+1);
}
}
}
Borrowedioperation：
package operation;
import book.Book;
import book.Booklist;
import java.util.Scanner;
public class BorrowOperation implements IOperation{
@Override
public void work(Booklist booklist) {
System.out.println("借阅图书");
/**
* 1.你要借阅那本书
* 2.借阅的书有没有
* 3.借阅的方式是什么
*/
Scanner scanner = new Scanner(System.in);
System.out.println("你要借阅哪本书：");
String name = scanner.nextLine();
int i = 0;
int currentSize = booklist.getUsedSize();
for (i = 0;i < currentSize;i++) {
Book book = booklist.getBook(i);
if (book.getName().equals(name)) {
book.setBorrowed(true);
System.out.println("借阅成功！");
System.out.println(book);
return;
}
}
System.out.println("你借阅的图书不存在！");
}
}
Delioperation ：
package operation;
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.println("请输入想要删除的书名：");
String name = scanner.nextLine();
int pos = -1;
int currentSize = booklist.getUsedSize();
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;
}
//开始删除
int j = pos;
for (; j < currentSize - 1; j++) {
Book book = booklist.getBook(j+1);
booklist.setBooks(j,book);
}
//将数组最后一个元素置为空
booklist.setBook(j,null);
//删除元素，更新 userSize
booklist.setUsedSize(currentSize - 1);
}
}
Exitioperation ：
package operation;
import book.Booklist;
public class ExitOperation implements IOperation{
@Override
public void work(Booklist booklist) {
System.out.println("退出系统");
System.exit(0);
}
}
Findioperation ：
package operation;
import book.Book;
import book.Booklist;
import java.util.Scanner;
public class FindOperation implements IOperation{
@Override
public void work(Booklist booklist) {
System.out.println("查找图书");
System.out.println("请输入你要查找的图书：");
Scanner scanner = new Scanner(System.in);
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("没有找到这本书！");
}
}
Returnioperation ：
package operation;
import book.Book;
import book.Booklist;
import java.util.Scanner;
public class ReturnOperation implements IOperation{
@Override
public void work(Booklist booklist) {
System.out.println("归还图书");
/**
* 1.你要归还那本书
* 2.归还的书有没有
* 3.归还的方式是什么
*/
Scanner scanner = new Scanner(System.in);
System.out.println("你要归还哪本书：");
String name = scanner.nextLine();
int i = 0;
int currentSize = booklist.getUsedSize();
for (i = 0;i < currentSize;i++) {
Book book = booklist.getBook(i);
if (book.getName().equals(name)) {
book.setBorrowed(false);
System.out.println("归还成功！");
System.out.println(book);
return;
}
}
System.out.println("你归还的图书不存在！");
}
}
Showioperation ：
package operation;
import book.Book;
import book.Booklist;
public class ShowOperation implements IOperation{
@Override
public void work(Booklist booklist) {
System.out.println("显示图书");
int currentSize = booklist.getUsedSize();
for (int i = 0;i < currentSize;i++) {
Book book = booklist.getBook(i);
System.out.println(book);
}
}
}
user 包中的 User ：
package user;
import book.Booklist;
import operation.IOperation;
public abstract class User {
protected String name;
protected 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：
package user;
import operation.*;
import java.util.Scanner;
public class AdminUser extends User{
public AdminUser(String name) {
super(name);
this.iOperations = new IOperation[] {
new ExitOperation(),
new AddOperation(),
new FindOperation(),
new DelOperation(),
new ShowOperation()
};
}
public int menu() {
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);
int choice = scanner.nextInt();
return choice;
}
}
NormalUser：
package user;
import operation.*;
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()
};
}
public int menu() {
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);
int choice = scanner.nextInt();
return choice;
}
}
Main 方法：
import book.Booklist;
import user.AdminUser;
import user.NormalUser;
import user.User;
import java.util.Scanner;
public class Main {
public static User login() {
System.out.println("请输入你的名字：");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
System.out.println("请输入您的身份：-> 1.管理员 2.普通用户");
int choice = scanner.nextInt();
if (choice == 1) {
return new AdminUser(name);
} else {
return new NormalUser(name);
}
}
public static void main(String[] args) {
Booklist booklist = new Booklist();
//user指向那个对象，就看返回值是什么
User user = login();
while (true) {
int choice = user.menu();
//根据choice的选择来决定，调用的是哪个方法
user.doIoperation(choice, booklist);
}
}
}