• 【Java实现图书管理系统】

    图书管理系统

    1. 设计背景

    使用Java语言中多态、继承、封装、接口等知识点综合来设计与实现图书管理系统。

    2. 设计思路

    1. 首先登录系统可区分出管理员和普通用户，不同的用户所展示的界面不同，创建一个父类用户，然后使用多态和继承来实现管理员和普通用户。
    2. 设计一个接口（定义一种规范），图书查询，借阅，归还等操作封装起来并引用这个接口。
    3. 把书的属性进行封装，同时设计一个书架类用来存放书的一个数组。
    4. 实现管理员功能（查找、新增、删除、显示、退出系统）。
    5. 实现普通用户功能（查找、借阅、归还）。

    3. 模块展示+代码演示

    3.1 Book类

    利用封装将书籍的属性：书名、作者、价格、是否被借出设为private权限；提供对应的 get 方法、set 方法、 空参构造器、和一个boolean类型的是否被借出的构造器（在这里可以不进行初始化，默认为false），再提供一个toString() 方法的重写来输出书籍这个数组。
    代码展示：

    package book;

public class Book {
    private String name;//书名
    private String author;//作者
    private int price;//价格
    private String type;//书的类型
    private boolean isBorrowed;//是否被借出  默认值是false

    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 == true) ? " ,已借阅" : " , 未借出")+
                //", isBorrowed=" + isBorrowed +
                '}';
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68

    3.2 BookList类（书架类）

    在BookList类提供一个Book类型的books数组来存储书籍，同时在空参构造器中进行初始化添加3本书，再提供对应的 get 方法和 set 方法。
    代码展示：

    package book;

public class BookList {
    private Book[] books;
    private int usedSize; //记录当前书架放了几本书

    public BookList() {
        this.books = new Book[10];
        this.books[0] = new Book("三国演义","罗贯中",10,"小说");
        this.books[1] = new Book("西游记","吴承恩",9,"小说");
        this.books[2] = new Book("红楼梦","曹雪芹",8,"小说");
        this.usedSize = 3;

    }

    public int getUsedSize() {
        // 获取数组大小
        return usedSize;
    }

    public void setUsedSize(int usedSize) {
        // 设置数组大小
        this.usedSize = usedSize;
    }

    public Book getBook(int pos) {
        // 获取数组某个位置上的书籍
        return books[pos];
    }

