java项目实战

用面向过程的思想完成一个酒店管理系统

1.分析项目需求

实现一个简单的酒店客房管理系统，它具备5个功能，分别为【1：查看所有房间功能；2：订房功能；3：退房功能；4：修改价格功能；5：退出本系统功能】

房间有哪些信息：所在楼层、房间编号、房间价格、房间状态、房间的类型.这些数据用数组来存储

房间的类型： 单人间、双人间，标准间，商务房，豪华包

房间的价格： 98 128 148 288 688

房间的状态：空闲 有人

房间的楼层： 1,2,3,4,5,6.。。。。。

房间的编号：101,102,103,104,201,202,203….

查看所有房间

实际上就是对数组的遍历，打印在控制台显示

订房

根据用户输入的房间号给该房间改变一下房间的状态即可

退房

根据用户的输入房间号，对该房间号状态改变为空闲即可

修改价格

要根据房间的类型，修改该类型的价格（拿到用户输入的新的价格，把这个新的价格替换掉老的价格）

退出

结束，用户不能在控制继续输入了

2.项目运行效果

3. 代码实现思路：

1.要动态生成一个酒店房间信息的数组

通过观察发现，我们的楼层和房间都是有序的,可以作为数组下标,那我们房间的价格.类型,状态是变化的,可以作为数据,那我们先把这些数据使用一个数组来存储,那我们可以使用到三维数组,结构图如下:

/**
     * 初始化酒店房间信息
     *
     * @param floor 楼层
     * @param count 每一楼包含房间数
     */
    public void initRoom(int floor, int count) {
        //开辟空间
        rooms = new int[floor][count][3];
        //循环赋值
        for (int i = 0; i < rooms.length; i++) { //二维数组
            for (int j = 0; j < rooms[i].length; j++) { //一维数组
                //随机生成一个0-4的整数, 随机产生房间类型, 房间价格
                int index = (int) (Math.random() * 5);
                //for (int k = 0; k < rooms[i][j].length; k++) { //一维数组的元素
                //    rooms[i][j][k]
                //}
                rooms[i][j][0] = prices[index]; //价格
                rooms[i][j][1] = index;//类型
                rooms[i][j][2] = 0;//状态
            }
        }
    }

由于一个三维数组只能存储一种数据类型,于是将类型与状态用在其数组的下标来代替

2.要生成一个酒店管理系统的菜单

要在用用户未按下退出时死循环一直询问客户,使房间信息可以连续操作

数字对应的功能方法执行单独用个方法写起来，在此方法里面调用具体的功能实现,按下数字时跳转至对应的函数

    /**
     * 显示菜单
     */
public void showMenu() {
        System.out.println("\n================欢迎使用飞思酒店管理系统================");
        System.out.println("1.查看房间\t2.订房\t3.退房\t4.修改价格\t5.退出系统");
        System.out.print("请选择您需要服务:");
        Scanner input = new Scanner(System.in);
        int choose = input.nextInt();
        switch (choose) {
            case 1:
                //查看房间
                showAllRoom();
                break;
            case 2:
                // 订房
                Reservation();
                break;
            case 3:
                //退房
                CheckOut();
                break;
            case 4:
                //修改价格
                Modification();
                break;
            case 5:
                //退出系统
                System.exit(1);
                break;
            default:
                System.out.println("没有该选项,请重新输入!");
                showMenu();//本方法调用自己, 方法的递归, 形成一个循环
                break;
        }
    }
public static void main(String[] args) {
        HotelMenager hotelMenager = new HotelMenager();
        hotelMenager.initRoom(3, 5);
        while (true) {
            hotelMenager.showMenu();
        }
    }

3.​ 生成查看所有房间的方法

将数组遍历打印出来简单粗暴,但可读性弱,格式也混乱,使用

 if (j > 0) {
                    System.out.print("\t\t");
                }

在不是在每一层的第一楼的情况下空出楼层的位置使格式整齐

使用函数

    /**
     * 显示房间编号方法
     *
     * @param floor 楼层 从1开始
     * @param index 房间序号(从1开始)
     * @return 房间编号
     */
private static String showRoomNum(int floor, int index) {
        String str = "";
        if ((index + 1) < 10) {
            str = floor + "0" + index;
        } else {
            str = floor + "" + index;
        }
        return str;
    }

在房间数小于十时自动补零,使其更符合日常使用

System.out.print(rooms[i][j][0] + "\t" + types[rooms[i][j][1]] + " \t\t" + status[rooms[i][j][2]]);

 由于rooms里面的类型与属性状态都是存储的下标,直接输出可读性差,将下标放入其数组中输入,可读性强.

    /**
     * 查看房间
     */
    public void showAllRoom() {
        System.out.println("楼层\t\t编号\t价格\t类型 \t\t状态");
        for (int i = 0; i < rooms.length; i++) { //二维数组
            System.out.print(i + 1 + "\t\t");
            for (int j = 0; j < rooms[i].length; j++) { //一维数组
                if (j > 0) {
                    System.out.print("\t\t");
                }
                String str = showRoomNum(i + 1, j + 1);
                System.out.print(str + "\t");
                System.out.print(rooms[i][j][0] + "\t" + types[rooms[i][j][1]] + " \t\t" + status[rooms[i][j][2]]);
                System.out.println();
            }
        }
    }

4.​ 生成订房的方法

为了用户输入时不会因为输入与Scanner函数所指定数据类型不同使系统报错,给用户不好的体验使用

input.hasNextInt()

在用户输入后先做数据类型判断,再使用Scanner函数接收数据.

为了让用户的交互性强,能够知道清楚的知道限制,本方法使用了比较复杂的多重条件语句,对

楼层,房间进行一步步的提示,

