房屋出租系统

从页面上来看，就是输出一些东西，并返回一些想对应的值

在这个系统将分为三个模块，

页面层：页面的输出以及输入。可以理解为，我们在app上所看到的一些画面，以及要输入的之类的

业务层：就是在看不到的地方，对接收的信息，进行的处理之类的

模板：房屋信息的模板

那么该怎么做呢？我们可以根据，化繁为简的方式，将其划分成一个个模块，如我们可以先将页面的样子做出

接着就是一个个模块如：1.查看房屋信息  2.新增房屋  3.删除房屋 4.修改房屋信息 5.完成确认退出

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() {
        /**id + '\t':数字 + '\t'，因'\t'但单引号，表示的是字符，那么在打印出来的时候,
        会将'\t' 转换成数字，在码表中 为数字0，你以为会输出： 1空格，实际会输出成下面：
        1+0，1和数字0拼接成一块
         10tom	119	海淀区	2000	未出租
         */
        return  id + "\t" +
                name + '\t' +
                phone + '\t' +
                address + '\t' +
                rent + '\t' +
                state;
    }
}

public class HouseService {
    private House[] houses;

    private int houseNum = 1;//已有房屋个数
    private int houseCounter = 1;

    public HouseService(int size) {
        houses = new House[size];
        houses[0] = new House(1, "tom", "119", "海淀区", 2000, "未出租");
    }


    //添加房屋信息
    public boolean add(House house) {
        if (houseNum == houses.length) {
            System.out.println("房屋信息已满");
            return false;
        }
        //存放房屋信息
        houses[houseNum++] = house;
        house.setId(++houseCounter);
        return true;
    }




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

    /**
     * 查找id  接收id - 方法的返回类型是什么，是House
     * 1.将页面层的id当作一个实参，那么我这边需要一个形参
     * 2.方法的返回类型是什么，是House
     * 3.传过来的id，怎么进行搜索？ 和已有的房屋信息个数，进行比较，看搜索id 和那个房屋信息的Id值相等
     * 4.没有查找等，返回什么？ 返回null
     */
    
    public House find(int findId) {
        /** 这所以这样些是因为，在待返回类型时，
         * 必须是在for循环， if语句的外面也要有返回，而这种方式就是在放回的外面带有返回类型
         * 弄了个 index 的原因，是要将数组中的某个元素返回，那么这样操作的话，就可以先确定是数组中的那个元素
         * 确定后将 i 赋值给 index，之后判断 如果还是index == -1，那么就是没有搜索到，所以直接为空，
         * 而直接为空后。
         * 要是index == -1，那么直接返回null，下面的代码就不会再执行，而如果不等于-1，
         * 那么会继续执行下面的代码，所以这里就直接将其数组中确定那个元素返回
         */
        int index = -1;

        for (int i = 0; i < houseNum; i++) {
            if (findId == houses[i].getId()) {
                index = i;
            }
        }

        if (index == -1) {
            System.out.println("您所查找的id不存在");
            return null;
        }

        return houses[index];
    }

    /**
     *  老韩写法
     */
//    public com.hspdeu.houserent.domain.House findById(int findId) {
//        for (int i = 0; i < houseNums; i++) {
//            //要查找的id是 数组houses[i]中的id属性==要查找的id
//            if (findId == houses[i].getId()) {
//                return houses[i];
//            }
//        }
//        return null;
//    }


