一、零钱通项目

1.1 项目开发流程说明

  1. 项目需求说明
    使用Java开发零钱通项目，可以完成收益入账，消费，查看明细，退出系统等功能。
  2. 项目的界面
    image.png
  3. 项目代码实现
    编写文件 SmallChangeSys.java 完成基本功能 (过程编程)
    提示：先使用过程编程，后面改成OOP版本，体会面向对象带来的好处
  4. 项目代码实现改进
    1. 用户输入4退出时，给出提示“你确定要退出吗？y/n”，必须输入正确的y/n，否则循环输入指令，直到输入y或者n
    2. 在收益入账和消费时，判断金额是否合理，并给出相应的提示
    3. 将面向过程的代码修改成面向对象的方法，编写 SmallChangeSysOOP.java 类，并使用 SmallChangeSysApp.java 完成测试

1.2 开发步骤

  1. 化繁为简
    1. 先完成显式菜单，并可以选择菜单，输出相应的数据或完成退出功能
    2. 完成零钱通明细
    3. 完成收益入账
    4. 完成消费
    5. 代码改进 ```java package com.hspedu.smallchange;

import java.text.SimpleDateFormat; import java.util.Date; import java.util.Scanner;

public class SmallChangeSys {

  1. //化繁为简
  2. //1. 先完成显式菜单，并可以选择菜单，给出对应提示
  3. //2. 完成零钱通明细
  4. //3. 完成收益入账
  5. //4. 完成消费
  6. //5. 退出
  7. //6. 用户输入4退出时，给出提示“你确定要退出吗？y/n”，必须输入正确的y/n，否则循环输入指令，直到输入y或者n
  8. //7. 在收益入账和消费时，判断金额是否合理，并给出相应的提示
  9. public static void main(String[] args) {
  10.     //定义相关变量
  11.     boolean loop = true;
  12.     Scanner scanner = new Scanner(System.in);
  13.     String key = "";
  15.     //2. 完成零钱通明细
  16.     //老韩思路,(1) 可以把收益入账和消费，保存到数组 (2) 可以使用对象 (3) 简单的话可以使用String拼接
  17.     String details = "----------------零钱通明细----------------";
  19.     //3. 完成收益入账
  20.     //老韩思路,定义新的变量
  21.     double money = 0;
  22.     double balance = 0;
  23.     Date date = null;  // data 是 java.util.Date 类型，表示日期
  24.     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");  //用于日期格式化
  26.     //4.完成消费
  27.     //老韩思路,定义新的变量,保存消费的项目
  28.     String note = null;
  31.     do {
  32.         System.out.println("\n----------------零钱通菜单----------------");
  33.         System.out.println("\t\t\t1 零钱通明细");
  34.         System.out.println("\t\t\t2 收益入账");
  35.         System.out.println("\t\t\t3 消 费");
  36.         System.out.println("\t\t\t4 退 出");
  38.         System.out.println("请选择(1-4):  ");
  39.         key = scanner.next();
  41.         //使用switch 分支控制
  42.         switch (key) {
  43.             case "1":
  44.                 System.out.println(details);
  45.                 break;
  46.             case "2":
  47.                 System.out.println("收益入账金额：");
  48.                 money = scanner.nextDouble();
  49.                 //money 的值范围应该校验 -> 等下完善
  50.                 //老师思路
  51.                 //找出 不正确 的金额条件，给出提示即可，直接break
  52.                 if (money <= 0) {
  53.                     System.out.println("收益入账金额需要大于0");
  54.                     break;
  55.                 }
  56.                 balance += money;
  57.                 //拼接收益入账信息到 details
  58.                 date = new Date(); //获取当前日期
  59.                 details += "\n收益入账\t+" + money + "\t" + sdf.format(date) + "\t余额:" + balance;
  60.                 break;
  61.             case "3":
  62.                 System.out.println("消费金额：");
  63.                 money = scanner.nextDouble();
  64.                 //余额校验 -> 等下完善
  65.                 //找出金额 不正确 的情况，给出提示即可，直接break
  66.                 if (money <= 0) {
  67.                     System.out.println("消费金额需要大于0");
  68.                     break;
  69.                 }
  70.                 if (money > balance) {
  71.                     System.out.println("消费金额不能大于现有余额" + balance);
  72.                     break;
  73.                 }
  74.                 System.out.println("请输入消费说明：");
  75.                 note = scanner.next();
  76.                 balance -= money;
  77.                 date = new Date(); //获取当前日期
  78.                 details += "\n" + note + "\t-" + money + "\t" + sdf.format(date) + "\t余额:" + balance;
  79.                 break;
  80.             case "4":
  81.                 //用户输入4退出时，给出提示“你确定要退出吗？y/n”，必须输入正确的y/n，否则循环输入指令，直到输入y或者n
  82.                 // 思路分析
  83.                 //(1) 定义一个变量choice，接收用户的输入
  84.                 //(2) 使用 while + break,来处理接收到输入时 y 或者 n
  85.                 //(3) 退出 while 后，再判断 choice 是 y 还是 n ,从而决定是否退出
  86.                 // 建议：一段代码，完成一个小功能，尽量不要混在一起
  87.                 String choice = "";
  88.                 while (true) {  //要求用户必须输入 y/n 否则一直循环
  89.                     System.out.println("你确定要退出吗？y/n");
  90.                     choice = scanner.next();
  91.                     if ("y".equals(choice) || "n".equals(choice)) {
  92.                         break;
  93.                     }
  94.                 }
  95.                 //当退出了 while ,再进行判断
  96.                 if ("y".equals(choice)) {
  97.                     loop = false;
  98.                 }
  99.                 break;
  100.             default:
  101.                 System.out.println("选择有误，请重新选择");
  102.         }
  104.     } while (loop);
  106.     System.out.println("\n--------退出了零钱通项目--------");
  107. }

}

  2. OPP(面向对象编程)版本
  3. ```java
  4. package com.hspedu.smallchange.oop_;
  6. import java.text.SimpleDateFormat;
  7. import java.util.Date;
  8. import java.util.Scanner;
  10. /**
  11.  * 该类是完成零钱通的各个功能的类
  12.  * 使用OOP（面向对象编程）完成
  13.  * 将各个功能对应一个方法
  14.  */
  15. public class SmallChangeSysOOP {
  16.     //属性
  17.     boolean loop = true;
  18.     Scanner scanner = new Scanner(System.in);
  19.     String key = "";
  20.     String details = "----------------零钱通明细----------------";
  21.     double money = 0;
  22.     double balance = 0;
  23.     Date date = null;  // data 是 java.util.Date 类型，表示日期
  24.     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");  //用于日期格式化
  25.     String note = null;
  27.     //1. 先完成显式菜单，并可以选择菜单
  28.     public void mainMenu() {
  29.         do {
  30.             System.out.println("\n----------------零钱通菜单(OOP)----------------");
  31.             System.out.println("\t\t\t1 零钱通明细");
  32.             System.out.println("\t\t\t2 收益入账");
  33.             System.out.println("\t\t\t3 消 费");
  34.             System.out.println("\t\t\t4 退 出");
  36.             System.out.println("请选择(1-4):  ");
  37.             key = scanner.next();
  39.             //使用switch 分支控制
  40.             switch (key) {
  41.                 case "1":
  42.                     this.detail();
  43.                     break;
  44.                 case "2":
  45.                     this.income();
  46.                     break;
  47.                 case "3":
  48.                     this.pay();
  49.                     break;
  50.                 case "4":
  51.                     this.exit();
  52.                     break;
  53.                 default:
  54.                     System.out.println("选择有误，请重新选择");
  55.             }
  56.         } while (loop);
  57.     }
  59.     //2. 完成零钱通明细
  60.     public void detail() {
  61.         System.out.println(details);
  62.     }
  64.     //3. 完成收益入账
  65.     public void income() {
  66.         System.out.println("收益入账金额：");
  67.         money = scanner.nextDouble();
  68.         if (money <= 0) {
  69.             System.out.println("收益入账金额需要大于0");
  70.             return;  //退出方法，不再执行后面的代码
  71.         }
  72.         balance += money;
  73.         date = new Date(); //获取当前日期
  74.         details += "\n收益入账\t+" + money + "\t" + sdf.format(date) + "\t余额:" + balance;
  75.     }
  77.     //4. 完成消费
  78.     public void pay() {
  79.         System.out.println("消费金额：");
  80.         money = scanner.nextDouble();
  81.         //余额校验 -> 等下完善
  82.         //找出金额 不正确 的情况，给出提示即可，直接break
  83.         if (money <= 0) {
  84.             System.out.println("消费金额需要大于0");
  85.             return;
  86.         }
  87.         if (money > balance) {
  88.             System.out.println("消费金额不能大于现有余额" + balance);
  89.             return;
  90.         }
  91.         System.out.println("请输入消费说明：");
  92.         note = scanner.next();
  93.         balance -= money;
  94.         date = new Date(); //获取当前日期
  95.         details += "\n" + note + "\t-" + money + "\t" + sdf.format(date) + "\t余额:" + balance;
  96.     }
  98.     //5. 完成退出
  99.     public void exit() {
  100.         String choice = "";
  101.         while (true) {  //要求用户必须输入 y/n 否则一直循环
  102.             System.out.println("你确定要退出吗？y/n");
  103.             choice = scanner.next();
  104.             if ("y".equals(choice) || "n".equals(choice)) {
  105.                 break;
  106.             }
  107.         }
  108.         //当退出了 while ,再进行判断
  109.         if ("y".equals(choice)) {
  110.             loop = false;
  111.         }
  112.     }
  113. }
  1. package com.hspedu.smallchange.oop_;
  3. /**
  4.  * 这里我们直接调用SmallChangeSysOOP对象，显示主菜单即可
  5.  */
  6. public class SmallChangeSysApp {
  7.     public static void main(String[] args) {
  8.         SmallChangeSysOOP smallChangeSysOOP = new SmallChangeSysOOP();
  9.         smallChangeSysOOP.mainMenu();
  10.     }
  11. }

