- 完整代码链接：https://gitee.com/zeng-xuehui/Java_repository/tree/master/test_11_27_1/src
- 我们在写这个系统时，首先需要搭建框架，再实现业务逻辑；
- 图书管理系统是用户通过各种功能对图书进行操作的一个系统；
- 我们需要通过三方面进行编写代码：1、用户 2、功能 3、图书，所以代码大的分为了这三部分；
1、代码主要就分为三大模块和一个Main类来测试图书管理系统；
2、 book包中的Book类和BookList类
Book类：是用来描述书这个对象的；
BookList类：用来描述书架上的书；
Book类代码：
package book;
public class Book {
// book的属性
private String name; // 名字
private String author; // 作者
private int price; // 价格
private String type; // 类型
private Boolean isBorrow = false; // 是否借阅->初始值false
// 如果这里不初始化，后面有些地方使用到isBorrow这个属性就会报错；
// 书的初始化
public Book() {
}
public Book(String name, String author, String type, int price) {
this.name = name;
this.author = author;
this.type = type;
this.price = price;
}
// 方法
public void setBorrow(Boolean isBorrow) {
this.isBorrow = isBorrow;
}
public String getName() {
return name;
}
public String getAuthor() {
return author;
}
public int getPrice() {
return price;
}
public String getType() {
return type;
}
public Boolean getBorrow() {
return isBorrow;
}
public void setName(String name) {
this.name = name;
}
public void setAuthor(String author) {
this.author = author;
}
public void setType(String type) {
this.type = type;
}
public void setPrice(int price) {
this.price = price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", author='" + author + '\'' +
", price=" + price +
", type='" + type + '\'' +
((isBorrow == true)? " 已借阅":" 未借阅") +
'}';
}
}
BookList类代码：
package book;
/**
* 难点：数组的初始化、数组应该如何使用
* 1、this.books = new Book[10]; // 将书架初始化为10，可以存放10本书
*
*/
public class BookList {
// 存放书本
private Book[] books; // 这是书架，存放书本
private int useSize; // 存放数量
// 初始化
public BookList() {
this.books = new Book[10]; // 将书架初始化为10，可以存放10本书
// 书架上有两本书，所以可以通过实例代码块实现，或者构造代码块实现
this.books[0] = new Book("java","高斯林","编程",32);
this.books[1] = new Book("C语言","xxxx","编程",45);
this.useSize = 2; // 书架上有两本书
}
public Book getBooks(int pos) {
return this.books[pos];
// 这里返回的是一本书，所以返回值是Book
}
public void setBook(Book book, int pos) {
// 书架上新增一本书，新增到哪个位置
this.books[pos] = book;
}
public int getUseSize() {
return useSize;
}
public void setUseSize(int useSize) {
this.useSize = useSize;
}
}
3、 user包中的User类、Administractor类、OrdinaryUser类
User类：用来描述用户这个对象的；
Administractor类：主要写的是管理员用户的特有方法和属性；
OrdinaryUser类：主要写的是普通用户的特有方法和属性；
在这里的有一个难点：我最初写的时候不理解功能数组的初始化；
User类代码：
package user;
import book.BookList;
import function.Function;
/**
* 难点：在用户中定义功能数组
* 1、protected Function[] functions; // 数组并没有初始化，没有为数组分配空间
*/
public abstract class User {
protected Function[] functions; // 数组并没有初始化，没有为数组分配空间
//用户属性
private String name; // 这是用户的姓名
public User(String name) {
this.name = name;
}
// 方法
public abstract int menu();
// 功能实现的方法
public void function(int choose, BookList bookList) {
// this.functions[] -> 这是一个功能对象
// this.functions[choose].work() -> 调用对象中的方法
// this.functions[choose].work(bookList);
// 接口不能new，但是接口可以引用对象，这里接口是应用的对象
Function function = this.functions[choose]; // 这是功能对象
function.work(bookList);
}
}
Administractor类代码：
package user;
import function.*;
import java.util.Scanner;
/**
* 难点：功能数组初始化
* // this既可以调用子类的成员，也可以调用父类的成员
* this.functions = new Function[]{
* new ExitSystem(),
* new AddFunction(),
* new ReturnFunction(),
* new DeleteFunction(),
* new ShowFunction()
* };
* 难点：选择功能之后为什么没有实现对应的功能
*/
public class Administrator extends User{
public Administrator(String name) {
super(name);
// this既可以调用子类的成员，也可以调用父类的成员
this.functions = new Function[]{
new ExitSystem(),
new AddFunction(),
new ReviseFunction(),
new DeleteFunction(),
new ShowFunction()
};
}
@Override
public int menu() {
System.out.println(".........管理员.........");
System.out.println("0、退出系统");
System.out.println("1、增加图书");
System.out.println("2、修改图书");
System.out.println("3、删除图书");
System.out.println("4、显示图书");
System.out.println(".......................");
System.out.print("请选择功能：");
Scanner scanner = new Scanner(System.in);
int choose = scanner.nextInt();
return choose;
}
}
OrdinaryUser类代码：
package user;
import function.*;
import java.util.Scanner;
/**
* 难点：数组的初始化
* // this既可以调用子类的成员，也可以调用父类的成员
* this.functions = new Function[]{
* new ExitSystem(),
* new BorrowFunction(),
* new ReturnFunction(),
* new ShowFunction()
* };
* 难点：选择功能之后为什么没有实现对应的功能
*/
public class OrdinaryUser extends User{
public OrdinaryUser(String name) {
super(name);
// this既可以调用子类的成员，也可以调用父类的成员
this.functions = new Function[]{
new ExitSystem(),
new BorrowFunction(),
new ReturnFunction(),
new ShowFunction(),
new FindFunction()
};
}
// 方法
@Override
public int menu() {
System.out.println("........普通用户........");
System.out.println("0、退出系统");
System.out.println("1、借阅图书");
System.out.println("2、归还图书");
System.out.println("3、显示图书");
System.out.println("4、查找图书");
System.out.println(".......................");
System.out.print("请选择功能：");
Scanner scanner = new Scanner(System.in);
int choose = scanner.nextInt();
return choose;
// 选择之后为什么没有实现功能呢？
}
}
4、function包中的各种操作类和一个Function接口
操作类：管理员的操作类、普通用户的操作类；
Function接口：通过操作类实现这个Function接口，目的就是使操作分离；
Function接口代码：
package function;
import book.BookList;
public interface Function {
// 这些功能都是对书架上的书进行操作
// 所以在操作时需要将书架传过来
void work(BookList bookList);
}
操作类代码：
新增图书代码：
package function;
import book.Book;
import book.BookList;
import java.util.Scanner;
public class AddFunction implements Function{
@Override
public void work(BookList bookList) {
System.out.println("增加图书");
Scanner scanner = new Scanner(System.in);
System.out.print("请输入新增图书书名：");
String name = scanner.nextLine();
System.out.print("请输入新增图书作者：");
String author = scanner.nextLine();
System.out.print("请输入新增图书类型：");
String type = scanner.nextLine();
System.out.print("请输入新增图书价格：");
int price = scanner.nextInt();
// 新增了书本，所以我们需要构造出一个书的对象
Book book = new Book(name, author, type, price);
// 新增图书所放的位置
// 可以放在数组的开头，也可以放在数组的中间，还可以放在数组的末尾
// 但是所放的位置，不允许当前位置之前为空！！！前一个位置必须有数据
// 但是我们在放这本书之前需要判断书架中是否存在这本书
for (int i = 0; i < bookList.getUseSize(); i++) {
Book systemBook = bookList.getBooks(i);
if(systemBook.getName().equals(name)) {
System.out.println("书架中已存在此书，新增失败！");
return ;
}
}
// 走到这里说明书架上没有这本书，新增成功
// 但是我们应该怎么在书架中新增呢？
// 将书放到数组中的某个下标就新增成功
bookList.setBook(book, bookList.getUseSize());
bookList.setUseSize(bookList.getUseSize() + 1);
System.out.println("新增成功!");
}
}
借阅图书代码：
package function;
import book.Book;
import book.BookList;
import java.util.Scanner;
/**
* 发现一个问题：借阅图书和归还图书都没有实际的操作，并没有使书架上的书减少，仅仅只是显示借阅和归还
* 借阅、归还图书操作并没有改变书架上的书
*/
public class BorrowFunction implements Function{
@Override
public void work(BookList bookList) {
System.out.println("借阅图书");
System.out.print("请输入借阅图书的书名：");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
// 再进行比较，存在这本书、不存在这本书；
int i = 0;
for (i = 0; i < bookList.getUseSize(); i++) {
if(bookList.getBooks(i).getName().equals(name)) {
// 进入这里面说明书架中有这本书
bookList.getBooks(i).setBorrow(true);
System.out.println("借阅成功!");
return; // 这里直接return，下面就不需要再进行判断
}
}
System.out.println("图书中没有这本书：" + name);
}
}
删除图书代码：
package function;
import book.Book;
import book.BookList;
import java.util.Scanner;
public class DeleteFunction implements Function{
@Override
public void work(BookList bookList) {
System.out.println("删除图书");
int index = -1; // 用来记录要删除图书的下标
System.out.print("请输入要删除图书书名：");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
int i = 0;
for (i = 0; i < bookList.getUseSize(); i++) {
// 先找到对应下标的书
Book book = bookList.getBooks(i);
if(book.getName().equals(name)) {
// 走到这儿说明已经找到了这本图书
// 当找到这本书就跳出循环
// 将找到书的下标给到index
index = i;
break;
}
}
// 走到这里说明在书架中没有找到这本书
if(i >= bookList.getUseSize()) {
System.out.println("书架中没有要删除的这本书!");
return ; // 结束当前这个方法
}
// 如何删除一本书，先在已经有了这本书的下标index
// 这里还需要考虑的是j小于多少,如果不减1的话会出现数组越界
for (int j = index; j < bookList.getUseSize()-1; j++) {
// 写到这里，怎么调用数组呀？
// 现在通过getBooks这个方法拿到了j+1位置处的下标
Book book = bookList.getBooks(j+1);
// 现在这个setBook方法，将book这本书放到j位置
bookList.setBook(book,j);
}
// 还需要将最后没有使用的对象置为空
bookList.setBook(null, bookList.getUseSize()-1);
bookList.setUseSize(bookList.getUseSize()-1);
}
}
退出系统代码：
package function;
import book.BookList;
public class ExitSystem implements Function{
@Override
public void work(BookList bookList) {
System.out.println("退出系统");
System.exit(0);
// 应该要对bookList手动回收
}
}
查找图书代码：
package function;
import book.Book;
import book.BookList;
import java.util.Scanner;
public class FindFunction implements Function{
@Override
public void work(BookList bookList) {
System.out.println("查找图书");
// 查找图书需要输入查找内容
System.out.print("请输入要查找的图书书名：");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
// 输入的数需要与书架上的书进行对比
// 难点：怎么和书架上的书进行比较
// 现在就是要遍历书架上的书
// 每遍历一次就要拿到一本书
// 拿到一本书后返回它的下标进行比较
for (int i = 0; i < bookList.getUseSize(); i++) {
// Book book = bookList[i];
// 这样写是错的，bookList是一个类，类中的Book对象才是一个数组
// 由于Book数组对象是一个私有的对象，所以需要提供一个方法来获取到i下标的对象
Book book = bookList.getBooks(i);
// 上面是查找的书名，所以比较的也是书名，需要获取到当前下标的书名
if(book.getName().equals(name)) {
System.out.print("存在这本书，信息如下：");
// 还有这里为什么直接就调用了Book类中的toString方法呢？
System.out.println(book);
return ; // 当我们找到了就要结束这个方法
}
}
System.out.println("没有你要找的书：" + name);
}
}
归还图书代码：
package function;
import book.BookList;
import java.util.Scanner;
public class ReturnFunction implements Function{
@Override
public void work(BookList bookList) {
System.out.println("归还图书");
System.out.print("请输入要归还图书的书名：");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
// 再进行比较，存在这本书、不存在这本书；
int i = 0;
for (i = 0; i < bookList.getUseSize(); i++) {
if(bookList.getBooks(i).getName().equals(name)) {
// 进入这里面说明书架中有这本书
bookList.getBooks(i).setBorrow(false);
System.out.println("归还成功!");
return; // 这里直接return，下面就不需要再进行判断
}
}
System.out.println("图书中没有要归还的这本书：" + name);
}
}
修改图书代码：
package function;
import book.Book;
import book.BookList;
import java.util.Scanner;
public class ReviseFunction implements Function{
@Override
public void work(BookList bookList) {
System.out.println("修改图书");
// 请输入要修改的图书
System.out.print("请输入要修改的图书：");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
// 判断书架上是否有这本书
for (int i = 0; i < bookList.getUseSize(); i++) {
Book book = bookList.getBooks(i);
if(book.getName().equals(name)) {
// 走到这里说明书架上有这本书
System.out.print("请输入要修改的图书的书名：");
String bookName = scanner.nextLine();
book.setName(bookName);
System.out.print("请输入要修改的图书的作者：");
String bookAuthor = scanner.nextLine();
book.setAuthor(bookAuthor);
System.out.print("请输入要修改的图书的类型：");
String bookType = scanner.nextLine();
book.setType(bookType);
System.out.print("请输入要修改的图书的价格：");
int bookPrice = scanner.nextInt();
book.setPrice(bookPrice);
System.out.println("修改成功!");
return;
}
}
System.out.println("书架上没有要删除的这本书：" + name);
}
}
显示图书代码：
package function;
import book.Book;
import book.BookList;
public class ShowFunction implements Function{
@Override
public void work(BookList bookList) {
System.out.println("显示图书");
// 显示图书就是拿到一本书的下标就打印一本书
for (int i = 0; i < bookList.getUseSize(); i++) {
// 先拿到这本书的下标
Book book = bookList.getBooks(i);
System.out.println(book);
}
}
}
5、Main类测试图书管理系统
Main类代码：
import book.Book;
import book.BookList;
import function.Function;
import user.Administrator;
import user.OrdinaryUser;
import user.User;
import java.util.Scanner;
/**
* * 1、找对象、创建对象、实现对象
* * 2、最容易想到的两个对象->书、人
* * 3、实现书这个对象，但是书不止一本，所以需要书架
* * 4、书架是用来存放书的，其中涉及的数组是难点（！）
* * 5、操作人员->普通用户、管理员用户
* * 6、不用的用户所提供的操作不相同，如何实现各自操作的分离
* * 7、每一个操作都写成一个类当中，每一个类都是对书进行操作，将这个对书的操作写成一个接口，每个类再去实现接口中的方法
* * 8、实现一个接口数组，一个是普通用户的操作接口数组，一个书管理员用户的操作接口数组，这样就将各自的操作分离了出来，目的就是为了类型统一
* * 9、用户是一个类，用户的基本信息应该包含；但是用户分为->普通用户、管理员用户；这两个类是用户类的子类；这三个类应该如何协同操作呢？
* * 10、我们需要一个登录页面进行操作
*/
public class Main {
public static User login() {
System.out.print("请输入你的姓名：");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
System.out.println("请选择你的身份：1、管理员用户 2、普通用户");
int choose = scanner.nextInt();
if(choose == 1) {
return new Administrator(name);
}else {
return new OrdinaryUser(name);
}
}
public static void main(String[] args) {
BookList bookList = new BookList();
// 登录页面
User user = login();
while(true) {
// 循环操作
int choose = user.menu(); // 返回了一个功能选择，所以需要接收
// 难点：那么需要怎样调用这些功能呢？
user.function(choose,bookList);
}
}
}
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
