devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

面向对象思想实现图书管理系统_现需要开发以“图书管理系统”,请采用第四章学习的面向对象方法进行设计,并提

作者：知新_RL | 2024-05-11 19:40:30

赞

踩

现需要开发以“图书管理系统”,请采用第四章学习的面向对象方法进行设计,并提

ps：

此工程分为四个包，分别是input（用于输入输出和给出提示信息），command（定义行为）,user（普通用户和管理员用户）和main（主函数）

  1. package 图书管理系统;
  2.  
  3. import 图书管理系统.book.BookStorage;
  4. import 图书管理系统.command.IExecutable;
  5. import 图书管理系统.input.Input;
  6. import 图书管理系统.input.QuitException;
  7. import 图书管理系统.user.User;
  8. import 图书管理系统.user.UserStorage;
  9.  
  10. public class Main {
  11.     // 由于输入过程，需要处理一些杂事
  12.     // 1) 打印提示信息
  13.     // 2) 读取用户输入
  14.     // 3) 用户有没有按 Ctrl + D 退出
  15.     // 直接封装一个对象去处理输入的问题
  16.     public static void main(String[] args) {
  17.         // 0. 实例化一个负责处理输入的对象
  18.         Input input = new Input();
  19.  
  20.         // 1. 我们的书架对象，在应用运行过程中，只需要一份
  21.         // 2. 改从文件中加载数据
  22.         BookStorage bookStorage = BookStorage.loadFromFile();
  23.  
  24.         try {
  25.             // 1. 用户登录
  26.             // 我们需要一个用户管理的对象，由该对象完成用户登录的具体操作
  27.             // 1.1. 要求用户输入
  28.             // 1.2. 判断用户角色 ...
  29.             UserStorage userStorage = new UserStorage();
  30.             User user = userStorage.login(input);
  31.  
  32.             // 2. 进入一个循环中
  33.             while (true) {
  34.                 // 2.1 打印用户角色对应的菜单，并且让用户选择
  35.                 // execute : 执行
  36.                 // executable : 具备可以执行的能力
  37.                 // IExecutable : 计划用接口去表示
  38.                 // command: 命令
  39.                 IExecutable command = input.menuAndSelect(user);
  40.                 // 2.2 根据用户的选择，执行对应的操作命令
  41.                 command.execute(bookStorage, user, input);
  42.             }
  43.         } catch (QuitException exc) {
  44.             // 用户要退出，我们什么都不做
  45.         }
  46.  
  47.         // 3. 用户退出，打印退出信息
  48.         System.out.println("欢迎下次使用");
  49.     }
  50. }

