JAVA二维数组模拟酒店管理系统-动力节点老杜

package 酒店;
import java.util.Scanner;
public class Room {
    
    

    public static void main(String[] args) {
    
    
        Hotel hotel = new Hotel();
        System.out.println("欢迎使用酒店管理系统，请认真阅读以下使用说明");
        System.out.println("功能编号对应的功能：[1]表示查看房间列表。[2]表示订房。[3]表示退房。[0]表示退出系统。");
        Scanner s = new Scanner(System.in);
        while(true){
    
    
            System.out.print("请输入功能编号：");
            int i = s.nextInt();
            if(i == 1){
    
    
                // 查看房间列表
                hotel.print();
            }else if(i == 2){
    
    
                // 订房
                System.out.print("请输入订房编号：");
                int roomNo = s.nextInt(); //小姐姐输入房间编号
                hotel.order(roomNo);
            }else if(i == 3){
    
    
                // 退房
                System.out.print("请输入退房编号：");
                int roomNo = s.nextInt(); //小姐姐输入房间编号
                hotel.exit(roomNo);
            }else if(i == 0){
    
    
                // 退出系统
                System.out.println("再见，欢迎下次再来！");
                return;
            }else{
    
    
                // 出错了！
                System.out.println("输入功能编号有误，请重新输入！");
            }
        }
    }


}
 class Hotel{
    
    
    private Roo[][] rooms;

    // 盖楼通过构造方法来盖楼。
    public Hotel() {
    
    
        // 一共有几层，每层的房间类型是什么，每个房间的编号是什么。
        // 我们可以先写死。一共三层、一层单人间、二层标准间、三层总统套房，每层有10个房间。
        /**
         * 房间编号
         * 1楼：101 102 103 104 105 106..
         * 2楼：201 202 203 204 205 206..
         * 3楼：301 302 303 304 305 306..
         * ...
         */
        // 动态初始化
        rooms = new Roo[3][10]; // 3行10列。3层楼，每层10个房间。

        // 创建30个Room对象，放到数组当中。
        // 怎么放？ 二维数组遍历。
        for (int i = 0; i < rooms.length; i++) {
    
     // i是下标：0 1 2。i+1是楼层：1,2,3
            for (int j = 0; j < rooms[i].length; j++) {
    
    
                if (i == 0) {
    
    
                    // 一层
                    rooms[i][j] = new Roo((i + 1) * 100 + j + 1, "单人间", true);
                } else if (i == 1) {
    
    
                    // 二层
                    rooms[i][j] = new Roo((i + 1) * 100 + j + 1, "标准间", true);
                } else if (i == 2) {
    
    
                    // 三层
                    rooms[i][j] = new Roo((i + 1) * 100 + j + 1, "总统套房", true);
                }
            }
        }
    }

    // 在酒店对象上提供一个打印房间列表的方法
    public void print(){
    
    
        // 打印所有房间状态,就是遍历二维数组
        for(int i = 0; i < rooms.length; i++){
    
    
            // 里面for循环负责输出一层。
            for(int j = 0; j < rooms[i].length; j++) {
    
    
                Roo room = rooms[i][j];
                System.out.print(room);
            }
            // 换行
            System.out.println();
        }
    }

    /**
     * 订房方法。
     * @param roomNo 调用此方法时需要传递一个房间编号过来。这个房间编号是前台小姐姐输入的。
     */
    public void order(int roomNo){
    
    
        // 订房最主要的是将房间对象的status修改为false。
        // Room对象的status修改为false。
        // 假设房间编号207（下标是 rooms[1][6] ）
        // 通过房间编号演算出下标。获取房间对象。
        Roo room = rooms[roomNo / 100 - 1][roomNo % 100 - 1];
        // 修改为占用。
        room.setStatus(false);
        System.out.println(roomNo + "已订房！");
    }

    /**
     * 退房
     * @param roomNo
     */
    public void exit(int roomNo){
    
    
        Roo room = rooms[roomNo / 100 - 1][roomNo % 100 - 1];
        // 修改为空闲。
        room.setStatus(true);
        System.out.println(roomNo + "已退房！");
    }
}
class Roo extends Object{
    
    
    /**
     * 房间编号
     * 1楼：101 102 103 104 105 106..
     * 2楼：201 202 203 204 205 206..
     * 3楼：301 302 303 304 305 306..
     * ...
     */
    private int no;
    /**
     * 房间类型：标准间 单人间 总统套房
     */
    private String type;
    /**
     * 房间状态。
     * true表示空闲，房间可以被预定。
     * false表示占用，房间不能被预定。
     */
    private boolean status;

    // 构造方法
    public Roo() {
    
    
    }

    public Roo(int no, String type, boolean status) {
    
    
        this.no = no;
        this.type = type;
        this.status = status;
    }

    // setter and getter
    public int getNo() {
    
    
        return no;
    }

    public void setNo(int no) {
    
    
        this.no = no;
    }

    public String getType() {
    
    
        return type;
    }

    public void setType(String type) {
    
    
        this.type = type;
    }

    // IDEA工具对于boolean类型的变量，生成的get方法的方法名是：isXxx()
    // 如果你不喜欢，可以修改为getXxx()
    /*public boolean isStatus() {
        return status;
    }*/
    public boolean getStatus() {
    
    
        return status;
    }

    public void setStatus(boolean status) {
    
    
        this.status = status;
    }

    // equals方法重写
    // equals是用来比较两个对象是否相同的。
    // 至于怎么比较，这个还是程序员自己定。
    // 你认为两个房间的编号相同，就表示同一个房间，那么你写代码比较房间编号就行。
    public boolean equals(Object obj) {
    
    
        if(obj == null || !(obj instanceof Room)) return false;
        if(this == obj) return true;
        Roo room = (Roo)obj;
        // 当前房间编号 等于 传过来的房间对象的房间编号。认为是同一个房间。
        return this.getNo() == room.getNo();
    }

    // toString方法重写
    // toString方法的目的就是将java对象转换成字符串形式。
    // 怎么转，转换成什么格式，程序员自己定。目的就是：简单、清晰明了。
    // 我不要看对象内存地址。我要看具体的信息。
    public String toString() {
    
    
        //return "[101,单人间,占用]";
        //return "[102,单人间,空闲]"; // 写死了。

        //动态（把一个变量塞到一个字符串当中，口诀：加一个双引号，双引号中间加两个加号，两个加号中间加变量名。）
        return "["+no+","+type+","+(status ? "空闲" : "占用")+"]";
    }

    // 编写一个临时程序测试以下
    // 一会可以删除这个main方法
    /*
    public static void main(String[] args) {
        //Room room = new Room(101, "单人间", true);
        Room room = new Room(101, "单人间", false);

        //System.out.println(room.toString());
        // room是一个引用
        // println(引用)，会自动调用引用的toString()方法。
        System.out.println(room);

        Room room1 = new Room(102, "单人间", false);
        System.out.println(room.equals(room1));
    }
     */
    // 多行注释：ctrl + shift + /
    // 查看一个类的属性和方法：ctrl + F12
}