一、导读

利用前面所学的知识点：类，抽象类，封装，继承，多态，接口等进行的一个代码的练习。通过这个练习，可以加强对面向对象的理解，进一步的掌握所学的知识点。

🍎图书管理系统主要通过四个部分来实现：

book包：对图书基本信息的实现
user包：对用户的信息与逻辑操作的实现。
operation 包：对系统相关操作的实现。
Main 文件：对系统进行整合，搭建整体逻辑。

二、主要需求

🍓简单的登录

🍓管理端

查找书籍
新增书籍
删除书籍
打印（显示）书籍列表
退出系统

🍓用户端

查找书籍
借阅书籍
归还书籍
退出系统

三、类的设计

🍓创建图书相关的类

创建 package book
创建 Book 类, 表示一本书。
图书的信息：书名、作者、价格、类型、是否借出

Book.java

package book;

public class Book {
    private String name; //书名
    private String author; //作者
    private double price; //价格
    private String type; //类型
    private boolean isBorrowed; //是否借出

    //构造方法，在创建图书的时候就是未借出（false）可以不用传 isBorrowed 参数
    public Book(String name, String author, String type,double price) {
        this.name = name;
        this.author = author;
        this.type = type;
        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 double getPrice() {
        return price;
    }
    //设置价格
    public void setPrice(double price) {
        this.price = price;
    }
    //获取价格
    public String getType() {
        return type;
    }
    //设置价格
    public void setType(String type) {
        this.type = type;
    }
    //获取图书是否被借出信息（初始值为 false -> 未被借出）
    public boolean isBorrowed() {
        return isBorrowed;
    }
    //设置图书是否被借出信息（如果被借出就改为true）
    public void setBorrowed(boolean borrowed) {
        isBorrowed = borrowed;
    }

    @Override
    //重写 toString 方法,打印图书的具体信息。
    //如果不重写，则会调用java中自己的toString方法（打印出来的是对象的地址）
    public String toString() {
        return "Book{" +
                "  书名：'" + name + '\'' +
                ", 作者：'" + author + '\'' +
                ", 价格：'" + price +'\'' +
                ", 类型：'" + type + '\'' +
                ", " + ((isBorrowed==true)? "已借出" :  "未借出") +
                '}';
    }
}

🍓创建 BookList 类, 用来保存 N 本书

BookList.java

public class BookList {
    //顺序表（数组）
    private Book[] books = new Book[10];

    //数组的有效数据个数，记录图书的数量
    private int userSize; 

    //在构造方法中先存储三本书的信息
    public BookList() {
        books[0] = new Book("西游记","吴承恩",57.9,"小说");
        books[1] = new Book("三国演义","罗贯中",85.9,"小说");
        books[2] = new Book("水浒传","施耐庵",77.9,"小说");
        books[3] = new Book("红楼梦","曹雪芹",65.9,"小说");
        this.userSize = 3;
    }

    //获取数组的大小
    public int getUserSize() {
        return userSize;
    }

    //设置数组的大小（新增图书或删除图书，数组的大小都要被改变）
    public void setUserSize(int userSize) {
        this.userSize = userSize;
    }

    /**
     * 获取 pos 位置的一本书
     * @param pos
     * @return
     */
    public Book getPos(int pos){
        if(pos<0 || pos>this.userSize){
            System.out.println("位置不合法");
            return null;
        }
            return this.books[pos];
    }

    /**
     * 在 pos 位置添加一本书
     * @param pos
     * @param book
     */
    public void setBook(int pos,Book book){
        this.books[pos] = book;
    }
}

🍓创建相关操作的类

1、创建 package operation

2、创建相关的操作类, 每个类对应一个用户的动作

AddOperation：增加图书
DelOperation：删除图书
FindOperation：查找图书
DisplayOperation：打印图书
BorrowOperation：借阅图书
ReturnOperation：归还图书
ExitOperation：退出系统

IOperation.java （接口）

package operation;

import book.BookList;

import java.util.Scanner;

public interface IOperation {
    void work(BookList bookList);
    //因为在每个操作类中都要输入数据，所以将 scanner 引用定义在接口中
    Scanner scanner = new Scanner(System.in);
}

AddOperation.java

package operation;

public class AddOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("新增图书！");
    }
}

