package book;

public class Book {
    public String bookName;//书籍名字
    public String author;//书籍作者
    public int price;//书籍价格
    public Boolean isBorrowed = false;//书籍是否被借出

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

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    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 Boolean getBorrowed() {
        return isBorrowed;
    }

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

    @Override
    public String toString() {
        return "Book{" +
                "bookName='" + bookName + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                ", isBorrowed=" + isBorrowed +
                '}';
    }
}

BookList类实现

BookList就相当于一个书架，这里我把它设置为书架能放100本书。

BookList包括Book的数组和书籍的有效个数

我们可以刚开始初始化几本书和书架里现有多少本书，提过对应的构造方法和getter方法和setter方法。

package book;

public class BookList {

    public Book[] books = new Book[100];//总共有一百本书
        public int usedSize;//书籍的有效个数
        //接下来我可以创建一个接口类型的数组
    public BookList() {
            books[0] = new Book("java编程思想","埃克尔",98);
            books[1] = new Book("C和指针","KennethA.Reek",55);
            books[2] = new Book("深入理解计算机系统","Randal E.Bryant",188);
            books[3] = new Book("编译原理","陈意云",49);
            books[4] = new Book("算法第四版","Robert SedgeWick",102);
        this.usedSize = 5;
    }

    //得到下标的这本书
    public Book getPos(int pos) {
        return books[pos];
    }
    //将这个下标设置为一本书
    public void setBook(int pos,Book book) {
        books[pos] = book;
    }

    public int getUsedSize() {
        return usedSize;
    }

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

用户

我们把用户分为两部分一个是普通用户，一个是管理人员。这两个用户成员都是一样的，就是自己内部实现细节不一样，这就用到了我们继承这个非常重要的知识点。

用户属性： 1）:用户名 2):每个用户对应自己的菜单 3):每个用户对应自己的功能

父类(User类实现)

package User;

import book.BookList;
import operation.IOperation;

public abstract class User {
    public String name;//用户姓名(1)
    public IOperation[] iOperations;//创建一个接口类型的数组(2)
    public User(String name) {//(3)
        this.name = name;
    }
    public abstract int menu();//每个用户对应的菜单(4)
    public void doOperation(int choice,BookList bookList) {//每个用户所选择对应的功能(5)
        this.iOperations[choice].work(bookList);
    }
}

详细剖析：

1）：每个用户对应的用户名字

2）：一个接口数组，用来存放每个用户自己对应的功能，就普通用户来说，这个接口数组就放着查找图书，借阅图书，归还图书，展示图书，退出系统这几个功能。而管理人员对应的接口数组就存放查找图书，删除图书，展示所有图书，增加图书，退出系统这几个功能。

3）：提供构造方法进行初始化。

4）：因为父类不需要有菜单这个功能，只有子类有这个功能，所以父类不需要具体的实现，我们就把它设置为抽象方法同时类也变为了抽象类。

5）：通过接口数组，选择对应的功能调用这个选择所对应的功能。

子类(Admin管理人员实现)

package User;

import operation.*;

import java.util.Scanner;

public class Admin extends User{

    public Admin(String name) {//(1）
        super(name);//(2)
        this.iOperations = new IOperation[]{//(3)
                new ExitSystem(),
                new FindOperation(),
                new AddOperation(),
                new DeleteOperation(),
                new DisplayOperation()
        };
    }

    @Override
    public int menu() {//(4)
        System.out.println("欢迎"+this.name+"进入图书管理系统");
        System.out.println("0.退出图书管理系统");
        System.out.println("1.查阅图书");
        System.out.println("2.添加图书");
        System.out.println("3.删除图书");
        System.out.println("4.展示所有图书");
        Scanner scan = new Scanner(System.in);
        System.out.println("请选择:");
        int choice = scan.nextInt();
        return choice;
    }
}

详细剖析

1)：提供构造方法进行初始化

2): 子类提供构造方法之前要先为父类构造

3) : 初始化这个接口数组，进而初始化接口数组里对应的功能。

4）：实现一个管理人员的菜单，并且进行选择，返回选择的结果。

子类(OrdinaryClint普通用户实现)

package User;

import operation.*;

import java.util.Scanner;

public class OrdinaryClint extends User{

    public OrdinaryClint(String name) {//(1)
        super(name);//(2)
        this.iOperations = new IOperation[]{//(3)
                new ExitSystem(),
                new FindOperation(),
                new BorrowOperation(),
                new ReturnOperation(),
                new DisplayOperation()
        };
    }

