【Java】图书管理系统练习_继续在前面创建的library数据库中,创建“图书目录表”books。 创建books表,并按要

1.前言

主要是通过写博客来巩固一下自己的所学,如有错误的地方,还望指教.

目标

1.利用Java中的语法(抽象类,接口,多态,继承,动态绑定等知识)来完成一个图书管理系统.
2.登录系统的用户分为管理员和普通用户,普通用户拥有查询图书,借阅图书,归还图书,退出系统四个功能. 管理员拥有查询图书,新增图书,删除图书,显示所有图书,退出系统五个功能.

2.构思

1.用户分为管理员和普通用户,所以我们可以把他们的的共性抽取出来,创建一个抽象类.
2.对于图书的操作有很多,所以我们可以提供一个接口,让各种操作来实现这个接口进而完成各种功能.

3.代码实现

3.1 书和书架的实现（放在了Book包中，方便管理）

创建book类用来存储书的各种信息,BookList类当做书架管理书籍.

public class Book {
    private String name;
    private String author;
    private String describe;
    private double price;
    private boolean isBorrowed=false;

    public Book(String name, String author, String describe, double price) {
        this.name = name;
        this.author = author;
        this.describe = describe;
        this.price = price;
    }

    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 getDescribe() {return describe;}

    public void setDescribe(String describe) {this.describe = describe;}

    public double getPrice() {return price;}

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

    public boolean isBorrowed() {return isBorrowed;}

