图书管理系统（JAVA实现）

@@@wang

已于 2024-05-26 21:45:01 修改

阅读量984

点赞数 10

文章标签： java

于 2024-03-10 22:29:21 首次发布

本文链接：https://blog.csdn.net/2201_76027754/article/details/136609142

版权

本文详细描述了一个基于JAVA的图书管理系统，区分了普通用户和管理员的功能，包括查找图书、借阅、归还、新增和删除图书，以及Book类和BookList类的设计。介绍了如何通过面向对象的方法实现用户界面和不同角色的操作逻辑。

摘要由CSDN通过智能技术生成

说明：该图书管理系统有两种人员可以使用：1.普通用户，2.图书管理员。他们俩所能进行的功能也不一样。普通用户有退出系统，借阅图书，归还图书，查找图书四种功能；图书管理员有退出系统，新增图书，删除图书，查找图书，打印图书等五种功能（后续功能有待开发）。JAVA语言是面向对象的，所以我在实现这个系统的时候，要先找到对象，然后创建对象，最后通过各种方法来使用对象。

在这个系统中一共有三个包，分别是：book包（用来存储书的一些数据：书名，作者，价格，类型，是否被借出），operation包（用来放各种操作：删除，新增，查找等），user包（用来放两个管理人员在页面所看的一些信息，具体后面会详细描述），还有一个Mian类来实现该系统。

效果实现：

1.普通用户和管理员用户的不同界面：

2.普通用户的操作实现：

2.1查找图书：（管理员用户一样的操作）

2.1.1 找到图书：

2.1.2 未找到图书：

2.2借阅图书：

2.2.1 借阅成功：

2.2.2 借阅失败：

2.3归还图书：

2.4退出系统：（管理员用户一样的操作）

3.管理员用户的操作实现：

3.1 新增图书：

3.1.1 新增成功：

3.1.2 新增失败：

3.2删除图书：

3.3打印图书：

1.book包：Book类和BookList类

1.1 Book包：

package book;

public class Book {
    private String name;
    private String author;
    private int price;
    private String type;
    private boolean is_borrow; //是否被借出，默认初始化为false，表示没有被借出

    public Book(String name, String author, int price, String type) {
        this.name = name;
        this.author = author;
        this.price = price;
        this.type = type;
    }
    public Book() {

    }
    //在重写这个toString方法时，在最后判断是否被借阅用了一个三目操作符
    //这也是下面给is_borrow从外部赋值的原因
    @Override
    public String toString() {
        return "book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", type='" + type + '\'' +
                ((is_borrow == true) ? "已被借阅" : "未被借阅")+
                '}';
    }
    public String getName() {
        return this.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 isIs_borrow() {
        return is_borrow;
    }
    //这里给这个方法，是为了后面用户在借阅或者归还图书的时候
    //将其状态通过外部转化为未被借阅还是已经借阅
    public void setIs_borrow(boolean is_borrow) {
        this.is_borrow = is_borrow;
    }
}

Book类中的一个属性：is_borrow很关键，当我们选择普通用户来操作该图书管理系统的时候，用户可能会借阅书目，我们如何让下一个人在借阅书的时候看某本书是否被借出，此时这个is_borrow属性的作用就出来了，如果当一个用户借走了这本书，那么下一个人在接这本书的时候，将会借阅失败，并且此时我们可以在借阅成功过后将is_borrow这个属性给置为true(默认为false，也就是没有被借出)。

1.2 BookList包：

package book;

public class BookList {
    private Book[] books;
    private int usedSize;//记录现在书架上实际上还有多少本书
    private static final int DEFAULT_CAPACITY = 10;//书架的容量
    public BookList() {
        this.books = new Book[DEFAULT_CAPACITY];
        this.books[0] = new Book("三国演义","罗贯中",10,"小说");
        this.books[1] = new Book("西游记","吴承恩",9,"小说");
        this.books[2] = new Book("红楼梦","曹雪芹",19,"小说");
        usedSize = 3;
    }