book包：

  1. package 图书管理系统.book;
  2.  
  3. import 图书管理系统.user.User;
  4.  
  5. public class Book implements Comparable {
  6.     public String name;
  7.     public String author;
  8.     public String type;
  9.     public int price;
  10.     public String borrowedBy;
  11.  
  12.     @Override
  13.     public int compareTo(Object o) {
  14.         Book b=(Book) o;
  15.         return name.compareTo(b.name);// 自然顺序是以书名为顺序
  16.         // 书名也是 String 类型，也得遵守对象的比较规则
  17.     }
  18.  
  19.     @Override
  20.     public String toString() {
  21.         //强行用StringBuilder
  22.         String.format("《%s》by %s,[%s],%d",name,author,type,price);
  23.         StringBuilder sb=new StringBuilder();
  24.         if (borrowedBy==null){
  25.             sb.append("可借用！");
  26.         }else {
  27.             sb.append("被");
  28.             sb.append(borrowedBy);
  29.             sb.append("借走了");
  30.         }
  31.         return sb.toString();
  32.     }
  33.  
  34.     public boolean isBorrowed(){
  35.         return borrowedBy==null;
  36.     }
  37.  
  38.     public boolean equalsByName(String name){
  39.         return this.name.equals(name);// 1. 也是为了封装，看起是一行一个方法
  40.         // 2. name 是 String 类型，判断相等性，也需要使用 equals 判断
  41.     }
  42.  
  43.     public void borrowed(User user){
  44.         borrowedBy=user.getUsername();
  45.     }
  46.  
  47.     @Override
  48.     public boolean equals(Object o) {
  49.         if (this == o) return true;
  50.         if (o == null || getClass() != o.getClass()) return false;
  51.         Book book = (Book) o;
  52.         return name.equals(book.name);
  53.     }
  54.  
  55.     public boolean isBorrowedBy(User user){
  56.         if (borrowedBy==null){
  57.             return false;
  58.         }
  59.         return borrowedBy.equals(user.getUsername());
  60.     }
  61.  
  62.     public void returned(User user){//换书操作
  63.         borrowedBy=null;
  64.     }
  65. }
  1. package 图书管理系统.book;
  2.  
  3. import java.io.File;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6. import java.io.PrintWriter;
  7. import java.lang.reflect.Array;
  8. import java.util.Arrays;
  9. import java.util.Scanner;
  10.  
  11. public class BookStorage {
  12.     private Book[] array;
  13.     private int size;
  14.  
  15.     public BookStorage(){
  16.         array=new Book[20];
  17.         size=0;
  18.     }
  19.  
  20.     // 要让静态方法能使用，也得使用静态属性
  21.     private static final File file=new File("C:\\java data\\.metadata\\book-storage.txt");
  22.     //直接使用类名调用的一定是静态方法
  23.     public static BookStorage loadFromFile(){
  24.         BookStorage bookStorage=new BookStorage();
  25.         if (!file.exists()){
  26.             return bookStorage;    //说明第一次运行，创建一个空对象
  27.         }
  28.         //开始加载
  29.         try {
  30.             Scanner sc=new Scanner(file,"UTF-8");
  31.             while (sc.hasNextLine()){
  32.                 String line=sc.nextLine();
  33.                 // split 按照指定字符串，进行切割
  34.                 String[] group=line.split("@");
  35.                 if (group.length!=5){
  36.                     throw new RuntimeException("文件格式不对");
  37.                 }
  38.                 String name=group[0];
  39.                 String author=group[1];
  40.                 String type=group[2];
  41.                 String priceStr=group[3];
  42.  
  43.                 int price;
  44.                 try{
  45.                     price=Integer.parseInt(priceStr);
  46.                 }catch (NumberFormatException exc){
  47.                     throw new RuntimeException("价格不是数字");
  48.                 }
  49.                 String borrowedByStr=group[4];
  50.                 String borrowedBy;
  51.                 if (borrowedByStr.equals("null")){
  52.                     borrowedBy=null;// 把字符串 "null" 转成 null
  53.                 }else {
  54.                     borrowedBy=borrowedByStr;
  55.                 }
  56.                 Book book=new Book();
  57.                 book.name=name;
  58.                 book.author = author;
  59.                 book.type = type;
  60.                 book.price = price;
  61.                 book.borrowedBy = borrowedBy;
  62.  
  63.                 bookStorage.add(book);
  64.             }
  65.             sc.close();
  66.             return bookStorage;
  67.         }catch (IOException e){
  68.             throw new RuntimeException(e);
  69.         }
  70.  
  71.     }
  72.  
  73.     public void add(Book book) {
  74.         //尾插
  75.         ensureCapacity();
  76.         array[size++]=book;
  77.         saveToFile();
  78.     }
  79.  
  80.     public Book[] toArray(){
  81.         //return array;   // 直接返回可不可以？   语法上成立。不可以
  82.         // 理论有 两条：
  83.         // 1. 返回 array，它的长度是 array.length ，但我们真正的书籍只有 size 本
  84.         // 应该是返回一个 长度是 size 的数组，而不是长度是 array.length 的数组
  85.         // 2. 一旦把 array 返回出去之后（数组对象逃逸了）
  86.         // 别人会怎么操作数组对象，我们完全无法控制
  87.         // 所以可能打破顺序表的一致性问题。比如 Arrays.fill(array, null)
  88.         // size > 0 但是 array 中全部是 null
  89.         return Arrays.copyOf(array,size);
  90.         // 实际上还是有风险的，因为只是浅拷贝
  91.         // 如果使用者有意还是无意改了 Book 对象属性
  92.         // 我们还是会收到影响的
  93.         // 最好的办法是做深拷贝，但这里不做那么复杂了
  94.     }
  95.  
  96.  
  97.     private void ensureCapacity() {
  98.         if (size<array.length){
  99.             return;
  100.         }
  101.         array= Arrays.copyOf(array,array.length*2);
  102.     }
  103.  
  104.     // TODO: 我们这里隐含一个假设，就是我们的书架中，不允许出现同名的书籍
  105.     // TODO: 否则删除的时候操作有歧义
  106.     // TODO: 这个判断，我们在 AddBookCommand 中是没有操作
  107.     public Book searchByName(String name){
  108.         for (int i=0;i<size;i++){
  109.             Book book=array[i];
  110.             if (book.equals(name)){
  111.                 return book;
  112.             }
  113.         }
  114.         return null;
  115.     }
  116.  
  117.     // 原则上，如果顺序表要保持原有顺序的情况下，删除某个元素（可能在中间）
  118.     // 则时间复杂度必然是 O(n) 的
  119.     // 我们这里需要保持顺序么？array 中的原始顺序其实在当前需求下不是那么重要！
  120.     public void remove(Book name){
  121.         for (int i=0;i<size;i++){
  122.             Book item=new Book();
  123.             if (item.equals(name)){
  124.                 array[i]=array[size-1];
  125.                 array[size-1]=null;
  126.                 size--;
  127.                 return;
  128.             }
  129.         }
  130.         saveToFile();
  131.     }
  132.  
  133.     // 普通方法，保存是当前 BookStorage 对象的内容
  134.     public void saveToFile() {
  135.         try{
  136.             PrintWriter writer=new PrintWriter(file,"UTF-8");
  137.             for (int i=0;i<size;i++){
  138.                 Book book=array[i];
  139.                 StringBuilder sb=new StringBuilder();
  140.                 sb.append(book.name);
  141.                 sb.append("@");
  142.                 sb.append(book.author);
  143.                 sb.append("@");
  144.                 sb.append(book.type);
  145.                 sb.append("@");
  146.                 sb.append(book.price);
  147.                 sb.append("@");
  148.                 sb.append(book.borrowedBy);
  149.                 writer.println(sb.toString());
  150.  
  151.             }
  152.             writer.flush();
  153.             writer.close();
  154.         }catch (IOException exc){
  155.             throw new RuntimeException(exc);
  156.         }
  157.     }
  158.  
  159.  
  160.  
  161. }

