【JAVA】用Java实现简易图书管理系统

1. 设计背景和系统功能和设计方法
- 1.1设计背景
- 1.2系统功能
- 1.3设计方法
2. 设计思路
3. 设计模块和代码实现
- 3.1 Book类的实现
- 3.2 BookList类的实现(书架)
- 3.3 User类的实现（用户类）
- - 3.3.1 AdminUser（管理员类）
  - 3.3.2 NormalUser（普通用户类）
- 3.4 Operation类的实现（操作类）
- - 3.4.1 IOperation（操作接口的实现）
  - 3.4.2 AddOperation（增加图书）
  - 3.4.3 FindOperation（查找图书）
  - 3.4.4 DelOperation（删除图书）
  - 3.4.5 ShowOperation（显示图书）
  - 3.4.6 BorrowOperation（借阅图书）
  - 3.4.7 ReturnOperation（归还图书）
  - 3.4.8 ExitOperation（退出系统）
- 3.7 Test类
4.总体效果展示
5. 总结

1. 设计背景和系统功能和设计方法

1.1设计背景

图书馆作为每个大学或者城市必不可少的部分，其存放的海量书籍与文献使得其管理显得尤为困难，此时图书管理系统就起

到了一个重大的作用。

1.2系统功能

一种是面向管理员开启的菜单和功能，一种是面向所有普通用户来提供的菜单和功能。这些功能包括对于图书的借阅，归

还，增加，删除，查找以及显示。

1.3设计方法

利用多态，继承，封装，接口等知识点，来综合的设计和实现一个简易的图书管理系统。

2. 设计思路

①首先我们需要区分出管理员与普通用户，不同的用户所展示的界面不同，利用继承和多态可以实现这一思路;

普通用户：查找图书，借阅图书，归还图书，退出系统。

管理员：   查找图书，新增图书，删除图书，展示图书，退出系统。

②我们可以将各个操作都封装起来，单独的设计成一个类，且这些操作都需要遵循一定的规范，而接口实际上就是定义了一种规范，这里可以使用接口来进行实现。

③我们需要将书的属性进行封装，同时设立一个书架类，即存放的是书的数组。

3. 设计模块和代码实现

3.1 Book类的实现

在这里插入图片描述

这里书籍的属性有：书名，作者，价格，种类，是否被借出。

注意：是否被借出: private boolean isBorrowed，boolean的默认值是fasle。

我们结合封装性，为了安全起见，将属性设置为private权限，并提供相应的get方法和set方法，并需要提供对应的toString()方法的重写。

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

3.2 BookList类的实现(书架)

BookList类我们主要提供一个Book[ ]数组来进行Book的存储，数组大小先定为10，用privat修饰，便于后面对书籍的操作。

BookList类我们使用 usedSize：记录书架上目前有几本书先加入几本书籍，先加入三本书，并提供对应的get和set方法，

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

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

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

    public int getUsedSize() {
        return usedSize;
    }

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

3.3 User类的实现（用户类）

在这里插入图片描述

用户类中，我们需要定义用户的名字，同时定义一个抽象方法menu()来给子类管理员类和读者类重写(二者的目录不同)。

同时要提供set和get方法，并提供抽象Operation方法给子类重写使用（子类的目录不同，执行的操作就会存在差异。

并调用ioPerations类中的work方法，就可以实现不同用户有不同功能。

public abstract class User {
    protected String name;
    public IOPeration[] ioPerations;
    public User(String name){
        this.name=name;
    }
    public abstract int menu();
    public void doOperation(int choice, BookList bookList){
        ioPerations[choice].work(bookList);
    }
}

3.3.1 AdminUser（管理员类）

首先，管理员类需要继承于用户类，同时实现用户类中的抽象方法menu()，

同时实现抽象方法Operation()，这里可以利用接口的多态性来进行实现。

利用下标访问：0. 退出系统，1. 查找图书，2. 新增图书，3，删除图书，4.展示图书

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

3.3.2 NormalUser（普通用户类）

首先，普通用户类需要继承于用户类，同时实现用户类中的抽象方法menu()，

同时实现抽象方法Operation()，这里可以利用接口的多态性来进行实现。

利用下标访问：0. 退出系统，1. 查找图书，2. 借阅图书，3. 归还图书

public class NormalUser extends User{
    public NormalUser(String name) {
        super(name);
        this.ioPerations=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 scanner=new Scanner(System.in);
        int choice=scanner.nextInt();
        return choice;
    }
}

3.4 Operation类的实现（操作类）

在这里插入图片描述

3.4.1 IOperation（操作接口的实现）

我们需要将操作类实现操作接口，同时为重写的方法提供书架类，便于进行操作。

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

3.4.2 AddOperation（增加图书）

我们需要将操作类实现操作接口，同时为重写的方法提供书架类，便于进行操作。代码实现如下:

public class AddOperation implements IOPeration{
    public void work(BookList bookList){
        System.out.println(" 新增图书！");
    }
}

3.4.3 FindOperation（查找图书）

public class FindOperation implements IOPeration{
    public void work(BookList bookList) {
        System.out.println(" 查找图书！");
        Scanner scanner=new Scanner(System.in);
        System.out.println(" 请输入您要查找的图书: ");
        String name=scanner.nextLine();

        int currentSize=bookList.getUsedSize();

        for(int i=0;i<currentSize;i++){
            Book book=bookList.getBooks(i);
            if(book.getName().equals(name)){
                System.out.println("找到了");
                System.out.println(book);
                return;
            }
        }
        System.out.println(" 很抱歉，没有找到！");
    }
}

3.4.4 DelOperation（删除图书）

public class DelOperation implements IOPeration{
    @Override
    public void work(BookList bookList) {
        System.out.println(" 删除图书！");

    }
}

3.4.5 ShowOperation（显示图书）

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.getBooks(i);
            System.out.println(book);
        }
    }
}

3.4.6 BorrowOperation（借阅图书）

public class BorrowOperation implements IOPeration{

    @Override
    public void work(BookList bookList) {
        System.out.println(" 借阅图书！");

    }
}

3.4.7 ReturnOperation（归还图书）

public class ReturnOperation implements IOPeration{
    
    @Override
    public void work(BookList bookList) {
        System.out.println(" 归还图书！");
    }
}

3.4.8 ExitOperation（退出系统）

public class ExitOperation implements IOPeration{

    @Override
    public void work(BookList bookList) {
        int currentSize= bookList.getUsedSize();
        for(int i=0;i<currentSize;i++){
            bookList.setBooks(i,null);
        }
        bookList.setUsedSize(0);
        System.exit(0);
    }
}

3.7 Test类

在这里插入图片描述

此时，我们所有的框架都已经搭建好了，只需要在Test类中添加main方法进行测试即可，代码如下：

public class Test{
    //可以利用返回值 的向上转型 达到发挥的一致性
    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) {
            /*AdminUser adminUser = new AdminUser(name);
            return adminUser;*/
            return new AdminUser(name);
        }else {
            /*NormalUser normalUser = new NormalUser(name);
            return normalUser;*/
            return new NormalUser(name);
        }
    }

    public static void main(String[] args) {

        BookList bookList = new BookList();

        User user = login();
        while (true) {
            int choice = user.menu();
            //user是哪个对象？ choice是几？ ---》 能够确定：我能够操作哪个对象的哪个方法？
            //通过这两个变量 可以确定了 但是怎么联系起来？？
            /**
             * 1. 先让双方 存好 对应自己的操作
             * 2. 就是调用对应的操作！
             */
            user.doOperation(choice, bookList);

           /* System.out.println(choice);
            System.out.println(user);*/
        }
    }
}