二、房屋出租系统

2.1 项目需求说明

实现基于文本界面的《房屋出租软件》。
能够实现堆房屋信息的添加、修改和删除（用数组实现），并能够打印房屋明细表。

2.2 项目界面

  1. 主菜单
    image.png
  2. 新增房源
    image.png
  3. 查找房源
    image.png
  4. 删除房源
    image.png
  5. 修改房源
    如果不希望修改某个信息，直接回车即可
    image.png
  6. 房屋列表
    image.png
  7. 退出系统
    image.png

2.3 项目设计 - 程序框架图

分层模式 => 当软件比较复杂，需要模式管理
框架图的作用：

  1. 系统有哪些类【文件】
  2. 类与类的调用关系

第一阶段实战项目 - 图9

2.4 项目设计 - 工具类引入

  1. 搭建本地目录结构
    com.hspedu.houserent //包名
    |—-view //界面类文件夹
    |—-service //业务类文件夹
    |—-domain //domain类文件夹
    |—-utils //工具类文件夹
    |—-HouseRentApp.java //程序入口文件

  2. 工具类的引入和使用案例
    |—-view
    |—-service
    |—-domain
    |—-utils
    |—-Utility.java
    |—-HouseRentApp.java

  1. package com.hspedu.houserent.utils;
  4. /**
  5.     工具类的作用:
  6.     处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
  7. */
  9. import java.util.*;
  10. /**
  13. */
  14. public class Utility {
  15.     //静态属性。。。
  16.     private static Scanner scanner = new Scanner(System.in);
  19.     /**
  20.      * 功能：读取键盘输入的一个菜单选项，值：1——5的范围
  21.      * @return 1——5
  22.      */
  23.     public static char readMenuSelection() {
  24.         char c;
  25.         for (; ; ) {
  26.             String str = readKeyBoard(1, false);//包含一个字符的字符串
  27.             c = str.charAt(0);//将字符串转换成字符char类型
  28.             if (c != '1' && c != '2' && 
  29.                 c != '3' && c != '4' && c != '5') {
  30.                 System.out.print("选择错误，请重新输入：");
  31.             } else break;
  32.         }
  33.         return c;
  34.     }
  36.     /**
  37.      * 功能：读取键盘输入的一个字符
  38.      * @return 一个字符
  39.      */
  40.     public static char readChar() {
  41.         String str = readKeyBoard(1, false);//就是一个字符
  42.         return str.charAt(0);
  43.     }
  44.     /**
  45.      * 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
  46.      * @param defaultValue 指定的默认值
  47.      * @return 默认值或输入的字符
  48.      */
  50.     public static char readChar(char defaultValue) {
  51.         String str = readKeyBoard(1, true);//要么是空字符串，要么是一个字符
  52.         return (str.length() == 0) ? defaultValue : str.charAt(0);
  53.     }
  55.     /**
  56.      * 功能：读取键盘输入的整型，长度小于2位
  57.      * @return 整数
  58.      */
  59.     public static int readInt() {
  60.         int n;
  61.         for (; ; ) {
  62.             String str = readKeyBoard(2, false);//一个整数，长度<=2位
  63.             try {
  64.                 n = Integer.parseInt(str);//将字符串转换成整数
  65.                 break;
  66.             } catch (NumberFormatException e) {
  67.                 System.out.print("数字输入错误，请重新输入：");
  68.             }
  69.         }
  70.         return n;
  71.     }
  72.     /**
  73.      * 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
  74.      * @param defaultValue 指定的默认值
  75.      * @return 整数或默认值
  76.      */
  77.     public static int readInt(int defaultValue) {
  78.         int n;
  79.         for (; ; ) {
  80.             String str = readKeyBoard(10, true);
  81.             if (str.equals("")) {
  82.                 return defaultValue;
  83.             }
  85.             //异常处理...
  86.             try {
  87.                 n = Integer.parseInt(str);
  88.                 break;
  89.             } catch (NumberFormatException e) {
  90.                 System.out.print("数字输入错误，请重新输入：");
  91.             }
  92.         }
  93.         return n;
  94.     }
  96.     /**
  97.      * 功能：读取键盘输入的指定长度的字符串
  98.      * @param limit 限制的长度
  99.      * @return 指定长度的字符串
  100.      */
  102.     public static String readString(int limit) {
  103.         return readKeyBoard(limit, false);
  104.     }
  106.     /**
  107.      * 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
  108.      * @param limit 限制的长度
  109.      * @param defaultValue 指定的默认值
  110.      * @return 指定长度的字符串
  111.      */
  113.     public static String readString(int limit, String defaultValue) {
  114.         String str = readKeyBoard(limit, true);
  115.         return str.equals("")? defaultValue : str;
  116.     }
  119.     /**
  120.      * 功能：读取键盘输入的确认选项，Y或N
  121.      * 将小的功能，封装到一个方法中.
  122.      * @return Y或N
  123.      */
  124.     public static char readConfirmSelection() {
  125.         System.out.println("请输入你的选择(Y/N)");
  126.         char c;
  127.         for (; ; ) {//无限循环
  128.             //在这里，将接受到字符，转成了大写字母
  129.             //y => Y n=>N
  130.             String str = readKeyBoard(1, false).toUpperCase();
  131.             c = str.charAt(0);
  132.             if (c == 'Y' || c == 'N') {
  133.                 break;
  134.             } else {
  135.                 System.out.print("选择错误，请重新输入：");
  136.             }
  137.         }
  138.         return c;
  139.     }
  141.     /**
  142.      * 功能： 读取一个字符串
  143.      * @param limit 读取的长度
  144.      * @param blankReturn 如果为true ,表示 可以读空字符串。 
  145.      *                       如果为false表示 不能读空字符串。
  146.      *             
  147.      *    如果输入为空，或者输入大于limit的长度，就会提示重新输入。
  148.      * @return
  149.      */
  150.     private static String readKeyBoard(int limit, boolean blankReturn) {
  152.         //定义了字符串
  153.         String line = "";
  155.         //scanner.hasNextLine() 判断有没有下一行
  156.         while (scanner.hasNextLine()) {
  157.             line = scanner.nextLine();//读取这一行
  159.             //如果line.length=0, 即用户没有输入任何内容，直接回车
  160.             if (line.length() == 0) {
  161.                 if (blankReturn) return line;//如果blankReturn=true,可以返回空串
  162.                 else continue; //如果blankReturn=false,不接受空串，必须输入内容
  163.             }
  165.             //如果用户输入的内容大于了 limit，就提示重写输入  
  166.             //如果用户如的内容 >0 <= limit ,我就接受
  167.             if (line.length() < 1 || line.length() > limit) {
  168.                 System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
  169.                 continue;
  170.             }
  171.             break;
  172.         }
  174.         return line;
  175.     }
  176. }
  1. package com.hspedu.houserent.utils;
  3. public class TestUtility {
  4.     public static void main(String[] args) {
  5.         //这时一个测试类，使用完毕就删除了
  6.         //要求输入一个字符串，长度最大为3
  7.         String s = Utility.readString(3);
  8.         System.out.println("s=" + s);
  10.         //要求输入一个字符串，长度最大为10，如果用户直接回车，就给一个默认值
  11.         String s1 = Utility.readString(10, "hspedu");
  12.         System.out.println("s1 = " + s1);
  14.         //解释
  15.         //这里直接使用了 类.方法() => 因为当一个方法是static时，就是一个静态方法
  16.         //注意：静态方法可以直接通过类名调用
  17.     }
  18. }

