【Java】简易版图书管理系统

基本思路

我们要做以一个图书管理系统首先肯定需要有一系列的图书 因为是简易版所以我们就存放在数组中

图书管理系统应该可以对图书实现一系列比如增加，删除等操作 所以创建一个可操作的接口 创建一系列类来实现这个操作接口

此外对登录的人也要有区分 由管理员和普通成员构成 因为它们都属于成员 所以我们可以抽象化一个User类 然后管理员和普通用户都继承他这个类

基本思路由上图可知

框架搭建

User

首先先抽象化User类

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

然后写他的子类管理员和普通成员

AdminUser

public class AdminUser extends User{
    public AdminUser(String name) {
        super(name);
    }
}

NormalUser

public class NormalUser extends User {
    public NormalUser(String name) {
        super(name);
    }
}

书架和图书

图书的基本信息

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 == false ?"没有被借出":"已经被借出") +
                '}';
    }
}

书架

public class BookList {
    private Book[] books = new Book[10];
    private int usedSize;

    //记录当前书架上一共有几本书
    public BookList() {
        books[0] = new Book("三国演义", "罗贯中", 19, "小说");
        books[1] = new Book("西游记", "吴承恩", 29, "小说");
        books[2] = new Book("水浒传", "施耐庵", 8, "小说");
        this.usedSize = 3;

    }

    public int getUsedSize() {
        return usedSize;
    }

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

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

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

操作接口和操作

操作接口Ioperation

public interface Ioperateion {
    void work(BookList books);
}

操作方法

对图书管理系统的操作可以简单分为
增加书籍 借出书籍 删除书籍 退出系统 查找书籍 归还书籍 展示书籍

这些操作都实现了Ioperation这个接口

这些操作我们在搭建完框架后在实现

菜单打印

因为我们有不同类型的用户管理员和普通用户
所以他们的界面也就是菜单是不同的
所以我们要分别在他们的类中实现一个菜单
管理员

 public int menu(){
        System.out.println("管理员菜单");
        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("0.退出系统");
        System.out.println("==============================");
        System.out.println("请输入你的操作");
        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;
    }

普通用户

public int menu() {
        System.out.println("普通用户菜单");
        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("==============================");
        System.out.println("请输入你的操作");
        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;
    }

操作方式

我们要根据我们菜单中所描述的信息来执行对应的操作
我们可以在父类User中来黄建一个数组来存储操作

 public Ioperateion[] ioperateion;
 //每个元素都是一个操作类型

在子类管理员和普通用户中就得用构造方法来初始化这个数组
管理员

 public AdminUser(String name) {
        super(name);
        this.ioperateion = new Ioperateion[]{
                new ExitOperation(),
                new FindOperation(),
                new Addoperation(),
                new DelOperation(),
                new ShowOperation()
        };
    }

普通用户

public NormalUser(String name) {
        super(name);
        this.ioperateion = new Ioperateion[]{
                new ExitOperation(),
                new FindOperation(),
                new BorrowOperation(),
                new ReturnOperation()};
    }

这些元素的存储位置和菜单上的要保持一致

操作的实现

我们在搭建框架的时候 并没有实际上实现每个操作
我们现在就实现一下这些操作
他们都是实现了Ioperation这个接口

Addoperation

public class Addoperation implements Ioperateion{
    @Override
    public void work(BookList books) {
        System.out.println("新增图书!");
        Scanner scanner = new Scanner(System.in);
        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 currentSize = books.getUsedSize();
		//获得书架中图书的个数
        books.setBooks(currentSize ,book);
        //将实例化的书放到书架的第currentSize个位置上
        books.setUsedSize(currentSize + 1);
        //书架上的书数目+1
        System.out.println("新增图书成功");
        //提示信息
    }
}

setbook在书架类中可以实现

