Java 从零开始写一个简单的图书管理系统

了解一下

先来了解要实现一个怎样的图书管理系统

从中可以看到有操作的 使用者 和 不同 的 功能

而不同的使用者有不同的 菜单

那要如何实现呢？

请继续看下去

如何实现

首先了解我们 需要什么

图书系统需要 书，放书的 书架 ，用户 中有 管理员 和 普通用户，以及 实现功能

也就是说

书：书 书架

用户：管理员 普通用户

操作功能：管理员功能 普通用户功能

书

1.书

写一个书类，创建它的书名，作者，价格，类型，是否借出（boolean类型），全部使用private修饰

创建get 和 set方法获取书的属性

创建构造方法以便之后的传值，boolean类型不需要创建构造方法，boolean默认为false，创建构造方法反而显得繁琐

由于之后需要打印重写一个toString方法

而boolean类型的打印为false，可以使用 三元操作条件运算符 来解决

public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", type='" + type + '\'' +
                (isBorrowed == true ? " 已借出":" 未借出")+//这里用三元条件运算符可以解决打印出来false和true的问题
//                ", isBorrowed=" + isBorrowed +
                '}';
    }

此时我们的book类就写完了 

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

    //再创建get set方法，以便后续的调用
    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;
    }

    //创建to String方法，便于打印
    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", type='" + type + '\'' +
                (isBorrowed == true ? " 已借出":" 未借出")+//这里用三元条件运算符可以解决打印出来false和true的问题
//                ", isBorrowed=" + isBorrowed +
                '}';
    }
}

2.书架

写一个书架类，创建一个Book数组，给上合适的空间

创建构造方法用来放书，使书架被创建的时候就能有书

定义当前书的数量useSize

给Book数组和useSize创建get 和 set方法

注意：需要再写一个能获取和设置单本书的方法，以便后续需要增加图书和删除图书

到这里我们的书架类也写完了

//书架类
public class BookList {
    //书架类用来放书，new一个书类型的数组，给上合适的空间
    Book[] books = new Book[10];

    //建立一个当前使用数
    private int useSize;
    //给书架创建构造方法，使书一开始就存在于书架
    public BookList() {
        books[0] = new Book("三块钱如何活一个月","Zack",3,"人生哲理");
        books[1] = new Book("如何征服美丽少女","Zack",999,"杂志");
        books[2] = new Book("为什么作者这么帅","Zack",666,"小说");
        this.useSize = 3;
    }

    //创建get 和set 方法便于后续使用
    //这里修改加入参数便于后续获取一本书
    public Book getBook(int pos) {
        return books[pos];
    }
    //这里为了获取全部的书
    public Book[] getBooks() {
        return books;
    }

    //同样设置一本书
    public void setBook(Book books,int pos) {
        this.books[pos] = books;
    }

    public int getUseSize() {
        return useSize;
    }

    public void setUseSize(int useSize) {
        this.useSize = useSize;
    }
}

那么书结束，接下来是用户

用户

1.User类

这里有 普通用户 和 管理员，我们很容易想到利用多态，写一个User抽象类

定义名字

创建构造方法

创建抽象方法menu

注意：这里返回类型需要定义为int类型，以便接收操作值

//由于这个类不能具体指向某个对象，所以定义为抽象类
public abstract class User {
    //想要这个变量被其他类使用，又想要有一点限制使用protected
    protected String name;
    //创建接口的数组，对应接收操作的数字
    protected IOperation[] iOperations;
    //同样创建构造方法

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

    //创建一个menu菜单方法，子类继承的时候会需要续写,设置成int类型方便返回值
    public abstract int menu();

    //实现向下转型
    public void doOperation(int choice, BookList bookList){
        iOperations[choice].work(bookList);
    }

}

2.普通用户

继承父类User，

重写父类构造方法，

重写menu，

由于不同类型的用户的菜单不同，所以需要根据不同用户的功能设计

从输入2开始就是进入了系统，那么根据需要设计想要实现的样子，这里仅供参考

public int menu() {
            System.out.println("-----欢迎 "+this.name+" 来到图书管理系统-----");
            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;
    }

那么管理员也是同理，只需要修改需要的功能 

到这里我们的用户类完成

接下来是写一个主类运行

主类

可以看到运行时优先出来的是要求输入姓名和身份

那么可以设置为静态方法

1.login静态方法

按照想要的要求来实现，这里的返回值设置成User方便之后接收返回值

具体实现

 //构造静态方法，一开始执行就会运行这个方法
    public static User login(){//这里把返回类型设置成User，这样不论是什么类型都可以接收
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的姓名：");
        String name = scanner.nextLine();
        System.out.println("请输入你的身份：");
        System.out.println("1. 管理员   2. 普通用户");
        int choice = scanner.nextInt();
        if (choice == 1){
            return new Admin(name);
        }else {
            return new Normal(name);
        }
    }

先创建一个书架对象，使书架里有

创建一个User对象，接收login方法的传来的值

用User创建的对象调用子类的方法，这样就形成了多态

具体实现

BookList bookList = new BookList();
        //用User类型来接收就可以形成多态
        User user = login();
//用一个choice来接收返回的操作值
            int choice = user.menu();

这里还可以写一个循环让菜单一直出现直到退出系统

接下来是操作方法的实现

操作方法

可以实现一个操作方法的接口，这样所有实现这个接口的类都需要重写它的方法，便于调用

由于操作的是书架所以需要输入书架的值 

//创建接口使实现接口的子类都需要实现方法,注意这里要操作的是书架所以参数是BookList。。。。
public interface IOperation {
    void work(BookList bookList);
}

 把要创建的方法实现这个接口，重写work方法

例如这种

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

这样就完成了操作方法

（本文章仅搭建一个框架，不包含功能的实现，功能的实现我会单独放在一篇文章）

如何调用方法

既然通过数字来确定操作方法，不如直接创建一个接口的数组，把操作方法放到数组里

那么首先在User类里创建一个接口的数组ioperations,这样子类会继承

//创建接口的数组，对应接收操作的数字
    protected IOperation[] iOperations;

而管理员和普通用户的方法不同，数组就需要放入不同的值

形如，放到构造方法中同样创建就会执行

iOperations = new IOperation[]{
                new ExitOperation(),
                new FindOperation(),
                new AddOperation(),
                new DeleteOperation(),
                new ShowOperation()
        };

调用的时候就再在User类中写一个调用的doOperation

参数放入书架BookList booklist 和下标pos

public void doOperation(int choice, BookList bookList){
        iOperations[choice].work(bookList);
    }

在主类中调用后就将框架实现了

public class Main {
    //构造静态方法，一开始执行就会运行这个方法
    public static User login(){//这里把返回类型设置成User，这样不论是什么类型都可以接收
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的姓名：");
        String name = scanner.nextLine();
        System.out.println("请输入你的身份：");
        System.out.println("1. 管理员   2. 普通用户");
        int choice = scanner.nextInt();
        if (choice == 1){
            return new Admin(name);
        }else {
            return new Normal(name);
        }
    }

    public static void main(String[] args) {
        BookList bookList = new BookList();
        //用User类型来接收就可以形成多态
        User user = login();


        //写一个死循环让菜单循环
        while(true){
            //用一个choice来接收返回的操作值
            int choice = user.menu();

            //利用这个返回的操作值来进行下一步
            user.doOperation(choice,bookList);
        }

    }
}

梳理运行步骤

首先主类的login方法会优先执行，返回一个类型

然后根据返回的类型调用方法

接收操作值之后就找到操作方法类并调用work方法

这里只是实现一个框架，功能的实现会放到下一篇文章

若有不足请及时指正