    public int getUsedSize() {
        return usedSize;
    }

    public void setUsedSize(int usedSize) {
        this.usedSize = usedSize;
    }
    //这里重写一个无参数的getbook的方法，是为了后面再增添图书的判断书架是够已满
    public Book[] getBook() {
        return books;
    }

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

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

2.user包：

2.1 User：（父类）

package user;

import book.Book;

import book.BookList;

import operation.*;

public abstract class User {
    protected String name;

    protected IOPeration[] ioperations;

    public User(String name) {
        this.name = name;
    }

    public abstract int menu();

    BookList bookList = new BookList();
    //这里就是对前面的choice和ioperation的一个应用，下面就可以直接通过该方法来执行对应的操作
    public void doOperation(int pos) {
        ioperations[pos].work(bookList);
    }
}

由于该图书管理系统有两种不同的操作方式，一就是普通用户来操作，另外一个就是管理员用户来操作，两种不同用户所出现的用户界面也不一样，所以我们可以将这两个用户定义成两个不同的类，并对它们进行共性的提取（有用户的名字，menu菜单（打印不同用户操作的菜单），带参（name）构造方法），从而就有了User类，并且我们还可以将此类给置为抽象类，以免我们实例化User的对象。

name和ioperations的修饰符被设计为projected，表示这两个属性只能在同一包/不同包的子类（也就只有继承User类才可以使用，后续如果多了一个新的用户，就可以直接继承这个User类（对用户共性的继承），然后实现某些自己独特的方法）中使用。

2.2NormolUser（普通用户）：

package user;

import operation.*;

import java.util.Scanner;

public class NormolUser extends User{

    public NormolUser(String name) {
        super(name);
        //这里跟下面的choice是一样的作用
        this.ioperations = new IOPeration[]{
                new ExitOperation(),
                new FindOperation(),
                new BorrowOperation(),
                new ReturnOperation()
        };
    }
    public int menu() {
        System.out.println("********1.普通用户********");
        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();
        //返回choice是为了在main方法里面能够直接通过这个choice来执行相应的操作
        return choice;
    }
}

2.2 AdminUser：（管理员用户）

package user;

import operation.*;

import java.util.Scanner;

public class AdminUser extends User{

    public AdminUser(String name) {
        super(name);
        this.ioperations = new IOPeration[]{
                new ExitOperation(),
                new AddOperation(),
                new DelOperation(),
                new FindOperation(),
                new ShowOperation()
        };
    }

    public int menu() {
        System.out.println("********2.管理员用户*******");
        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;
    }
}

ioperations这里使用了向上转型，实例化的是不同的操作类，用接口的引用来接受，从而当你想要添加一个新的操作时，只需要重新定义一个类，然后实现这个接口就行了，然后重写里面的work方法（具体的操作方法）。

3.operation包：

3.1 IOPeration：（接口）

package operation;

import book.BookList;

public interface IOPeration {
    
    void work(BookList bookList);

}

3.2 AddOperation：（新增图书）

package operation;

import book.Book;

import book.BookList;

import java.util.Scanner;

public class AddOperation implements IOPeration {
    public void work(BookList bookList) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("新增图书！");

        System.out.println("请输入书名：");
        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, price, type);
        int i = 0;
        //获取现在书架上有多少本书
        int currentSize = bookList.getUsedSize();
        for(i = 0; i < currentSize; i++) {
            Book book1 = bookList.getBook(i);
            //equal方法是用的String重写的方法，默认的Object包中的epual方法是比较两个对象的地址 
            //然后返回一个boolean类型的值
            if(book1.getName().equals(name)) {
                System.out.println("现有你所想要新增的书！！");
                break;
            }
        }
        if(currentSize == bookList.getBook().length) {
            System.out.println("书架已满，不可再增添新书！！");
        }else {
            //默认放到书架上书的最后一个位置
            bookList.setBook(currentSize, book);
            //添加成功，将书架上书的数量加一，这就是setUsedSize的用处
            bookList.setUsedSize(currentSize + 1);
        }

    }

}

