Java创建简单订房管理程序（附详细代码）_java 根据房间数量 创建多次订单

如何用java创建一个简单的订房管理程序呢

首先，我们需要明确功能，该订房管理程序有4个基本功能：
1. 订房 2. 退房 3. 查询 4. 退出
我们假设某酒店有3层客房，一层为单人间，二层为标准间，三层为豪华间，每层相应的房间数量都为10个，用户输入所对应的数字进行相应操作，如果不退出的话会一直循环，直到输入4才能退出。订房时不考虑每次订房数量问题。

其次，我们需要分析各层功能该如何编写。
程序首先要进行初始化，定义数组，记录房型，房间号，和房间状态
对三种房型分别进行定义初始化。
由于不退出的话会一直循环，所以要定义一个外层循环判断
订房功能：
若有空余房间，则可以根据选择预订需要的房间，每次成功订完后，相应剩余空闲房间数-1，直到房间订完提示没有空房
退房功能：
如果没有订房就退房，肯定不行，会提示尚未预订，若订过房后退房，则剩余空闲房间数+1，只考虑客户退房房型输入正确的情况
查询功能：
客户订房退房后，酒店可以查询空房状态，显示各房型有哪些空余闲房间
退出功能：
客户输入4后跳出循环，退出程序

最后，编写运行。

