[java篇]圖書管理系統，是你的期末大作業嗎？

圖書管理系統框架一覽圖

整體思想：

我們在敲代碼之前先構思一下，即然要實作圖書系統，那么就要有書，而圖書館里又不只有一本書，所以我們要出創建一個書架，存放所有的書，
當我們說到用戶了，用戶分為圖書管理員和普通用戶，而這兩個用戶又隸屬于一個父類user類，因為我們在呼叫功能的時候普通用戶和管理員有著相同的功能，
功能：我們創建一個功能介面，讓每個具體功能都實作功能介面中的抽象方法，
Main類：創建登錄方法，通過個人選擇，去選擇普通用戶選單，還是管理員選單，然后通過選單回傳要具體實作的功能，呼叫Operation包下的某個功能類

• 創建一個書類：里面的屬性包括：書名，作者，書的型別，價格，此書有沒有被借出
• 創建一個書架：里面包含所有的書，還有一些具體方法
• 在User包下，創建兩個類，分別是customer類，和Librarian類，都繼承了user類，分別在兩個子類中實作各自的選單，

Book包

Book類

在Book類中，實作封裝書的屬性，依次為 書名，作者，書的特性，價格，此書是否被借出，

package Book;
public class Book {
    //創建書的屬性
    //包括 書名 作者 種類 價格 是否借出
    private String name;
    private String author;
    private String type;
    private int price;
    private boolean isLent;
    //實作書的構造方法
    public Book(String name, String author, String type, int price) {
        this.name = name;
        this.author = author;
        this.type = type;
        this.price = price;
    }
    //實作setter 和 getter 方法 以便在其他類中呼叫書的屬性

    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 getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public int getPrice() {
        return price;
    }

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

    public boolean isLent() {
        return isLent;
    }

    public void setLent(boolean lent) {
        isLent = lent;
    }
    //重寫toString()方法

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

BookList類

實作書架，在這里創建一個Book陣列，存放全部的書，和一些方法的實作

 public class BookList {
    //實作書架
    //其實在整個圖書管理系統中，都是對書架的操作
    public Book []books = new Book[10];//先初始化書的書目為10本，其實我們在這里還可以實作擴容
    private int useSize;
    public BookList(){
        this.books[0] = new Book("水滸傳","施耐庵","小說",45);
        this.books[1] = new Book("三國演義","羅貫中","小說",40);
        this.books[2] = new Book("西游記","吳承恩","小說",39);
        this.books[3] = new Book("紅樓夢","曹雪芹","小說",50);
        this.useSize = 4; //現在具體書被初始化的有4本
    }

    public int getUseSize() { //獲得書的書目
        return useSize;
    }

    public void setUseSize(int useSize) { //設定書的書目
        this.useSize = useSize;
    }
    public Book getPos(int size){ //得到對應下標的某本書
        return books[size];
    }
    public void setBook(Book book,int size){ //設定在某個下標有某本書
         books[size] = book;
    }
    public Book getBook(int size){ //得到對應下標的某本書
        return books[size];
    }
}

User包

普通用戶Customer類

在Customer類中，他繼承了user類，擁有了user類中的屬性，先呼叫父類中的構造方法，然后在選單中列印出各個功能的編號，并且在子類中的構造方法中實作一個功能陣列，這個陣列的每個元素為對應選單中的功能的物件，
最后回傳選擇后的功能下標，

 package User;
import Operation.*;
import java.util.Scanner;
public class Customer extends user {
    //呼叫父類的構造方法
    public Customer(String name){
        super(name);
        this.iOperations = new IOperation[]{
                new ExitOperation(),
                new IsLentOperation(),
                new ReturnOperation(),
                new FindOperation()
        };
    }
    public int menu(){
        System.out.println("hello" + this.name + "歡迎來到圖書管理系統");
        System.out.println("============= 普通用戶選單 ==============");
        System.out.println("1.借閱圖書");
        System.out.println("2.歸還圖書");
        System.out.println("3.查找圖書");
        System.out.println("0.退出系統");
        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;
    }
}

管理員Librarian類

和普通用戶一樣，先呼叫父類中的構造方法，作為子類擁有父類中的所有屬性(除private修飾外),在子類的構造方法中創建功能陣列，陣列中的每個元素都是對應專屬管理員執行的功能物件，然后列印管理員選單，最后回傳功能選擇，