 public void setBooks(int pos, Book book){
        books[pos] = book;
    }//将实例化的书添加到书架中

BorrwoOperation

public class BorrowOperation implements Ioperateion {
    @Override
    public void work(BookList books) {
        System.out.println("借阅图书!");
        System.out.println("请输入借阅图书的名字");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
		//通过名字索引图书
        int currentSize = books.getUsedSize();
        //获得书架中书的个数
        for (int i = 0; i < currentSize; i++) {
       	//循环遍历书架找到书
            Book book = books.getBook(i);
            //获得书架上i下标位置的书
            if (book.getName().equals(name)) {
            //判断书是不是在书架上
            //下面这个if-else判断书是否被借出
                if (book.isBorrowed() == true) {
                    System.out.println("该书已经被借出");
                } else {
                    book.setBorrowed(true);
                    //如果没有借出 就把这本书的状态改为已经借出
                    System.out.println("借阅成功");
                }
            }
        }//遍历了一遍书架还没有找到要的书 说明书架上没有这本书
        System.out.println("没有你要借阅的这本书");
    }
}

DelOperation

public class DelOperation implements Ioperateion {
    @Override
    public void work(BookList books) {
        System.out.println("删除图书！");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你要删除的书");
        String name = scanner.nextLine();
        int currentSize = books.getUsedSize();
        //上面的操作都基本相似

        int delIndex = -1;
        int i = 0;
        for (; i < currentSize; i++) {
            Book book = books.getBook(i);
            if (book.getName().equals(name)) {
                delIndex = i;
                break;
            }
        }
        //遍历书架找到这本书
       //如果找到记录下标 没有找到delIndex还是-1
        if (delIndex == -1) {
            System.out.println("没有要删除的这本书");
            return;
        }

        for (int j = delIndex; j < currentSize - 1; j++) {
            //让j+1下标给j下标位置的值
            Book book = books.getBook(j + 1);
            books.setBooks(j, book);
        }
        //覆盖删除法
        //将这本书下一个位置的书覆盖掉这本书
        //循环将后面的所有书都这样操作
        books.setBooks(currentSize - 1, null);
        //将最后一本书所指向的位置指向空 因为他已经被复制到前一个位置
        
        books.setUsedSize(currentSize - 1);
        //将书本数目-1
        System.out.println("删除图书成功");
    }
}

ExitOperation

public class ExitOperation implements Ioperateion{
    @Override
    public void work(BookList books) {
        System.out.println("退出系统");
        System.exit(0);
    }
}

FindOperation

public class FindOperation implements Ioperateion{
    @Override
    public void work(BookList books) {
        System.out.println("查找图书！");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你要查找的书");
        String name = scanner.nextLine();
		//相同的操作
		//查找操作和前面的操作有共同点
		//都是遍历书架找书
        int currentSize = books.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book book = books.getBook(i);
            if(book.getName().equals(name)){
                System.out.println("找到这本书了");
                System.out.println(book.toString());
                //将这本书打印
                //这里要重写book的toString方法
                return;
            }
        }
        System.out.println("没有这本书");
    }
}

ReturnOperation

归还图书

public class ReturnOperation implements Ioperateion{
    @Override
    public void work(BookList books) {
        System.out.println("归还图书！");
        System.out.println("请输入归还图书的名字");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
		//类似的操作
        int currentSize = books.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
        //遍历找到这本书 如果找到了将是可否被借出改为false
            Book book = books.getBook(i);
            if(book.getName().equals(name)){
                book.setBorrowed(false);
            }
        }
        //没有找到这本书
        System.out.println("没有你要归还的这本书");
    }
}

ShowOperation

public class ShowOperation implements Ioperateion{
    @Override
    public void work(BookList books) {
        System.out.println("显示图书！");
        int currentSize = books.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book book = books.getBook(i);
            System.out.println(book.toString());
        }
    }
	//就是将所有书籍信息打印出来
}

逻辑框架

我们第一步应该是初始化书架

BookList bookList = new BookList();
//实例化一个书架对象

书架在初始化的时候就已经有三本书 并且将usedSIZE设置为三 在前面的代码有体现

第二步就是实例化一个用户对象
我们有两个对象继承了User抽象类 所以我们在登陆一个账号的时候要选择一个身份登录普通用户还是管理员
所以我们在实现一个登陆的方法在主类中

public static User login() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的姓名");
        String name = scanner.nextLine();
        while (true) {
            System.out.println("请输入你的身份：1代表管理员 2代表普通用户");
            int choice = scanner.nextInt();
            if (choice == 1) {
                return new AdminUser(name);
            } else if (choice == 2) {
                return new NormalUser(name);
            } else {
                System.out.println("输入错误 请重新输入");
                continue;
            }
        }
    }

**这段代码根据我们选择的身份返回一个对象 **
输入1返回一个管理员对象 输入2返回一个普通用户对象 返回类型选择他们的父类User类型
在main函数中用一个父类接受

User user = login();

接下来就该打印菜单然后选择操作了

但是这时又有一个问题就是 我们的打印菜单方法都是在子类中实现的 父类中并没有这个方法 但是我们又是以向上转型来用父类接受这个实例化的类

也就是说父类中并没有打印菜单这个方法 但是因为子类实现了 我们可以在父类中声明一下 然后通过动态绑定来调用子类的打印菜单方法

只需要在父类中写一个这样的抽象方法即可

public abstract int menu();

我们在打印菜单后就要来实现调用操作的方法

在父类中实现这个方法

public void doOperation(int choice, BookList books) {
        this.ioperateion[choice].work(books);
        //参数1就是根据目录选择的操作
        //参数2就是书架
        //根据调用者类型来调用操作数组中choice下标的操作
        //对books书架进行操作
    }

public static void main(String[] args) {
        BookList bookList = new BookList();
        User user = login();
        while (true) {
        //循环为了每次操作后还能打印一个菜单和输入一个操作
        //直到我们选择的退出系统才会结束运行
            int choice = user.menu();
            user.doOperation(choice, bookList);
        }
    }

代码链接

图书管理系统: 代码