[Java知识库] [java篇]图书管理系统，是你的期末大作业吗？

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> [java篇]图书管理系统，是你的期末大作业吗？ -> 正文阅读

[Java知识库][java篇]图书管理系统，是你的期末大作业吗？

前言：博主在之前的文章中分别介绍了，包，封装，继承和多态，总感觉哪里好像没有学透，所以今天特意复习了一下，用一个图书管理系统，把之前学过的东西全部运用进去。
前期文章： [java篇]包，继承和组合]
[java篇]多态，抽象类和接口

图书管理系统框架一览图

在这里插入图片描述

整体思想：

我们在敲代码之前先构思一下，即然要实现图书系统，那么就要有书，而图书馆里又不只有一本书，所以我们要出创建一个书架，存放所有的书。
当我们说到用户了，用户分为图书管理员和普通用户，而这两个用户又隶属于一个父类user类，因为我们在调用功能的时候普通用户和管理员有着相同的功能。
功能：我们创建一个功能接口，让每个具体功能都实现功能接口中的抽象方法。
Main类：创建登录方法，通过个人选择。去选择普通用户菜单，还是管理员菜单，然后通过菜单返回要具体实现的功能，调用Operation包下的某个功能类

创建一个书类：里面的属性包括：书名，作者，书的类型，价格，此书有没有被借出
创建一个书架：里面包含所有的书，还有一些具体方法
在User包下，创建两个类，分别是customer类，和Librarian类，都继承了user类。分别在两个子类中实现各自的菜单。

Book包

Book类

在Book类中，实现封装书的属性，依次为 书名，作者，书的特性，价格，此书是否被借出。

package Book;
public class Book {
    //创建书的属性
    //包括 书名 作者 种类 价格 是否借出
    private String name;
    private String author;
    private String type;
    private int price;
    private boolean isLent;
    //实现书的构造方法
    public Book(String name, String author, String type, int price) {
        this.name = name;
        this.author = author;
        this.type = type;
        this.price = price;
    }
    //实现setter 和 getter 方法 以便在其他类中调用书的属性

    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 String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public boolean isLent() {
        return isLent;
    }

    public void setLent(boolean lent) {
        isLent = lent;
    }
    //重写toString()方法

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", type='" + type + '\'' +
                ", price=" + price +
                ","+((isLent == false) ? "未借出" :"已借出") +
                '}';
    }
}

BookList类

实现书架，在这里创建一个Book数组，存放全部的书，和一些方法的实现

 public class BookList {
    //实现书架
    //其实在整个图书管理系统中，都是对书架的操作
    public Book []books = new Book[10];//先初始化书的书目为10本，其实我们在这里还可以实现扩容
    private int useSize;
    public BookList(){
        this.books[0] = new Book("水浒传","施耐庵","小说",45);
        this.books[1] = new Book("三国演义","罗贯中","小说",40);
        this.books[2] = new Book("西游记","吴承恩","小说",39);
        this.books[3] = new Book("红楼梦","曹雪芹","小说",50);
        this.useSize = 4; //现在具体书被初始化的有4本
    }

    public int getUseSize() { //获得书的书目
        return useSize;
    }

    public void setUseSize(int useSize) { //设置书的书目
        this.useSize = useSize;
    }
    public Book getPos(int size){ //得到对应下标的某本书
        return books[size];
    }
    public void setBook(Book book,int size){ //设置在某个下标有某本书
         books[size] = book;
    }
    public Book getBook(int size){ //得到对应下标的某本书
        return books[size];
    }
}

User包

普通用户Customer类

在Customer类中，他继承了user类，拥有了user类中的属性，先调用父类中的构造方法，然后在菜单中打印出各个功能的编号。并且在子类中的构造方法中实现一个功能数组，这个数组的每个元素为对应菜单中的功能的对象。
最后返回选择后的功能下标。

 package User;
import Operation.*;
import java.util.Scanner;
public class Customer extends user {
    //调用父类的构造方法
    public Customer(String name){
        super(name);
        this.iOperations = new IOperation[]{
                new ExitOperation(),
                new IsLentOperation(),
                new ReturnOperation(),
                new FindOperation()
        };
    }
    public int menu(){
        System.out.println("hello" + this.name + "欢迎来到图书管理系统");
        System.out.println("============= 普通用户菜单 ==============");
        System.out.println("1.借阅图书");
        System.out.println("2.归还图书");
        System.out.println("3.查找图书");
        System.out.println("0.退出系统");
        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;
    }
}

管理员Librarian类

和普通用户一样，先调用父类中的构造方法，作为子类拥有父类中的所有属性(除private修饰外),在子类的构造方法中创建功能数组，数组中的每个元素都是对应专属管理员执行的功能对象。然后打印管理员菜单。最后返回功能选择。

 package User;