 package User;
import Operation.*;
import java.util.Scanner;
public class Librarian extends user{
    public Librarian(String name){
        super(name);
        this.iOperations = new IOperation[]{
                new ExitOperation(),
                new AddOperation(),
                new RemoveOperation(),
                new FindOperation(),
                new DisplayOperation(),
                new ArrangeOperation()
        };
    }
    public int menu(){
        System.out.println("hello" + this.name + "歡迎來到圖書管理系統");
        System.out.println("=============  管理員選單 ==============");
        System.out.println("1.新增圖書");
        System.out.println("2.洗掉圖書");
        System.out.println("3.查找圖書");
        System.out.println("4.顯示圖書");
        System.out.println("5.整理圖書");
        System.out.println("0.退出系統");
        Scanner scanner = new Scanner(System.in);
        int choice = scanner.nextInt();
        return choice;//回傳功能下標
    }
}

用戶(user)類—父類

在父類user類，先封裝一個屬性，即用戶的名字，然后通過構造方法對這個屬性進行初始化，我們現在可以使用abstract來修飾父類，在父類中的所有抽象方法，都要在子類中被重寫，我們在父類中寫一個抽象方法為void menu()方法，當呼叫我們選擇的功能下標時，我們可以直接呼叫父類中的menu方法，實作向上轉型，動態系結，

 package User;
import Book.BookList;
import Operation.IOperation;
public  abstract class user {
    //因為用戶包含有兩類
    protected String name;
    public user(String name){
        this.name = name;
    }
    //實作選單
    public  abstract int menu();
    protected  IOperation []iOperations; //創建一個功能陣列
    public void doOperation(int choice,BookList bookList){ //操作功能陣列，并且呼叫功能包中的類中的被重寫的方法，
            iOperations[choice].work(bookList);
    }
}

功能包-- Operation包

創建介面–IOperation介面

創建一個介面，讓其他類實作介面中的抽象方法

 package Operation;
import Book.BookList;
public interface IOperation  {
    void work(BookList bookList);
}

新增圖書–AddOperation

首先在原有的書籍中查找有沒有你要添加的圖書，如果有就提示你此書已經存在，你無需添加，在查找有沒有這本書的時候我們需要遍歷原書架上的所有書籍，所以我們要在BookList類中實作一個方法得到所有的書，如果在原有的書籍中沒有找到你要添加的這本書，那么接在原來書架的末尾，添加上這本書(呼叫BookList類中的setBook()方法)，最后把書的個數加一(呼叫BookList類中的getsueSize()方法)，

 package Operation;
import Book.Book;
import Book.BookList;
import java.util.Scanner;
public class AddOperation implements IOperation{
    public void work(BookList bookList){
        System.out.println("新增圖書");
        System.out.println("請輸入書名");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        System.out.println("請輸入書的作者");
        String author = scanner.nextLine();
        System.out.println("請輸入圖書的型別");
        String type = scanner.nextLine();
        System.out.println("請輸入圖書的價格");
        int price = scanner.nextInt();
        Book book = new Book(name,author,type,price);
        //在原有的書籍中查找是否已經存在了要添加的這本書
        //得到書的每下標

        for(int i = 0;i < bookList.getUseSize();i++) {
            Book book1 = bookList.getPos(i);
            if (name.equals(book1.getName())){
                System.out.println("此書已經存在，無需添加");
                return;
            }
        }
        bookList.setBook(book,bookList.getUseSize()); //把這本書添加到書架的末尾
        bookList.setUseSize(bookList.getUseSize()+1); //書的書目加1
        System.out.println("添加成功");
    }
}

洗掉圖書–RemoveOperation

首先輸入你要洗掉的圖書，看書架上有沒有這本書，如果沒有就提示書庫中沒有你要洗掉的書，如果書架上有，那么就讓要洗掉的這本書的后一本書去覆寫將要洗掉的這本書，即[i] = [i+1].最后在原有的書架上的圖書個數減一，