DelOperation.java

package operation;

public class DelOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("删除图书！");
    }
}

FindOperation.java

package operation;

public class FindOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("查找图书！");
    }
}

DisplayOperation.java

package operation;

public class DisplayOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("显示图书！");
    }
}

BorrowOperation.java

package operation;

public class BorrowOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("借阅图书！");
    }
}

ReturnOperation.java

package operation;

public class ReturnOperation implements IOperation{
    @Override
    public void work(BookList bookList) {
        System.out.println("归还图书！");
    }
}

ExitOperation.java

package operation;

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

🍓创建用户相关的类

1、创建 package user

2、因为管理员和用户有很多共性，所以创建 User 父类, 管理员类与普通用户类继承 User 类。

3、每个子类需要做两件事情：

初始化对应的操作数组
实现 Menu 菜单

User.java

package user;

import book.BookList;
import operation.IOperation;

public  abstract class User {
    //使用者姓名
    protected String name;
    //创建使用者操作数组，数组中存储相关操作的功能
    protected IOperation[] operations; 
    
    public User(String name) {
        this.name = name;
    }
    //子类继承父类的方法，打印菜单
    public abstract int Menu();

    //根据用户选项，执行对应的操作
    public void doWork(int choice, BookList bookList){
        operations[choice].work(bookList);
    }
}

AdminUser.java

package user;

import operation.*;

import java.util.Scanner;

//管理员
public class AdminUser extends User {
    public AdminUser(String name){
        super(name);
        this.operations = new IOperation[]{
                new ExitOperation(),
                new FindOperation(),
                new AddOperation(),
                new DelOperation(),
                new DisplayOperation()
        };
    }
    public int Menu(){
        System.out.println("=========管理员菜单=========");
        System.out.println("欢迎 " + 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("==========================");
        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;
    }
}

NomalUser.java

package user;

import operation.*;

import java.util.Scanner;
//普通用户
public class NormalUser extends User{
    public NormalUser(String name) {
        super(name);
        this.operations = new IOperation[]{
               new ExitOperation(),
               new FindOperation(),
               new BorrowOperation(),
               new ReturnOperation()
        };
    }

    public int Menu(){
        System.out.println("=========普通用户菜单=========");
        System.out.println("欢迎 " + this.name + " 使用图书管理系统");
        System.out.println("1. 查找图书");
        System.out.println("2. 借阅图书");
        System.out.println("3. 归还图书");
        System.out.println("0. 退出系统");
        System.out.println("===========================");
        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;
    }
}

四、进行整合

🎄创建 Main 类和 main 方法, 搭建整体逻辑

1、创建登录方法

输入姓名，选择身份。
登录成功后，返回选择的身份的对象。所以登录的方法（login）返回类型为User
通过向上转型调用登录方法，引用哪个对象，取决于返回的是哪个对象。
通过动态绑定调用子类的菜单，返回的是哪个对象，就调用哪个对象的菜单。

import user.AdminUser;
import user.NormalUser;
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.表示管理员，0.表示普通用户）");
        int choice = scanner.nextInt();

        //根据choice的值，实例化不同的对象
        if(choice==1){
            /*  向上转型
            User user = new AdminUser(name);
            return user;*/
            return new AdminUser(name);
        }else {
            /*   向上转型
            User user = new NormalUser(name);
            return user;*/
            return new NormalUser(name);
        }
    }
    public static void main(String[] args) {
            User user = login(); //向上转型
            user.Menu(); //动态绑定（菜单）
    }
}

运行结果

打印完菜单后，根据菜单的内容输入相应数字调用对应的操作。
在User父类中定义一个 IOperation 类型的数组，在子类中对 IOperation 数组实例化。
在User父类中写一个doWork方法，在main方法中通过数组下标来获取对应的操作，实现相应的功能。

五、实现具体的每个操作类并完善Main类中的main方法