import Operation.*;
import java.util.Scanner;
public class Librarian extends user{
    public Librarian(String name){
        super(name);
        this.iOperations = new IOperation[]{
                new ExitOperation(),
                new AddOperation(),
                new RemoveOperation(),
                new FindOperation(),
                new DisplayOperation(),
                new ArrangeOperation()
        };
    }
    public int menu(){
        System.out.println("hello" + this.name + "欢迎来到图书管理系统");
        System.out.println("=============  管理员菜单 ==============");
        System.out.println("1.新增图书");
        System.out.println("2.删除图书");
        System.out.println("3.查找图书");
        System.out.println("4.显示图书");
        System.out.println("5.整理图书");
        System.out.println("0.退出系统");
        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;//返回功能下标
    }
}

用户(user)类—父类

在父类user类，先封装一个属性，即用户的名字，然后通过构造方法对这个属性进行初始化，我们现在可以使用abstract来修饰父类，在父类中的所有抽象方法，都要在子类中被重写，我们在父类中写一个抽象方法为void menu()方法，当调用我们选择的功能下标时，我们可以直接调用父类中的menu方法。实现向上转型，动态绑定。

 package User;
import Book.BookList;
import Operation.IOperation;
public  abstract class user {
    //因为用户包含有两类
    protected String name;
    public user(String name){
        this.name = name;
    }
    //实现菜单
    public  abstract int menu();
    protected  IOperation []iOperations; //创建一个功能数组
    public void doOperation(int choice,BookList bookList){ //操作功能数组，并且调用功能包中的类中的被重写的方法。
            iOperations[choice].work(bookList);
    }
}

功能包-- Operation包

创建接口–IOperation接口

创建一个接口，让其他类实现接口中的抽象方法

 package Operation;
import Book.BookList;
public interface IOperation  {
    void work(BookList bookList);
}

新增图书–AddOperation

首先在原有的书籍中查找有没有你要添加的图书，如果有就提示你此书已经存在，你无需添加。在查找有没有这本书的时候我们需要遍历原书架上的所有书籍，所以我们要在BookList类中实现一个方法得到所有的书。如果在原有的书籍中没有找到你要添加的这本书，那么接在原来书架的末尾，添加上这本书(调用BookList类中的setBook()方法)，最后把书的个数加一(调用BookList类中的getsueSize()方法)。

 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("请输入图书的类型");
        String type = scanner.nextLine();
        System.out.println("请输入图书的价格");
        int price = scanner.nextInt();
        Book book = new Book(name,author,type,price);
        //在原有的书籍中查找是否已经存在了要添加的这本书
        //得到书的每下标

        for(int i = 0;i < bookList.getUseSize();i++) {
            Book book1 = bookList.getPos(i);
            if (name.equals(book1.getName())){
                System.out.println("此书已经存在，无需添加");
                return;
            }
        }
        bookList.setBook(book,bookList.getUseSize()); //把这本书添加到书架的末尾
        bookList.setUseSize(bookList.getUseSize()+1); //书的书目加1
        System.out.println("添加成功");
    }
}

删除图书–RemoveOperation

首先输入你要删除的图书，看书架上有没有这本书，如果没有就提示书库中没有你要删除的书，如果书架上有，那么就让要删除的这本书的后一本书去覆盖将要删除的这本书，即[i] = [i+1].最后在原有的书架上的图书个数减一。

 package Operation;
import Book.Book;
import Book.BookList;
import java.util.Scanner;
public class RemoveOperation implements IOperation{
    public void work(BookList bookList){
        System.out.println("删除图书");
        System.out.println("请输入删除的书名");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        int pos = -1;
        for(int i = 0;i<bookList.getUseSize();i++){
            Book book = bookList.getPos(i);
            if(book.getName().equals(name)) {
             pos = 1;
            }
        }
        if(pos == 1){
        //进行删除
            for(int i = pos;i<bookList.getUseSize() - 1;i++){
                Book book = bookList.getPos(i+1);
                bookList.setBook(book,i);
            }
            bookList.setUseSize(bookList.getUseSize() - 1);
            System.out.println("删除成功");
        }else{
            System.out.println("没有你要删除的图书");
        }
    }
}

查找图书–FindOperation

 package Operation;
import Book.Book;
import Book.BookList;
import java.util.Scanner;
public class FindOperation implements IOperation{
    public void work(BookList bookList){
        System.out.println("查找图书");
        System.out.println("请输入你要查找的书籍");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        for(int i = 0;i<bookList.getUseSize();i++){
            Book book = bookList.getPos(i);
            if(book.getName().equals(name)){
                System.out.println("已经找到");
                System.out.println(book);
                return;
            }
        }
        System.out.println("找不到");
    }
}

显示图书–DisplayOperation

 package Operation;
import Book.Book;
import Book.BookList;
public class DisplayOperation implements IOperation{
    public void work(BookList bookList){
        System.out.println("显示所有图书");
        if(bookList.getUseSize() == 0){
            System.out.println("书库无书");
            return;
        }
         for(int i = 0;i<bookList.getUseSize();i++){
             System.out.println(bookList.getBook(i));
         }
    }
}

整理图书–ArrangeOperation