input包：

  1. package 图书管理系统.input;
  2.  
  3. import 图书管理系统.command.IExecutable;
  4. import 图书管理系统.user.User;
  5.  
  6. import java.util.Scanner;
  7.  
  8. public class Input {
  9.     Scanner scanner=new Scanner(System.in);
  10.     public String prompt(String prompt){
  11.         System.out.println(prompt+":");
  12.         System.out.print(">");
  13.         if (!scanner.hasNextLine()){//说明用户按下了ctrl+D，想要退出
  14.             throw new QuitException();//通过异常向外部通知
  15.         }
  16.         return scanner.nextLine();
  17.     }
  18.  
  19.     public IExecutable menuAndSelect(User user){
  20.         IExecutable[] supportedCommands = user.getSupportedCommands();
  21.         while (true){
  22.             showMenu(supportedCommands);
  23.             // 角色不同，理论上拥有的功能不同
  24.             // 需要当前用户信息
  25.             String selectStr=prompt("请选择您要进行的操作");
  26.             try {
  27.                 int select=Integer.parseInt(selectStr);
  28.                 if (select>=1&select<=supportedCommands.length){
  29.                     return supportedCommands[select-1];
  30.                 }
  31.                 System.out.println("请输入正确的序号！");
  32.             }catch (NumberFormatException exc){
  33.                 System.out.println("请输入正确的数字");
  34.             }
  35.         }
  36.     }
  37.  
  38.     private void showMenu(IExecutable[] supportedCommands) {
  39.         // 2. 遍历并打印每个命令的名称，显示操作菜单
  40.         System.out.println("----------------");
  41.         for (int i=0;i<supportedCommands.length;i++){
  42.             IExecutable command=supportedCommands[i];
  43.             System.out.printf("    %2d. %s\n", i + 1, command.getName());
  44.         }
  45.         System.out.println("----------------");
  46.     }
  47.  
  48. }
  1. package 图书管理系统.input;
  2.  
  3. public class QuitException extends RuntimeException{
  4. }