public static void main(String[] args) {
        // 功能：
        // 1、订房 2、退房 3、查询 4、退出
        System.out.println("================");
        System.out.println("=== 1、订房");
        System.out.println("=== 2、退房");
        System.out.println("=== 3、查询");
        System.out.println("=== 4、退出");
        System.out.println("================");

        // 初始化房间容量
        int sig = 10;
        int dou = 10;
        int nic = 10;

        // 初始剩余房间量
        int sigRemain = 10;
        int douRemain = 10;
        int nicRemain = 10;

        // 初始化单人间状态
        String[][] sigRoom = new String[10][3];
        for (int i = 0; i < sigRoom.length; i++) {
            for (int j = 0; j < sigRoom[i].length; j++) {
                sigRoom[i][0] = "单人间 ";
                sigRoom[i][1] = (i + 101) + " ";
                sigRoom[i][2] = "空闲";
            }
        }

        // 初始化标准间状态
        String[][] douRoom = new String[10][3];
        for (int i = 0; i < douRoom.length; i++) {
            for (int j = 0; j < douRoom[i].length; j++) {
                douRoom[i][0] = "标准间 ";
                douRoom[i][1] = (i + 201) + " ";
                douRoom[i][2] = "空闲";
            }
        }

        // 初始化豪华间状态
        String[][] nicRoom = new String[10][3];
        for (int i = 0; i < nicRoom.length; i++) {
            for (int j = 0; j < nicRoom[i].length; j++) {
                nicRoom[i][0] = "豪华间 ";
                nicRoom[i][1] = (i + 301) + " ";
                nicRoom[i][2] = "空闲";
            }
        }

        // 不考虑每次订房数量且不同房型和退房房型输入不正确的情况,且仅考虑输入情况为数字

        // 定义初始订房历史记录数为0,防止一直退房成功
        int sigHistory = 0;
        int douHistory = 0;
        int nicHistory = 0;
        while (true) {
            System.out.println("请选择你要进行的功能：");
            int num = new Scanner(System.in).nextInt();
            switch (num) {
                // 1、订房
                // 订房时从每层第一间开始订
                case 1:
                    System.out.println("======================");
                    System.out.println("请选择你要预定的房间类型：");
                    System.out.println("=== 1、单人间");
                    System.out.println("=== 2、标准间");
                    System.out.println("=== 3、豪华间");
                    System.out.println("======================");
                    // 定义输入判断1，若输入错误则需一直输入直到正确
                    boolean flag1 = true;
                    while (flag1) {
                        int select = new Scanner(System.in).nextInt();
                        if (select > 0 && select < 4) {
                            // 预订单人间
                            if (select == 1 && sigRemain > 0) {
                                // 预订一次剩余房间数-1
                                sigRemain--;
                                // 订过房则有订房记录，可以退房
                                sigHistory++;
                                System.out.println("恭喜您单人间预定成功！");
                            // 预订标准间
                            } else if (select == 2 && douRemain > 0) {
                                // 预订一次剩余房间数-1
                                douRemain--;
                                // 订过房则有订房记录，可以退房
                                douHistory++;
                                System.out.println("恭喜您标准间预定成功！");
                            // 预订豪华间
                            } else if (select == 3 && nicRemain > 0) {
                                // 预订一次剩余房间数-1
                                nicRemain--;
                                // 订过房则有订房记录，可以退房
                                nicHistory++;
                                System.out.println("恭喜您豪华间预定成功！");
                            // 如果没房则无法订房
                            } else {
                                System.out.println("不好意思，房间已经全部订完！");
                                break;
                            }
                            // 预定成功跳出循环
                            flag1 = false;
                        } else {
                            System.out.println("选择房间类型错误，请重新输入！");
                        }
                    }
                    break;

                // 2、退房
                case 2:

                    System.out.println("请选择你要退订的房间类型：");
                    // 定义输入判断2，若输入房间类型错误则需一直输入直到正确
                    boolean flag2 = true;
                    while (flag2) {
                        // 接收要退订的房间类型
                        int select2 = new Scanner(System.in).nextInt();
                        if (select2 > 0 && select2 < 4) {
                            switch (select2) {
                                case 1:
                                    // 若未订过单人间，报错退出
                                    if (sigHistory - 1 < 0) {
                                        System.out.println("您尚未预订单人间！请重新选择功能！");
                                        break;
                                    }
                                    sigRemain++;
                                    sigHistory--;
                                    System.out.println("恭喜您单人间退房成功！");
                                    break;
                                case 2:
                                    // 若未订过标准间，报错退出
                                    if (douHistory - 1 < 0) {
                                        System.out.println("您尚未预订标准间！请重新选择功能！");
                                        break;
                                    }
                                    douRemain++;
                                    douHistory--;
                                    System.out.println("恭喜您标准间退房成功！");
                                    break;
                                case 3:
                                    // 若未订过豪华间，报错退出
                                    if (nicHistory - 1 < 0) {
                                        System.out.println("您尚未预订豪华间！请重新选择功能！");
                                        break;
                                    }
                                    nicRemain++;
                                    nicHistory--;
                                    System.out.println("恭喜您豪华间退房成功！");
                                    break;
                            }
                            // 退订成功跳出循环
                            flag2 = false;
                        } else {
                            System.out.println("输入房间型错误，请重新输入");
                        }
                    }
                    break;

                // 3、查询
                case 3:
                    System.out.println("*************************");
                    System.out.println("空房状态：");
                    System.out.println("*************************");
                    // 输出空闲的单人间
                    for (int i = sig - sigRemain; i < sig; i++) {
                        for (int j = 0; j < sigRoom[i].length; j++) {
                            System.out.print(sigRoom[i][j] + " ");
                        }
                        System.out.println();
                    }
                    System.out.println("*************************");
                    // 输出空闲的标准间
                    for (int i = dou - douRemain; i < dou; i++) {
                        for (int j = 0; j < douRoom[i].length; j++) {
                            System.out.print(douRoom[i][j] + " ");
                        }
                        System.out.println();
                    }
                    System.out.println("*************************");
                    // 输出空闲的豪华间
                    for (int i = nic - nicRemain; i < nic; i++) {
                        for (int j = 0; j < nicRoom[i].length; j++) {
                            System.out.print(nicRoom[i][j] + " ");
                        }
                        System.out.println();
                    }
                    break;

                // 4、退出系统
                case 4:
                    System.exit(0);
                default:
                    System.out.println("输入错误，请重新输入！");
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196

有兴趣的小伙伴们可以尝试自己动手编写运行一下哦！