3.3 DelOperation：（删除图书）

package operation;

import book.Book;

import book.BookList;

import java.util.Scanner;

public class DelOperation 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();
        int i = 0;
        int pos = 0;
        //找到要删除的图书的位置，找到它的下标
        for(; i < currentSize; i++) {
            Book book = bookList.getBook(i);
            if(book.getName().equals(name)) {
                pos = i;
                break;
            }
        }
        if(i == currentSize) {
            System.out.println("没有你要删除的这本书！");
        }
        int j = 0;
        //找到要删除的图书的位置下标过后，就让这本书后一本书来将前一本书给覆盖了，然后依次循环，                                    
        //直到currentSize - 2的下标位置然后停下来，最后在将currentSize - 1的位置的书置为null
        for(j = pos; j < currentSize - 1; j++) {
             Book book = bookList.getBook(j + 1);
             bookList.setBook(j, book);
        }

        bookList.setBook(currentSize - 1, null);
        //重新设置书架上书的数目
        bookList.setUsedSize(currentSize - 1);
    }
}

3.4 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("查找图书！");
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入你要查找的书名：");
        String name = scanner.nextLine();
        int currentSize = bookList.getUsedSize();
        int i = 0;
        for(i = 0; i < currentSize; i++) {
            Book book = bookList.getBook(i);
            if(book.getName().equals(name)) {
                System.out.println("成功找到！");
                System.out.println(book);
                break;
            }
        }
        //这里需要判断一下是否这个书架上有这本上书，在设计时应该想到的一点
        if(i == currentSize) {
            System.out.println("没有这本书！！");
        }
    }
}

3.5 ShowOperation：（打印图书）

package operation;

import book.Book;

import book.BookList;

public class ShowOperation implements IOPeration {
    public void work(BookList bookList) {
        System.out.println("打印图书！");

        int currentSize = bookList.getUsedSize();
        for(int i = 0; i < currentSize; i++) {
            Book book = bookList.getBook(i);
             //为null的书不打印
            if(book == null) {
                continue;
            }else {
                System.out.println(book);
            }
        }
    }
}

3.6 BorrowOperation：（借阅图书）

package operation;

import book.Book;

import book.BookList;

import java.util.Scanner;

public class BorrowOperation 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();
        int i = 0;
        for(i = 0; i < currentSize; i++) {
            Book book = bookList.getBook(i);
            if(book.getName().equals(name)) {
                //该书已被借阅，所以需要外部将这个状态给设置进去
                book.setIs_borrow(true);
                System.out.println("借阅成功！");
                System.out.println(book);
                break;
            }
        }
        if(i == currentSize) {
            System.out.println("你想要借阅的图书没有！！");
        }
    }
}

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

        int currentSize = bookList.getUsedSize();
        int i = 0;
        for(i = 0; i < currentSize; i++) {
            Book book = bookList.getBook(i);
            if(book.getName().equals(name)) {
                book.setIs_borrow(false);
                System.out.println("归还成功！");
                System.out.println(book);
                break;
            }
        }
    }
}

4.Main类：

import user.AdminUser;

import user.NormolUser;

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.管理员用户*******");
        System.out.println("请输入身份：");

        int choice = scanner.nextInt();
        if(choice == 1) {
            //普通用户
            return new NormolUser(name);
        }else {
            //管理员
            return new AdminUser(name);
        }
    }

    public static void main(String[] args) {
        User user = login();
        int choice = 1;
        while(choice != 0) {
            choice = user.menu();
            //看操作的输入是够合法
            if((choice < 4) || (choice < 5)) {
                System.out.println("choice: " + choice);
                user.doOperation(choice);
            }else  {
                System.out.println("输入错误，请重新输入");
            }

        }

    }
}

这里在设计登录方法（login）时的返回值为User，而我们返回的AdminUser的对象/NormalUser的对象，这里也发生了向上转型，以便我们在后面可以直接通过这个返回值来调用不同用户的操作页面的打印和进行图书相关操作的方式。