2.5 项目功能实现 - 完成House类

|—-view
|—-service
|—-domain
|—-House.java
|—-utils
|—-Utility.java
|—-HouseRentApp.java

编号 房主 电话 地址 月租 状态(已出租/未出租)

  1. package com.hspedu.houserent.domain;
  3. /**
  4.  * House 的对象表示一个 房屋的信息
  5.  */
  6. public class House {
  7.     //编号 房主 电话 地址 月租 状态(未出租/已出租)
  8.     private int id;
  9.     private String name;
  10.     private String phone;
  11.     private String address;
  12.     private int rent;
  13.     private String state;
  15.     //构造器
  16.     public House(int id, String name, String phone, String address, int rent, String state) {
  17.         this.id = id;
  18.         this.name = name;
  19.         this.phone = phone;
  20.         this.address = address;
  21.         this.rent = rent;
  22.         this.state = state;
  23.     }
  25.     //为了方便的输出对象信息，我们重写 toString
  26.     @Override
  27.     public String toString() {
  28.         return id +
  29.                 "\t\t" + name +
  30.                 "\t" + phone +
  31.                 "\t\t" + address +
  32.                 "\t" + rent +
  33.                 "\t" + state ;
  34.     }
  36.     //set() 和 get() 方法
  37.     public int getId() {
  38.         return id;
  39.     }
  41.     public void setId(int id) {
  42.         this.id = id;
  43.     }
  45.     public String getName() {
  46.         return name;
  47.     }
  49.     public void setName(String name) {
  50.         this.name = name;
  51.     }
  53.     public String getPhone() {
  54.         return phone;
  55.     }
  57.     public void setPhone(String phone) {
  58.         this.phone = phone;
  59.     }
  61.     public String getAddress() {
  62.         return address;
  63.     }
  65.     public void setAddress(String address) {
  66.         this.address = address;
  67.     }
  69.     public int getRent() {
  70.         return rent;
  71.     }
  73.     public void setRent(int rent) {
  74.         this.rent = rent;
  75.     }
  77.     public String getState() {
  78.         return state;
  79.     }
  81.     public void setState(String state) {
  82.         this.state = state;
  83.     }
  84. }

