【OOP】租房系统复盘总结

迈不过友情╰ 2023-09-29 13:36 13阅读 0赞

#### 学习目录 ####

*   *  前言
     *  一.需求
     *  二.分层设计
     *  三.具体功能
     *   *  1.显示主菜单功能
         *  2.查找房源功能
         *  3.增添房源功能
         *  4.删除房源功能
         *  5.修改房屋功能
         *  6.显示房源功能
         *  7.退出校验功能
         *  8.用户入口

### 前言 ###

通过这个小项目，加深入了我Java面向对象的理解，树立了编程重视逻辑的认知，以及对细节的处理能力，对需求的实现能力，以下是我对这个小项目的理解：  
~还有很多前端页面没有写，也没有连接数据库就当作是个半成品吧  
.这是跟着老韩做的有没有小伙伴也跟着写过呢哈哈哈

### 一.需求 ###

实现基于文本界面的房屋出租软件。  
能够实现对房屋信息的添加、修改和删除（用数组实现），并能够打印房屋明细表  
![在这里插入图片描述][6e1c5cddf20f405bacec7c9abf03f0e5.png]

展示一个草草写的前端页面：(有点丑哈哈哈)  
![在这里插入图片描述][8410a4e66fb940ae9f93982fb5d85d0d.png]

### 二.分层设计 ###

**1.编写House类用于存放属性  
2.编写HouseView类用于显示  
3.编写HouseService用于实现功能  
4.编写HouseShow用于在主方法中调用方法实现用户操作**  
通过多个类之间属性，方法的调用实现功能的交互，每个类各司其职，条理更加清晰

### 三.具体功能 ###

**操作的细节都写在代码块的注释里了噢**  
房源属性设置：

public class House {
        
        //编号 房主 电话 地址 月租 状态(未出租/已出租)
        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;
        } 
        //这里用于封装的get,set 方法省略了....
        //为了方便的输出对象信息,我们实现toString
        public String toString(){
        
            return id+"\t"+name+"\t"+phone+"\t"+address+"\t\t"+rent+"\t\t"+state;
        }
    }

初始化业务层对象HouseService，引入工具包Utility