    /**  删除房屋
     *  要先查找有没有这个id，找到后进行删除
     *  1.返回类型要返回什么呢？
     *  返回布尔类型，因为返回布尔类型，页面层才可以做判断，不然该怎么判断呢
     *  怎么查找房屋id？
     *  通过要删除的id == 数组中房屋信息中id 等于 要删除的id时
     *  要怎么进行删除呢？
     *  把数组中，要 删除的房屋 在数组中具体是那个元素，将这个元素的下一个元素整体向前挪就可以
     *
     */
    public boolean delHouse(int deleteId) {
        int index = -1;
        for (int i = 0; i < houseNum; i++) {
            if (deleteId == houses[i].getId()) {
                index = i;
            }
        }
        if (index == -1) {
            System.out.println("您所要删除的id信息不存在");
            return false;
        }

        //删除房屋信息
        //怎么个往前挪，确定到要删除的位置，将此后所有的位置向前整体挪，并将最后一位自空

        //上面index，已经定位到要删除的房屋id，在数组中是那个元素了，
        // 那么此刻循环，只是将数组中，已有的房屋信息个数，将其整体向前移动
        //而 houseNum - 1的原因是，不减的话，就会造成数组越界报错
        //如：数组长度是10，而已有10个房屋信息，在houses[i] = houses[i + 1]时
        //i=9时， i+1=10，数组中又没有house[10]，所以就会报错
        for (int i = index; i < houseNum - 1; i++) {
            houses[i] = houses[i + 1];
        }

//        houses[houseNum - 1] = null;
//        houseNum--;
        //简化写法
        houses[--houseNum] = null;
        return true;
    }
    
    /** 老韩写法
    public boolean del(int delId) {
        //应当先找到要删除房屋信息对应的下标
        //老韩强调：一定要搞清楚  下标和房屋的编号不是一回事
        int index = -1;
        //houseNums:是标记已添加房屋信息标记的个数
        for (int i = 0; i < houseNums; i++) {
            //要删除的房屋id，是数组下标为[i]的元素
            if (delId == houses[i].getId()) {
                index = i;
            }
        }
        if (index == -1) {//说明delId在数组中不存在
            return false;
        }
        //如果找到了,删除数组[下标]元素
        //怎么删除呢？就是将数组下一个元素里面的内容，替换掉当前元素的内容
        //houseNums - 1：是因为如果不减1的话，数组会一直执行下去一直到数组的最后一个下标
        //那么到达最后一个下标后，此刻代码还需要将最后一个的下一个数组元素替换给前一个，
        // 因数组中已经没有了元素，所以会报错
        for (int i = index; i < houseNums - 1; i++) {
            houses[i] = houses[i + 1];
        }

        //而这是将已把内容赋值给前一个数组下标的，将此时赋值后的数组下标清空，也就是指向null;
        //houseNums - 1 :把当前houses数组 中存在房屋信息数组中的下标
//        houses[houseNums - 1] = null;
//        //指向null后，数组中确定id
//        houseNums--;

        //简便写法
        houses[--houseNums] = null;
        return true;
    }
     */

}

public class HouseView {

    boolean loop = true;

    char key;

    Utility utility = new Utility();

    Scanner scanner = new Scanner(System.in);

    House house;

    HouseService houseService = new HouseService(2);


    /** 添加房屋
     * 思路：页面层 只是显示添加的页面，也就是别人能看到以及输入的，那么页面
     */
    public void addHouse() {
        System.out.println("-----------添加房屋-----------");
        System.out.println("姓名： ");
        String name = scanner.next();
        System.out.println("电话： ");
        String phone = scanner.next();
        System.out.println("地址： ");
        String address = scanner.next();
        System.out.println("月租： ");
        int rent = scanner.nextInt();
        System.out.println("状态： ");
        String state = scanner.next();

        house = new House(0, name, phone, address, rent, state);

        if (houseService.add(house)) {
            System.out.println("-------添加成功-------");
        }else {
            System.out.println("-------添加失败--------");
        }

    }

    /**  查找房源
     * （页面）输入房屋id - 将id传给业务层，将结果在返回回来
     * 那么这里怎么判断返回，且将怎么些呢？
     * 判断如果为空，那么直接打印，并且直接不执行下面的语句了，如果不为空，就打印结果
     * 如果是不为空，你没有办法进行判断，这里就是先判断
     */
    public void findHouse() {
        System.out.println("-----------查找房屋-----------");
        System.out.println("请输入你要查找的id: ");
        int findId = scanner.nextInt();

        House house = houseService.find(findId);
        if (house == null) {
            return;
        }

        System.out.println(house);
    }

