【面向对象项目之图书馆管理系统】

项目需求

不同的用户有不同的菜单，然后进行操作。 

设计思路

通过需求我们可以提取图书类，书架类
图书类存放图书的基本信息，书架类存放书本及其它的数量，以及操作图书的方法等等。
接口类（用来操作书架里面的图书）-》写具体的操作实现类

其次提取出用户类，用户类分为普通用户类 和 管理员类

基本框架代码：

package book;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-16 - 11 - 16 - 20:59
 * @Description: com.bookmanagement.book
 * @version: 1.0
 */
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) {//这里没构造isBorrowed是因为它的默认值是false，意味着刚开始书都是未被借出的
        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=" + isBorrowed +
                '}';
    }
}

package book;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-17 - 11 - 17 - 23:55
 * @Description: com.bookmanagement.book
 * @version: 1.0
 */
public class BookList {//书架类
    public static final int DEFAULT_SIZE = 10;
    private Book[] books = new Book[DEFAULT_SIZE];
    private int usedSize;//当前books数组当中的数量
    
    public int getUsedSize() {
        return usedSize;
    }
    public void setUsedSize(int usedSize) {
        this.usedSize = usedSize;
    }
}

package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:37
 * @Description: operate
 * @version: 1.0
 */
public interface Ioperation {//图书的操作接口
    void work(BookList bookList);//操作书架类中的书数组
}

package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:48
 * @Description: operate
 * @version: 1.0
 */
public class AddOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("新增图书！");
    }
}

package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:53
 * @Description: operate
 * @version: 1.0
 */
public class BrrowOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("借阅图书！");
    }
}

package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:50
 * @Description: operate
 * @version: 1.0
 */
public class DeleteOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("删除图书！");
    }
}

package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:51
 * @Description: operate
 * @version: 1.0
 */
public class ExitOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("退出系统！");
    }
}

package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:49
 * @Description: operate
 * @version: 1.0
 */
public class FindOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("查找图书！");
    }
}

package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:52
 * @Description: operate
 * @version: 1.0
 */
public class ReturnOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("归还图书！");
    }
}

package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:51
 * @Description: operate
 * @version: 1.0
 */
public class ShowOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("显示图书！");
    }
}

package user;
import book.BookList;
import operate.Ioperation;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:34
 * @Description: user
 * @version: 1.0
 */
public abstract class User {
    protected String name;
    protected Ioperation[] ioperations;//操作方法的接口数组，存放操作方法的实现类
    public User(String name) {
        this.name = name;
    }
    //因为菜单在这儿不需要具体的实现，所以将菜单定义为抽象方法，自然User也变成了抽象类
    public abstract int menu();
    //通过用户的选择，来实现不同的操作，调用接口数组里面的操作实现类的方法
    public void doWork(int choice, BookList bookList) {
        this.ioperations[choice].work(bookList);//通过接口数组下标得到具体的操作实现类，再调用操作类的方法
    }
}

package user;
import operate.*;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:35
 * @Description: user
 * @version: 1.0
 */