在整理图书的时候，博主设计了你要按怎样的方式进行整理，是书名，作者，类型，还是价格。这让我们不由的想到了上一篇博主介绍的Comparator接口，分别实现各自的构造器。，然后通过Arrays.sort()方法，对所有的书籍进行排序。在这里我们一定要格外的关注Arrays.sort(),方法中要传两个参数，第一个是你要对什么进行排序，简单的说也就是一个数组，例如我们现在要传的第一个参数就要是一个书籍数组，把所有的书籍整成一个数组，然后传进去，第二个参数是你实现的比较器类的对象。
在这里一共要建4个比较器。我们可以将它们整成数组。

Comparator []comparators;

书名比较器：

 class NameComparator implements Comparator<Book>{
    public int compare(Book book1,Book book2){
        return book1.getName().compareTo(book2.getName());
    }
}

作者比较器：

 class AuthorComparator implements Comparator<Book>{
    public int compare(Book book1,Book book2){
        return book1.getAuthor().compareTo(book2.getAuthor());
    }
}

特性比较器：

 class TypeComparator implements Comparator<Book>{
    public int compare(Book book1,Book book2){
        return book1.getType().compareTo(book2.getType());
    }
}

价格比较器：

 class PriceComparator implements Comparator<Book>{
    public int compare(Book book1,Book book2){
        return book1.getPrice() - book2.getPrice();
    }
}

注意：在实现接口的时候。我们一定要注意Comparator<>里边的泛型，他表示的是你要比较的东西的类型。

然后我们继续实现操作接口，因为Arrays.sort()的第一个参数是一个关于书的数组，所以我们要建立一个newBook数组，存放所有的书籍，我们还应该注意，我们不能向Arrays.sort()里直接传BookList.books因为它传过去的还有为被初始化的书籍，所以我们要出进去的是已经被初始化好的。

 public class ArrangeOperation implements IOperation{
    public Book[] arrayBook(Book []books,int size){
        //把书架上的所有书籍全部转移到另一个数组中
        Book []books1 = new Book[size];
        for(int i = 0;i<size;i++){
            books1[i] = new Book(books[i].getName(),books[i].getAuthor(),books[i].getType(),books[i].getPrice());
        }
        return books1;
    }
    public void work(BookList bookList){
        System.out.println("你要怎样整理？");
        System.out.println("0-->按书名整理  1-->按作者名字整理  2-->按书的价格整理 3-->按书的类型整理");
        Scanner scanner = new Scanner(System.in);
        Comparator []comparators = new Comparator[]{ //把构造器整成一个数组
                new NameComparator(),
                new AuthorComparator(),
                new PriceComparator(),
                new TypeComparator()
        };
        int choice = scanner.nextInt();
        Book []newBooks arrayBook(bookList.books,bookList.getUseSize());
        Arrays.sort(newBooks,comparators[choice]);
        for(int i = 0;i<bookList.getUseSize();i++){ //显示排序后的书
            System.out.println(newBooks[i]);
        }
        System.out.println("排序成功");
    }
}

借阅图书–LentOperation

 package Operation;
import Book.Book;
import Book.BookList;
import java.util.Scanner;
public class IsLentOperation implements IOperation{
    public void work(BookList bookList){
        System.out.println("借出图书");
        System.out.println("请输入书名");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        for(int i = 0;i<bookList.getUseSize();i++){
            Book book = bookList.getPos(i);
            if(book.getName().equals(name)){
                book.setLent(true);
                System.out.println("借阅成功");
                return;
            }
        }
        System.out.println("图书馆没有你要借的书，或者此书已被人借走");
    }
}

归还图书–ReturnOperation

 package Operation;
import Book.Book;
import Book.BookList;
import java.util.Scanner;
public class ReturnOperation implements IOperation{
    public void work(BookList bookList){
        System.out.println("归还图书");
        System.out.println("请输入还书书名");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        for(int i = 0;i<bookList.getUseSize();i++){
            Book book = bookList.getPos(i);
            if(book.getName().equals(name)){
                book.setLent(false);
                return;
            }
        }
        System.out.println("还书失败");
    }
}

Mian类–实现登录，连接程序

在调用各个功能之前，我们首向要实现一个登陆页面。
首先让使用者，输入自己的姓名，然后选择管理员，还是普通用户，根据不同的选择调用不同的菜单。

     //创建一个登陆页面
    public  static  user login(){
        System.out.println("请输入姓名");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        System.out.println("请选择 0--> 管理员  1--> 普通用户");
        int choice = scanner.nextInt();
        if(choice == 0){
            return new Librarian(name);
         }else{
            //调用普通用户类
            return  new Customer(name);
        }
    }

然后连接代码全部，第一步实现登陆页面，第二步通过向上转型，动态绑定之后，返回选择之后的功能下标，然后根据功能下标，调用不同的功能方法来操作书架。

   public static void main(String[] args) {
        user user = login();
        BookList bookList = new BookList();
        while(true){
            int choice = user.menu();
            user.doOperation(choice,bookList);
        }
    }