• 简易版 图书管理系统

    目录

    1. Book包

    1.1 Book类

    1.2 BookList类

    2. User包

    2.1 User抽象类

    2.2 AdminUser类

    2.3  NormalUser类

    3. Operate包

    3.1 MyOperate接口

    3.2  AddOperation类

    3.3  DelOperation类

     3.4 ExitOperation

     3.5  FindOperation类

     3.6 ShowOperation类

     3.7 BorrowedOperation类

    3.8 ReturnOperation类

    4. Main类

    本章作为一个练习，对于前面学过的那些语法进行一个整合运用。

    语法方面主要包括：封装、继承、多态、抽象类和接口。

    首先，我们将整个系统分为4个包，

    分别是Book类用于封装书和书架的具体信息。

    Main包也就是封装主类，用于对整个系统的具体操作。

    Operate包用于封装具体的操作。

    User包用于管理用户信息。

    我们一个包一个包来讲解。

    1. Book包

    Book包分为两类，分别是书和书架。

    1.1 Book类

    该类主要是对书的一些基本信息进行封装，并且提供Getting和Setting方法。

    1. package Book;
    2.  
    3. public class Book {
    4.     private String name;//书名
    5.     private String author;//作者
    6.     private int price;//价格
    7.     private String type;//类型
    8.     private boolean isBorrowed;//是否被借出
    9.  
    10.     public Book(String name, String author, int price, String type) {
    11.         this.name = name;
    12.         this.author = author;
    13.         this.price = price;
    14.         this.type = type;
    15.     }
    16.  
    17.     public String getName() {
    18.         return name;
    19.     }
    20.  
    21.     public void setName(String name) {
    22.         this.name = name;
    23.     }
    24.  
    25.     public String getAuthor() {
    26.         return author;
    27.     }
    28.  
    29.     public void setAuthor(String author) {
    30.         this.author = author;
    31.     }
    32.  
    33.     public int getPrice() {
    34.         return price;
    35.     }
    36.  
    37.     public void setPrice(int price) {
    38.         this.price = price;
    39.     }
    40.  
    41.     public String getType() {
    42.         return type;
    43.     }
    44.  
    45.     public void setType(String type) {
    46.         this.type = type;
    47.     }
    48.  
    49.     public boolean isBorrowed() {
    50.         return isBorrowed;
    51.     }
    52.  
    53.     public void setBorrowed(boolean borrowed) {
    54.         isBorrowed = borrowed;
    55.     }
    56.  
    57.     @Override
    58.     public String toString() {
    59.         return "Book.Book{" +
    60.                 "name='" + name + '\'' +
    61.                 ", author='" + author + '\'' +
    62.                 ", price=" + price +
    63.                 ", type='" + type + '\'' +
    64.                 ", isBorrowed=" + isBorrowed +
    65.                 //", isBorrowed=" + isBorrowed +
    66.                 (isBorrowed  ? "  已经被借出" : "  未被借出") +
    67.                 '}';
    68.     }
    69. }

    1.2 BookList类

    书架的创建：

    包括了初始化，以及对一些书籍的基本操作。

    1. package Book;
    2.  
    3. public class BookList {
    4.     private Book[] books = new Book[10];//创建书架
    5.     private int usedSize;//记录书架上书的数量
    6.     public BookList() {//初始化3本书
    7.         books[0] = new Book("我们仨","杨绛",89,"文学");
    8.         books[1] = new Book("明朝那些事","当年明月",78,"历史");
    9.         books[2] = new Book("红楼梦","曹雪芹",49,"小说");
    10.         this.usedSize = 3;
    11.     }
    12.  
    13.     public Book[] getBooks() {
    14.         return books;
    15.     }
    16.  
    17.     public void setBooks(int pos,Book book) {
    18.         books[pos] = book;
    19.     }
    20.  
    21.     public int getUsedSize() {
    22.         return usedSize;
    23.     }
    24.  
    25.     public void setUsedSize(int usedSize) {
    26.         this.usedSize = usedSize;
    27.     }
    28.  
    29.     public Book getBook(int pos) {
    30.         return this.books[pos];
    31.     }
    32.  
    33.     //重写setBook方法作用于设置图书（增删）
    34.     public void setBook(Book book) {
    35.         this.books[usedSize] = book;
    36.     }
    37.     public void setBook(int pos,Book book) {
    38.         this.books[pos] = book;
    39.     }
    40. }

    2. User包

    User包被分为三类，其中User类是抽象类，用于管理人员类和普通用户类继承。

    AdminUser是管理类，NormalUser类是普通用户类。

    2.1 User抽象类

    因为对于不同的用户而言，他们的访问权限是不同的，所以需要将菜单抽象出来以示区分。

    另外就是基本信息。

    1. package User;
    2.  
    3. import Book.BookList;
    4. import Operate.MyOperate;
    5.  
    6. //抽象出menu()菜单方法
    7. public abstract class User {
    8.     //protected是访问权限，改为更大的也可以
    9.     protected String name;
    10.     protected MyOperate[] myOperate;//等会到Operate包再讲
    11.     //用户信息
    12.     public User(String name) {
    13.         this.name = name;
    14.     }
    15.     public abstract int menu();
    16.     //作用于main方法中对不同的用户进行区分
    17.     public void doWork(int choice, BookList bookList) {
    18.         this.myOperate[choice].work(bookList);
    19.     }
    20. }

    2.2 AdminUser类

    这里开辟的MyOperate数组是对管理人员的访问权限开辟空间，其中功能包括 退出，查找，增加，删除，显示。

    1. package User;
    2.  
    3. import Operate.*;
    4.  
    5. import java.util.Scanner;
    6.  
    7. public class AdminUser extends User {
    8.     //管理人员所拥有的访问权限
    9.     public AdminUser(String name) {
    10.         super(name);
    11.         this.myOperate = new MyOperate[]{
    12.                 new ExitOperation(),
    13.                 new FindOperation(),
    14.                 new AddOperation(),
    15.                 new DelOperation(),
    16.                 new ShowOperation(),
    17.         };
    18.     }
    19.     //管理人员拥有的权限
    20.     public int menu() {
    21.         System.out.println("*****************************************");
    22.         System.out.println("hello"+ name +"欢迎来到图书小小练习");
    23.         System.out.println("1：查找图书");
    24.         System.out.println("2：新增图书");
    25.         System.out.println("3：删除图书");
    26.         System.out.println("4：显示图书");
    27.         System.out.println("0：退出系统");
    28.         Scanner scanner = new Scanner(System.in);
    29.         int choice  = scanner.nextInt();
    30.         return choice;
    31.     }
    32. }

    2.3  NormalUser类

    这里开辟的MyOperate数组是对普通用户的访问权限开辟空间，其中功能包括 退出，查找，借书，还书。

    1. package User;
    2.  
    3. import Operate.*;
    4.  
    5. import java.util.Scanner;
    6.  
    7. public class NormalUser extends User {
    8.     //普通用户所拥有的访问权限
    9.     public NormalUser(String name) {
    10.         super(name);
    11.         this.myOperate = new MyOperate[]{
    12.                 new ExitOperation(),
    13.                 new FindOperation(),
    14.                 new BorrowedOperate(),
    15.                 new ReturnOperation(),
    16.         };
    17.     }
    18.     //普通用户拥有的权限
    19.     @Override
    20.     public int menu() {
    21.         System.out.println("****************************");
    22.         System.out.println("hello "+name+" 欢迎来到图书小练习");
    23.         System.out.println("1.查找图书！");
    24.         System.out.println("2.借阅图书！");
    25.         System.out.println("3.归还图书！");
    26.         System.out.println("0.退出系统！");
    27.         System.out.println("****************************");
    28.         System.out.println("请输入你的操作：");
    29.         Scanner scanner = new Scanner(System.in);
    30.         int choice = scanner.nextInt();
    31.         return choice;
    32.     }
    33. }

    3. Operate包

    Operate的各个操作，增、删、查、借书、还书、退出。

    我们 Operate包 将普通用户和管理员用户的具体实现操作类全写在Operate包 中。

    3.1 MyOperate接口

    MyOperate接口只设计好了各个Operation规范（方法）

    1. package Operate;
    2.  
    3. import Book.BookList;
    4.  
    5. public interface MyOperate {
    6.     public void work(BookList bookList);
    7. }

    3.2  AddOperation类

    本类用于添加书籍得基本信息，并且做了基本的判断。

    1. package Operate;
    2.  
    3. import Book.Book;
    4. import Book.BookList;
    5.  
    6. import java.util.Scanner;
    7.  
    8. public class AddOperation implements MyOperate {
    9.  
    10.     @Override
    11.     public void work(BookList bookList) {
    12.         System.out.println("新增图书");
    13.         Scanner scanner = new Scanner(System.in);
    14.         System.out.println("输入书名");
    15.         String name = scanner.nextLine();
    16.  
    17.         System.out.println("输入作者");
    18.         String author = scanner.nextLine();
    19.  
    20.         System.out.println("输入类型");
    21.         String type = scanner.nextLine();
    22.  
    23.         System.out.println("输入价格");
    24.         int price = scanner.nextInt();
    25.  
    26.         Book book = new Book(name, author, price, type);
    27.         //得到此时书架上书的数量
    28.         int currentSize = bookList.getUsedSize();
    29.         //遍历，查找是否想添加的书已经存在了
    30.         //默认添加在最后面
    31.         for (int i = 0; i < currentSize; i++) {
    32.             Book tmp = bookList.getBook(i);
    33.             if(tmp.getName().equals(name)) {
    34.                 System.out.println("已经存在这本书了，不能再放入了！");
    35.                 return;//如果存在即退出
    36.             }
    37.         }
    38.         //如果不存在即添加
    39.         bookList.setBook(book);
    40.         //每添加一本书下表向后移
    41.         bookList.setUsedSize(currentSize + 1);
    42.  
    43.     }
    44. }

    3.3  DelOperation类

    先上代码：

    1. package Operate;
    2.  
    3. import Book.Book;
    4. import Book.BookList;
    5.  
    6. import java.util.Scanner;
    7.  
    8. public class DelOperation implements MyOperate {
    9.     @Override
    10.     public void work(BookList bookList) {
    11.         System.out.println("删除图书！");
    12.         System.out.println("请输入你要删除图书的名字：");
    13.         Scanner scanner = new Scanner(System.in);
    14.         String name = scanner.nextLine();
    15.         //得到当前下标
    16.         int currentSize = bookList.getUsedSize();
    17.         int index = -1;
    18.         //遍历，tmp.getName().equals(name)为真即表示书架存在该书
    19.         //否则则该书不存在
    20.         for (int i = 0; i < currentSize; i++) {
    21.             Book tmp = bookList.getBook(i);
    22.             if (tmp.getName().equals(name)) {
    23.                 index = i;
    24.                 break;
    25.             }
    26.         }
    27.         //图示说明
    28.         for (int j = index; j < currentSize - 1; j++) {
    29.             Book book = bookList.getBook(j+1);
    30.             bookList.setBook(j,book);
    31.         }
    32.  
    33.         bookList.setUsedSize(currentSize - 1);
    34.         //删除对象，把最后一个设置为bull
    35.         bookList.setBook(currentSize - 1, null);
    36.     }
    37. }

    图示：

     假设currentSize 在这里，我们想要删掉该书，那么我们就将currentSize + 1 赋值给currentSize；

    接着currentSize向后走：

     重复上述操作：

    知道最后一个：

    直接将最后一个删除，毕竟每删除一个都需要将 书架上的书减少一本：

    这样也解释了为什么之前需要重写setBook（）方法。

     3.4 ExitOperation

    该类就只提供一个方法：exit（）

    1. import Book.BookList;
    2.  
    3. public class ExitOperation implements MyOperate {
    4.     @Override
    5.     public void work(BookList bookList) {
    6.         System.out.println("退出系统！");
    7.         System.exit(0);
    8.     }
    9. }

     为什么exit（）方法中的参数是0，因为我们正常退出是就是0：

     3.5  FindOperation类

    FindOperation类实现很简单，只需要提供书名再进行遍历，当然也可以根据价格、作者进行遍历。

    1. package Operate;
    2.  
    3. import Book.Book;
    4. import Book.BookList;
    5.  
    6. import java.util.Scanner;
    7.  
    8. public class FindOperation implements MyOperate{
    9.     @Override
    10.     public void work(BookList bookList) {
    11.         System.out.println("查找图书！");
    12.         System.out.println("请输入书名！");
    13.         Scanner scanner = new Scanner(System.in);
    14.         String name = scanner.nextLine();
    15.         //获取当前图书在书架得下标
    16.         int currentSize = bookList.getUsedSize();
    17.         //遍历
    18.         for (int i = 0; i < currentSize; i++) {
    19.             //System.out.println(bookList[i]);
    20.             Book book = bookList.getBook(i);
    21.             if (book.getName().equals(name)) {
    22.                 System.out.println("找到了这本书");
    23.                 System.out.println(book.toString());
    24.                 return;
    25.             }
    26.         }
    27.         System.out.println("没有找到"+name);
    28.     }
    29. }

     3.6 ShowOperation类

    遍历获取通过Getting方法打印即可。

    1. package Operate;
    2.  
    3. import Book.Book;
    4. import Book.BookList;
    5.  
    6. public class ShowOperation implements MyOperate {
    7.     @Override
    8.     public void work(BookList bookList) {
    9.         System.out.println("打印所有图书！");
    10.         int currentSize = bookList.getUsedSize();
    11.         for (int i = 0; i < currentSize; i++) {
    12.             Book book = bookList.getBook(i);
    13.             System.out.println(book);
    14.         }
    15.     }
    16. }

    以上便是管理员访问得全部权限，当然有需要还可以自己添加所需要的方法。

    后面得便是普通用户特有的权限，普通用户也有FindOperation、ShowOperation。

     3.7 BorrowedOperation类

    方法的逻辑很简单，只需稍加注意

    1. package Operate;
    2.  
    3. import Book.Book;
    4. import Book.BookList;
    5.  
    6. import java.util.Scanner;
    7.  
    8. public class BorrowedOperate implements MyOperate {
    9.     @Override
    10.     public void work(BookList bookList) {
    11.         System.out.println("借阅图书！");
    12.         System.out.println("请输入你要借阅的图书：");
    13.         Scanner scanner = new Scanner(System.in);
    14.         String name = scanner.nextLine();
    15.         //获取
    16.         int currentSize = bookList.getUsedSize();
    17.         //遍历
    18.         for (int i = 0; i < currentSize; i++) {
    19.             Book book = bookList.getBook(i);
    20.             //不仅需要判断书是否存在书架上，并且还需要判断是否已经借出
    21.             if (book.getName().equals(name) &&
    22.             book.isBorrowed() == false) {
    23.                 book.setBorrowed(true);
    24.                 System.out.println("借阅成功");
    25.                 return;
    26.             }
    27.         }
    28.     }
    29. }

    3.8 ReturnOperation类

    逻辑于BorrowedOperation类相似

    1. package Operate;
    2.  
    3. import Book.Book;
    4. import Book.BookList;
    5.  
    6. import java.util.Scanner;
    7.  
    8. public class ReturnOperation implements MyOperate {
    9.  
    10.     @Override
    11.     public void work(BookList bookList) {
    12.         System.out.println("归还图书！");
    13.         System.out.println("请输入你要归还的图书：");
    14.         Scanner scanner = new Scanner(System.in);
    15.         String name = scanner.nextLine();
    16.         int currentSize = bookList.getUsedSize();
    17.         for (int i = 0; i < currentSize; i++) {
    18.             Book book = bookList.getBook(i);
    19.             if (book.getName().equals(name) &&
    20.                     book.isBorrowed()) {
    21.                 book.setBorrowed(false);
    22.                 System.out.println("归还成功");
    23.                 return;
    24.             }
    25.         }
    26.     }
    27. }

    4. Main类

     Main类中只有一个类，主类，整个程序的入口。

    上代码：

    1. package Main;
    2.  
    3. import Book.BookList;
    4. import User.AdminUser;
    5. import User.User;
    6. import User.NormalUser;
    7. import java.util.Scanner;
    8.  
    9. public class Main {
    10.     //提供一个静态方法用于创建身份，是判断管理员还是普通用户
    11.     public static User login() {
    12.         System.out.println("请输入你的姓名");
    13.         Scanner scanner = new Scanner(System.in);
    14.         String name = scanner.nextLine();
    15.         System.out.println("输入你的身份 1 -> 管理员  2->普通用户");
    16.         int choice = scanner.nextInt();
    17.         if (choice == 1) {
    18.             return new AdminUser(name);
    19.         } else {
    20.             return new NormalUser(name);
    21.         }
    22.     }
    23.     public static void main(String[] args) {
    24.         BookList bookList = new BookList();
    25.         User user = login();
    26.         while (true) {
    27.             int choice = user.menu();
    28.             user.doWork(choice,bookList);
    29.         }
    30.     }
    31. }

    这里发生了一个向上转型：

     主方法的内容非常简单：

    1. 创建一个书架；

    2.通过登录方法确认用户信息；

    3.一个死循环，不停的使用“权限”，知道用户输入0退出。

    这里就体现了面向对象的思想，所有的过程全部封装完成，只对外提供了公开的方法。

    本章的思路都非常简单，只是有些地方需要稍加注意，本章的目的便是体验面向对象的思想。

    案例演示：

  • 相关阅读:
    称重系统为了做到无人，电气设备需要什么样控制要求
    python_data_analysis_and_mining_action-master-8
    【SpringCloud-学习笔记】Docker基本操作
    C++ STL进阶与补充（算法）
    VR结合｜山海鲸虚拟展厅解决方案
    【ansible问题处理】远程执行用户环境变量加载问题
    Jmeter 自动化性能测试常见问题汇总
    大白话理解-微信小程序的授权登录
    ZooKeeper学习笔记
    读写信号量
  • 原文地址：https://blog.csdn.net/weixin_67807492/article/details/127939657