    @Override
    public int menu() {//(4)
        System.out.println("欢迎"+this.name+"进入图书管理系统");
        System.out.println("0.退出图书管理系统");
        System.out.println("1.查阅图书");
        System.out.println("2.借阅图书");
        System.out.println("3.归还图书图书");
        System.out.println("4.展示所有图书");
        Scanner scan = new Scanner(System.in);
        System.out.println("请选择:");
        int choice = scan.nextInt();
        return choice;
    }

}

详细剖析

1)：提供构造方法进行初始化

2): 子类提供构造方法之前要先为父类构造

3) : 初始化这个接口数组，进而初始化接口数组里对应的功能。

4）：实现一个普通用户的菜单，并且进行选择，返回选择的结果。

Operation类

Operation类中IOperition接口实现

package operation;

import book.BookList;

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

为啥要实现这个接口呢？？？

因为每个用户所使用的功能都要操作BookList来执行对应的功能，所以我们就可以创建一个接口，让每一个功能都实现这个接口，然后重写接口中的方法，每个功能调用这个方法就可以实现对应的功能。

Operation类中AddOperation增加图书操作实现

package operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class AddOperation implements IOperation{

    @Override
    public void work(BookList bookList) {
        System.out.println("新增书籍");
        System.out.println("请输入你要新增的图书书名");
        Scanner scan = new Scanner(System.in);
        String name = scan.nextLine();
        System.out.println("请输入你要新增图书的作者");
        String author = scan.nextLine();
        System.out.println("请输入你要新增图书的价格");
        int price = scan.nextInt();
        Book book = new Book(name,author,price);
        bookList.setBook(bookList.getUsedSize(), book);
        System.out.println("新增图书成功！！！");
        bookList.setUsedSize(bookList.getUsedSize()+1);
    }
}

详细剖析：

增加图书，我们首先要输入图书的信息包括书名，作者，价格，然后将它存到这个数组中就可以了。

详细解释一下这段代码：

通过输入的信息，将它实例化出一本书放到对象变量中存放起来，然后调用bookList的setbook(这个方法是将pos下标处，放入你要添加的那本书)方法就可以把书籍存放在books这个数组中,之后添加完这本书要将书籍有效个数加1，提示添加成功。

Operation类中FindOperation查找图书操作实现

package operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class FindOperation  implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("查找图书");
        System.out.println("请输入你要查找的图书书名");
        Scanner scan = new Scanner(System.in);
        String name = scan.nextLine();
        int i =0;
        for(i =0;i<bookList.getUsedSize();++i) {
            Book book = bookList.getPos(i);
            if(bookList.getPos(i).bookName.equals(name)) {
                System.out.println("查找图书成功~~~"+"~~~图书信息如下：");
                System.out.println(book);
                return;
            }
        }
        if(i==bookList.getUsedSize()){
            System.out.println("没有找到这本书");
        }
    }
}

详细剖析：

查找图书思路:就是遍历整个数组，如果发现某一本书的书名和你要查找的书名一样，那就查找成功，return出去不要再继续查找了。最后如果数组中没有找到这本书那就提示没有找到这本书。

Operation类中BorrowOperation借阅图书操作实现

package operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class BorrowOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("借阅书籍");
        System.out.println("请输入你要借阅的书籍");
        Scanner scan = new Scanner(System.in);
        String name = scan.nextLine();
        int i =0;
        for(i =0;i<bookList.getUsedSize();++i) {
            Book book = bookList.getPos(i);
            if(bookList.getPos(i).bookName.equals(name)) {
                System.out.println("查找图书成功~~~"+"~~~图书信息如下：");
                System.out.println(book);
                if(book.getBorrowed()==false){//true
                    System.out.println("该书籍没有借出，可以借出");
                    book.setBorrowed(true);
                    System.out.println("借出成功");
                }else {
                    System.out.println("该书籍已经借出~~~");
                }
                return;
            }
        }
        if(i==bookList.getUsedSize()){
            System.out.println("没有找到这本书");
        }
    }
}

详细剖析：

借阅图书的第一步首先是输入你要借阅的图书，然后在去查找有没有这本要借阅的书，在调用book的getBorrowed方法看这本书的借出信息，如果是false代表没有借出，那这边本书就可以借出，然后调用setBorrowed方法把这本书的接触信息改为true，这就代表借出成功。最后如果数组中没有找到这本书那就提示没有找到这本书，无法借阅。

Operation类中ReturnOperation归还图书操作实现

package operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class ReturnOperation  implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("归还图书");
        System.out.println("请输入你要归还的书籍");
        Scanner scan = new Scanner(System.in);
        String name = scan.nextLine();
        int i =0;
        for(i =0;i<bookList.getUsedSize();++i) {
            Book book = bookList.getPos(i);
            if(bookList.getPos(i).bookName.equals(name)) {
                System.out.println("查找图书成功~~~"+"~~~图书信息如下：");
                System.out.println(book);
                if(book.getBorrowed()==true){//true
                    book.setBorrowed(false);
                    System.out.println("归还图书成功~~~");
                }else {
                    System.out.println("该图书并没有被借走，无需归还");
                }
                return;
            }
        }
        if(i==bookList.getUsedSize()){
            System.out.println("没有找到这本书");
        }
    }
}

详细剖析：

归还图书思路：归还图书第一步实现要输入你要归还的书名，然后查找这本书有没有，如果有这本书，那就调用book的getBorrowed方法看接触信息为true还是为false，如果是true，那就证明书籍处于借出状态可以归还，那就调用book的setBorrowed方法来讲这本书借出状态设置为false证明归还成功，最后如果数组中没有找到这本书那就提示没有找到这本书，无法归还。

Operation类中DisplayOperation展示所有图书操作实现

package operation;

import book.Book;
import book.BookList;

public class DisplayOperation implements IOperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("展示所有书籍");
        for(int i=0;i<bookList.getUsedSize();++i) {
            Book book = bookList.getPos(i);
            System.out.println(book);
        }
    }
}

详细剖析：

Display操作思路：就是遍历数组，然后通过调用book的getpos方法获取这本书，将它打印即可。

Operation类中ExitSystem退出系统操作实现

package operation;

import book.BookList;

public class ExitSystem  implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("退出图书管理系统");
       for(int i =0;i< bookList.getUsedSize();++i) {
           bookList.setBook(i,null);
       }
        System.exit(0);
    }
}

详细剖析：

思路：退出系统之前要将数组中的元素全部设置为null，自己手动销毁，然后调用System.exit(0)就会终止程序结束，退出即可。

Operation类中DeleteOperation删除图书操作实现

package operation;

import book.Book;
import book.BookList;

import java.util.Scanner;

public class DeleteOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("删除书籍");
        System.out.println("请输入你要删除的书籍");
        Scanner scan = new Scanner(System.in);
        String name = scan.nextLine();
        int i =0;
        int index =0;
        for(i =0;i<bookList.getUsedSize();++i) {
            Book book = bookList.getPos(i);
            if(bookList.getPos(i).bookName.equals(name)) {
                System.out.println("查找图书成功~~~" + "~~~图书信息如下：");
                System.out.println(book);
                index =i;
                break;
            }
        }
        //跳出来有两种情况:
        //2.一种是全部遍历完成
        if(i==bookList.getUsedSize()){
            System.out.println("没有找到这本书,无法删除");
            return;
        }
        //1.一种是找到要删除的书籍
         for(int j = index;j< bookList.getUsedSize()-1;++j) {
             Book book = bookList.getPos(j+1);//获取这本书
             bookList.setBook(j,book);
             System.out.println("删除图书成功~~~");
         }
         bookList.setUsedSize(bookList.getUsedSize()-1);
         return;
    }
}

详细剖析：

删除书籍思路：第一步输入你要删除的书籍，然后查找你要删除的书籍，如果书籍存在记录，这个要删除的书籍的下标，采取覆盖来进行删除，这里要注意for循环的判定条件不是有效个数了，而是有效个数减一，因为如果遍历到最后一个元素还要继续覆盖的话，那就回导致数组越界。最后如果数组中没有找到这本书那就提示没有找到这本书，无法删除。

测试(TestMain类)

import User.User;
import book.BookList;
import User.Admin;
import User.OrdinaryClint;

import java.util.Scanner;

public class TestMain {

    //登陆操作
    public static User login() {
        System.out.println("请输入你的名字");
        Scanner scan = new Scanner(System.in);
        String name = scan.nextLine();//输入姓名
        System.out.println("请选择你的身份：1->管理员，0->普通用户");
        int choice = scan.nextInt();
        if(choice==1) {
            //管理员身份
            return new Admin(name);
        }else {
            return new OrdinaryClint(name);
        }
    }

    public static void main(String[] args) {
        BookList bookList = new BookList();//准备书籍（1）
        User user = login();//登陆图书管理系统（2）
        while(true) {
            int choice = user.menu();//（3）
            //接下来根据用户的选择进行调用方法
            user.doOperation(choice,bookList);//（4）
        }
    }
}

详细剖析：

首先我们要进行登陆操作，先输入名字，在输入身份，然后根据你输入的身份，返回子类对象，用于父类接收，这就用到了向上转型知识点，父类对象的引用引用子类对象，此时父类对象变量接受的就是你选择的身份，然后根据身份来进行执行子类对象的菜单，执行完菜单，就会返回菜单中的一个选择，通过这个选择，就可以调用doOperation这个方法对bookList这本书进行操作。