 package Operation;
import Book.Book;
import Book.BookList;
import java.util.Scanner;
public class RemoveOperation implements IOperation{
    public void work(BookList bookList){
        System.out.println("洗掉圖書");
        System.out.println("請輸入洗掉的書名");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        int pos = -1;
        for(int i = 0;i<bookList.getUseSize();i++){
            Book book = bookList.getPos(i);
            if(book.getName().equals(name)) {
             pos = 1;
            }
        }
        if(pos == 1){
        //進行洗掉
            for(int i = pos;i<bookList.getUseSize() - 1;i++){
                Book book = bookList.getPos(i+1);
                bookList.setBook(book,i);
            }
            bookList.setUseSize(bookList.getUseSize() - 1);
            System.out.println("洗掉成功");
        }else{
            System.out.println("沒有你要洗掉的圖書");
        }
    }
}

查找圖書–FindOperation

 package Operation;
import Book.Book;
import Book.BookList;
import java.util.Scanner;
public class FindOperation implements IOperation{
    public void work(BookList bookList){
        System.out.println("查找圖書");
        System.out.println("請輸入你要查找的書籍");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        for(int i = 0;i<bookList.getUseSize();i++){
            Book book = bookList.getPos(i);
            if(book.getName().equals(name)){
                System.out.println("已經找到");
                System.out.println(book);
                return;
            }
        }
        System.out.println("找不到");
    }
}

顯示圖書–DisplayOperation

 package Operation;
import Book.Book;
import Book.BookList;
public class DisplayOperation implements IOperation{
    public void work(BookList bookList){
        System.out.println("顯示所有圖書");
        if(bookList.getUseSize() == 0){
            System.out.println("書庫無書");
            return;
        }
         for(int i = 0;i<bookList.getUseSize();i++){
             System.out.println(bookList.getBook(i));
         }
    }
}

整理圖書–ArrangeOperation

在整理圖書的時候，博主設計了你要按怎樣的方式進行整理，是書名，作者，型別，還是價格，這讓我們不由的想到了上一篇博主介紹的Comparator介面，分別實作各自的構造器，，然后通過Arrays.sort()方法，對所有的書籍進行排序，在這里我們一定要格外的關注Arrays.sort(),方法中要傳兩個引數，第一個是你要對什么進行排序，簡單的說也就是一個陣列，例如我們現在要傳的第一個引數就要是一個書籍陣列，把所有的書籍整成一個陣列，然后傳進去，第二個引數是你實作的比較器類的物件，
在這里一共要建4個比較器，我們可以將它們整成陣列，

Comparator []comparators;

書名比較器：

 class NameComparator implements Comparator<Book>{
    public int compare(Book book1,Book book2){
        return book1.getName().compareTo(book2.getName());
    }
}

作者比較器：

 class AuthorComparator implements Comparator<Book>{
    public int compare(Book book1,Book book2){
        return book1.getAuthor().compareTo(book2.getAuthor());
    }
}

特性比較器：

 class TypeComparator implements Comparator<Book>{
    public int compare(Book book1,Book book2){
        return book1.getType().compareTo(book2.getType());
    }
}

價格比較器：

