java实现简单图书管理系统（附带源码）

诗航在改bug

3370人浏览 · 2024-04-15 16:12:02

诗航在改bug · 2024-04-15 16:12:02 发布

项目要求

该项目会用到类和对象，封装、继承、多态、接口、等，会帮你巩固并加强这类知识

设计要求及思路

1.要求有两套系统分别给管理员和普通用户使用，经过开始的选择会有两个对应功能不同的菜单，这里两种角色我们可以放一个包里并且用到继承和多态，可以去很多冗余

2. 功能项目，对应有七个不同的功能，我们需要用到接口

3. 定义一个书本类使用封装，并用书架来接受书本数组

4. 包的创建，每个方法放在对应的包下面

项目实现

book包

Book类

书类就是存放一些书的属性：书名，作者，价格，类型，是否被借出，以上用封装包装好，并用get and set方法提供接口并需要，对参数进行重写，提供一个to string（）方法的重写，用于后续对书本的打印，大部分都可以通过编译器快速生成。

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
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", type='" + type + '\'' +
                ", isBorrowed=" + (isBorrowed==false?"未借出":"借出") +
                '}';
    }
}

BookList类

书架类创建的作用就是用来存放一个书本类的数组，并定义一个变量记录书本的个数，这里的也是用到封装，参数都用private修饰，所以需要定义get and set方法，但是这里对数组的方法需要注意一下，直接生成的完成不了我们想要的功能，需要修改一下

public class BookList {
    private Book[] books;
    private int BookSize;

    public BookList(){//构造里面初始化数据一定要加上this
        this.books=new Book[10];
        this.books[0]=new Book("sgyy","lgz",10,"xiaoshuo");
        this.books[1]=new Book("hlm","cxq",10,"xiaoshuo");
        this.books[2]=new Book("xyj","wce",10,"xiaoshuo");
        this.BookSize=3;
    }

    public Book getBooks(int pos) {
        return books[pos];//通过调用BookLis.getBook(i),传入pos参数，可以获得pos1····位置对应的书
    }

    public void setBooks(Book book,int pos) {
        books[pos]=book;//将传入的Book覆盖到pos位置
    }

    public int getBookSize() {
        return BookSize;
    }

    public void setBookSize(int bookSize) {
        BookSize = bookSize;
    }
}

user包

user父类

这里因为需要有两个不同的菜单，所以我们定义一个user类，让AdminUser和NormalUser分别继承这个类，且都需要不同的菜单，所以在user定义一个抽象菜单，所以user也就需要为抽象类

package user;
import book.BookList;
import operation.IOperation;

public abstract class User {
    protected String name;

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

    protected IOperation[] iOperations;//创建操作数组

    public void doIoperation(int choice,BookList bookList){
        this.iOperations[choice].work(bookList);//会通过传递的choice参数调用不同的方法
    }

    public abstract int menu();
}

AdminUser类 & NormalUser类

两个类分别构造自己的功能数组重写自己的菜单，并且需要返回一个选择

//管理员类
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 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;
    }
}

//普通用户类
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(),
                new ShowOperation(),
        };
    }

    @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 scanner=new Scanner(System.in);
        int choice=scanner.nextInt();
        return choice;
    }
}

这里因为两种用户需要调用的方法不一样，菜单也不一样，所以我们在父类定义一个功能数组，并在子类调用时对其实例化，其中doOperation方法就是功能菜单和功能数组之间的桥梁，通过菜单返回的不同的值调用不同的功能方法，也就是实现功能数组的choice下标对应的方法

Main类

import book.BookList;
import 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=login();
        while (true){
            int choice=user.menu();
            user.doIoperation(choice,bookList);
        }
    }
}

这里主函数内容就是新建一个书架，并通过login（）选择出用户是管理员还是普通用户，再对其用户死循环获取菜单返回值，并执行该返回值对应的功能方法

operation包

IOperation类

该类是接口，其中主要是为了被operation包其他类其他继承后重写work方法，其中传递BookList就是为了功能方法的实施对象是新建的booklist

package operation;
import book.BookList;

public interface IOperation {
    public void work(BookList bookList);
}

ExitOperation类

该类就是两个菜单都有的退出方法，也是最简单的

package operation;
import book.BookList;

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

ShowOperation类

展示所有图书的功能，获取当前书本的个数 int size=bookList.getBookSize();通过booklist获取书书本的个数并用size来接受，for循环打印

package operation;
import book.Book;
import book.BookList;

public class ShowOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("展示所有图书");

        int size=bookList.getBookSize();
        for (int i = 0; i < size; i++) {
            Book book=bookList.getBooks(i);
            System.out.println(book);
        }
    }
}

FindOperation类

这里的if(book.getName().equals(name))比较费解一点，就是将当前输入的a书名和i位置的书名用equals（）方法比较，equals（）结果就是true或者false

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 size=bookList.getBookSize();
        for (int i = 0; i < size; i++) {
            Book book=bookList.getBooks(i);
            if(book.getName().equals(name)){
                System.out.println("已查找到该书");
                System.out.println(book);
                return;
            }
        }
        System.out.println("抱歉暂无此书");
    }
}

