Day16.小练习：酒店管理系统、模拟栈

酒店管理系统(部分)

（java路上第一个小型项目。锻炼一下面向对象。）
    为某个酒店编写程序：酒店管理系统，模拟订房、退房、打印所有房间状态等功能。
    1、该系统的用户是：酒店前台。
    2、酒店使用一个二维数组来模拟。“Room[][] rooms;”
    3、酒店中的每一个房间应该是一个java对象：Room
    4、每一个房间Room应该有：房间编号、房间类型、房间是否空闲.
    5、系统应该对外提供的功能：
        可以预定房间：用户输入房间编号，订房。
        可以退房：用户输入房间编号，退房。
        可以查看所有房间的状态：用户输入某个指令应该可以查看所有房间状态。

public class Room {

    private int ID;
    private boolean state;  //房间状态
    private String type;    //房间类型 双人、单人(未加入类型功能)


    public Room() {                     //无参构造
    }
    public Room(int ID, String type) {  //有参构造
        this.ID = ID;
        this.state = true;  //房间状态 默认true 空闲
        this.type = type;
    }      //无参构造


    public int getID() {
        return ID;
    }
    public void setID(int ID) {
        this.ID = ID;
    }
    public boolean isState() {
        return state;
    }
    public void setState(boolean state) {
        this.state = state;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }


    @Override
    public String toString() {          //重写toString 方法 打印房间信息
        String i = "["+ID+","+type+","+(state? "空闲" : "占用")+"]";
        return i;
    }
}

public class Hotel {

    private Room[][] hotelRoom;         //酒店房间  Room类型的数组
    private String name;                //酒店名称

    Scanner scanner = new Scanner(System.in);

    public Hotel() {     //无参构造               
    }
    public Hotel(String name,int c,int l) {   //有参构造    c,l层数,列数
        this.hotelRoom = new Room[c][l];
        this.name = name;
        for(int i = 0; i < hotelRoom.length;i++){           
            for(int j = 0; j < hotelRoom[i].length ;j++){    //遍历酒店
                //调用Room有参构造，在每个元素中创建对象
                hotelRoom[i][j] = new Room(((i+1)*100+(j+1)),"单人间");//
            }
        }
    }

    public void dingFang(){
        System.out.println("请输入需要订购的房间号:");
        int id = scanner.nextInt();
        for(int i = 0;i< hotelRoom.length;i++){
            for(int j = 0;j< hotelRoom[i].length;j++){
                if(id == hotelRoom[i][j].getID()){              //遍历酒店，查找该房间号
                    if(hotelRoom[i][j].isState() == true){
                        hotelRoom[i][j].setState(false);
                        System.out.println("["+id+","+hotelRoom[i][j].getType()+"]"+"订房成功！");
                        return;
                    }else{
                        System.out.println("该房间已满，订房失败。");
                        return;
                    }
                }
            }
        }
        System.out.println("房间号"+id+"不存在！");
    }

    public void tuiFang(){
        System.out.println("请输入需要退订的房间号:");
        int id = scanner.nextInt();
        for(int i = 0;i< hotelRoom.length;i++){
            for(int j = 0;j< hotelRoom[i].length;j++){
                if(id == hotelRoom[i][j].getID()){
                    if(hotelRoom[i][j].isState() == false){
                        hotelRoom[i][j].setState(true);
                        System.out.println("["+id+","+hotelRoom[i][j].getType()+"]"+"已退房。");
                        return;
                    }else{
                        System.out.println("房间未订购，退房失败。");
                        return;
                    }
                }
            }
        }
        System.out.println("房间号"+id+"不存在！");
    }

    public void printRoom(){
        for(int i = 0; i < hotelRoom.length;i++){
            if (i == 0){                                //第一行显示酒店名称
                System.out.println("["+name+"酒店]");
            }
            for(int j = 0; j < hotelRoom[i].length ;j++){
                System.out.print(hotelRoom[i][j]);     //遍历、打印房间
            }
            System.out.println('\t');                  //每一层换行
        }
    }
}

public class Test {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("欢迎使用模拟酒店系统，下面将创建您的专属酒店。");
        System.out.println("请输入酒店的名称：");
        String name = scanner.next();
        System.out.println("请输入酒店的楼层数：");
        int ceng = scanner.nextInt();
        System.out.println("请输入酒店每层的房间数量：");
        int lie = scanner.nextInt();

        Hotel hotel = new Hotel(name,ceng,lie);

        System.out.println("酒店创立完毕。");

        System.out.println("欢迎使用"+name+"酒店管理系统,请认真阅读以下使用说明：");
        while (true){
            System.out.println("请输入对应的功能编号：[1]查看房间列表。[2]订房。[3]退房。[0]退出系统。");
            int i = scanner.nextInt();
            switch(i){
                case 1:
                    hotel.printRoom();
                    break;
                case 2:
                    hotel.printRoom();
                    hotel.dingFang();
                    break;
                case 3:
                    hotel.printRoom();
                    hotel.tuiFang();
                    break;
                case 0:
                    return;
                default:
                    System.out.println("功能不存在，请认真阅读说明");
            }
        }
    }
}

模拟栈

    编写程序，使用一维数组，模拟栈数据结构。
    要求：
        1、这个栈可以存储java中的任何引用类型的数据。
        2、在栈中提供push方法模拟压栈。（栈满了，要有提示信息。）
        3、在栈中提供pop方法模拟弹栈。（栈空了，也有有提示信息。）
        4、编写测试程序，new栈对象，调用push pop方法来模拟压栈弹栈的动作。
        5、假设栈的默认初始化容量是10，（请注意无参构造方法的编写方式）

public class Mystack {


    private Object[] elements;   //数组模拟栈
    private int index;    //模拟栈帧


    public Mystack(int i){
        this.elements = new Object[i];  //构造器，输入栈的大小
        this.index = 0;
    }
    //get and set
    public Object[] getElements() {
        return elements;
    }
    public void setElements(Object[] elements) {
        this.elements = elements;
    }
    public int getIndex() {
        return index;
    }
    public void setIndex(int index) {
        this.index = index;
    }


    //压栈
    public void push(Object x) throws MyStackOperationException{  //传入压栈的元素
        if (this.index >= this.elements.length){  //如果栈帧小于等于栈，没位置

            //MyStackOperationException e = new MyStackOperationException("栈已满，压栈失败");
            //throw e; 合并 ↓
            throw new MyStackOperationException("栈已满，压栈失败");

/*            System.out.println("栈已满，压栈失败");  改良之前
            return;*/
        }else if(this.index < this.elements.length){  //如果有位置
            this.elements[index] = x; //将元素填入栈
            System.out.println("压栈成功，栈帧"+index+"为:"+x);
            this.index++;  //栈帧+1
        }
    }

    //弹栈
    public void pop(){
        if(this.index == 0){
            System.out.println("栈已空，弹栈失败。");
        }else{
            System.out.println("栈帧"+(index-1)+"为:"+elements[index-1]+"，弹出成功");
            this.elements[index-1] = null;
            this.index--;
        }
    }
}

//栈操作异常.自定义异常
public class MyStackOperationException extends Exception{
    public MyStackOperationException(){
    }
    public MyStackOperationException(String s){
        super(s);
    }
}

public class Test {
    public static void main(String[] args) {

        Mystack mystack = new Mystack(3);

        try {
            mystack.push(1);
            mystack.push(new Object());
            mystack.push("aaa");
            mystack.push(4545);
        } catch (MyStackOperationException e) {
            //e.printStackTrace();
            System.out.println(e.getMessage());
        }
        mystack.pop();
        mystack.pop();
        mystack.pop();
}