【Java】图书管理系统的完整实现过程

椰椰椰耶

发布于 2024-10-15 15:26:36

5120

文章被收录于专栏：学习学习

框架

Main 类

login()方法——登录

返回类型为 User

创建变量 name 来接收输入的姓名
创建变量 choice 来接收身份数字（1：管理员 2：普通用户）
- 对接收的数字进行判断
  - 若 choice == 1 ，实例化一个 AdminUser 的对象 adminUser ，名字为上面接收姓名的 name
  - 若 choice == 2 ，实例化一个 NormalUser 的对象 normalUser ，名字为上面接收姓名的 name

程序入口，main函数

实例化一个书架 BookList 的对象 bookList
实例化一个 User 的对象 user ，调用 login() 方法
创建一个 choice 变量，来接收调用 menu() 方法的返回值
用户 user 调用 doIoperation 方法，进行图书管理操作

代码

import book.BookList;
import user.AdminUser;
import user.NormalUser;
import user.User;

import java.util.Scanner;

public class Main {

    public static User login(){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的姓名：");
        String username = sc.nextLine();

        System.out.println("请输入你的身份：1.管理员   2.普通用户");
        int choice = sc.nextInt();

        if(choice == 1){
            AdminUser adminUser = new AdminUser(username);
            return adminUser;
        }else if(choice == 2){
            NormalUser normalUser = new NormalUser(username);
           return normalUser;
        }else{
            System.out.println("输入错误");
            return null;
        }
    }

    public static void main(String[] args) {
        BookList bookList = new BookList();
        User user = login();

        while(user != null){
            int choice = user.menu();

            user.doIoperation(choice,bookList);
        }
    }
}

book 包

Book类——图书信息

添加图书类初始化成员变量
- name、author、price、type和isLend
重写 toString 方法

代码

package book;

public class Book {
    private String name;
    private String author;
    private int price;
    private String type;
    private boolean isLend;

    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 isLend() {
        return isLend;
    }

    public void setLend(boolean lend) {
        isLend = lend;
    }

    public Book(String name, String author, int price, String type) {
        this.name = name;
        this.author = author;
        this.price = price;
        this.type = type;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", type='" + type + '\'' +
                ", isLend=" + isLend +
                '}';
    }
}

BookList类——书架搭建

创建一个数组 Book[ ] ，并初始化为 books[10]
- 在构造方法中初始化图书的信息（用数组下标访问赋值）
创建一个 usedSize 成员变量
- 记录当前书架中存放了几本书
后续满足接口功能所需要实现的方法
1. 创建一个 getBook() 方法，参数为 int pos ，返回一个 Book 类型的对象
  - 返回值为 book[pos]
    - 方便之后在 查询书籍 中能通过下标访问到每一本书
2. 创建一个 isFull() 方法，无参，返回类型为 boolean
  - 若 usedSize==book.length ，则返回 true
  - 否则返回 false
3. 创建一个 setBooks() 方法，参数为 int pos 和一个 Book类型的对象
  - 将 book 书本信息插入书架中 books[pos]

代码

package book;

public class BookList {
    private Book[] books = new Book[10];
    private int usedSize;

    public BookList() {
        books[0] = new Book("命运","蔡崇达",60,"社会小说");
        books[1] = new Book("绝叫","叶真中显",30,"悬疑推理");
        books[2] = new Book("教父","马里奥·普佐",60,"外国文学");
        this.usedSize = 3;
    }

    public int getUsedSize() {
        return usedSize;
    }

    public void setUsedSize(int usedSize) {
        this.usedSize = usedSize;
    }

    public boolean isFull(){
        if(usedSize == books.length)
            return true;
        else
            return false;
    }

    public void addBook(int pos,Book book){
        books[pos] = book;
    }

    public Book getBook(int pos){
        return books[pos];
    }

    public void setBooks(int pos, Book book){
        books[pos] = book;
    }
}

user包——用户管理

User类——父类

一个用户姓名 name 成员变量
一个抽象的 menu() 方法
- 不需要实现，具体功能让子类实现
定义一个 IOPeration[ ] 数组，叫 ioPeration ，用来区分管理员和普通用户的操作
创建一个 doIoperation() 方法
- 用来完成书架的选择和主要功能的调用