public class NormalUser extends User {
    public NormalUser(String name) {
        super(name);
        /*this.ioperations = new Ioperation[4];
        ioperations[0] = new ExitOperation();
        ioperations[1] = new FindOperation();
        ioperations[2] = new BrrowOperation();
        ioperations[3] = new ReturnOperation();*/
        //动态初始化接口数组的变量  （接口数组存放操作的实现类）
        this.ioperations = new Ioperation[]{
                new ExitOperation(),
                new FindOperation(),
                new BrrowOperation(),
                new ReturnOperation()
        };
    }
    @Override
    public int menu() {
        System.out.println("❀❀*********❀❀❀**********❀❀");
        System.out.println("hello🌻 " + 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;
    }
}

package user;
import operate.*;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:34
 * @Description: user
 * @version: 1.0
 */
public class AdminUser extends User {
    public AdminUser(String name) {
        super(name);
        this.ioperations = new Ioperation[]{
                new ExitOperation(),
                new FindOperation(),
                new AddOperation(),
                new DeleteOperation(),
                new ShowOperation()
        };
    }
    @Override
    public int menu() {//因为要根据不同的输入，做不同的操作，所以返回值用int接受
        System.out.println("❀❀*********❀❀❀**********❀❀");
        System.out.println("hello🌻 " + 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;
    }
}

import book.BookList;
import user.AdminUser;
import user.NormalUser;
import user.User;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 9:53
 * @Description: PACKAGE_NAME
 * @version: 1.0
 */
public class Main {
    public static User login() {//父类当作方法的返回值，返回的是一个具体的子类对象（向上转型）
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的姓名：");
        String name = scanner.nextLine();
        System.out.println("请输入你的身份：1-》管理员 0-》普通用户");
        int choice = scanner.nextInt();
        if (1 == choice) {
            return new AdminUser(name);
        } else {
            return new NormalUser(name);
        }
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        BookList bookList = new BookList();
        User user = login();//根据返回的不同用户，调用不同的菜单
        while (true) {
            int choice = user.menu();//接受操作数，根据操作数调用不同的操作方法
            //根据 choice 和 user 来确定调用哪个对象的哪个操作
            user.doWork(choice, bookList);
        }
    }
}

此时的框架已经搭建好了，只需要写具体操作实现类的业务逻辑。

Book类的toString方法修改：

BookList类新增getBook方法： 

ShowOperation类修改：

ExitOperation类修改： 

FindOperation类修改： 

BookList类新增setBook方法：

AddOpration类：

BookLisk类重载setBook方法：

DeleteOperation类：

 

BorrowOperation类： 

 

ReturnOperation类：

最终代码

package book;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-16 - 11 - 16 - 20:59
 * @Description: book
 * @version: 1.0
 */
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) {//这里没构造isBorrowed是因为它的默认值是false，意味着刚开始书都是未被借出的
        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=" + isBorrowed +
                (isBorrowed == false ? " 未被借出" : " 已被借出") +
                '}';
    }
}

package book;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-17 - 11 - 17 - 23:55
 * @Description: book
 * @version: 1.0
 */
public class BookList {//书架类
    public static final int DEFAULT_SIZE = 10;
    private Book[] books = new Book[DEFAULT_SIZE];
    private int usedSize;//当前books数组当中的数量
    public BookList() {
        books[0] = new Book("数据结构", "张三", 40, "计算机类");
        books[1] = new Book("计算机组成原理", "李四", 45, "计算机类");
        books[2] = new Book("操作系统", "王五", 50, "计算机类");
        books[3] = new Book("计算机网络", "themyth", 35, "计算机类");
        books[4] = new Book("Java程序设计", "Holis", 25, "计算机类");
        this.usedSize = 5;
    }
    //因为存放Book类的数组是被封装的，所以要提供方法来获取书，通过下标pos得到具体的一本书
    public Book getBook(int pos) {
        return this.books[pos];//返回的是下标为pos的书
    }
    //在书架的最后一本书位置后面接着存放一本书
    public void setBook(Book book) {
        this.books[usedSize] = book;//[0, usedSize - 1]这个区间是原来每本书的下标
    }
    //在书架的指定位置增加一本书
    public void setBook(int pos, Book book) {
        this.books[pos] = book;
    }
    public int getUsedSize() {
        return usedSize;
    }
    public void setUsedSize(int usedSize) {
        this.usedSize = usedSize;
    }
}

package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:37
 * @Description: operate
 * @version: 1.0
 */
public interface Ioperation {//图书的操作接口
    void work(BookList bookList);//操作书架类中的书数组
}

package operate;
import book.Book;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:51
 * @Description: operate
 * @version: 1.0
 */