2.6 项目功能实现 - 显示主菜单和完成退出功能

说明：实现功能的三部曲【明确功能 -> 思路分析 -> 代码实现】

  1. 功能说明
    用户打开软件，可以看到主界面，可以退出软件

  2. 思路分析
    在 HouseView.java 中，编写一个方法 mainMenu，显示菜单

  3. 代码实现 ```java package com.hspedu.houserent.view;

import com.hspedu.houserent.utils.Utility;

/**

  • 1.显示界面
  • 2.接收用户输入

  • 3.调用HouseService完成对房屋信息的各种操作 */ public class HouseView {

    private boolean loop = true; //控制显示菜单 private char key = ‘ ‘; //接收用户选择

    //显示主菜单 public void mainMenu() {

    1.  do {
    2.      System.out.println("---------------房屋出租系统---------------");
    3.      System.out.println("\t\t\t1 新 增 房 源");
    4.      System.out.println("\t\t\t2 查 找 房 屋");
    5.      System.out.println("\t\t\t3 删 除 房 屋");
    6.      System.out.println("\t\t\t4 修 改 房 屋 信 息");
    7.      System.out.println("\t\t\t5 房 屋 列 表");
    8.      System.out.println("\t\t\t6 退       出");
    9.      System.out.println("请输入你的选择(1-6): ");
    10.      key = Utility.readChar();
    11.      switch (key) {
    12.          case '1':
    13.              System.out.println("新增");
    14.              break;
    15.          case '2':
    16.              System.out.println("查找");
    17.              break;
    18.          case '3':
    19.              System.out.println("删除");
    20.              break;
    21.          case '4':
    22.              System.out.println("修改");
    23.              break;
    24.          case '5':
    25.              System.out.println("列表");
    26.              break;
    27.          case '6':
    28.              System.out.println("退出");
    29.              loop = false;
    30.              break;
    31.      }
    32.  } while (loop);

    } } ```