代码（user.User）

package user;

import book.BookList;
import operation.IOPeration;

public abstract class User {
    private String name;
    public IOPeration[] operations;

    public User(String name) {
        this.name = name;
    }

    public abstract int menu();

    public void doIoperation(int choice, BookList bookList){
        this.operations[choice].work(bookList);
    }
}

AdminUser类——管理员

继承于User类

登录过来之后，会继承 ioPeration 数组，接下来对数组进行=初始化
- 将要实现的功能所对应的类都初始化到 ioPeration 数组中，方便后续通过下标进行访问操作
image.png|480
重写菜单 menu() 的实现方法
创建一个 choice 成员变量
- 用来接收用户输入的数字
返回接收的数字

代码（user.User.AdminUser）

package user;

import operation.*;

import java.util.Scanner;

public class AdminUser extends User{

    public AdminUser(String name) {
        super(name);
        this.operations = new IOPeration[]{
                new ExitOperation(),
                new FindOperation(),
                new AddOperation(),
                new DelOperation(),
                new ShowOperation()
        };
    }

    @Override
    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("*****************");
        System.out.println("请输入你的操作：");

        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;
    }
}

NormalUser类——普通用户

继承与User类

登录过来之后，会继承 ioPeration 数组，接下来对数组进行=初始化
- 将要实现的功能所对应的类都初始化到 ioPeration 数组中，方便后续通过下标进行访问操作
image.png
重写菜单 menu() 的实现方法
创建一个 choice 成员变量
- 用来接收用户输入的数字
返回接收的数字

代码（user.User.NormalUser）

package user;

import operation.*;

import java.util.Scanner;

public class NormalUser extends User{

    public NormalUser(String name) {
        super(name);
        this.operations = new IOPeration[]{
                new ExitOperation(),
                new FindOperation(),
                new BorrowOperation(),
                new ReturnOperation()
        };
    }

    @Override
    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("******************");
        System.out.println("请输入你的操作：");

        Scanner sc = new Scanner(System.in);
        int choice = sc.nextInt();
        return choice;
    }
}

operation包——具体操作的实现

IOPeration接口

方便后续每一个操作实现各自的功能
- 内置一个 work() 抽象方法
- 后续用来实现具体功能的类均要实现这个类，然后重写 work() 这个抽象方法，实现具体功能

代码（operation.IOPeration）

package operation;

import book.BookList;

public interface IOPeration {
    abstract void work(BookList bookList);
}

AddOperation类——新增图书

实现 IOperation接口
重写 work() 方法
1. 判断书架是否装满
  - 调用 isFull() 方法
2. 依次输入新增书籍的所有信息
3. 实例化一个 Book 对象 book 来接受这些信息
4. 创建一个 currentSize 成员变量来接收书本数量
5. 调用 setBooks() 方法，插入书籍信息
6. 调用 setUsedSize() 方法，将书架中的书本数量 +1
7. 增加成功

代码（operation.AddOperation）

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("增加图书");
        if(bookList.isFull()){
            System.out.println("书架满了，不能新增了");
            return;
        }

        System.out.println("你要新增的书的书名为：");
        Scanner sc = new Scanner(System.in);
        String bookName = sc.nextLine();

        System.out.println("作者信息为：");
        String author = sc.nextLine();

        System.out.println("价格信息为：");
        int price = sc.nextInt();

        System.out.println("图书类型为：");
        String type = sc.nextLine();

        Book book = new Book(bookName, author, price, type);

        int number = bookList.getUsedSize();
        bookList.addBook(number,book);
        bookList.setUsedSize(number+1);

        System.out.println("新增图书成功");
    }
}

FindOperation类——查找图书

实现 IOperation 接口
重写 work() 方法
1. 输入要找的书
  - 通过一个 String 类型的 bookName 成员变量来接收
2. 遍历书架，寻找书籍
  1. 先创建一个 currentSize 变量来接收书架中目前书的数量
  2. for 循环遍历书架
  3. 实例化一个 Book 对象 book 用来接收当前通过 getBook() 方法取到的书籍的信息
3. 分别对取到的书名与目标书名进行相等判断
  - 找到，return
  - 找不到

