java面向对象之实现房屋出租系统

一.先对需求进行分析

我们的房屋出租系统用数组简单实现，首先分析需求主要分为：

              1.新增房源                    
              2.查找房屋                    
              3.删除房屋信息                
              4.修改房屋信息                
              5.房屋列表                
              6.退出系统 

六大功能。在实现较为复杂的功能时，我们应该有意识的将代码分为各个模块。

r

二.分别处理不同层

view层主要实现显示的功能

/**
 * 1.显示界面
 * 2.接收用户的输入
 * 3.调用HouseService完成对房屋信息的各种操作
 */
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("              1.新增房源                    ");
            System.out.println("              2.查找房屋                    ");
            System.out.println("              3.删除房屋信息                ");
            System.out.println("              4.修改房屋信息                ");
            System.out.println("              5.房屋列表                ");
            System.out.println("              6.退出系统                ");
            System.out.println("请选择（1-6）：                          ");
            key = util.Utility.readChar();
            //使用分支结构
            switch (key){
                case '1' :
                    addHouse();
                    break;
                case '2' :
                    searchHouse();
                    break;
                case '3' :
                    deleteHouse();
                    break;
                case '4' :
                    changeHouse();
                    break;
                case '5' :
                    listHouses();
                    break;
                case '6':
                    exit();
                    break;
                default:
                    System.out.println("选择有误，请重新选择 ");
            }
        }while(loop);
    }

    //接收输入，创建House对象，调用add方法
    public void addHouse(){
        System.out.println("---------------房屋添加---------------");
        System.out.println("姓名:");
        String name = util.Utility.readString(8);
        System.out.println("电话:");
        String phone = util.Utility.readString(12);
        System.out.println("地址:");
        String address = util.Utility.readString(16);
        System.out.println("月租:");
        int rent = util.Utility.readInt();
        System.out.println("状态:");
        String state = util.Utility.readString(3);
        //创建一个新的House对象，id是系统分配，用户不能输入
        House newHouse = new House(0,name,phone,address,rent,state);
        if (houseService.add(newHouse)){
            System.out.println("============添加房屋成功=============");
        }else{
            System.out.println("============添加房屋失败=============");
        }
    }

    public void searchHouse(){
        System.out.println("---------------房屋查询---------------");
        System.out.println("==========输入你要查找的房屋id=========");
        int searchId = util.Utility.readInt();
        House house = houseService.search(searchId);
        if (house==null){
            System.out.println("你输入的id有误");
        }else{
            System.out.println("编号\t\t房主\t\t电话\t\t地址\t\t月租\t\t状态(未出租/已出租)");
            System.out.println(house);
        }
    }

    public void deleteHouse(){
        System.out.println("---------------房屋删除---------------");
        System.out.println("输入你要删除房屋的id(-1)退出");
        int delId = util.Utility.readInt();
        if (delId == 1) {
            System.out.println("============放弃删除房屋信息============");
        }
        //注意该方法本身就有循环判断的逻辑，必须输出Y/N
        char choice = util.Utility.readConfirmSelection();//注意只有输入正确才能成功
        if (choice == 'Y') {//真的要删除
           System.out.println("你已经删除成功");
        }
    }

    public void changeHouse(){
        System.out.println("---------------请输入你要修改房屋的id---------------");
        int changeId = util.Utility.readInt();
        House house = houseService.search(changeId);
        if (house == null) {
            System.out.println("你输入的id有误");
        }else{
            System.out.println("编号\t\t房主\t\t电话\t\t地址\t\t月租\t\t状态(未出租/已出租)");
            System.out.println(house);
            System.out.println("输入你要修改的房屋的信息");
            System.out.println("姓名:");
            String name = util.Utility.readString(8);
            System.out.println("电话:");
            String phone = util.Utility.readString(12);
            System.out.println("地址:");
            String address = util.Utility.readString(16);
            System.out.println("月租:");
            int rent = util.Utility.readInt();
            System.out.println("状态:");
            String state = util.Utility.readString(3);
            house.setHouseOwer(name);
            house.setPhone(phone);
            house.setAddress(address);
            house.setRent(rent);
            house.setState(state);
        }
    }

    //编写listHouses()显示房屋列表
    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[i] != null){
                System.out.println(houses[i]);
            }
        }
        System.out.println("----------房屋列表显示完毕------------");
    }

    public void exit(){
        char choice = util.Utility.readConfirmSelection();//注意
        if (choice == 'Y') {//真的要删除
            System.out.println("退出系统成功");
            loop = false;
        }
    }
}

service主要实现我们所用到的具体的方法:

/**
 * //定义House[]，保存House对象
 * 1.响应HouseView的调用
 * 2.完成对房屋信息的各种操作(增删改查)
 */
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[size];
        houses[0] = new House(1,"张三","123","临沂",45,"1");
    }

    public House[] list(){
        return houses;
    }

    //add添加新对象，返回boolean
    public boolean add(House newHouse){
        //判断是否可以继续添加（我们暂时不考虑数组扩容的问题）
        if (houseNums == houses.length){
            System.out.println("数组已经满了，不能添加");
            return false;
        }
        houses[houseNums++] = newHouse;
        //我们程序员需要设置一个id自增长的机制
        newHouse.setId(++idCounter);
        return true;
    }

    //定义一个方法，删除一个房屋信息
    public boolean delete(int delId) {
        //应该要找到删除房屋的信息对应的下标
        //下标和房屋编码号不一致
          int index = -1;
          for (int i = 0; i < houseNums; i++){
              if (delId == houses[i].getId()) {//删除房屋对应的id，在下标为i的元素
                  index = i;//使用index记录这个i
              }   
          }
          if (index == -1){//说明delId在数组中不存在
              return false;
          }
          for (int i = 0; i < houseNums - 1; i++){
              houses[i] = houses[i+1];
          }
          houses[--houseNums] = null;//把当有存在的房屋信息的最后一个，设置null
          return true;
    }

    public House search(int searchId) {
        int index = 0;
        for (int i = 0; i < houseNums; i++){
            if(searchId == houses[i].getId()) {
                index = i;//记录id相同的数组的下标
            }
        }
        if (index==0){
            return null;
        }
        else{
            return houses[index];
        }
    }

    public void change(House house){

    }

}

util是我们的工具包类,里边有对输入的相关处理方法的封装：

public class 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;
        }
    }
}