【Java】图书管理系统(菜鸟版)

最新推荐文章于 2024-04-23 13:01:43 发布

富春山居_ZYY(已黑化)

最新推荐文章于 2024-04-23 13:01:43 发布

阅读量2.2k

点赞数 47

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/weixin_46103589/article/details/120580291

版权

JavaSE 专栏收录该内容

12 篇文章 5 订阅

订阅专栏

前言

在前面的几节博客中，山居向大家剖析了类和对象，介绍了包，详析了面向对象的基本特征，生动讲解了什么是接口，总结的过程中，收益匪浅。

此次，山居将容这些东西于一体，写一个 Java 图书管理系统

在这里插入图片描述

通通都没有！（不是）。。。

该图书馆管理系统只是为了总结之前所学，将其投入应用当中，不整太高级的，只为融会贯通，菜鸟版图书管理系统，菜鸟值得拥有！

在这里插入图片描述

一、对象与功能剖析

面向对象编程首先需要明白对象都有哪些

建立一个图书管理图书系统应该有的大体对象有：图书，用户以及管理系统的各种功能

关于图书

需要一个类（Book）包含图书的各项信息

需要一个书架，将书（Book）放在其中

关于用户

普通用户

图书管理员

关于功能(对于不同的用户实现的功能有所不同)

普通用户：

查找书籍
借阅书籍
归还书籍
退出系统

图书管理员：

查找书籍
增加书籍
删除书籍
打印书籍
整理书籍
退出系统

所有的功能都是针对 BookList 类展开的，为了将各种方法联系在一起，需要功能们都实现接口 IFunction，重写该接口中的抽象方法。

最后还需要一个 Main 类将上面的类、各种信息串通在一起

在这里插入图片描述

二、代码实现

此次的项目一共建立了三个包来装类

Book 包：装图书相关类
Users 包：装用户类
Function 包：装功能类

2.1 Book包

2.1.1 书籍类（Book）

书籍信息包括书名、作者、价格以及是否被借出（为了安全性，实现封装，书籍信息用 private 关键字修饰）
提供书籍信息的 Getter and Setter 方法（alt + insert -> Getter and Setter），使外界可以获取书的信息
提供书籍类含有书名、作者、价格的三个参数的构造方法（借出状态是一种状态，无需传参）
重写 toString 方法（alt + insert -> toString()），可以做适当的修改，例如借出状态默认为 false（打印未借出），当书被借出，其状态为 true （打印已借出）

package Book;

public class Book {
    //书籍相关信息
    private String name;
    private String author;
    private Double price;
    private Boolean isBorrow = false ;
    //书籍信息的 Getter and Setter 方法
    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 Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    public Boolean getBorrow() {
        return isBorrow;
    }
    public void setBorrow(Boolean borrow) {
        isBorrow = borrow;
    }
    public Book(String name, String author, Double price) {
        this.name = name;
        this.author = author;
        this.price = price;

    }
    //重写 toString 方法
    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", isBorrow=" + ((isBorrow)?"已借出":"未借出") +
                '}';
    }
}

注意：

在 Java 中也有 Book类，而我们需要使用的我们自定义的 Book 类，在实例>化的时候需要导入正确的包（import Book.Book;），否则会报错

2.1.2 书架类（BookList）

书架中包含书本的数目（bookCount）和各种 Book 类型的书（创造Book类型的 books 数组）
提供 BookList 类的无参的构造方法来初始化 books 数组（在这里放了三本书），书本的数目（bookCount）为3
提供 returnBook 方法，返回 books 数组中下标为 i 的书籍，例如打印书籍功能就需要该方法访问到每本书籍
提供 setBooks 方法，在books 数组中下标为 num 的位置放置书籍，例如增加书籍功能中就需要在遍历完 books 数组来确认书架上没有想要增加的书的情况下，在下标为 bookCount 的位置放置新增加的书
提供 getBookCount 方法，使外界获取书本的数目
提供 setBookCount 方法，使外界可以改变书本的数目，例如删除书籍功能中就需要在遍历完 books 数组来确认书架上有想要删除的书的情况下，将书籍删除，通过该方法将书本数目减一

package Book;

public class BookList {
    private int bookCount;
    public Book[] books = new Book[20];
    public BookList() {
        books[0] = new Book("Java","C张三",32.8);
        books[1] = new Book("C++","B李四",59.0);
        books[2] = new Book("Python","A王五",29.8);
        this.bookCount = 3;
    }
    //返回在i下标处的书本
    public Book returnBook(int i) {
        return books[i];
    }
    //在num位置放置一本书
    public void setBooks(Book book,int num) {
        books[num] = book;
    }
    //返回此时书本的本数
    public int getBookCount() {
        return bookCount;
    }
    //改变书本的数目
    public void setBookCount(int bookCount) {
        this.bookCount = bookCount;
    }
}