    public void setBorrowed(boolean borrowed) {isBorrowed = borrowed;}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

1、Book类中包含五个属性[书名,作者,书的描述,价格,是否被借出]。
2、一个构造方法(isBorrowed不用放到构造方法中,因为这个属性随着借入和归还一直变化,所以创建setter方法对他进行修改。
3、重写toString方法，这样打印出来才能看出来书籍信息，不重写的话打印出来的是哈希值。

public class BookList {
    Book[] books=new Book[10];		//这里我设计的最多存放10本书，可以随意
    private int usedSized=3;				
    public BookList(){
        books[0]=new Book("红楼梦","曹雪芹","清代小说",25.0);
        books[1]=new Book("高等数学","XX教授","工科必修",44.0);
        books[2]=new Book("笑傲江湖","金庸","长篇武侠小说",55.0);

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

    public int getUsedSized() {return usedSized;}

    public void setUsedSized(int usedSized) {this.usedSized = usedSized;}

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

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

1、BookList类中设置了书的数组，用来存放书。还有当前书的数量。
2、一些方法

• 获得书架上的某本书【getBooks】
• 获取当前存储了书的数量【getUsedSized】
• 修改当前存储的书的数量【setUsedSized】
• 修改某本书【setBooks】

3.2 、对书架的操作的实现（放在Operation包中）

普通用户拥有查询图书,借阅图书,归还图书,退出系统四个功能。 管理员拥有查询图书,新增图书,删除图书,显示所有图书,退出系统五个功能。
去掉重复的，其实就只有7个功能【新增、删除、查找、借阅、归还、显示所有书籍、退出系统】
内容比较简单，直接上代码

3.2.1 操作接口

public interface IOperation {
    public void work(BookList bookList);
}
1
2
3

让那7个功能来实现这个接口，从而完善各自的内容。

3.2.2 新增图书

public class AddOperation implements  IOperation{
    public void work(BookList bookList){
        if(bookList.getUsedSized()==10){
            System.out.println("书架已满,无法新增书籍");
            return;
        }
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入书籍名称");
        String name=sc.next();
        System.out.println("请输入书籍作者");
        String author=sc.next();
        System.out.println("请输入书籍的描述");
        String describe=sc.next();
        System.out.println("请输入书籍价格");
        Double price=sc.nextDouble();
        int pos=bookList.getUsedSized();
        Book book=new Book(name,author,describe,price);
        bookList.setBooks(pos,book);
        bookList.setUsedSized(pos+1);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.2.3 删除图书

public class DeleteOPeration implements IOperation{
    @Override
    public void work(BookList bookList) {
        if(bookList.getUsedSized()==0){
            System.out.println("删除失败,书架上没有书籍");
            return;
        }
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入书籍名称");
        String name=sc.next();
        for (int i = 0; i < bookList.getUsedSized(); i++) {
            if(name.equals(bookList.getBooks(i).getName())){
                while(bookList.getUsedSized()-i-1!=0){
                    bookList.setBooks(i,bookList.getBooks(i+1));
                    i++;
                }
                bookList.setUsedSized(bookList.getUsedSized()-1);
                System.out.println("删除成功");
                return;
            }
        }
        System.out.println("删除失败,没有这本书");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3.2.4 查找图书

public class FindOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        if(bookList.getUsedSized()==0){
            System.out.println("书库无书");
            return;
        }
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入你要查询的书籍的名称");
        String name=sc.next();
        for (int i = 0; i < bookList.getUsedSized(); i++) {
            if(name.equals(bookList.getBooks(i).getName())){
                System.out.println("查找到该书,信息如下");
                System.out.println(bookList.getBooks(i));
                return;
            }
        }
        System.out.println("查找不到这本书");

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.2.5 借阅图书

public class BorrowOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        if(bookList.getUsedSized()==0){
            System.out.println("书架没有书");
            return;
        }
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入书名");
        String name=sc.next();
        System.out.println();
        for (int i = 0; i < bookList.getUsedSized(); i++) {
            if (name.equals(bookList.getBooks(i).getName())){
                if(bookList.getBooks(i).isBorrowed()==false){
                    System.out.println("借阅成功");
                    bookList.getBooks(i).setBorrowed(true);
                    return;
                }
                System.out.println("该书已经被借阅");
                return;
            }
        }
        System.out.println("没有该书");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

3.2.6 归还图书

public class ReturnOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入归还书籍的名称");
        String name=sc.next();
        for (int i = 0; i < bookList.getUsedSized(); i++) {
            if(name.equals(bookList.getBooks(i).getName())){
                if(bookList.getBooks(i).isBorrowed()==true){
                    System.out.println("归还成功");
                    bookList.getBooks(i).setBorrowed(false);
                    return;
                }else{
                    System.out.println("该书未被借阅");
                    return;
                }
            }
        }
        System.out.println("没有该书或者书名错误");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.2.7 显示所有书籍

public class DisplayOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        if(bookList.getUsedSized()==0){
            System.out.println("书架为空");
            return;
        }
        for (int i = 0; i < bookList.getUsedSized(); i++) {
            System.out.println(bookList.getBooks(i));
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

3.2.8退出系统

public class ExitOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("退出成功");
        System.exit(0);
    }
}
1
2
3
4
5
6
7

3.3 用户功能的实现（放在User包中）

用户分为管理员和普通用户，我们抽象出管理员和普通用户的共同点创建User类，然后让管理员和普通用户继承User类，再去创建他们特有的属性或方法。

3.3.1 User类

public abstract  class User {
    protected String name;
    protected Operation[] Operations;

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

    public abstract int menu();

    public void doOperation(int choice , BookList bookList){
        iOperations[choice].work(bookList);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

管理员和普通用户有姓名、这个比较好理解，难点在于下面三段代码

protected IOperation[] iOperations;
//创建这个数组是为了存储操作书架的功能。
public abstract int menu();
//管理员和普通用户的菜单肯定是不一样的，所以让他们自己去重写方法。
public void doOperation(int choice , BookList bookList){
        Operations[choice].work(bookList);
    }
//管理员和普通用户对由于动态绑定，会各自调用各自Operation数组，在后面整合时会比较容易理解。
1
2
3
4
5
6
7
8

3.3.2 AdminUser类

public class AdminUser extends User{
    public AdminUser(String name) {
        super(name);
        this.iOperations=new IOperation[]{new ExitOperation(),new FindOperation(),new AddOperation(),
                new DeleteOPeration(),new DisplayOperation()};
    }
    @Override
    public int menu() {
        System.out.println("=====管理员菜单=====");
        System.out.println("1.查找图书");
        System.out.println("2.新增图书");
        System.out.println("3.删除图书");
        System.out.println("4.显示图书");
        System.out.println("0.退出系统");
        System.out.println("请输入你要执行的操作");
        Scanner sc=new Scanner(System.in);
        int choice=sc.nextInt();
        return choice;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.3.2 NormalUser类

public class NormalUser extends User{
    public NormalUser(String name) {
        super(name);
        this.iOperations=new IOperation[]{new ExitOperation(),new FindOperation(),new BorrowOperation(),new ReturnOperation()};
    }
    @Override
    public int menu() {
        System.out.println("====用户菜单====");
        System.out.println("1.查询图书");
        System.out.println("2.借阅图书");
        System.out.println("3.归还图书");
        System.out.println("0.退出系统");
        Scanner sc=new Scanner(System.in);
        int choice=sc.nextInt();
        return choice;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.4 整合代码

public class Main {
    public static User login(){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入你的姓名");
        String name=sc.next();
        System.out.println("欢迎"+name+"登录系统");
        System.out.println("请问你是管理员(0)还是普通用户(1)");
        int choice=sc.nextInt();
        if(choice==1){
            return new NormalUser(name);
        }else{
            return new AdminUser(name);
        }
    }
    public static void main(String[] args) {
        BookList bookList=new BookList();
        User user=login();
        while(true){
            int choice=user.menu();
            user.doOperation(choice,bookList);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

我们先看main方法，首先new了一个书架出来，然后创建了login方法，这个方法用来输入你的姓名和判断你是管理员还是普通用户。如果你是普通用户，则new一个NormalUser类并return。我们知道了该用户是普通用户，就可以弄对应的菜单了。

 while(true){
            int choice=user.menu();
            user.doOperation(choice,bookList);
        }
1
2
3
4

之前user对象接收的是NormalUser子类，所以由于动态绑定user.menu（）实际上相当于new NormalUser(name).menu（），因此调用普通用户的菜单，在该用户做出选择后，choice接受到选择的数字，doOperation便可以根据该数字执行对应的操作了。

4.总结

虽然对该代码有了一定的理解，但是语言表述能力还是太差，不过这个图书管理系统实现起来其实也不难，有兴趣的老铁可以实现一下。