import yu7.daily.houserent.utility.Utility;
    
    /**
     * //定义House[],保存House对象
     * //1.响应HouseView的调用
     * //2.完成对房屋信息的各种操作(增删改查lc[create]r[read]u[update]d[delete])
     */
    public class HouseService {
        
        private House[] houses;  //保存House对象
        private int houseNum = 1;
        private int idCounter = 1;  //记录房屋个数
    
        //带参构造器
        public HouseService(int size) {
        
            houses = new House[size];  //当创建HouseService对象,指定数组大小
            //为了配合测试，这里初始化一个对象
            houses[0] = new House(1, "mike", "18995895873", "xxxxx",   2000, "未出租");
        }

引入显示层必要属性：

private boolean loop = true;  //控制do-while语句
        private String key;//控制switch语句
        private HouseService houseService = new HouseService(10);  //创建设置数组大小为10

#### 1.显示主菜单功能 ####

显示层：

//主菜单
        public void mainMenu() {
        
            do {
        
                System.out.println("=========房屋出租系统===========");
                System.out.println("\t1 查 找 房 源");
                System.out.println("\t2 新 增 房 源");
                System.out.println("\t3 删 除 房 屋 信 息");
                System.out.println("\t4 修 改 房 屋 信 息");
                System.out.println("\t5 房 屋 列 表");
                System.out.println("\t6 退 出");
                System.out.println("\t请输入1-6");
                key = Utility.readString(1);    //调用的是Utility里的静态方法 不用实例化直接用！
                switch (key) {
           //开关控制 处理输入的key
                    case "1":
                        findHouse(); //查找房源
                        break;
                    case "2":
                        addHouse(); //增添房源
                        break;
                    case "3":
                        delHouse(); //删除房源
                        break;
                    case "4":
                        update(); //修改房源
                        break;
                    case "5":
                        listHouse(); //显示房源
                        break;
                    case "6":
                        backOf(); //退出
                        loop = false;   //退出循环啦
                        break;
                }
            } while (loop);   //退出do-while的条件loop=false
        }

**用户只需要在主函数调用此方法就可体验所有功能**

#### 2.查找房源功能 ####

显示层：

//查找房屋操作
        public void findHouse() {
        
            System.out.println("================查找房屋信息==============");
            System.out.println("请输入查找id:");
            int findId = Utility.readInt();
            House house = houseService.findByid(findId);  //实例化的对象house指向地址！！
            //findByid方法的返回类型是House 这里我要创建一个House对象来调用对应的方法
            // 体现了"类型一致性原则!"
            if (house != null) {
        
                System.out.println(house); 
          //如果地址不为空 那我就输出那个地址，也就是houseService.findByid(findId)中对应的house[i]
            } else {
        
                System.out.println("对不起没找到~~~");
            }
        }

业务层：

//查找房屋id
    public House findByid(int findId){
        
        for (int i = 0; i < houseNum; i++) {
            //遍历数组
            if (houses[i].getId()==findId){
        
                 return houses[i];    //如果找到了 就返回当前数组元素里的全部信息，也就是房屋信息
            }
        }return null;   //循环完了没找到 就返回空
    }

#### 3.增添房源功能 ####

显示层：

//通过addHouse()接收输入，创建House对象，调用add方法
        public void addHouse() {
        
            System.out.println("------------添加房屋-----------");
            System.out.println("姓名:");
            String name = Utility.readString(8);   //通过引用工具包静态方法实现录入输进去的字符串
            System.out.println("电话:");
            String phone = Utility.readString(11);
            System.out.println("地址:");
            String address = Utility.readString(12);
            System.out.println("月租:");
            int rent = Utility.readInt(5);
            System.out.println("状态(已出租/未出租)");
            String state = Utility.readString(3);
            //创建一个新的House对象，id是系统分配的
            House house = new House(0, name, phone, address, rent, state);
            if (houseService.add(house)) {
           //这里我直接调用方法当条件 是因为我的判断逻辑写在方法里
                System.out.println("添加房屋成功~~~~");
            } else {
        
                System.out.println("添加房屋失败~~~~");
            }
        }

业务层：

//增添房源，添加新对象，返回boolean
        public boolean add(House newHouse) {
        
            if (houseNum == houses.length) {
         //不能再添加了
                System.out.println("数组已满，不能再添加了！！！");
                return false;
            }
            //把newHouse对象新增到新加的房屋
            houses[houseNum++] = newHouse;
            //设计一个id自增机制
            //调用set方法就是对返回的id进行控制 通过在方法里传入自增的idCounter来实现自增
            idCounter++;
            newHouse.setId(idCounter);
    //      newHouse.setId(++idCounter);
            return true;
        }

#### 4.删除房源功能 ####

显示层：

//编写delHouse()输入id，调用HouseService里的del()方法删除
        public void delHouse() {
        
            System.out.println("===========删除房屋信息===========");
            System.out.println("请输入要删除的房屋编号(输入-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("=========放弃了删除房屋信息========");
            }
        }

业务层：

//del删除房屋信息方法
        public boolean del(int delId){
        
            //1.先找到要删除的房屋信息对应的下标！
            int index=-1;
            //!!!下标和房屋编号不是一回事 要区分清楚
            for (int i = 0; i <houseNum; i++) {
        
                if (delId == houses[i].getId()) {
                //保持类型一致
                    index = i;  //使用index记录i
                }
            }
            if (index==-1) {
            //说明输入的delId在getId里面找不到
                    return false;
                }
            //2.删除
            for (int i=index;i<houseNum-1;i++){
        
            //在找到要删除的对应房屋下标i之后 我就把他对应位置的后一个元素的地址给前一个，起到一个覆盖的作用间接实现删除
                  houses[i]=houses[i+1];
            }
            houses[houseNum]=null;  //然后把i+1的元素地址滞空  两者相结合达到删除的效果
            houseNum--;
            return true;
        }

#### 5.修改房屋功能 ####

无需分层，直接通过调用setName方法来修改

//修改房屋信息
        public void update() {
        
            System.out.println("==============修改房屋信息================");
            System.out.println("请选择待修改房屋的编号~(-1退出)");
            int updateId = Utility.readInt();
            if (updateId == -1) {
        
                System.out.println("============放弃修改房屋===========");
                return;
            }
            //根据输入得到的updateId,查找对象
            House house = houseService.findByid(updateId);     //返回的是引用类型，就是数组里的元素
            if (house == null) {
           //如果输入的编号不能找到的 就退出
                System.out.println("您要修改的房屋不存在");
                return;
            }
    
            System.out.print("姓名(" + house.getName() + "):");
            String name = Utility.readString(4, "无");   //用户直接回车不修改，给一个默认值“无”
            if (!"无".equals(name)) {
          //当我没有输入的要修改的name，直接回车，给的是默认值 就不满足修改的条件我就不会把值传给setName方法
                house.setName(name);   //修改操作  把新修改的值给setName方法达到修改的目的
            }
            System.out.print("电话(" + house.getPhone() + "):");
            String phone = Utility.readString(11, "无");
            if (!"无".equals(phone)) {
        
                house.setPhone(phone);   //修改操作
            }
            System.out.print("地址(" + house.getAddress() + "):");
            String address = Utility.readString(10, "无");
            if (!"无".equals(address)) {
        
                house.setAddress(address);   //修改操作
            }
            System.out.print("月租(" + house.getRent() + "):");
            int rent = Utility.readInt(15);
            if (!"无".equals(rent)) {
        
                house.setRent(rent);   //修改操作
            }
            System.out.print("状态(" + house.getState() + "):");
            String state = Utility.readString(10, "无");
            if (!"无".equals(state)) {
        
                house.setState(state);   //修改操作
            }
            System.out.println("修改成功~~~");
            return ;
    
        }

#### 6.显示房源功能 ####

显示层：

//调用list()方法，通过返回值显示出来
      public void listHouse() {
        
            System.out.println("=========房屋列表========");
            System.out.println("编号\t房主\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) {
        
                    //这个逻辑的作用在于 当我循环遍历整个数组，房屋个数小于十个我就不会出现输出null的情况
                    break;
                }
                System.out.println(houses[i]);
            }
            System.out.println("-------------房屋列表显示完成-------------");
        }