 class PriceComparator implements Comparator<Book>{
    public int compare(Book book1,Book book2){
        return book1.getPrice() - book2.getPrice();
    }
}

注意：在實作介面的時候，我們一定要注意Comparator<>里邊的泛型，他表示的是你要比較的東西的型別，

然后我們繼續實作操作介面，因為Arrays.sort()的第一個引數是一個關于書的陣列，所以我們要建立一個newBook陣列，存放所有的書籍，我們還應該注意，我們不能向Arrays.sort()里直接傳BookList.books因為它傳過去的還有為被初始化的書籍，所以我們要出進去的是已經被初始化好的，

 public class ArrangeOperation implements IOperation{
    public Book[] arrayBook(Book []books,int size){
        //把書架上的所有書籍全部轉移到另一個陣列中
        Book []books1 = new Book[size];
        for(int i = 0;i<size;i++){
            books1[i] = new Book(books[i].getName(),books[i].getAuthor(),books[i].getType(),books[i].getPrice());
        }
        return books1;
    }
    public void work(BookList bookList){
        System.out.println("你要怎樣整理？");
        System.out.println("0-->按書名整理  1-->按作者名字整理  2-->按書的價格整理 3-->按書的型別整理");
        Scanner scanner = new Scanner(System.in);
        Comparator []comparators = new Comparator[]{ //把構造器整成一個陣列
                new NameComparator(),
                new AuthorComparator(),
                new PriceComparator(),
                new TypeComparator()
        };
        int choice = scanner.nextInt();
        Book []newBooks arrayBook(bookList.books,bookList.getUseSize());
        Arrays.sort(newBooks,comparators[choice]);
        for(int i = 0;i<bookList.getUseSize();i++){ //顯示排序后的書
            System.out.println(newBooks[i]);
        }
        System.out.println("排序成功");
    }
}

借閱圖書–LentOperation

 package Operation;
import Book.Book;
import Book.BookList;
import java.util.Scanner;
public class IsLentOperation implements IOperation{
    public void work(BookList bookList){
        System.out.println("借出圖書");
        System.out.println("請輸入書名");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        for(int i = 0;i<bookList.getUseSize();i++){
            Book book = bookList.getPos(i);
            if(book.getName().equals(name)){
                book.setLent(true);
                System.out.println("借閱成功");
                return;
            }
        }
        System.out.println("圖書館沒有你要借的書，或者此書已被人借走");
    }
}

歸還圖書–ReturnOperation

 package Operation;
import Book.Book;
import Book.BookList;
import java.util.Scanner;
public class ReturnOperation implements IOperation{
    public void work(BookList bookList){
        System.out.println("歸還圖書");
        System.out.println("請輸入還書書名");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        for(int i = 0;i<bookList.getUseSize();i++){
            Book book = bookList.getPos(i);
            if(book.getName().equals(name)){
                book.setLent(false);
                return;
            }
        }
        System.out.println("還書失敗");
    }
}

Mian類–實作登錄，連接程式

在呼叫各個功能之前，我們首向要實作一個登陸頁面，
首先讓使用者，輸入自己的姓名，然后選擇管理員，還是普通用戶，根據不同的選擇呼叫不同的選單，

     //創建一個登陸頁面
    public  static  user login(){
        System.out.println("請輸入姓名");
        Scanner scanner = new Scanner(System.in);
        String name = scanner.nextLine();
        System.out.println("請選擇 0--> 管理員  1--> 普通用戶");
        int choice = scanner.nextInt();
        if(choice == 0){
            return new Librarian(name);
         }else{
            //呼叫普通用戶類
            return  new Customer(name);
        }
    }

然后連接代碼全部，第一步實作登陸頁面，第二步通過向上轉型，動態系結之后，回傳選擇之后的功能下標，然后根據功能下標，呼叫不同的功能方法來操作書架，

   public static void main(String[] args) {
        user user = login();
        BookList bookList = new BookList();
        while(true){
            int choice = user.menu();
            user.doOperation(choice,bookList);
        }
    }

總結

要實作一個普通的小專案，之前一定要有自己的結構框架，如何快速學習封裝繼承，和多型，老實人告訴你，多寫代碼，多練習！！！