public void Reservation() {
    Scanner input = new Scanner(System.in);
    int floor = rooms.length; // 总楼数
    System.out.print("请选择楼层(1-" + floor + "):");
    if (input.hasNextInt()) {
        int roomFloor = input.nextInt(); // 输入的楼层数
        if (roomFloor > 3 || roomFloor < 1) {
            System.out.println("没有该楼层,请重新输入");
            Reservation(); // 递归调用Reservation()方法，重新选择楼层
        } else {
            int room = rooms[roomFloor - 1].length; // 总房间数
            System.out.print("请选择房间(1-" + room + "):");
            if (input.hasNextInt()) {
                int roomNum = input.nextInt(); // 输入的房间数
                if (roomNum > 8 || roomNum < 1) {
                    System.out.println("没有该房间,请重新输入");
                    Reservation(); // 递归调用Reservation()方法，重新选择房间
                } else {
                    if (rooms[roomFloor - 1][roomNum - 1][2] == 0) {
                        System.out.println("订房成功!您预订房间编号:" + showRoomNum(roomFloor, roomNum));
                        rooms[roomFloor - 1][roomNum - 1][2] = 1; // 将房间状态标记为已入住

                    } else {
                        System.out.println("房间已经有人入住!");
                        Reservation(); // 递归调用Reservation()方法，重新选择房间
                    }
                }
            } else {
                System.out.println("错误提示:输入有误");
                Reservation(); // 递归调用Reservation()方法，重新选择房间
            }
        }
    } else {
        System.out.println("错误提示:输入有误");
        Reservation(); // 递归调用Reservation()方法，重新选择楼层
    }
}

rooms[roomFloor - 1][roomNum - 1][2]输入的房间数-1就是输入房间的数组下标[2]是类型

4.​ 生成退房的方法

退房与订房并没有太大不同对于房间输入的限制,提示几乎一模一样,只需修改最后的一步即可

public void CheckOut() {
    Scanner input = new Scanner(System.in); // 创建一个Scanner对象来获取用户输入
    int floor = rooms.length; // 获取楼层数
    System.out.print("请选择楼层(1-" + floor + "):"); // 提示用户选择楼层
    if (input.hasNextInt()) { // 检查用户输入是否为整数
        int bookFloor = input.nextInt(); // 获取用户输入的楼层号
        if (bookFloor > 3 || bookFloor < 1) { // 检查楼层号是否超出范围
            System.out.println("没有该楼层,请重新输入"); // 提示用户重新输入
            CheckOut(); // 递归调用CheckOut()方法，重新选择楼层
        } else {
            int roomNum = rooms[floor - 1].length; // 获取选择楼层的房间数
            System.out.print("请选择房间(1-" + roomNum + "):"); // 提示用户选择房间
            if (input.hasNextInt()) { // 检查用户输入是否为整数
                int bookRoom = input.nextInt(); // 获取用户输入的房间号
                if (bookRoom > 8 || bookRoom < 1) { // 检查房间号是否超出范围
                    System.out.println("没有该房间,请重新输入"); // 提示用户重新输入
                    CheckOut(); // 递归调用CheckOut()方法，重新选择房间
                } else {
                    if (rooms[bookFloor - 1][bookRoom - 1][2] == 1) { // 检查选择的房间是否有人入住
                        System.out.println("退房成功!您退出房间编号:" + showRoomNum(bookFloor, bookRoom)); // 打印退房成功消息
                        rooms[bookFloor - 1][bookRoom - 1][2] = 0; // 将房间的入住状态设置为0，表示空房间
                    } else {
                        System.out.println("房间没有人入住!"); // 打印房间没有人入住的消息
                        CheckOut(); // 递归调用CheckOut()方法，重新选择房间
                    }
                }
            } else {
                System.out.println("错误提示:输入有误"); // 提示用户输入有误
                CheckOut(); // 递归调用CheckOut()方法，重新选择房间
            }
        }
    } else {
        System.out.println("错误提示:输入有误"); // 提示用户输入有误
        CheckOut(); // 递归调用CheckOut()方法，重新选择楼层
    }
}

5.​ 生成修改价格的方法

在输入房间类型名后,遍历找到每个有房间类型名的房间,修改他们的价格

public void Modification() {
    Scanner input = new Scanner(System.in); // 创建一个Scanner对象来获取用户输入
    System.out.println("请输入要修改价格的房间类型:"); // 提示用户输入要修改价格的房间类型
    String roomType = input.next(); // 获取用户输入的房间类型
    boolean flag = false; // 创建一个标志变量，用于判断是否找到了要修改价格的房间类型
    for (int r = 0; r < types.length; r++) { // 遍历房间类型数组
        if (types[r].equals(roomType)) { // 如果找到了要修改价格的房间类型
            System.out.println("请输入要修改的价格:"); // 提示用户输入要修改的价格
            int roomPrice = input.nextInt(); // 获取用户输入的价格
            flag = true; // 将标志变量设置为true，表示找到了要修改价格的房间类型
            for (int i = 0; i < rooms.length; i++) { // 遍历楼层
                for (int j = 0; j < rooms[i].length; j++) { // 遍历房间
                    if (roomType.equals(types[rooms[i][j][1]])) { // 如果房间类型与要修改价格的房间类型相同
                        rooms[i][j][0] = roomPrice; // 修改房间的价格
                    }
                }
            }
        }
    }
    if (!flag) { // 如果没有找到要修改价格的房间类型
        System.out.println("没有这种房间类型,请重新输入"); // 提示用户重新输入
        Modification(); // 递归调用Modification()方法，重新输入房间类型
    } else {
        System.out.println("修改价格成功!"); // 打印修改价格成功的消息
    }
}