业务层：

//通过创建返回类型为House的方法返回已有的houses信息
        public House[] list() {
           //注意这里是House[]   要注意类型一致
            return houses;
        }

#### 7.退出校验功能 ####

显示层：

//确认退回操作
        public void backOf() {
          //此方法用于接收 然后在本类中调用
            if (houseService.back()) {
           //用方法当判断条件，是因为逻辑在方法里已经体现了
                System.out.println("您已经退出了系统~~~");
            } else {
        
                System.out.println("您刚刚竟然取消了操作！oh my god!");
            }
        }

业务层：

//确认退回操作
        public boolean back(){
        
            char choiceKey= Utility.readConfirmSelection();   // 确认Y/N工具
            if (choiceKey=='Y'){
           //读取的是Y就退出，反之
                return true;
            }
            if (choiceKey=='N'){
        
            }return false;
        }

#### 8.用户入口 ####

public class HouseShow {
        
        public static void main(String[] args) {
        
            new HouseView().mainMenu();  //多学学这个调用类方法的写法 比以前实例化类用对象来调方法简洁，一句话搞定！
    
        }
    }

一个简单的功能可能需要复杂的逻辑去实现，更别说复杂的功能  
路的尽头终究是路  
写在最后：  
引用一个小伙伴儿的话：你间歇性的努力和蒙混过日子，都是对之前努力的清零。

[6e1c5cddf20f405bacec7c9abf03f0e5.png]: https://img-blog.csdnimg.cn/6e1c5cddf20f405bacec7c9abf03f0e5.png
[8410a4e66fb940ae9f93982fb5d85d0d.png]: https://img-blog.csdnimg.cn/8410a4e66fb940ae9f93982fb5d85d0d.png