AddOperation类

添加函数，这里需要注意2点

就是添加的书本是否已经在书架上，如果在就不需要添加了，如果不在就可以继续添加
在用完scanner.nextInt();需要用到scanner.nextLine();//吞回车，不然会出现报错

package operation;
import book.*;
import java.util.Scanner;

public class AddOperation 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 size=bookList.getBookSize();
        for (int i = 0; i < size; i++) {
            Book book=bookList.getBooks(i);
            if(book.getName().equals(name)){
                System.out.println("已有该图书无需再添加");
                return;
            }
        }
        System.out.println("请输入作者");
        String author=scanner.nextLine();
        System.out.println("请输入价格");
        int price=scanner.nextInt();

        scanner.nextLine();//吞回车
        System.out.println("请输入书类型");
        String type=scanner.nextLine();
        Book book=new Book(name,author,price,type);
        bookList.setBooks(book,size);
        bookList.setBookSize(size+1);

    }
}

DelOperation类

删除方法，这里需要注意几点

当前书架是否有需要删除的a书，如果本来就没有a书就不需要删除，这里用到index的值来检查是否有a书
删除方法选择的是从后向前覆盖
最后覆盖完会有一个本书出现两次，就将最后的位置置空

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

        int index=-1;//索引
        int size=bookList.getBookSize();
        for (int i = 0; i < size; i++) {
            Book book=bookList.getBooks(i);
            if(book.getName().equals(name)){
                index=i;
            }
        }

        if(index==-1){
            System.out.println("未找到该书");
            return;
        }

        for (int j = index; j < size-1; j++) {
            Book book=bookList.getBooks(j+1);
            bookList.setBooks(book,j);
        }
        bookList.setBookSize(size-1);
        System.out.println("删除成功");
    }
}

BorrowOperation类

借阅方法，需要注意两点

book.isBorrowed()，获取到的是true或者false，如果是借阅，需要a书是false状态
book.setBorrowed(true);//改为借出

package operation;
import book.*;
import java.util.Scanner;

public class BorrowOperation 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 size=bookList.getBookSize();
        for (int i = 0; i < size; i++) {
            Book book=bookList.getBooks(i);
            if(book.getName().equals(name)){
                if(!book.isBorrowed()) {//未借出的是false
                    book.setBorrowed(true);//改为借出
                    System.out.println("借阅成功");
                    return ;
                }
            }
        }
        System.out.println("抱歉暂无此书");
    }
}

ReturnOperation类

这里就和借阅方法没什么区别了

package operation;
import book.*;
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 name=scanner.nextLine();

        int size=bookList.getBookSize();
        for (int i = 0; i < size; i++) {
            Book book=bookList.getBooks(i);
            if(book.getName().equals(name)){
                if(book.isBorrowed()) {//借出的是true
                    book.setBorrowed(false);//改为借出
                    System.out.println("还书成功");
                    return ;
                }
            }
        }
        System.out.println("抱歉此书不在还书范围中");
    }
}

好了以上就是图书管理系统的全部内容了，希望可以多多点赞评论收藏支持一下

java代码: 欢迎您，哈哈哈哈哈哈哈哈https://gitee.com/poetics-c/java-code-.git这里是我的码云图书管理系统代码在20240413文件下，感谢大家点赞收藏支持

天工造物局

北京人形旗下天工造物具身智能开源社区，聚焦具身天工与慧思开物两大平台

更多推荐

LMCache CLI 实战：用 `lmcache kvcache clear` 管理运行中服务的 KV Cache 状态

本文是一份针对 LMCache 官方 CLI 命令 `lmcache kvcache` 的完整技术指南。该命令用于在**运行中的 LMCache 服务（MP HTTP server）**上管理 KV cache 状态，当前提供 `clear` 子命令，用于清空 L1（CPU 内存）层中缓存的全部 KV 数据。读完本文，你将掌握该命令的完整参数体系、退出码语义、终端/JSON/静默三种输出模式，并能

天工造物局

Plate 编辑器降级契约（Degradation Contract）：为虚拟化与 Shell 模式划定原生行为底线

本文围绕 Plate 仓库 `.agents/skills/performance/rules/degradation-contract.md` 中的核心规则展开，说明在编辑器引入虚拟化渲染、Shell 岛屿（shell islands）、模型驱动选择（model-backed selection）或分阶段挂载（staged mounting）等激进性能手段时，如何为每一种降级模式登记完整的行为契

天工造物局

Dozzle 在 Kubernetes 中的部署与配置：实时查看 Pod 日志的完整指南

Dozzle 是一个面向容器的实时日志查看器，原生支持 Docker、Swarm 与 Kubernetes 三种运行环境。本文围绕官方 Kubernetes 支持文档展开，讲解如何通过 `DOZZLE_MODE=k8s` 在集群内以最小权限 RBAC 部署 Dozzle、如何安装并依赖 Kubernetes Metrics API 展示资源用量，以及如何用 `DOZZLE_NAMESPACE` 与