2.2 Users 包

无论是普通用户还是图书管理员都共同属于用户，因此他们共同的信息就可以写在用户类中，来继承用户类，从而达到代码的重用

2.2.1 用户类（User）

用户都拥有的变量是用户名字
提供用户类含有一个参数（name）的构造方法
提供抽象方法 menu，因为普通用户和图书管理员的菜单是不同的，重写 menu，当发生向上转型的时候，通过重写的 menu 可以访问到不同类型的用户的菜单，实现了多态
该类中还包含着 IFunction（接口）类型的数组 iFunctions，因为不同类型的用户可以实现的功能是不同的，可以在子类帮父类进行构造方法的构造时定义不同内容的 iFunctions
提供 getFunction 方法，对 bookList（通过 BookList 类实例化的对象即书架）实现 iFunctions 数组下标为 choice 的功能

package Users;
import Book.BookList;
import Function.IFunction;

public abstract class User {
    //用户姓名
    protected String name;
    //该数组可以接收不同类型用户的功能
    protected IFunction[] iFunctions;
	//构造方法
    public User(String name) {
        this.name = name;
    }
    //需要被重写以达到多态，拿到不同菜单的抽象方法 menu
    public abstract int menu();
    //choice 表示iFunctions数组的下标，choice 不同，实现的功能不同
    public void getFunction(int choice,BookList bookList) {
        this.iFunctions[choice].work(bookList);
    }
}

2.2.2 普通用户类（NormalUser）

普通用户类继承了用户类，帮父类进行构造的时候初始化父类的 iFunctions 的数组
重写父类的抽象方法 menu

package Users;
import Function.*;
import java.util.Scanner;

public class NormalUser extends User{
    public NormalUser(String name) {
        super(name);
        //初始化父类的 iFunctions 的数组
        iFunctions = new IFunction[]{
                new ExitFunction(),
                new FindFunction(),
                new BorrowFunction(),
                new ReturnFuntion()
        };
    }
    // 重写父类的抽象方法 menu
    @Override
    public int menu() {
        System.out.println("=========普通用户菜单==========");
        System.out.println("Hello " + this.name + " 欢迎来到图书管理系统");
        System.out.println("1.查找书籍");
        System.out.println("2.借阅书籍");
        System.out.println("3.归还书籍");
        System.out.println("0.退出系统");
        System.out.println("请选择你想要进行的操作");
        Scanner scanner = new Scanner(System.in);
        while (true) {
            int choice = scanner.nextInt();
            if (choice >= 0 && choice <= 3) {
                return choice;
            } else {
                System.out.println("选择错误，请重新选择！");
            }
        }
    }
}

2.2.3 图书管理员类（Administrator）

和普通用户类方法一样

package Users;
import Function.*;
import java.util.Scanner;

public class Administrator extends User{
    public Administrator(String name) {
        super(name);
        //初始化父类的 iFunctions 的数组
        iFunctions = new IFunction[] {
                new ExitFunction(),
                new FindFunction(),
                new AddFunction(),
                new DelFunction(),
                new DisplayFunction(),
                new SortFunction()
        };
    }
    // 重写父类的抽象方法 menu
    @Override
    public int menu() {
        System.out.println("=========图书管理员菜单==========");
        System.out.println("Hello " + this.name + " 欢迎来到图书管理系统");
        System.out.println("1.查找书籍");
        System.out.println("2.增加书籍");
        System.out.println("3.删除书籍");
        System.out.println("4.打印书籍");
        System.out.println("5.整理书籍");
        System.out.println("0.退出系统");
        System.out.println("请选择你想要进行的操作");
        Scanner scanner = new Scanner(System.in);
        while (true) {
            int choice = scanner.nextInt();
            if (choice >= 0 && choice <= 5) {
                return choice;
            } else {
                System.out.println("选择错误，请重新选择！");
            }
        }
    }
}

2.3 Function 包

实际上功能往往是放在最后完成的，除了功能以外的部分就是整个项目的框架，完成了框架后，再来实现功能就很简单了。

2.3.1 IFunction 接口

实现接口 IFunction

package Function;
import Book.BookList;

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

2.3.2 查找书籍（FindFunction）

遍历 bookList 查看是否有想要查找的书籍

package Function;
import Book.BookList;
import java.util.Scanner;

