✨✨谢谢大家捧场，祝屏幕前的小伙伴们每天都有好运相伴左右，一定要天天开心哦！✨✨
🎈🎈作者主页： 🎈丠丠64-CSDN博客🎈
✨✨ 帅哥美女们，我们共同加油！一起进步！✨✨
目录
一、前言
前面用了大量篇幅来介绍了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;
import org.omg.CORBA.PUBLIC_MEMBER;
public class Book {
private String name; //书名
private String author; //作者
private String type; //类型
private int price; //价格
private boolean ifBorrowed; //是否被借出，默认为false
//构造方法
public Book(String name, String author, String type, int price) {
this.name = name;
this.author = author;
this.type = type;
this.price = price;
}
//private访问限制需要用get和set方法引用读写
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 getisIfBorrowed() {
return ifBorrowed;
}
public void setIfBorrowed(boolean ifBorrowed) {
this.ifBorrowed = ifBorrowed;
}
//重写toString，不重写会打印哈希值
@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 BookLise {
private Book[] books = new Book[10]; //对书籍管理的数组，默认为10个空位
private int nowSize; //书架实际书的数目
//构造方法
public BookLise() {
this.books[0] = new Book("三国演义","罗贯中","小说",15);
this.books[1] = new Book("西游记","吴承恩","小说",15);
this.books[2] = new Book("红楼梦","曹雪芹","小说",15);
this.nowSize = 3;
}
//rivate访问限制需要用get和set方法引用读写
public Book getBooks(int pos) {
return books[pos];
}
public void setBooks(Book book,int pos) {
this.books[pos] = book;
}
public int getNowSize() {
return nowSize;
}
public void setNowSize(int nowSize) {
this.nowSize = nowSize;
}
}
2.user包
我们发现系统面对的两个用户，管理员和普通用户实现的功能都差不多，都是进入以后实名制以后打印对应的菜单，所以我们可以使用一个抽象类的父类来实现两个子类的功能
-User类
我们来构造一个父类，首先是子类共有的东西姓名，然后实现各自的菜单，我们可以将其写为抽象方法，子类通过重写来实现各自的菜单，因为有了抽象方法，所以该User类也是抽象类。
同时为了实现管理员与普通用户在操作上的独立性，我们可以构造一个功能数组ioPerations方法用来分别存各自的功能，再构建一个方法来实现数组对应的功能的实现
package user;
import book.BookLise;
import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import operation.IOperation;
/*
User类为一个抽象父类
*/
public abstract class User {
//共有属性：name用户名字
protected String name;
//ioPerations为功能数组
public IOperation[] ioPerations;
//构造方法
public User(String name) {
this.name = name;
}
/*
抽象方法menu：用于实现各自菜单的打印
需要重写
参数：无
返回值：用户需要实现的功能根据菜单上的数字进行的返回
*/
public abstract int menu();
/*
toOperation方法:为了实现各自操作操作各自的功能，实现相互独立
通过输入用户菜单的选项的数字
进而操作功能数组通过下标来确定要实现的操作的方法work
参数：用户菜单的选项的数字，以及操作的对象
返回值：无
*/
public void toOperation(int choice, BookLise bookLise){
ioPerations[choice].work(bookLise);
}
}
-AdminUser类
我们构造一个AdminUser类，来实现管理员的功能，首先继承User父类的功能在对抽象方法菜单进行重写。并且创建一个功能数组并且初始化自己的功能。
package user;
import operation.*;
import java.util.Scanner;
/*
AdminUser继承了父类User
主要实现管理员相关功能
*/
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 operation.*;
import java.util.Scanner;
/*
NormalUser继承了父类User
主要实现普通用户相关功能
*/
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.BookLise;
/*
IOperation为接口
用于实现功能标准化
*/
public interface IOperation {
/*
work方法：用于实现各自的功能
需要重写
参数：操作对象书架
返回值：无
*/
public void work(BookLise bookLise);
}
-AddOperation类
这个类实现增加图书的功能，使用IOperation这个接口，重写里面标准方法。
用户输入要添加书的信息，阅历书架，没有这本书就可以放入，有就提示已经存在这本书不能放并且退出，放入书架总数也加一。
package operation;
import book.Book;
import book.BookLise;
import java.util.Scanner;
/*
AddOperation类：用于实现图书的增添
通过输入添加书籍来遍历书架寻找
该书书架没有且不重复则添加成功
该书书架已经存在，则添加失败
*/
public class AddOperation implements IOperation {
//重写接口标准方法 work
@Override
public void work(BookLise bookLise) {
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();
//遍历书架来判断是否有相同书
for (int i = 0; i < bookLise.getNowSize(); i++) {
if (name.equals(bookLise.getBooks(i).getName())) {
//有相同的书，直接退出
System.out.println("不能添加重复的书籍" + "《"+ name + "》");
return;
}
}
//没有相同的书执行添加书操作，默认为最后一个
bookLise.setBooks(new Book(name,author,type,price),bookLise.getNowSize());
成功增添目标书，并且书架书总数加一
bookLise.setNowSize(bookLise.getNowSize()+1);
System.out.println("《"+ name + "》" + "增加成功");
}
}
-DelOperation类
这个类实现删减图书的功能，使用IOperation这个接口，重写里面标准方法。
输入想要删除的书名，若书架中有则删除后面书往前移，若没有则退出。书架总数也减一。
package operation;
import book.BookLise;
import java.util.Scanner;
/*
DelOperation类：用于实现图书的删减
通过输入删减书籍来遍历书架寻找
该书书架有则删减成功
该书书架没有，则删减失败
*/
public class DelOperation implements IOperation {
//重写接口标准方法 work
@Override
public void work(BookLise bookLise) {
System.out.println("删减图书");
//输入删减书的名字
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你增加查找的图书名字");
String name = scanner.nextLine();
//遍历书架判断是否有需要删除的书
for (int i = 0; i < bookLise.getNowSize(); i++) {
if (name.equals(bookLise.getBooks(i).getName())) {
//有需要删除的书，进行删除并且后面书往前移
int index = i;
for (int j = index;j < bookLise.getNowSize() - 1; j++) {
//自需要删除的书位置后后面书往前整体移一个位置
bookLise.setBooks(bookLise.getBooks(j+1),j);
}
//成功删掉目标书，并且书架书总数减一，并且直接退出
bookLise.setNowSize(bookLise.getNowSize() - 1);
System.out.println("《"+ name + "》" + "删除成功");
return;
}
}
System.out.println("《"+ name + "》" + "没有要删的这本书");
}
}
-FindOperation类
这个类实现查找图书的功能，使用IOperation这个接口，重写里面标准方法。
用户输入想要查找的书以后，阅历书架来寻找。
package operation;
import book.Book;
import book.BookLise;
import java.util.Scanner;
/*
FindOperation类：用于实现图书的查找
通过输入查找书籍来遍历书架寻找
该书书架有，打印出该书的信息
该书书架不存在，则未找到
*/
public class FindOperation implements IOperation {
//重写接口标准方法 work
@Override
public void work(BookLise bookLise) {
System.out.println("查找图书");
//输入查找书的名字
System.out.println("请输入你需要查找的图书名字");
Scanner scanner = new Scanner(System.in);
String name = scanner.nextLine();
//遍历书架寻找
for (int i = 0; i < bookLise.getNowSize(); i++) {
if(name.equals(bookLise.getBooks(i).getName())){
//找到了打印出书的信息并且退出
System.out.println("找到了"+ "《"+ name + "》");
System.out.println(bookLise.getBooks(i));
return;
}
}
//遍历书架未找到该书
System.out.println("未找到"+ "《"+ name + "》");
}
}
-ShowOperation类
这个类实现显示图书的功能，使用IOperation这个接口，重写里面标准方法。
然后通过遍历数组的方式，遍历books数组来实现显示图书的功能
package operation;
import book.BookLise;
/*
ShowOperation类：用于实现图书的显示
通过遍历书架来显示各种信息
*/
public class ShowOperation implements IOperation {
//重写接口标准方法 work
@Override
public void work(BookLise bookLise) {
System.out.println("显示图书");
//遍历书架了显示
for (int i = 0; i < bookLise.getNowSize(); i++) {
System.out.println(bookLise.getBooks(i));
}
}
}
-BorrowedOperation类
这个类实现借阅图书的功能，使用IOperation这个接口，重写里面标准方法。
输入想要借阅的书名字以后，遍历书架，成功找到目标书以后并且没有被借出，将借阅状态置为true
package operation;
import book.BookLise;
import java.util.Scanner;
/*
BorrowedOperation类：用于实现图书的借阅
通过输入借阅书籍来遍历书架寻找
该书书架有且未被借阅，则借阅成功
该书书架没有，则借阅失败
*/
public class BorrowedOperation implements IOperation {
//重写接口标准方法 work
@Override
public void work(BookLise bookLise) {
System.out.println("借阅图书");
//输入借阅的书的名字
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你要借的书的名字");
String name = scanner.nextLine();
//遍历书架来判断是否有相同书
for (int i = 0; i < bookLise.getNowSize(); i++) {
if(name.equals(bookLise.getBooks(i).getName())){
//相同名字进入
if(bookLise.getBooks(i).getisIfBorrowed() == false) {
//未被借阅，则成功借阅，直接退出，并且借阅状态为true
bookLise.getBooks(i).setIfBorrowed(true);
System.out.println("成功借阅" + "《"+ name + "》");
return;
}else{
//存在该书但是被借出
System.out.println("《"+ name + "》" + "该书已被借阅");
}
}
}
//该书遍历书架没有找到
System.out.println("未找到"+ "《"+ name + "》");
}
}
-RetuenOperation类
这个类实现归还图书的功能，使用IOperation这个接口，重写里面标准方法。
输入想要归还的书名字以后，遍历书架，成功找到目标书以后，将借阅状态置为false。
package operation;
import book.BookLise;
import java.util.Scanner;
/*
RetuenOperation类：用于实现图书的归还
通过输入归还书籍来遍历书架寻找
该书书架有且被借出则归还成功
该书书架不存在或未被借出，则归还失败
*/
public class RetuenOperation implements IOperation {
//重写接口标准方法 work
@Override
public void work(BookLise bookLise) {
System.out.println("归还图书");
//输入归还书的名字
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你要还的书的名字");
String name = scanner.nextLine();
//遍历书架来判断是否有相同书
for (int i = 0; i < bookLise.getNowSize(); i++) {
//书架中有相同的书
if(name.equals(bookLise.getBooks(i).getName())){
//书架存在的书被借出
if(bookLise.getBooks(i).getisIfBorrowed() == true) {
//成功归还，并且将书的状态置为flase，直接退出
bookLise.getBooks(i).setIfBorrowed(false);
System.out.println("成功归还"+ "《"+ name + "》");
return;
}else{
//该书存在但未被借出
System.out.println("《"+ name + "》" + "该书为被借出");
}
}
}
//遍历书架未找到该书
System.out.println("未找到"+ "《"+ name + "》");
}
}
-ExitOperation类
这个类实现退出系统的功能，使用IOperation这个接口，重写里面标准方法。
使用exit退出，并且对书架的书和总数进行清零。
package operation;
import book.BookLise;
/*
ExitOperation类：用于实现图书系统的关闭
使用exit退出，并且对书架的书和总数进行清零
*/
public class ExitOperation implements IOperation {
//重写接口标准方法 work
@Override
public void work(BookLise bookLise) {
System.out.println("退出系统");
//遍历书架清空书置为null
for (int i = 0; i < bookLise.getNowSize(); i++) {
bookLise.setBooks(null,i);
}
//书架的书总数也为0
bookLise.setNowSize(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 book.Book;
import book.BookLise;
import user.AdminUser;
import user.NormalUser;
import user.User;
import java.util.Scanner;
public class Main {
/*
login方法：输入姓名用于后面实例化的姓名
输入1或0 来判断用户为普通用户还是管理员
根据对应的输入创建实例化对象
参数：无
返回：返回一个实例化对象
*/
public static User login() {
//输入姓名
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的姓名");
//输入身份
String name = scanner.nextLine();
System.out.println("请输入你的身份 1-》管理员，0-》普通用户");
//判断操作对象并返回对应实例化对象
if(scanner.nextInt() == 1){
//返回实例化对象管理员
return new AdminUser(name);
}else{
//返回实例化对象普通用户
return new NormalUser(name);
}
}
public static void main(String[] args){
//实例化书架上的书，初始化为3本书
BookLise bookLise = new BookLise();
//根据login的返回值确定操作对象为用户或者管理员
User user = login();
//进入菜单死循环，直到输入用户0退出系统
while(true){
//choice用于接受menu菜单的返回值即用户想要实现的操作
int choice = user.menu();
//根据接受的值来对书架上的书进行操作
user.toOperation(choice,bookLise);
}
}
}
希望对你有帮助
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