2.7 项目功能实现 - 显示房屋列表

  1. 功能说明
    image.png

  2. 思路分析
    需要编写HouseView.java 和 HouseService.java

  3. 代码实现 ```java //编写 HouseView.java 加入如下内容 private HouseService houseService = new HouseService(10); //设置数组的大小为10

//编写listHouse()显示房屋列表 public void listHouse() { System.out.println(“\n————————-房屋列表————————-“); System.out.println(“编号\t\t房主\t\t电话\t\t地址\t\t月租\t\t状态”); House[] houses = houseService.list(); //得到所有房屋 for (int i = 0; i < houses.length; i++) { if (houses[i] != null) { System.out.println(houses[i]); } } System.out.println(“\n——————-房屋列表显示完毕——————-“); }

//在显示主菜单中 switch(key) 修改内容如下 case ‘5’: listHouse(); break;

  1. ```java
  2. //编写 HouseService 文件
  3. package com.hspedu.houserent.service;
  5. import com.hspedu.houserent.domain.House;
  7. /**
  8.  * HouseService.java <=> 类【业务层】
  9.  * //定义House[]数组，保存House对象
  10.  * 1. 相应HouseView的调用
  11.  * 2. 完成对房屋信息的各种操作
  12.  * c(creat) r(read) u(update) d(delete)
  13.  */
  14. public class HouseService {
  15.     private House[] houses; //保存House对象
  16.     public HouseService(int size) {
  17.         houses = new House[size];  //当创建HouseService对象，指定数组大小
  18.         //为了配合测试列表信息，这里初始化一个House对象
  19.         houses[0] = new House(1,"Javk","112","浦东区",1000,"未出租");
  20.     }
  22.     //list方法，返回houses
  23.     public House[] list() {
  24.         return houses;
  25.     }
  26. }