    /**  删除房源
     * 页面：输入id
     * 业务层：这个传入的id，怎么进行查找，也有可能查找不到，那肯定就删除不了
     *
     */
    public void del() {
        System.out.println("请选择待删除的房屋编号(-1退出)");
        int deleteId = scanner.nextInt();

        //if判断（true和false）时，默认为true

        if (houseService.delHouse(deleteId)) {
            System.out.println("----删除成功-------");
        } else {
            System.out.println("-----删除失败-------");
        }
    }

    //查看房屋列表
    public void list() {
        System.out.println("-----------查看房屋-----------");
        House[] houses = houseService.getHouses();
        for (int i = 0; i < houses.length; i++) {
            if (houses[i] != null) {
                System.out.println(houses[i]);
            }
        }
    }

    /**  修改房屋信息
     *  1. 输入修改的id - 搜索有没有该房屋id - 要修改信息时，要将之前的信息显示出来
     *  没有找到房屋信息该怎么处理？ 判断业务层 业务层返回的是类，如果是null，直接结束方法
     *  怎么显示？ 字符拼接 + get方法，将之前的信息显示出来
     *
     */
    public void amend() {
        System.out.println("-----------修改房屋-----------");

        System.out.print("请选择待修改的房屋编号(-1退出): ");
        //查找房屋编号
        int amendId = scanner.nextInt();
        House amendHouse = houseService.find(amendId);
        //没有找到房屋编号时的处理
        if (amendHouse == null) {
            System.out.println("-----------修改失败------------");
            return;
        }

        System.out.println("姓名(" + amendHouse.getName() + "): ");
        String name = scanner.next();
        if (!(" ".equals(name))) {
            amendHouse.setName(name);
        }

        System.out.println("电话(" + amendHouse.getPhone() + ")： ");
        String phone = scanner.next();
        amendHouse.setPhone(phone);
        if (! (name.equals(""))) {
            amendHouse.setPhone(phone);
        }

        System.out.println("地址(" + amendHouse.getAddress() + ")： ");
        String address = scanner.next();
        amendHouse.setAddress(address);
        if (! (name.equals(""))) {
            amendHouse.setAddress(address);
        }

        System.out.println("租金(" + amendHouse.getRent() + ")： ");
        int rent = scanner.nextInt();
        amendHouse.setRent(rent);

        System.out.println("状态(" + amendHouse.getState() + ")： ");
        String state = scanner.next();
        if (! (name.equals(""))) {
            amendHouse.setState(state);
        }


    }

    /**
     * 1.页面先实现
     * 2思路：怎么实现  页面一直存在，那么肯定是要循环，是要用那个循环方法呢 do while
     * 还是 while。 do 是不管怎么都会先执行一遍
     */
    public void mainMenu() {
        do {
            System.out.println("-------------房屋出租系统-------------");
            System.out.println("\t\t\t1 新 增 房 源");
            System.out.println("\t\t\t2 查 找 房 屋");
            System.out.println("\t\t\t3 删 除 房 屋");
            System.out.println("\t\t\t4 修 改 房 屋 信 息");
            System.out.println("\t\t\t5 房 屋 列 表");
            System.out.println("\t\t\t6 删      除");
            System.out.println("请输入选择1-6: ");
            key = utility.readChar();
            switch (key) {
                case '1' :
                    addHouse();
                    break;
                case '2' :
                    findHouse();
                    break;
                case '3' :
                    del();
                    break;
                case '4' :
                    amend();
                    break;
                case '5' :
                    list();
                    break;
                case '6' :
                    loop = false;
            }

        }while (loop);
    }
}

运行

public class HouseRentApp {
    public static void main(String[] args) {
        new HouseView().mainMenu();
    }

}