✨✨谢谢大家捧场，祝屏幕前的小伙伴们每天都有好运相伴左右，一定要天天开心哦！✨✨
🎈🎈作者主页： 🎈丠丠64-CSDN博客🎈
✨✨ 帅哥美女们，我们共同加油！一起进步！✨✨
目录
一、前言
二、问题描述
三、思路
四、实现过程
1.book包
-Book类
-BookList类
2.user包
-User类
-AdminUser类
-NormalUser类
3.operation包
-IOperation接口
-AddOperation类
-DelOperation类
-FindOperation类
-ShowOperation类
-BorrowedOperation类
-RetuenOperation类
-ExitOperation类
4.主函数Main
一、前言
前面用了大量篇幅来介绍了JAVASE的大量知识，JAVA的基本语法我们了解的差不多了，我们来实操一个完整的一个代码功能包含了接口，继承等很多全面的知识，以便于我们对该部分的知识更加有印象。
二、问题描述
我们要实现一个图书管理系统，来系统的管理图书。一本书的信息包含书名，作者，类型，价格。在进入系统后首先实名制姓名，然后进入对应的菜单实现对应的功能。
普通用户只能实现查阅、借阅跟归还；
图书管理员不仅可以实现普通用户的所有功能还可以实现删减图书跟增添图书来管理。
三、思路
可以将这个问题大致分为3个模块，分别从用户，图书，以及实现的功能，三个方面去分别实现各自的大致功能，再将三个模块联系在一起来实现。
所以我们先针对这三个模块，各自建立一个包了实现各自功能。
四、实现过程
1.book包
-Book类
首先一上来就是最基本的书，我们先在book这个包下创建一个Book类，用来实现一本书的信息。
分别创建成员变量name、author、typr、price、ifBorrowed
package book;
public class Book {
private String name;//书名
private String author;//作者
private String type;//类型
private int price;//价格
private boolean ifBorrowed;//是否被借出
}并对其创建构建方法（因为默认的书就是为未借出，所以可以不构造ifBorrowed这一成员）
因为成员访问权限为private ，所以也要提供get与put函数了实现对外对其访问
并且重写ToString方法，后续会对书进行打印
package book;
public class Book {
private String name;//书名
private String author;//作者
private String type;//类型
private int price;//价格
private boolean ifBorrowed;//是否被借出
public Book(String name, String author, String type, int price) {
this.name = name;
this.author = author;
this.type = type;
this.price = price;
}
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 String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public boolean isIfBorrowed() {
return ifBorrowed;
}
public void setIfBorrowed(boolean ifBorrowed) {
this.ifBorrowed = ifBorrowed;
}
@Override
public String toString() {
return "凯旋图书馆：{" +
"书名='" + name + '\'' +
", 作者='" + author + '\'' +
", 类型='" + type + '\'' +
", 价格=" + price +
((ifBorrowed == true)?" ,被借出":" ,未借出")+
'}';
}
}-BookList类
我们实现了单个图书以后，想要对图书进行一个整合，类似于书架一样的功能。我们创建一个书的数组books 通过访问下标的方式，来模拟书架对单个书进行管理。
我们先给初始化数组给定10个大小，并且创建一个成员变量用来记录目前书架上书的数量
package book;
public class BookList {
private Book[] books = new Book[10];
private int usedSize;//实际放书数量
}
构造方法并对其书架上面的书初始化，我们假设现在设定暂放3本书，所以usedSize也为3
package book;
public class BookList {
private Book[] books = new Book[10];
private int usedSize;//实际放书数量
public BookList() {
this.books[0] = new Book("三国演义","罗贯中","小说",15);
this.books[1] = new Book("西游记","吴承恩","小说",15);
this.books[2] = new Book("红楼梦","曹雪芹","小说",15);
this.usedSize = 3;
}
}
因为成员访问权限为private，分别构造出usedSize与 books的get与put函数
package book;
public class BookList {
private Book[] books = new Book[10];
private int usedSize;//实际放书数量
public BookList() {
this.books[0] = new Book("三国演义","罗贯中","小说",15);
this.books[1] = new Book("西游记","吴承恩","小说",15);
this.books[2] = new Book("红楼梦","曹雪芹","小说",15);
this.usedSize = 3;
}
public Book getBooks(int pos) { //相当于查看书架书的信息
return books[pos];
}
public void setBooks(Book book,int pos) { //相当于通过下标传入位置放书
books[pos] = book;
}
public int getUsedSize() {
return usedSize;
}
public void setUsedSize(int usedSize) {
this.usedSize = usedSize;
}
}
2.user包
我们发现系统面对的两个用户，管理员和普通用户实现的功能都差不多，都是进入以后实名制以后打印对应的菜单，所以我们可以使用一个抽象类的父类来实现两个子类的功能
-User类
我们来构造一个父类，首先是子类共有的东西姓名，然后实现各自的菜单，我们可以将其写为抽象方法，子类通过重写来实现各自的菜单，因为有了抽象方法，所以该User类也是抽象类。
同时为了实现管理员与普通用户在操作上的独立性，我们可以构造一个功能数组ioPerations方法用来分别存各自的功能，再构建一个方法来实现数组对应的功能的实现
package user;
public abstract class User {
protected String name; //共有属性
public User(String name) { //构造方法
this.name = name;
public IOperation[] ioPerations; //构造的一个功能数组
}
public abstract int menu(); //抽象方法 菜单，返回不同的值用来实现不同的功能
public void doOperation(int choice, BookList bookList){
ioPerations[choice].work(bookList); //通过功能数组来实现各自的功能
}
}
-AdminUser类
我们构造一个AdminUser类，来实现管理员的功能，首先继承User父类的功能在对抽象方法菜单进行重写。并且创建一个功能数组并且初始化自己的功能。
package user;
import java.util.Scanner;
public class AdminUser extends User{
public AdminUser(String name) { //父类的构造方法
super(name);
}
//对应的方法数组
this.ioPerations = new IOperation[]{
new ExitOperation(), //下标0为退出系统
new ShowOperation(), //下标1为显示书
new FindOperation(), //下标2为查找书
new AddOperation(), //下标3为增添书
new DelOperation() //下标4为删减书
};
@Override
public int menu() { //菜单
System.out.println("***********************************");
System.out.println(this.name + "欢迎来到管理员菜单");
System.out.println("1. 显示书");
System.out.println("2. 查找书");
System.out.println("3. 增添书");
System.out.println("4. 删减书");
System.out.println("0. 退出系统");
System.out.println("***********************************");
System.out.println("请输入你的操作:");
Scanner scanner = new Scanner(System.in); //用户进行选择
int choice = scanner.nextInt();
return choice; //返回不同的值用来实现不同的功能
}
}
-NormalUser类
我们再构造一个NormalUser类，来实现普通用户的功能，首先继承User父类的功能在对抽象方法菜单进行重写。并且创建一个功能数组并且初始化自己的功能。
package user;
import java.util.Scanner;
public class NormalUser extends User {
public NormalUser(String name) { //父类构造方法
super(name);
}
//功能数组
this.ioPerations = new IOperation[]{
new ExitOperation(), //下标0为退出系统
new ShowOperation(), //下标1为显示书
new FindOperation(), //下标2为超找书
new BorrowedOperation(), //下标3为借阅书
new RetuenOperation(), //下标4为归还书
};
@Override
public int menu(){ //重写菜单
System.out.println("***********************************");
System.out.println(this.name + "欢迎来到用户菜单");
System.out.println("1. 显示书");
System.out.println("2. 查找书");
System.out.println("3. 借阅书");
System.out.println("4. 归还书");
System.out.println("0. 退出系统");
System.out.println("***********************************");
System.out.println("请输入你的操作");
Scanner scanner = new Scanner(System.in); //用户进行选择
int choice = scanner.nextInt();
return choice; //返回不同的值用来实现不同的功能
}
}
3.operation包
这个包用来实现功能，我们可以构建一个接口来对这些功能进行一个规范，让功能重写方法实现各自功能。
-IOperation接口
因为所有的功能都针对于书籍，都操作的BookList这个书架，所以我们构建一个规范。
package operation;
import book.BookList;
public interface IOperation {
public void work(BookList bookList); //重写方法
}
-AddOperation类
这个类实现增加图书的功能，使用IOperation这个接口，重写里面标准方法。
用户输入要添加书的信息，阅历书架，没有这本书就可以放入，有就提示已经存在这本书不能放并且退出，放入书架总数也加一。
package operation;
import book.Book;
import book.BookList;
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();
scanner.nextLine();
System.out.println("请输入价格 ：");
int price = scanner.nextInt();
Book book = new Book(name,author,type,price); //为新增的书创建应该实例化对象
int currentSize = bookList.getUsedSize(); //获取书架此时的书数量
for (int i = 0; i < currentSize; i++) {
Book book1 = bookList.getBooks(i);
if(book1.getName().equals(name)){
System.out.println("书架已经有这本书，不能添加"); //阅历查找是否书架已有
return;
}else{
bookList.setBooks(book,currentSize); //在书架默认的最后一个放入新加的书
}
}
bookList.setUsedSize(currentSize+1); //成功加入书以后，书架总数量也要增加
}
}
-DelOperation类
这个类实现删减图书的功能，使用IOperation这个接口，重写里面标准方法。
输入想要删除的书名，若书架中有则删除后面书往前移，若没有则退出。书架总数也减一。
package operation;
import book.BookList;
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 currentSize = bookList.getUsedSize(); //获取目前书架书的总数
int index = -1; //设置默认值为-1
for (int i = 0; i < currentSize; i++) {
Book book = bookList.getBooks(i);
if(book.getName().equals(name)){
index = i; //书架中有目标书以后，index值为目标书的下标
break;
}
}
if(index == -1){
System.out.println("没有你删除的书"); //若没有找到书，则值还为-1，退出
return;
}else{
for (int i = index; i < currentSize-1; i++) {
Book book1 = bookList.getBooks(i+1); //找到目标书，将后面的书往前移
bookList.setBooks(book1,i);
}
}
bookList.setUsedSize(currentSize-1); //成功删除以后，书架总数要减一
}
}
-FindOperation类
这个类实现查找图书的功能，使用IOperation这个接口，重写里面标准方法。
用户输入想要查找的书以后，阅历书架来寻找。
package operation;
import book.BookList;
public class FindOperation 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 currentSize = bookList.getUsedSize(); //获取bookList中实际书的数量
for (int i = 0; i < currentSize; i++) {
Book book = bookList.getBooks(i);
if(book.getName().equals(name)){ //遍历查阅看看与用户输入的书是否有相等
System.out.print("找到了: ");
System.out.println(book); //找到退出
return;
}else{
System.out.println("找不到");
}
}
}
}
-ShowOperation类
这个类实现显示图书的功能，使用IOperation这个接口，重写里面标准方法。
然后通过遍历数组的方式，遍历books数组来实现显示图书的功能
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(); //获取bookList中实际书的数量
for (int i = 0; i < currentSize; i++) {
Book book = bookList.getBooks(i); //遍历数组，打印所有书
System.out.println(book);
}
}
}
-BorrowedOperation类
这个类实现借阅图书的功能，使用IOperation这个接口，重写里面标准方法。
输入想要借阅的书名字以后，遍历书架，成功找到目标书以后并且没有被借出，将借阅状态置为true
package operation;
import book.BookList;
public class BorrowedOperation 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 currentSize = bookList.getUsedSize();
for (int i = 0; i < currentSize; i++) {
Book book1 = bookList.getBooks(i);
if(book1.getName().equals(name)){
if(book1.isIfBorrowed() == false) {
book1.setIfBorrowed(true);
System.out.println("借阅成功");
return;
}else{
System.out.println("已经被借阅，不能再借");
}
}
}
System.out.println("没有你要借的书");
}
}
-RetuenOperation类
这个类实现归还图书的功能，使用IOperation这个接口，重写里面标准方法。
输入想要归还的书名字以后，遍历书架，成功找到目标书以后，将借阅状态置为false。
package operation;
import book.BookList;
public class RetuenOperation 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 currentSize = bookList.getUsedSize();
for (int i = 0; i < currentSize; i++) {
Book book1 = bookList.getBooks(i);
if(book1.getName().equals(name)){
book1.setIfBorrowed(false);
System.out.println("归还成功");
return;
}
}
System.out.println("没有你要还的书");
}
}
-ExitOperation类
这个类实现退出系统的功能，使用IOperation这个接口，重写里面标准方法。
使用exit退出，并且对书架的书和总数进行清零。
package operation;
import book.BookList;
public class ExitOperation implements IOperation{
@Override
public void work(BookList bookList) { //重写接口的标准方法
System.out.println("退出系统");
int currentSize = bookList.getUsedSize(); //获取bookList中实际书的数量
for (int i = 0; i < currentSize; i++) {
bookList.setBooks(null,i); //遍历数组将所有元素置为null
}
bookList.setUsedSize(0); //将实际书数量置为0
System.exit(0); //退出系统
}
}
4.主函数Main
在主程序中首先我们要做的就是登录系统，我们可以用一个方法来区分是否为管理员还是普通用户
拿User接受返回值，在输入不同的数字构造不同的用户，输入1构造AdminUser管理员，输入2为NormalUser普通用户
public static User login(){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的姓名：");
String name = scanner.nextLine();
System.out.println("请输入你的身份 1-》管理员，0-》普通用户");
int choice = scanner.nextInt();
if(choice == 1){
return new AdminUser(name);
}else{
return new NormalUser(name);
}
}在主函数main中，先实例化书架里面原有的书
向上转型接受login方法的返回值，再通过不同的构造对象打印出不同的菜单
然后循环调用相关的操作，直到用户退出系统
import user.AdminUser;
import user.NormalUser;
import user.User;
import java.util.Scanner;
public class Main {
public static User login(){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的姓名：");
String name = scanner.nextLine();
System.out.println("请输入你的身份 1-》管理员，0-》普通用户");
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 = login(); //对应数字实例化对象
while(true){
int choice = user.menu(); //打印并返回对应对象的菜单要实现的功能
user.doOperation(choice, bookList); //调用对应的操作
{
}
}
希望对你有帮助