public class ShowOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("显示图书！");
        int currentSize = bookList.getUsedSize();//得到书架类当前书的数量
        for (int i = 0; i < currentSize; i++) {
            //System.out.println(bookList[i]);bookList只是一个引用，不是数组
            Book book = bookList.getBook(i);//通过下标的变换，得到不同的书
            System.out.println(book);//因为这里重写了toString，可以直接打印书的详细信息
        }
    }
}

package operate;
import book.BookList;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:51
 * @Description: operate
 * @version: 1.0
 */
public class ExitOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("退出系统！");
        System.exit(0);//退出JVM
    }
}

package operate;
import book.Book;
import book.BookList;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:49
 * @Description: operate
 * @version: 1.0
 */
public class FindOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("查找图书！");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你要查找的书名：");
        String findBookName = scanner.nextLine();
        int currentSize = bookList.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book book = bookList.getBook(i);
            if (findBookName.equals(book.getName())) {
                System.out.println("找到了这本书！");
                System.out.println(book);
                return;
            }
        }
        System.out.println("查无此书！");
    }
}

package operate;
import book.Book;
import book.BookList;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:48
 * @Description: operate
 * @version: 1.0
 */
public class AddOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("新增图书！");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入书名：");
        String addBookName = scanner.nextLine();
        System.out.println("请输入作者：");
        String author = scanner.nextLine();
        System.out.println("请输入价格：");
        int price = scanner.nextInt();
        System.out.println("请输入类型：");
        String type = scanner.next();//注意这儿不能用nextLine()，因为会读取上面的回车符，导致不能录入类型
        Book book = new Book(addBookName, author, price, type);
        int currentSize = bookList.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book tmpBook = bookList.getBook(i);
            if (addBookName.equals(tmpBook.getName())) {
                System.out.println("已经有这本书了，不能存入了！");
                return;
            }
        }
        bookList.setBook(book);
        //修改usedSize
        bookList.setUsedSize(currentSize + 1);
    }
}

package operate;
import book.Book;
import book.BookList;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:50
 * @Description: operate
 * @version: 1.0
 */
public class DeleteOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("删除图书！");
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要删除的书名：");
        String deleteBookName = scanner.nextLine();
        int index = -1;
        int currentSize = bookList.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book tmpBook = bookList.getBook(i);
            if (deleteBookName.equals(tmpBook.getName())) {
                index = i;
                break;
            }
        }
        if (index != -1) {
            for (int j = index; j < currentSize - 1; j++) {//j <= currentSize - 2
                //bookList[j] = bookList[j + 1];
                Book book = bookList.getBook(j + 1);
                bookList.setBook(j, book);
            }
            //书本数量减少一本
            bookList.setUsedSize(currentSize - 1);
            //因为删除的是对象，要把最后一个元素置为null
            bookList.setBook(currentSize - 1, null);
            System.out.println("删除成功！");
        } else {
            System.out.println("这本书不存在，无法删除！");
        }
    }
}

package operate;
import book.Book;
import book.BookList;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:53
 * @Description: operate
 * @version: 1.0
 */
public class BrrowOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("借阅图书！");
        System.out.println("输入你要借阅的图书：");
        Scanner scanner = new Scanner(System.in);
        String borrowBookName = scanner.nextLine();
        int currentSize = bookList.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book tmpbook = bookList.getBook(i);
            if (borrowBookName.equals(tmpbook.getName()) && !tmpbook.isBorrowed()) {//tmpbook.isBorrowed() == false
                tmpbook.setBorrowed(true);
                System.out.println("借阅成功！");
                return;
            }
            /*if (borrowBookName.equals(bookList.getBook(i).getName()) && !bookList.getBook(i).isBorrowed()) {
                bookList.getBook(i).setBorrowed(true);
                System.out.println("借阅成功！");
            }*/
        }
        System.out.println("没有这本书！");
    }
}

package operate;
import book.Book;
import book.BookList;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:52
 * @Description: operate
 * @version: 1.0
 */