2.8 项目功能实现 - 添加房屋信息

  1. 功能说明
    image.png

  2. 思路分析
    HouseView.java 中添加 addHouse() 方法，用于显示添加房屋界面
    HouseService.java 中添加 add() 方法，用于将新的House对象加入到数组中

  3. 代码实现 ```java //编写 addHouse() 接收输入，创建 House 对象，调用add方法 public void addHouse() {

    1.  System.out.println("\n-----------------添加房屋-----------------");
    2.  System.out.print("姓名：");
    3.  String name = Utility.readString(8);
    4.  System.out.print("电话：");
    5.  String phone = Utility.readString(12);
    6.  System.out.print("地址：");
    7.  String address = Utility.readString(16);
    8.  System.out.print("月租：");
    9.  int rent = Utility.readInt();
    10.  System.out.print("状态：");
    11.  String state = Utility.readString(3);
    12.  //创建一个新的对象，注意 id是系统分配的，用户不能输入
    13.  House house = new House(0, name, phone, address, rent, state);
    14.  if (houseService.add(house)) {
    15.      System.out.println("\n-----------------添加完成-----------------");
    16.  } else {
    17.      System.out.println("\n-----------------添加失败-----------------");
    18.  }

    }

//在显示主菜单中 switch(key) 修改内容如下 case ‘1’: addHouse(); break;

  1. ```java
  2. //编写 HouseService.java
  3. //add方法，添加新对象，返回boolean
  4.     public boolean add(House newHouse) {
  5.         //判断是否还可以继续添加（暂时不考虑数组扩容问题）
  6.         if (houseNums == houses.length) {  //不能再添加
  7.             System.out.println("数组已满，不能再添加了...");
  8.             return false;
  9.         }
  10.         //把newHouse对象加入到房屋队列最后面
  11.         houses[houseNums++] = newHouse;
  12.         //我们程序员还要设计一个id自增长的机制,然后更新 newHouse的id
  13.         newHouse.setId(++idCounter);
  14.         return true;
  15.     }

