【Java实现图书管理系统】

图书管理系统

1. 设计背景
2. 设计思路
3. 模块展示+代码演示
- 3.1 Book类
- 3.2 BookList类（书架类）
- 3.4 用户类 - User类
- 3.5 子类管理员类 -- AdminUser类
- 3.6 子类普通用户类 -- NormalUser类
- 3.7 操作接口
- 3.8 操作类
- - 3.8.1 查找操作 -- FindOperation类
  - 3.8.2 增加操作 -- AddOperation类
  - 3.8.3 删除操作 -- DelOperation类
  - 3.8.4 显示操作 -- ShowOperation类
  - 3.8.5 退出系统 -- ExitOperation类
  - 3.8.6 借阅操作 -- BorrowOperation类
  - 3.8.7 归还操作 -- ReturnOperation类
- 3.9 Main类
4. 效果展示

1. 设计背景

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

2. 设计思路

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

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

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

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

}

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

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

3.7 操作接口

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

package operation;

import book.Book;
import book.BookList;

public interface IOperation {
    void work(BookList bookList);

}

3.8 操作类

3.8.1 查找操作 – FindOperation类

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

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

代码展示：

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

3.8.2 增加操作 – AddOperation类

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

输入新增书籍信息
实例化这本书
得到书架大小然后再去遍历这个书架，如果有本书，返回已经存放
没有就新增，在bookList书架调用设置书的内容和位置
再把书架大小+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
    }
}

3.8.3 删除操作 – DelOperation类

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

输入想要删除书名
定义一个index，当删的书在书架上，记录要删除的书的下标
得到书架大小然后再去遍历这个书架，书在书架上，把 i（即书的位置）赋给index。
如果书架上没有该书，返回没找到要删除的书
有进行删除操作，从index开始遍历到当前书架大小-1，调用getBook拿到j+1，再调用setbook放在 j 上，即把后一个的书的数据覆盖前一个的书的数据
回收内存，调用书架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("删除成功");
    }
}

3.8.4 显示操作 – ShowOperation类

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

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

代码展示：

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

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

3.8.6 借阅操作 – BorrowOperation类

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

得到书架大小然后再去遍历这个书架
如果有，调用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);
    }
}

3.8.7 归还操作 – ReturnOperation类

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

得到书架大小然后再去遍历这个书架
如果有，调用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);
    }
}

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

    }
}