论坛 › SAP › Java学习-第一部分-第一阶段-第八节：项目-房屋出租系统（中级）

知者何南 发表于 2022-9-3 01:19:41

Java学习-第一部分-第一阶段-第八节：项目-房屋出租系统（中级）

项目-房屋出租系统

笔记目录：(https://www.cnblogs.com/wenjie2000/p/16378441.html)
房屋出租系统-需求

●项目需求说明
实现基于文本界面的《房屋出租软件》。
能够实现对房屋信息的添加、修改和删除(用数组实现)，并能够打印房屋明细表。
●项目界面-主菜单
https://img2022.cnblogs.com/blog/2592433/202207/2592433-20220728133153665-2070986967.png
●项目界面-1新增房源
https://img2022.cnblogs.com/blog/2592433/202207/2592433-20220728133159377-67220158.png
●项目界面-2查找房源
https://img2022.cnblogs.com/blog/2592433/202207/2592433-20220728133205430-2020521498.png
●项目界面-3删除房源
https://img2022.cnblogs.com/blog/2592433/202207/2592433-20220728133216244-1139400664.png
●项目界面-4修改房源
如果不希望修改某个信息,则直接回车
https://img2022.cnblogs.com/blog/2592433/202207/2592433-20220728133223565-358060493.png
●项目界面-5房屋列表
https://img2022.cnblogs.com/blog/2592433/202207/2592433-20220728133231516-955990016.png
●项目界面-6退出系统
https://img2022.cnblogs.com/blog/2592433/202207/2592433-20220728133239522-1496046043.png
项目结构

https://img2022.cnblogs.com/blog/2592433/202207/2592433-20220728133256326-1942765078.png
结构细节

https://img2022.cnblogs.com/blog/2592433/202207/2592433-20220728133301525-573099041.png
程序文件结构

https://img2022.cnblogs.com/blog/2592433/202207/2592433-20220728133308300-986616602.png
代码

程序答案不唯一
HouseRentApp

package com.hspedu.houserent;

import com.hspedu.houserent.view.HouseView;

public class HouseRentApp {
    public static void main(String[] args) {
      //整个程序入口
      new HouseView().mainMenu();
      System.out.println("已退出系统");
    }
}House

package com.hspedu.houserent.domain;

import com.hspedu.houserent.service.HouseService;
import com.hspedu.houserent.utils.Utility;

public class House {
    //房屋编号姓名电话地区租金状态
    private int id;
    private String name;
    private String phone;
    private String address;
    private int rent;
    private String state;

    public House(int id, String name, String phone, String address, int rent, String state) {
      this.id = id;
      this.name = name;
      this.phone = phone;
      this.address = address;
      this.rent = rent;
      this.state = state;
    }

    public int getId() {
      return id;
    }

    public void setId(int id) {
      this.id = id;
    }

    public String getName() {
      return name;
    }

    public void setName(String name) {
      this.name = name;
    }

    public String getPhone() {
      return phone;
    }

    public void setPhone(String phone) {
      this.phone = phone;
    }

    public String getAddress() {
      return address;
    }

    public void setAddress(String address) {
      this.address = address;
    }

    public int getRent() {
      return rent;
    }

    public void setRent(int rent) {
      this.rent = rent;
    }

    public String getState() {
      return state;
    }

    public void setState(String state) {
      this.state = state;
    }

    @Override
    public String toString() {
      return id +
                "\t\t" + name +
                "\t\t" + phone +
                "\t\t" + address +
                "\t\t" + rent +
                "\t\t" + state;
    }
}HouseService

package com.hspedu.houserent.service;

import com.hspedu.houserent.domain.House;
import com.hspedu.houserent.utils.Utility;

public class HouseService {
    private House[] houses;//保存House对象
    private int houseNums = 1;//记录当前有多少个房屋信息
    private int idCounter = 1;//记录当前的id增长到哪个值

    public HouseService(int size) {
      //new houses
      houses = new House;
      houses = new House(1, "jack", "112", "海淀区", 2000, "未出租");
    }

    public boolean modify(int modifyId){
      int index = -1;
      for (int i = 0; i < houseNums; i++) {
            if (modifyId == houses.getId()) {//要删除的房屋(id)，是数组下标为i的元素
                index = i;//就使用index记录i
                break;
            }
      }
      if (index == -1) {//说明delId在数组中不存在(有点绕..)
            return false;
      }
      System.out.print("姓名("+houses.getName()+"):");
      String name = Utility.readString(8);
      houses.setName(name);
      System.out.print("电话("+houses.getPhone()+"):");
      String phone = Utility.readString(12);
      houses.setPhone(phone);
      System.out.print("地址("+houses.getAddress()+"):");
      String address = Utility.readString(16);
      houses.setAddress(address);
      System.out.print("月租("+houses.getRent()+"):");
      int rent = Utility.readInt();
      houses.setRent(rent);
      System.out.print("状态("+houses.getState()+"):");
      String state = Utility.readString(3);
      houses.setState(state);
      return true;
    }

    public boolean find(int findId){
      int index = -1;
      for (int i = 0; i < houseNums; i++) {
            if (findId == houses.getId()) {//要删除的房屋(id)，是数组下标为i的元素
                index = i;//就使用index记录i
                break;
            }
      }
      if (index == -1) {//说明delId在数组中不存在(有点绕..)
            return false;
      }
      //如果找到，输出
      System.out.println(houses.toString());
      return true;
    }


    // add方法,添加新对象，返回boolean
    public boolean add(House newHouse) {
      //判断是否还可以继续添加(我们暂时不考虑数组扩容的问题)
      if (houseNums == houses.length) {//不能再添加
            System.out.println("数组已满,不能再添加了...");
            return false;
      }
      //把newHouse对象加入到，新增加了一个房屋
      houses = newHouse;
      //我们程序员需要设计一个id自增长的机制，然后更新newHouse的id
      newHouse.setId(++idCounter);
      return true;
    }

    // del方法,删除一个房屋信息
    public boolean del(int delId) {
      //应当先找到要删除的房屋信息对应的下标
      //老韩强调，一定要搞清楚下标和房屋的编号不是一回事
      int index = -1;
      for (int i = 0; i < houseNums; i++) {
            if (delId == houses.getId()) {//要删除的房屋(id)，是数组下标为i的元素
                index = i;//就使用index记录i
            }
      }
      if (index == -1) {//说明delId在数组中不存在(有点绕..)
            return false;
      }
      //如果找到，这里需要小伙伴动脑筋
      for (int i = index; i < houseNums - 1; i++) {
            houses = houses;
      }
      //把当有存在的房屋信息的最后一个设置null
      houses[--houseNums] = null;
      return true;

    }


    //list方法，返回houses
    public House[] list() {
      return houses;
    }
}Utility

package com.hspedu.houserent.utils;

/**
工具类的作用:
处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
*/

import java.util.*;
/**

*/
public class Utility {
    //静态属性。。。
    private static Scanner scanner = new Scanner(System.in);


    /**
   * 功能：读取键盘输入的一个菜单选项，值：1——5的范围
   * @return 1——5
   */
    public static char readMenuSelection() {
      char c;
      for (; ; ) {
            String str = readKeyBoard(1, false);//包含一个字符的字符串
            c = str.charAt(0);//将字符串转换成字符char类型
            if (c != '1' && c != '2' &&
                  c != '3' && c != '4' && c != '5') {
                System.out.print("选择错误，请重新输入：");
            } else break;
      }
      return c;
    }

    /**
   * 功能：读取键盘输入的一个字符
   * @return 一个字符
   */
    public static char readChar() {
      String str = readKeyBoard(1, false);//就是一个字符
      return str.charAt(0);
    }
    /**
   * 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
   * @param defaultValue 指定的默认值
   * @return 默认值或输入的字符
   */

    public static char readChar(char defaultValue) {
      String str = readKeyBoard(1, true);//要么是空字符串，要么是一个字符
      return (str.length() == 0) ? defaultValue : str.charAt(0);
    }

    /**
   * 功能：读取键盘输入的整型，长度小于2位
   * @return 整数
   */
    public static int readInt() {
      int n;
      for (; ; ) {
            String str = readKeyBoard(10, false);//一个整数，长度<=10位
            try {
                n = Integer.parseInt(str);//将字符串转换成整数
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
      }
      return n;
    }
    /**
   * 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
   * @param defaultValue 指定的默认值
   * @return 整数或默认值
   */
    public static int readInt(int defaultValue) {
      int n;
      for (; ; ) {
            String str = readKeyBoard(10, true);
            if (str.equals("")) {
                return defaultValue;
            }

            //异常处理...
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
      }
      return n;
    }

    /**
   * 功能：读取键盘输入的指定长度的字符串
   * @param limit 限制的长度
   * @return 指定长度的字符串
   */

    public static String readString(int limit) {
      return readKeyBoard(limit, false);
    }

    /**
   * 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
   * @param limit 限制的长度
   * @param defaultValue 指定的默认值
   * @return 指定长度的字符串
   */

    public static String readString(int limit, String defaultValue) {
      String str = readKeyBoard(limit, true);
      return str.equals("")? defaultValue : str;
    }


    /**
   * 功能：读取键盘输入的确认选项，Y或N
   * 将小的功能，封装到一个方法中.
   * @return Y或N
   */
    public static char readConfirmSelection() {
      System.out.println("请输入你的选择(Y/N): 请小心选择");
      char c;
      for (; ; ) {//无限循环
            //在这里，将接受到字符，转成了大写字母
            //y => Y n=>N
            String str = readKeyBoard(1, false).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N') {
                break;
            } else {
                System.out.print("选择错误，请重新输入：");
            }
      }
      return c;
    }

    /**
   * 功能： 读取一个字符串
   * @param limit 读取的长度
   * @param blankReturn 如果为true ,表示 可以读空字符串。
   *                   如果为false表示 不能读空字符串。
   *
   * 如果输入为空，或者输入大于limit的长度，就会提示重新输入。
   * @return
   */
    private static String readKeyBoard(int limit, boolean blankReturn) {

      //定义了字符串
      String line = "";

      //scanner.hasNextLine() 判断有没有下一行
      while (scanner.hasNextLine()) {
            line = scanner.nextLine();//读取这一行

            //如果line.length=0, 即用户没有输入任何内容，直接回车
            if (line.length() == 0) {
                if (blankReturn) return line;//如果blankReturn=true,可以返回空串
                else continue; //如果blankReturn=false,不接受空串，必须输入内容
            }

            //如果用户输入的内容大于了 limit，就提示重写输入
            //如果用户如的内容 >0 <= limit ,我就接受
            if (line.length() < 1 || line.length() > limit) {
                System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
      }

      return line;
    }
}HouseView

package com.hspedu.houserent.view;

import com.hspedu.houserent.domain.House;
import com.hspedu.houserent.service.HouseService;
import com.hspedu.houserent.utils.Utility;

public class HouseView {
    private boolean loop = true;//控制显示菜单
    private char key;//接受用户选择
    private HouseService houseService = new HouseService(10);

    //显示主菜单
    public void mainMenu() {
      do {
            System.out.println("\n-----------------房屋出租系统-----------------");
            System.out.println("\t\t1 新 增 房 源");
            System.out.println("\t\t2 查 找 房 屋");
            System.out.println("\t\t3 删 除 房 屋");
            System.out.println("\t\t4 修 改 房 屋 信 息");
            System.out.println("\t\t5 房 屋 列 表");
            System.out.println("\t\t6 退      出");
            System.out.println("\n请选择(1-6):");
            key = Utility.readChar();
            switch (key) {
                case '1':
                  System.out.println("1 新增房源");
                  addHouse();
                  break;
                case '2':
                  System.out.println("2 查找房屋");
                  findHouse();
                  break;
                case '3':
                  System.out.println("3 删除房屋");
                  delHouse();
                  break;
                case '4':
                  System.out.println("4 修改房屋信息");
                  modifyHouse();
                  break;
                case '5':
                  System.out.println("5 房屋列表");
                  listHouses();
                  break;
                case '6':
                  System.out.println("6 退出");
                  exit();
                  break;
            }
      } while (loop);
    }


    //1 添加房子
    public void addHouse() {
      System.out.println("=============添加房屋============ ");
      System.out.print("姓名:");
      String name = Utility.readString(8);
      System.out.print("电话:");
      String phone = Utility.readString(12);
      System.out.print("地址:");
      String address = Utility.readString(16);
      System.out.print("月租:");
      int rent = Utility.readInt();
      System.out.print("状态:");
      String state = Utility.readString(3);
      //创建一个新的House对象，注意id是系统分配的,
      House newHouse = new House(0, name, phone, address, rent, state);
      if (houseService.add(newHouse)) {
            System.out.println("\n========房屋添加成功=====\n");
      } else {
            System.out.println("\n========房屋添加失败=====\n");
      }
    }

    //2查找
    public void findHouse(){
      System.out.println("=============查找房屋信息============");
      System.out.println("请输入需要查找的房屋id(-1退出):");
      int findId=Utility.readInt();
      if (findId == -1) {
            System.out.println("=============放弃查找房屋信息============");
            return;
      }
      if (!houseService.find(findId)) {//查找不成功
            System.out.println("房屋编号不存在，查找失败");
      }

    }

    //3 删除房屋编写delHouse()接收输入的id,调用Service 的del方法
    public void delHouse() {
      System.out.println("=============删除房屋信息============");
      System.out.print("请输入待删除房屋的编号(-1退出):");
      int delId = Utility.readInt();
      if (delId == -1) {
            System.out.println("=============放弃删除房屋信息============");
            return;
      }
      //注意该方法本身就有循环判断的逻辑,必须输出Y/N
      char choice = Utility.readConfirmSelection();
      if (choice == 'Y') {//真的删除
            if (houseService.del(delId)) {
                System.out.println("删除房屋信息成功");
            } else {
                System.out.println("房屋编号不存在，删除失败");
            }
      } else {
            System.out.println("=============放弃删除房屋信息============");
      }
    }

    //4修改
    public void modifyHouse(){
      System.out.println("-----------------修改信息-----------------");
      System.out.print("请输入修改房屋的编号(-1退出):");
      int modifyId = Utility.readInt();
      if (modifyId == -1) {
            System.out.println("=============放弃查找房屋信息============");
            return;
      }
      if (!houseService.modify(modifyId)){//未找到
            System.out.println("房屋编号不存在");
      }

    }

    //5 编写listHouse()显示房屋列表
    public void listHouses() {
      System.out.println("-----------------房屋列表-----------------");
      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 == null) {
                break;
            }
            System.out.println(houses);
      }
      System.out.println("\n=============房屋列表显示完毕============\n");
    }

    //6 退出
    //完成退出确认
    public void exit() {
      //这里我们使用Utility提供方法，完成确认
      char c = Utility.readConfirmSelection();
      if (c == 'Y') {
            loop = false;
      }
    }
}
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

查看完整版本: Java学习-第一部分-第一阶段-第八节：项目-房屋出租系统（中级）