2.9 项目功能实现 - 删除房屋信息

  1. 功能说明
    image.png

  2. 思路分析
    需要编写 HouseView 和 HouseService

  3. 代码实现 ```java //编写 HouseView.java //编写delHouse() 接收输入的id，调用 Service 的 del() 方法 public void delHouse() {

    1.  System.out.println("\n-----------------删除房屋-----------------");
    2.  System.out.println("请输入待删除房屋的编号(-1退出)：");
    3.  int delId = Utility.readInt();
    4.  if (delId == -1) {
    5.      System.out.println("-------------放弃删除房屋信息-------------");
    6.      return;
    7.  }
    8.  //注意该方法本身就有循环的逻辑，必须输入Y/N
    9.  char chioce = Utility.readConfirmSelection();
    10.  if (chioce == 'Y') {
    11.      if (houseService.del(delId)) {
    12.          System.out.println("\n-----------------删除成功-----------------");
    13.      } else {
    14.          System.out.println("房屋编号不存在，删除失败！");
    15.      }
    16.  } else {
    17.      System.out.println("-------------放弃删除房屋信息-------------");
    18.      return;
    19.  }

    }

//在显示主菜单中 switch(key) 修改内容如下 case ‘3’: delHouse(); break;

  1. ```java
  2. //编写 HouseService.java
  3. //del方法，删除一个房屋的信息
  4.     public boolean del(int delId) {
  5.         //应当先找到要删除的房屋信息对应的下标
  6.         //房屋的编号和下标不是一回事
  7.         int index = -1;
  8.         for (int i = 0; i < houseNums; i++) {
  9.             if (delId == houses[i].getId()) {  //要删除的房屋(id)，是数组下标为i的元素
  10.                 index = i; //就使用index记录i
  11.             }
  12.         }
  13.         if (index == -1) {  //说明delId 在数组中不存在
  14.             return false;
  15.         }
  16.         //如果找到
  17.         for (int i = 0; i < houseNums - 1; i++) {
  18.             houses[i] = houses[i + 1];
  19.         }
  20.         houses[--houseNums] = null;
  21.         return true;
  22.     }
  24. //在显示主菜单中 switch(key) 修改内容如下
  25.         case '3':
  26.             delHouse();
  27.             break;