public class FindFunction implements IFunction{
    @Override
    public void work(BookList bookList) {
        System.out.println("请输入你想要查找的书籍：");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        int num = bookList.getBookCount();
        for (int i = 0; i < num; i++) {
            if (name.equals(bookList.returnBook(i).getName())) {
                System.out.println(bookList.returnBook(i));
                System.out.println("查找成功！");
                return;
            }
        }
        System.out.println("不存在这本书！");
    }
}

2.3.3 增加书籍（AddFunction）

重写接口中的 work 方法
遍历 bookList 里的所有书，当不存在该书时，就实例化一本书，通过 setBooks 方法将书放到书架上，通过 setBookCount 方法使书本数目加一

package Function;
import Book.Book;
import Book.BookList;
import java.util.Scanner;

public class AddFunction implements IFunction{
    @Override
    public void work(BookList bookList) {
        System.out.println("想要添加的书籍的名字：");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        int num = bookList.getBookCount();
        for (int i = 0; i < num; i++) {
            if (name.equals(bookList.returnBook(i).getName())) {
                System.out.println("已经存在该本书！");
                return;
            }
        }
        System.out.println("书籍的作者：");
        String author = scanner.nextLine();
        System.out.println("书籍的价格：");
        Double price = scanner.nextDouble();
        Book book = new Book(name,author,price);
        bookList.setBooks(book,num);
        bookList.setBookCount(num + 1);
        System.out.println("增加成功！");
    }
}

2.3.4 删除书籍（DelFunction）

总体思想和增加一本书差不多
当在 bookList 中找到想要删除的书籍时（例如书籍所在的下标为 i ），那么就得到下标为 i + 1 的书籍使之覆盖下标为 i 处的书籍，i ++ ，切记i 的值一定要小于书本的数目减一，否则会访问到非书籍的部分（越界）
删除成功后一定要记得将书本的数目减一

package Function;
import Book.BookList;
import java.util.Scanner;

public class DelFunction implements IFunction{
   @Override
   public void work(BookList bookList) {
       System.out.println("请输入你想要删除的书籍：");
       Scanner scanner = new Scanner(System.in);
       String name = scanner.nextLine();
       int num = bookList.getBookCount();
       for (int i = 0; i < num; i++) {
           if (name.equals(bookList.returnBook(i).getName())) {
               for (int j = i; j < num - 1; j++) {
                   bookList.setBooks(bookList.returnBook(j + 1),j);
               }
               System.out.println("删除成功！");
               bookList.setBookCount(num - 1);
               return;
           }
       }
       System.out.println("不存在这本书！");
   }
}

2.3.5 打印书籍（DisplayFunction）

package Function;
import Book.BookList;

public class DisplayFunction implements IFunction{
    @Override
    public void work(BookList bookList) {
        int num = bookList.getBookCount();
        for (int i = 0; i < num; i++) {
            System.out.println(bookList.returnBook(i));
        }
    }
}

2.3.6 整理书籍（SortFunction）

整理书籍即对 BookList 上的书籍以自己的想要的标准进行排序，这里就用到了 Comparator 接口，具体用法在生动例子详解接口这一小节中有所介绍，这里就不多言
在 SortFunction 类中定义一个 Comparator 接口类型的数组 comparators，通过该数组来选择比较器

package Function;
import Book.Book;
import Book.BookList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

class NameComparator implements Comparator<Book> {
    @Override
    public int compare(Book o1, Book o2) {
        return o1.getName().compareTo(o2.getName());
    }
}
class AuthorComparator implements Comparator<Book> {
    @Override
    public int compare(Book o1, Book o2) {
        return o1.getAuthor().compareTo(o2.getAuthor());
    }
}
class PriceComparator implements Comparator<Book> {
    @Override
    public int compare(Book o1, Book o2) {
        return (int)(o1.getPrice()-o2.getPrice());
    }
}
public class SortFunction implements IFunction{
    public Book[] array(Book[] book,int num) {
        Book[] books = new Book[num];
        for (int i = 0; i < num; i++) {
            books[i] = new Book(book[i].getName(),book[i].getAuthor(),book[i].getPrice());
        }
        return books;
    }
    @Override
    public void work(BookList bookList) {
        Scanner scanner = new Scanner(System.in);
        Comparator[] comparators = new Comparator[] {
                new NameComparator(),
                new AuthorComparator(),
                new PriceComparator()
        };
       while (true) {
           System.out.println("请问想要以什么标准进行排序：0.name 1.author 2.price 3.isBorrow");
           int choice = scanner.nextInt();
           if (choice >= 0 && choice <= 2 ) {
               Book[] newBooks = array(bookList.books,bookList.getBookCount());
               Arrays.sort(newBooks, comparators[choice]);
               for (int i = 0; i < newBooks.length; i++) {
                   System.out.println(newBooks[i]);
               }
               System.out.println("排序完成！");
               return;
           }else {
               System.out.println("选择错误！");
           }
       }
    }
}