public class ReturnOperation implements Ioperation {
    @Override
    public void work(BookList bookList) {
        System.out.println("归还图书！");
        System.out.println("输入你要归还的图书：");
        Scanner scanner = new Scanner(System.in);
        String returnBookName = scanner.nextLine();
        int currentSize = bookList.getUsedSize();
        for (int i = 0; i < currentSize; i++) {
            Book tmpbook = bookList.getBook(i);
            if (returnBookName.equals(tmpbook.getName()) && tmpbook.isBorrowed()) {//tmpbook.isBorrowed() == ture
                tmpbook.setBorrowed(false);
                System.out.println("归还成功！");
                return;
            }
        }
    }
}

package user;
import book.BookList;
import operate.Ioperation;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:34
 * @Description: user
 * @version: 1.0
 */
public abstract class User {
    protected String name;
    protected Ioperation[] ioperations;//接口数组存放操作的实现类
    public User(String name) {
        this.name = name;
    }
    //因为菜单在这儿不需要具体的实现，所以将菜单定义为抽象方法，自然User也变成了抽象类
    public abstract int menu();
    //通过用户的选择，来实现不同的操作，调用接口数组里面的操作实现类的方法
    public void doWork(int choice, BookList bookList) {
        this.ioperations[choice].work(bookList);//通过接口数组下标得到具体的操作实现类，再调用操作类的方法
    }
}

package user;
import operate.*;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:35
 * @Description: user
 * @version: 1.0
 */
public class NormalUser extends User {
    public NormalUser(String name) {
        super(name);
        /*this.ioperations = new Ioperation[4];
        ioperations[0] = new ExitOperation();
        ioperations[1] = new FindOperation();
        ioperations[2] = new BrrowOperation();
        ioperations[3] = new ReturnOperation();*/
        //动态初始化接口数组的变量  （接口数组存放操作的实现类）
        this.ioperations = new Ioperation[]{
                new ExitOperation(),
                new FindOperation(),
                new BrrowOperation(),
                new ReturnOperation()
        };
    }
    @Override
    public int menu() {
        System.out.println("❀❀*********❀❀❀**********❀❀");
        System.out.println("hello🌻 " + 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;
    }
}

package user;
import operate.*;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 0:34
 * @Description: user
 * @version: 1.0
 */
public class AdminUser extends User {
    public AdminUser(String name) {
        super(name);
        this.ioperations = new Ioperation[]{
                new ExitOperation(),
                new FindOperation(),
                new AddOperation(),
                new DeleteOperation(),
                new ShowOperation()
        };
    }
    @Override
    public int menu() {//因为要根据不同的输入，做不同的操作，所以返回值用int接受
        System.out.println("❀❀*********❀❀❀**********❀❀");
        System.out.println("hello🌻 " + 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;
    }
}

import book.BookList;
import user.AdminUser;
import user.NormalUser;
import user.User;
import java.util.Scanner;
/**
 * @Auther: TheMyth
 * @Date: 2022-11-18 - 11 - 18 - 9:53
 * @Description: PACKAGE_NAME
 * @version: 1.0
 */
public class Main {
    public static User login() {//父类当作方法的返回值，返回的是一个具体的子类对象（向上转型）
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的姓名：");
        String name = scanner.nextLine();
        System.out.println("请输入你的身份：1-》管理员 0-》普通用户");
        int choice = scanner.nextInt();
        if (1 == choice) {
            return new AdminUser(name);
        } else {
            return new NormalUser(name);
        }
    }
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        BookList bookList = new BookList();
        User user = login();//根据返回的不同用户，调用不同的菜单
        while (true) {
            int choice = user.menu();//接受操作数，根据操作数调用不同的操作方法
            //根据 choice 和 user 来确定调用哪个对象的哪个操作
            user.doWork(choice, bookList);
        }
    }
}