    public void setbook(Book book,int pos) {
        //设置数组某个位置的书籍
        books[pos] = book;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    3.4 用户类 - User类

    在用户类中定义用户的名字，定义一个抽象方法menu() 来给子类管理员类和普通用户类重写，再设计一个接口类型的数组iOperations，存放后面的图书操作功能。
    代码展示：

    package user;

import book.BookList;
import operation.IOperation;

public abstract class User {
    protected String name;

    // 数组没有初始化，因为没有给他分配内存
    protected IOperation[] iOperations;

    public User(String name) {
        this.name = name;
    }
    public abstract int menu();
    public void doOperation(int choice, BookList bookList) {
        //this.iOperations[choice].work(bookList);
        IOperation iOperation = this.iOperations[choice];
        iOperation.work(bookList);
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    3.5 子类管理员类 – AdminUser类

    继承User类，用构造方法 一定会对IOperation数组进行初始化，实现menu() 方法。
    代码展示：

    package user;

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

public class AdminUser extends User{
    // 会调用构造方法 一定会对IOperation数组进行初始化
    public AdminUser(String name) {
        super(name);
        this.iOperations = new IOperation[] {
                new ExitOperation(),
                new FindOperation(),
                new AddOperation(),
                new DelOperation(),
                new ShowOperation()
        };
    }

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    3.6 子类普通用户类 – NormalUser类

    继承User类，用构造方法 一定会对IOperation数组进行初始化，实现menu() 方法。
    代码展示：

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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    3.7 操作接口

    实现图书查找、新增等操作都需要遵循一定的规范，而这个规范由接口来实现，设计一个work() 方法，并提供对应的work() 方法供接口的实现类，即对各种操作进行重写。
    代码展示：

    package operation;

import book.Book;
import book.BookList;

public interface IOperation {
    void work(BookList bookList);

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    3.8 操作类

    3.8.1 查找操作 – FindOperation类

    引用接口，重写work() 方法，用到 .equals()方法。
    思路：

    1. 得到书架大小然后再去遍历这个书架
    2. 如果输入的书名与书架上的书名相等,查找成功，并输出书籍信息
    3. 没有返回没找到

    代码展示：

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

        int currentSize = bookList.getUsedSize();
        //Book book = bookList[i];
        // bookList不是数组 是类 有一个Book数组是private拿不到
        // 提供一个方法拿到books数组的i下标
        for (int i = 0; i < currentSize; i++) {
            Book book = bookList.getBook(i);
            if (book.getName().equals(name)) {
                System.out.println("存在这本书，信息如下：");
                System.out.println(book);
                return;
            }
        }
        System.out.println("没有你要找的这本书："+name);
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    3.8.2 增加操作 – AddOperation类

    将操作类实现操作接口，同时为重写的方法提供书架类，便于操作。
    思路：

    1. 输入新增书籍信息
    2. 实例化这本书
    3. 得到书架大小然后再去遍历这个书架，如果有本书，返回已经存放
    4. 没有就新增，在bookList书架调用设置书的内容和位置
    5. 再把书架大小+1.
      代码展示：
    package operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class AddOperation implements IOperation{
    public void work(BookList bookList) {
        System.out.println("新增图书");
        System.out.println("请输入你要新增的图书的书名：");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();

        System.out.println("请输入你要新增的图书的作者：");
        String author = scanner.nextLine();

        System.out.println("请输入你要新增的图书的价格：");
        int price = scanner.nextInt();

        System.out.println("请输入你要新增的图书的类型：");
        //scanner.nextLine();  // 多读一次
        //String type = scanner.nextLine();  会把输入价格后的回车给吞进去 就不能输入type
        String type = scanner.next();

        Book book = new Book(name,author,price,type);
        int currentSize = bookList.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book tmp = bookList.getBook(i);
            if (tmp.getName().equals(name)) {
                System.out.println("已经存放了这本书，不能重复添加");
                return;
            }
        }
        //没有重复的书  开始新增
        bookList.setbook(book,currentSize);//调用setbook方法存放书籍和位置
        bookList.setUsedSize(currentSize+1);//书架大小+1
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    3.8.3 删除操作 – DelOperation类

    与增加同理，引用IOperation接口，重写work()方法。删除就是移动后面的数据进行覆盖，最后size–。
    思路：

    1. 输入想要删除书名
    2. 定义一个index，当删的书在书架上，记录要删除的书的下标
    3. 得到书架大小然后再去遍历这个书架，书在书架上，把 i（即书的位置）赋给index。
    4. 如果书架上没有该书，返回没找到要删除的书
    5. 有 进行删除操作，从index开始遍历到当前书架大小-1，调用getBook拿到j+1，再调用setbook放在 j 上，即把后一个的书的数据覆盖前一个的书的数据
    6. 回收内存，调用书架setbook() 方法把currentSize-1 设为null，书架大小-1
    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 currentSize = bookList.getUsedSize();
        int i = 0;
        int index = -1;
        for (; i < currentSize; i++) {
            Book tmp = bookList.getBook(i);
            if (tmp.getName().equals(name)) {
                index = i;
                break; //记录下来了要删除图书的下标
            }
        }
        if (i >= currentSize) {
            System.out.println("没找到你要删除的书名："+name);
            return;
        }
        // 可以删除了  移动后面的数据进行覆盖  最后size--
        for (int j = index; j < currentSize-1; j++) {
            //bookList[j] = bookList[j+1]  报错  bookList不是数组是一个类
            //调用bookList类里getBook拿到后面一本书j+1，再调用setBook
            // 把后一本书放进前一本书里面j
            Book book = bookList.getBook(j+1);
            bookList.setbook(book,j);
        }
        //因为删除一本书把后面的数据往前覆盖，最后一个内存要回收
        bookList.setbook(null,currentSize-1);
        bookList.setUsedSize(currentSize-1);
        System.out.println("删除成功");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

    3.8.4 显示操作 – ShowOperation类

    引用IOperation接口，重写work()方法。
    思路：

    1. 得到书架大小然后再去遍历这个书架
    2. 循环输出书架数组的信息

    代码展示：

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    3.8.5 退出系统 – ExitOperation类

    引用接口，重写work方法。
    在Java中,System.exit(0);输入0即可退出。

    package operation;

import book.BookList;

public class ExitOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("退出系统");
        //应该要对bookList 资源回收
        System.exit(0);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    3.8.6 借阅操作 – BorrowOperation类

    引用接口，重写work方法。
    思路：

    1. 得到书架大小然后再去遍历这个书架
    2. 如果有，调用book类的setBorrowed方法设为true，更改成为已借出的标识

    代码展示：

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

        int currentSize = bookList.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book book = bookList.getBook(i);
            if (book.getName().equals(name)) {
                System.out.println("借阅成功");
                book.setBorrowed(true);
                return;
            }
        }
        System.out.println("没有你要借阅的图书"+name);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    3.8.7 归还操作 – ReturnOperation类

    引用接口，重写work方法。
    思路：

    1. 得到书架大小然后再去遍历这个书架
    2. 如果有，调用book类的setBorrowed方法设为false，更改成为未借出的标识

    代码展示：

    package operation;

import book.Book;
import book.BookList;
import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils;

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 currentSize = bookList.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book book = bookList.getBook(i);
            if (book.getName().equals(name)) {
                System.out.println("归还成功");
                book.setBorrowed(false);
                return;
            }
        }
        System.out.println("没有你要归还的图书"+name);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    3.9 Main类

    以上所有的框架都搭建好了，点击main方法测试：

    import book.BookList;
import operation.IOperation;
import user.AdminUser;
import user.NormalUser;
import user.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();
        //发生多态绑定 引用的对象不一样  调用menu()所表现的行为不一样
        // user = new AdminUser(name)
        // user = new NormalUser(name);
        User user = login();
        while (true) {
            // 父类引用子类对象，调用menu()，要父类有menu()，子类重写方法
            int choice = user.menu();
            //根据你菜单返回的choice来执行对应的操作
            user.doOperation(choice,bookList);
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    4. 效果展示

    在这里插入图片描述
    在这里插入图片描述

    源码链接: 源码，点击跳转https://gitee.com/xiao-jiahao6/java/tree/master/TestBook/src

  • 相关阅读:
    React-Props进阶
    中石化、中石油接口文档源码分享
    Docker-06：仓库
    Js与Jq实战：第三讲：JavaScript对象编程
    python+selenium进行cnblog的自动化登录测试
    六级高频词汇
    【牛客 - 剑指offer】JZ11 旋转数组的最小数字 Java实现
    audit交叉编译
    如何正确复制CSDN文章到自己的博客
    React报错之Encountered two children with the same key
  • 原文地址：https://blog.csdn.net/m0_63440113/article/details/134444344