注意：

Arrays.sort(参数一,参数二);参数一是需要进行排序的对象，参数二是使用到的比较器
切记！！不可以将 bookList 里的 books 直接传到参数一中，因为 books 中可以放20本书，但是真正初始化的却不足20本（例如该数组中最初只有3本书，那么剩下17个未初始化的下标的内容全是null），用比较器就会发生空指针异常
因此可以通过 array 方法来获取到 books 中真正被初始化的内容

山居因为大意了，在此坑中躺了蛮久。。。

在这里插入图片描述

2.3.7 借阅书籍（BorrowFunction）

思路大同小异，遍历 bookList 中的书，借阅即将找到的那本书的借阅状态改为 true，如果该书的借阅状态在借之前就是 true ，说明该书已经被借走了

package Function;
import Book.BookList;
import java.util.Scanner;

public class BorrowFunction implements IFunction{
    @Override
    public void work(BookList bookList) {
        System.out.println("请输入你想要借阅的书籍：");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        int num = bookList.getBookCount();
        for (int i = 0; i < num; i++) {
            if (name.equals(bookList.returnBook(i).getName())) {
                if (bookList.returnBook(i).getBorrow()) {
                    System.out.println("该书已被借阅");
                    return;
                }
                bookList.returnBook(i).setBorrow(true);
                System.out.println("借阅成功！");
                return;
            }
        }
        System.out.println("不存在这本书！");

    }
}

2.3.8 归还书籍（ReturnFunction）

归还思路与借阅同

package Function;
import Book.BookList;
import java.util.Scanner;

public class ReturnFuntion implements IFunction{
    @Override
    public void work(BookList bookList) {
        System.out.println("请输入你想要归还的书籍：");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        int num = bookList.getBookCount();
        for (int i = 0; i < num; i++) {
            if (name.equals(bookList.returnBook(i).getName())) {
                if (!bookList.returnBook(i).getBorrow()) {
                    System.out.println("未借阅过此书");
                    return;
                }
                bookList.returnBook(i).setBorrow(false);
                System.out.println("归还成功！");
                return;
            }
        }
        System.out.println("不存在这本书！");
    }
}

2.3.9 退出系统（ExitFUnction）

当从键盘中读入一个0时成功退出系统

package Function;
import Book.BookList;

public class ExitFunction implements IFunction{
    @Override
    public void work(BookList bookList) {
        System.out.println("成功退出系统！");
        System.exit(0);
    }
}

2.4 Main类

实例化一个 BookList 类的对象，创造一个书架 bookList
提供 login 方法，该方法中通过不同的选择返回不同的结果，发生向上转型，使 user 访问到不同的菜单
通过菜单进行选择功能，返回的值传入 getFunction 方法中，获取不同的功能

import Book.BookList;
import Users.Administrator;
import Users.NormalUser;
import Users.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=》管理员 0=》普通用户");
        while (true) {
            int choice = scanner.nextInt();
            if (choice == 1) {
                return new Administrator(name);
            }else if (choice == 0) {
                return new NormalUser(name);
            }else {
                System.out.println("选择错误，请重新输入！");
            }
        }
    }
    public static void main(String[] args) {
        BookList bookList = new BookList();
        User user = login();
        while (true) {
            int choice = user.menu();
            user.getFunction(choice,bookList);
        }
    }
}

讲到这儿，一切联系了起来。。。。

在这里插入图片描述

三、项目总结

在这里插入图片描述

没啥好总结的，我知道的内容都老实交代了，没明白的大兄弟，咱再看一遍。。。
或者来复习复习
【Java】剖析类和对象
 【Java】包与继承
 【Java】多态与抽象类
 【Java】生动例子详解接口
散了散了。。。。。。

富春山居_ZYY(已黑化)

关注

47
点赞
踩
68

收藏

觉得还不错? 一键收藏
打赏
28
评论
【Java】图书管理系统(菜鸟版)

文章目录前言一、对象与功能剖析二、代码实现2.1 Book包2.1.1 书籍类（Book）2.1.2 书架类（BookList）2.2 Users 包2.2.1 用户类（User）2.2.2 普通用户类（NormalUser）2.2.3 图书管理员类（Administrator）2.3 Function 包2.3.1 IFunction 接口2.3.2 查找书籍（FindFunction）2.3.3 增加书籍（AddFunction）2.3.4 删除书籍（DelFunction）2.3.5 打印书籍（Di
复制链接

扫一扫