2.10 项目功能实现 - 完善退出确认功能

  1. 功能说明
    要求在退出时提示“确认是否退出(Y/N): ”，必须输入Y/N，否则循环提示

  2. 思路分析
    需要编写 HouseView

  3. 代码实现 ```java //编写HouseView //完善退出功能 ,加入退出确认方法 public void exitConfirm() {

    1.  System.out.println("确认是否退出(Y/N)：");
    2.  char c;
    3.  for (; ; ) {//无限循环
    4.      String str = Utility.readKeyBoard(1, false).toUpperCase();
    5.      c = str.charAt(0);
    6.      if (c == 'Y' || c == 'N') {
    7.          break;
    8.      } else {
    9.          System.out.print("选择错误，请重新输入：");
    10.      }
    11.  }
    12.  if (c == 'Y') {
    13.      loop = false;
    14.  }

    }

//在显示主菜单中 switch(key) 修改内容如下 case ‘6’: exitConfirm(); break;

  2. <a name="eFx4a"></a>
  3. #### 2.11  项目功能实现 - 查找房屋
  5. 1. 功能说明<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/12677686/1631176707622-47bbf43c-fa00-4230-bd3f-da74145b21a2.png#clientId=u08d2f56f-eb11-4&from=paste&height=207&id=XEmE8&margin=%5Bobject%20Object%5D&name=image.png&originHeight=254&originWidth=615&originalType=binary&ratio=1&size=107739&status=done&style=none&taskId=u214b6646-85f3-45d7-a983-aaff0345f9a&width=500)
  7. 1. 思路分析
  8.    1. HouseView.java 中编写 findHouse()，用于显示查找房屋界面
  9.    1. HouseService 中编写方法findById(int findId);返回House对象如果没有，返回null
  11. 3. 代码实现
  12. ```java
  13. //编写 HouseView 文件
  14. //编写 findHouse，实现查找房屋
  15.     public void findHouse() {
  16.         System.out.println("\n-----------------查找房屋-----------------");
  17.         System.out.print("请输入要查找的id：");
  18.         int findId = Utility.readInt();
  19.         House house = houseService.findById(findId);
  20.         if (house != null) {
  21.             System.out.println(house);
  22.         } else {
  23.             System.out.println("\n----------------没有该房屋----------------");
  24.         }
  25.     }
  27. //在显示主菜单中 switch(key) 修改内容如下
  28.         case '2':
  29.             findHouse();
  30.             break;
  1. //编写 HouseService 文件
  2. //find() 方法，查找一个房屋的信息
  3.     public House findById(int findId) {
  4.         //遍历数组
  5.         for (int i = 0; i < houseNums; i++) {
  6.             if (findId == houses[i].getId()) {
  7.                 return houses[i];
  8.             }
  9.         }
  10.         return null;
  11.     }

2.12 项目功能实现 - 修改房屋信息

  1. 功能说明
    image.png

  2. 思路分析

HouseView.java 中编写updateHouse()，显示修改房屋界面

  1. 代码实现 ```java //编写 updateHouse()，实现修改房屋信息 public void updateHouse() {
    1.  System.out.println("\n---------------修改房屋信息---------------");
    2.  System.out.print("请选择待修改房屋编号(-1退出)：");
    3.  int updateId = Utility.readInt();
    4.  if (updateId == -1) {
    5.      System.out.println("---------------放弃修改房屋信息---------------");
    6.      return;
    7.  }
    8.  House house = houseService.findById(updateId);
    9.  if (house != null) {
    10.      System.out.print("姓名(" + house.getName() + "): ");
    11.      String name = Utility.readString(8,"");
    12.      if (!"".equals(name)) {
    13.          house.setName(name);
    14.      }
    15.      System.out.print("电话(" + house.getPhone() + "): ");
    16.      String phone = Utility.readString(12,"");
    17.      if (!"".equals(phone)) {
    18.          house.setPhone(phone);
    19.      }
    20.      System.out.print("地址(" + house.getAddress() + "): ");
    21.      String address = Utility.readString(16,"");
    22.      if (!"".equals(address)) {
    23.          house.setAddress(address);
    24.      }
    25.      System.out.print("月租(" + house.getRent() + "): ");
    26.      int rent = Utility.readInt(-1);
    27.      if (rent != -1) {
    28.          house.setRent(rent);
    29.      }
    30.      System.out.print("状态(" + house.getState() + "): ");
    31.      String state = Utility.readString(3,"");
    32.      if (!"".equals(state)) {
    33.          house.setState(state);
    34.      }
    35.      System.out.println("\n-----------------修改完成-----------------");
    36.  } else {
    37.      System.out.println("\n----------------没有该房屋----------------");
    38.  }
    }

//在显示主菜单中 switch(key) 修改内容如下 case ‘4’: updateHouse(); break; ```

学习参考（致谢）：

  1. B站 @程序员鱼皮 Java学习一条龙
  2. B站 @韩顺平 零基础30天学会Java