代码（operation.FindOperation）

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 sc = new Scanner(System.in);
        String bookName = sc.nextLine();

        int number = bookList.getUsedSize();
        for (int i = 0; i < number; i++) {
            Book book = bookList.getBook(i);

            if(book.getName().equals(bookName)){
                System.out.println("找到了这本书");
                System.out.println(book);
                return;
            }
        }
        System.out.println("没有找到这本书");
    }
}

DelOperation类——删除图书

实现 IOperation 接口
重写 work() 方法
1. 创建一个 currentSize 变量，来接收 bookList 访问 getUsedSize() 方法所得到的书籍数量
2. 遍历书架
3. 通过 bookList 调用 setBooks() 方法，将第** i ** 位书设置为 null
4. 退出系统
  - System. exit(0);

代码（operation.DelOperation）

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("删除图书");

        System.out.println("输入你想要删除的图书名：");
        Scanner sc = new Scanner(System.in);
        String bookName = sc.nextLine();

        int number = bookList.getUsedSize();
        for (int i = 0; i < number; i++) {
            Book book = bookList.getBook(i);
            if (book.getName().equals(bookName)) {

            }
        }
    }
}

ShowOperation类——展示图书

实现 IOperation 接口
重写 work() 方法
1. 创建一个 currentSize 变量，用来接收通过 bookList 调用 getUsedSize() 方法所得到的书籍数量
2. 实例化一个 Book 类对象 book，用来接收 bookList 通过下标依次调用 getBook() 方法所得到的书籍的信息
3. 打印出每一个 book 的信息

代码（operation.ShowOperation）

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);  
        }    
    }
}

BorrowOperation类——借阅图书

实现 IOperation 接口
重写 work() 方法
1. 创建一个 bookName 成员用来接收要借阅的书籍名字
2. 创建一个 currentSize 变量，用来接收通过* bookList* 调用 getUsedSize() 方法所得到的书籍数量
3. 遍历书架，找到那本书
  - 若找到，将 setLend 设置为 true，借阅成功
  - 若未找到，借阅失败

代码（operation.BorrowOperation）

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("借阅图书");

        System.out.println("需要借阅的书籍名称为：");
        Scanner sc = new Scanner(System.in);
        String bookName = sc.nextLine();

        int number = bookList.getUsedSize();
        for(int i = 0; i < bookList.getUsedSize(); i++){
            Book book = bookList.getBook(i);
            if(book.getName().equals(bookName)) {
                book.setLend(true);
                System.out.println("借阅成功");
                return;
            }
        }
        System.out.println("借阅失败");
    }
}

ReturnOperation类——归还图书

实现 IOperation 接口
重写 work() 方法
1. 创建一个 bookName 成员变量来接收输入的书名
2. 创建一个 currentSize 变量，用来接收通过 bookList 调用 getUsedSize() 方法所得到的书籍数量
3. 遍历书架，寻找那本书
  - 若找到，将 setLend 设置为 false，归还成功
  - 若未找到，归还失败

代码（operation.ReturnOperation）

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("归还图书");

        System.out.println("你要归还的书籍名称是：");
        Scanner scanner = new Scanner(System.in);
        String bookName = scanner.nextLine();

        int number = bookList.getUsedSize();
        for (int i = 0; i < number; i++) {
            Book book = bookList.getBook(i);
            if(book.getName().equals(bookName)) {
                book.setLend(false);
                System.out.println("归还成功");
                return;
            }
        }
        System.out.println("归还失败");
    }
}

ExitOperation类——退出系统

实现 IOperation 接口
重写 work() 方法
1. 创建一个 currentSize 变量，用来接收通过 bookList 调用 getUsedSize() 方法所得到的书籍数量
2. 遍历书架，将每一本书的信息都设为 null
3. 退出系统
  - System.exit(0);

代码（operation.ExitOperation）

package operation;

import book.Book;
import book.BookList;

public class ExitOperation implements IOPeration{
    @Override
    public void work(BookList bookList) {
        System.out.println("退出系统");

        int number = bookList.getUsedSize();
        for (int i = 0; i < number; i++) {
            bookList.setBooks(i,null);
        }
        System.exit(0);
    }
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-07-30，如有侵权请联系 cloudcommunity@tencent.com 删除

对象