user包：

  1. package 图书管理系统.user;
  2.  
  3. import 图书管理系统.command.IExecutable;
  4.  
  5. public abstract class User {
  6.     private String username;
  7.  
  8.     public User(String name){
  9.         this.username=name;
  10.     }
  11.     public String getUsername(){
  12.         return username;
  13.     }
  14.     // 所以也完全不知道支持哪些命令
  15.     // 应该定义成抽象方法，供子类去实现
  16.     public abstract IExecutable[] getSupportedCommands();
  17. }
  18.  
  1. package 图书管理系统.user;
  2.  
  3. import 图书管理系统.command.*;
  4.  
  5. public class AdminUser extends User {
  6.     public AdminUser(String name) {
  7.         super(name);
  8.     }
  9.  
  10.     @Override
  11.     public IExecutable[] getSupportedCommands() {
  12.         return new IExecutable[] {
  13.                 // 管理员支持 添加书籍命令
  14.                 new AddBookCommand(),
  15.                 // 管理员支持 删除书籍命令
  16.                 new RemoveBookCommand(),
  17.                 // 管理员支持 根据书名列出书籍命令
  18.                 new ListBookOrderByNameCommand(),
  19.                 // 管理员支持 根据价格列出书籍命令
  20.                 new ListBookOrderByPriceCommand(),
  21.                 // 管理员支持 根据借阅情况列出书籍命令
  22.                 new ListBookOrderByBorrowedCommand()
  23.         };
  24.     }
  25. }
  1. package 图书管理系统.user;
  2.  
  3. import 图书管理系统.command.*;
  4.  
  5. public class CommandUser extends User {
  6.     public CommandUser(String name) {
  7.         super(name);
  8.     }
  9.  
  10.     @Override
  11.     public IExecutable[] getSupportedCommands() {
  12.         return new IExecutable[] {
  13.                 new ListBookOrderByNameCommand(),
  14.                 new ListBookOrderByPriceCommand(),
  15.                 new ListBookOrderByBorrowedCommand(),
  16.                 new BorrowBookCommand(),
  17.                 new ReturnBookCommand()
  18.         };
  19.     }
  20. }
  1. package 图书管理系统.user;
  2.  
  3. import 图书管理系统.input.Input;
  4.  
  5. public class UserStorage {
  6.     // 提前定义一些用户名，作为管理员
  7.     private static final String[] ADMIN_USERNAMES={
  8.       "文佳怡",
  9.       "耿超扬"
  10.     };
  11.  
  12.     private boolean isAdmin(String name){
  13.         for (String admin:ADMIN_USERNAMES){
  14.             if (admin.equals(name)){
  15.                 return true;
  16.             }
  17.         }
  18.         return false;
  19.     }
  20.  
  21.     public User login(Input input){
  22.         // 1. 先让用户输入用户名
  23.         //prompt:提示符
  24.         String username=input.prompt("请输入用户名");
  25.         // 2. 根据用户名，角色是管理员还是普通的用户
  26.         // 3. 根据不同的角色，创建不同的用户
  27.         // admin: 管理员
  28.         if (isAdmin(username)){
  29.             return new AdminUser(username);
  30.         }else {
  31.             return new CommandUser(username);
  32.         }
  33.     }
  34. }

comand：

  1. package 图书管理系统.command;
  2.  
  3. import 图书管理系统.book.Book;
  4. import 图书管理系统.book.BookStorage;
  5. import 图书管理系统.input.Input;
  6. import 图书管理系统.user.User;
  7.  
  8. import java.lang.reflect.Array;
  9. import java.util.Arrays;
  10. import java.util.Comparator;
  11.  
  12. // 由于 AbsListBookCommand 是 抽象类，允许出现抽象方法
  13. public abstract class AbsListBookCommand implements IExecutable {
  14.     protected abstract Comparator getComparator();
  15.  
  16.     @Override
  17.     public void execute(BookStorage bookStorage, User user, Input input) {
  18.         Comparator comparator=getComparator();
  19.         Book[] books=bookStorage.toArray();
  20.         if (comparator==null){
  21.             Arrays.sort(books);
  22.         }else {
  23.             Arrays.sort(books,comparator);
  24.         }
  25.         for (Book book:books){
  26.             System.out.println(book);
  27.         }
  28.     }
  29. }
  1. package 图书管理系统.command;
  2.  
  3. import 图书管理系统.book.Book;
  4. import 图书管理系统.book.BookStorage;
  5. import 图书管理系统.input.Input;
  6. import 图书管理系统.user.User;
  7.  
  8. public class AddBookCommand implements IExecutable {
  9.     @Override
  10.     public String getName() {
  11.         return "添加书籍";
  12.     }
  13.  
  14.     @Override
  15.     public void execute(BookStorage bookStorage, User user, Input input) {
  16.         System.out.println("开始添加书籍，首先读取书籍信息:");
  17.         String name = input.prompt("请输入书籍名称");
  18.         String author = input.prompt("请输入书籍作者");
  19.         String type = input.prompt("请输入书籍类型");
  20.         int price;
  21.         while (true) {
  22.             try {
  23.                 String priceStr = input.prompt("请输入书籍价格（必须是数字）");
  24.                 price = Integer.parseInt(priceStr);
  25.                 break;
  26.             } catch (NumberFormatException exc) {
  27.                 System.out.println("价格格式错误");
  28.             }
  29.         }
  30.         // 刚加架的书肯定没被借阅
  31.         Book book = new Book();
  32.         book.name = name;
  33.         book.author = author;
  34.         book.type = type;
  35.         book.price = price;
  36.         book.borrowedBy = null;
  37.  
  38.         System.out.println("将书籍添加到 书架上");
  39.         bookStorage.add(book);
  40.  
  41.         System.out.println(user.getUsername() + " 完成了 添加书籍的操作: " + name);
  42.     }
  43. }
  44.  
  1. package 图书管理系统.command;
  2.  
  3. import 图书管理系统.book.Book;
  4. import 图书管理系统.book.BookStorage;
  5. import 图书管理系统.input.Input;
  6. import 图书管理系统.user.User;
  7.  
  8. public class BorrowBookCommand implements IExecutable {
  9.     @Override
  10.     public void execute(BookStorage bookStorage, User user, Input input) {
  11.         // 通过书名，完成借阅
  12.         System.out.println("开始借阅书籍，首先读取书籍信息:");
  13.         String name = input.prompt("请输入书籍名称");
  14.  
  15.         Book book = bookStorage.searchByName(name);
  16.         if (book == null) {
  17.             // 没有找到
  18.             System.out.println("没有这本书 " + name + "，无法借阅");
  19.             return;
  20.         }
  21.  
  22.         if (book.isBorrowed()) {
  23.             System.out.println("书籍已经被 " + book.borrowedBy + " 借走，暂时不允许借阅");
  24.             return;
  25.         }
  26.  
  27.         // 由于 book 返回的引用，指向的书籍对象，和 BookStorage 中保存的 Book 对象是同一个对象
  28.         // 通过 book 引用修改，也会让 BookStorage 中生效
  29.         book.borrowed(user);
  30.         bookStorage.saveToFile();
  31.  
  32.         System.out.println(user.getUsername() + " 完成了 借阅书籍的操作: " + name);
  33.     }
  34.  
  35.     @Override
  36.     public String getName() {
  37.         return "借阅书籍";
  38.     }
  39. }
  40.  
  1. package 图书管理系统.command;
  2.  
  3. import 图书管理系统.book.BookStorage;
  4. import 图书管理系统.input.Input;
  5. import 图书管理系统.user.User;
  6.  
  7. public interface IExecutable {
  8.     void execute(BookStorage bookStorage, User user, Input input);
  9.     String getName();
  10. }
  1. package 图书管理系统.command;
  2.  
  3. import 图书管理系统.book.Book;
  4.  
  5. import java.util.Comparator;
  6.  
  7. public class ListBookOrderByBorrowedCommand extends AbsListBookCommand {
  8.     private final Comparator comparator = new Comparator() {
  9.         @Override
  10.         public int compare(Object o1, Object o2) {
  11.             Book b1 = (Book) o1;
  12.             Book b2 = (Book) o2;
  13.  
  14.             int br1 = b1.borrowedBy == null ? 0 : 1;
  15.             int br2 = b2.borrowedBy == null ? 0 : 1;
  16.  
  17.             return br1 - br2;       // 未借走的书籍比较“小”
  18.         }
  19.     };
  20.  
  21.     @Override
  22.     public String getName() {
  23.         return "根据借阅情况排序，列出书籍";
  24.     }
  25.  
  26.     @Override
  27.     protected Comparator getComparator() {
  28.         return comparator;
  29.     }
  30. }
  1. package 图书管理系统.command;
  2.  
  3. import java.util.Comparator;
  4.  
  5. public class ListBookOrderByNameCommand extends AbsListBookCommand {
  6.     @Override
  7.     public String getName() {
  8.         return "根据书名排序，列出书籍";
  9.     }
  10.  
  11.     @Override
  12.     protected Comparator getComparator() {
  13.         return null;
  14.     }
  15. }
  16.  
  1. package 图书管理系统.command;
  2.  
  3. import 图书管理系统.book.Book;
  4.  
  5. import java.util.Comparator;
  6.  
  7. public class ListBookOrderByPriceCommand extends AbsListBookCommand {
  8.     private static class PriceComparator implements Comparator {
  9.  
  10.         @Override
  11.         public int compare(Object o1, Object o2) {
  12.             Book b1 = (Book) o1;
  13.             Book b2 = (Book) o2;
  14.  
  15.             return b1.price - b2.price;
  16.         }
  17.     }
  18.  
  19.     private final Comparator comparator = new PriceComparator();
  20.  
  21.     @Override
  22.     protected Comparator getComparator() {
  23.         return comparator;
  24.     }
  25.  
  26.     @Override
  27.     public String getName() {
  28.         return "根据价格排序，列出书籍";
  29.     }
  30. }
  1. package 图书管理系统.command;
  2.  
  3. import 图书管理系统.book.Book;
  4. import 图书管理系统.book.BookStorage;
  5. import 图书管理系统.input.Input;
  6. import 图书管理系统.user.User;
  7.  
  8. public class RemoveBookCommand implements IExecutable {
  9.     @Override
  10.     public String getName() {
  11.         return "删除书籍";
  12.     }
  13.  
  14.     @Override
  15.     public void execute(BookStorage bookStorage, User user, Input input) {
  16.         // 只支持按照名称删除
  17.         System.out.println("开始删除书籍，首先读取要删除的书籍信息:");
  18.         String name = input.prompt("请输入书籍名称");
  19.         // 增加一些业务逻辑：如果书籍已经借走，则不允许删除
  20.         Book book = bookStorage.searchByName(name);
  21.         if (book == null) {
  22.             // 没有找到
  23.             System.out.println("没有这本书 " + name + "，无法删除");
  24.             return;
  25.         }
  26.         // 看起来 book.isBorrowed() 和 book.borrowedBy != null 是逻辑等价的
  27.         // 应该用 book.isBorrowed() 比 后边更好，为什么？
  28.         // 从职责划分的角度（封装）
  29.         // 提到了方法的重用挺好，但这里的原因不是这个
  30.         if (book.isBorrowed()) {
  31.             System.out.println("书籍已经被 " + book.borrowedBy + " 借走，暂时不允许删除");
  32.             return;
  33.         }
  34.  
  35.         bookStorage.remove(book);
  36.  
  37.         System.out.println(user.getUsername() + " 完成了 删除书籍的操作: " + name);
  38.     }
  39. }
  1. package 图书管理系统.command;
  2.  
  3. import 图书管理系统.book.Book;
  4. import 图书管理系统.book.BookStorage;
  5. import 图书管理系统.input.Input;
  6. import 图书管理系统.user.User;
  7.  
  8. public class ReturnBookCommand implements IExecutable {
  9.     @Override
  10.     public void execute(BookStorage bookStorage, User user, Input input) {
  11.         // 通过书名，完成归还
  12.         System.out.println("开始借阅书籍，首先读取书籍信息:");
  13.         String name = input.prompt("请输入书籍名称");
  14.  
  15.         Book book = bookStorage.searchByName(name);
  16.         if (book == null) {
  17.             // 没有找到
  18.             System.out.println("没有这本书 " + name + "，无法归还");
  19.             return;
  20.         }
  21.  
  22.         if (!book.isBorrowed()) {
  23.             System.out.println("书籍没有被借走，不需要归还");
  24.             return;
  25.         }
  26.  
  27.         if (!book.isBorrowedBy(user)) {
  28.             System.out.println("书籍不是被 " + user.getUsername() + " 借走的，无法归还");
  29.             return;
  30.         }
  31.  
  32.         book.returned(user);
  33.         bookStorage.saveToFile();
  34.  
  35.         System.out.println(user.getUsername() + " 完成了 归还书籍的操作: " + name);
  36.     }
  37.  
  38.     @Override
  39.     public String getName() {
  40.         return "归还书籍";
  41.     }
  42. }
  43.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/556075
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号