DAY04（访问控制权限，Object，面向对象小项目）

1、访问控制权限

1.1

访问修饰符	本类	同包的类	子类不同包	其他包中的类
public	可以	可以	可以	可以
protected	可以	可以	可以	不行
默认为空	可以	可以	不行	不行
private	可以	不行	不行	不行

注意：
protected使用总结：
1.在子类中可以通过子类对象来访问父类的protected属性和方法
2.在子类中不能通过父类对象来访问父类的protected属性和方法
3.在子类中不能通过其他子类的对象来访问父类的protected属性和方法

package com.feng.demo01;

public class Person {
    protected int a = 2;
}

2、Object

• String toString()
  返回对象的字符串表示形式。

  	public String toString() {
          return getClass().getName() + "@" + Integer.toHexString(hashCode());
      }
  

  • 默认实现是：类名@对象内存 地址转换成 十六进制的形式

  • 建议所有子类重写此方法：重写方法的可读性越强越好（简洁明了）

  • System.out.println(X);如果传入的是对象，则默认会调用tostring方法

    PrintStream.java
    	public void print(Object obj) {
    	        write(String.valueOf(obj));
    	    }
    String.java
        public static String valueOf(Object obj) {
    	    return (obj == null) ? "null" : obj.toString();
    	}
    

• boolean equals(Object obj)
  判断两个对象是否相等
  默认实现：

  public boolean equals(Object obj) {
          return (this == obj);
      }
  

  • 判断基本数据类型使用“==”

  • 判断两个对象使用equals方法，如果比较两个对象用“==”，则比较的是地址

  • 又因为默认实现是“== ”，所以在使用时，需要重写
    推荐写法：

    public class EqualsTest {
        private int filed1;
        private int filed2;
        private int filed3;
    
        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            //如果equals的语义可以在子类中改变，就是用getClass
            if (obj == null || getClass() != obj.getClass()) return false;
            //如果所有的子类都有相同的相等性语义，就可以使用instanceof
            if (! (obj instanceof Person)) return false;
            EqualsTest that = (EqualsTest) obj;
            return filed1 == that.filed1 &&
                    filed2 == that.filed2 &&
                    filed3 == that.filed3;
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(filed1, filed2, filed3);
        }
    }
    
    

• protected void finalize(）
  当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。
  源代码：protected void finalize() throws Throwable { }
  - 由jvm的GC负责调用
  - 当Java对象被回收时，执行该方法

• int hashCode()
  返回对象的哈希码值。

• protected Object clone()
  创建并返回此对象的副本

• 类<?> getClass()
  返回此 Object的运行时类。

• void notify()
  唤醒正在等待对象监视器的单个线程。

• void notifyAll()
  唤醒正在等待对象监视器的所有线程。

• void wait()
  导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。

• void wait(long timeout)
  导致当前线程等待，直到另一个线程调用 notify()方法或该对象的 notifyAll()方法，或者指定的时间已过。

• void wait(long timeout, int nanos)
  导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法，或者某些其他线程中断当前线程，或一定量的实时时间。

任务一：

public class MyStack {
    int index = 0;
    Object[] elements; //用来存储元素

    public MyStack(int n) {
        elements = new Object[n];
    }

    /**
     * 判断栈满
     * @return 返回判断的结果
     */
    public boolean full() {
        if (index == elements.length) return true;
        return false;
    }

    /**
     * 判断栈为空
     * @return 返回判断的结果为空还是不为空
     */
    public boolean empty() {
        if (index == 0) return true;
        return false;
    }


    /**
     * 压栈
     * @param obj 插入的对象
     */
    public void push(Object obj) {
        if (!full()) {
            elements[index] = obj;
            index++;
        } else throw new RuntimeException("栈已满，压栈失败");
    }

    /**
     * 出栈
     */
    public void pop() {
        if (!empty()) {
            elements[index-1] = null;
            index--;
        } else throw new RuntimeException("栈为空，出栈失败");
    }
   }

测试通过：

任务二：

public class AdminRoom {
    private Object rooms[][];

    public AdminRoom() {
        public AdminRoom() {
        for (int i = 0; i < rooms.length; i++) {
            for (int j = 0; j < rooms.length; j++) {
                if (i == 0) rooms[i][j] = new Room(8 * 1000 + (100 * (i + 1)) + j + 1, "麻将房", RoomState.EMPTY);
                if (i == 1) rooms[i][j] = new Room(8 * 1000 + (100 * (i + 1)) + j + 1, "套房", RoomState.EMPTY);
                if (i == 2) rooms[i][j] = new Room(8 * 1000 + (100 * (i + 1)) + j + 1, "KTV房", RoomState.EMPTY);
            }
        }
    }
    }

    /**
     * 订房
     *
     * @param id 酒店前台输入订房id
     * @return 返回房间订购状态
     */
    public boolean setRoom(int id) {
        //定义一个标志，表示订购成功还是失败
        boolean flag = false;
        for (int i = 0; i < rooms.length; i++) {
            for (int j = 0; j < rooms.length; j++) {
                Room room = (Room) rooms[i][j];
                if (room.getId() == id) {
                    if (room.getRoomState() == RoomState.EMPTY) {
                        room.setRoomState(RoomState.FULL);
                        flag = true;
                    } else flag = false;
                }
            }
        }
        //判断成功还是失败
        if (flag) return true;
        return false;
    }

    public boolean getRoom(int id) {
        //定义一个标志，表示退房成功还是失败
        boolean flag = false;
        for (int i = 0; i < rooms.length; i++) {
            for (int j = 0; j < rooms.length; j++) {
                Room room = (Room) rooms[i][j];
                if (room.getId() == id) {
                    if (room.getRoomState() == RoomState.FULL) {
                        room.setRoomState(RoomState.EMPTY);
                        flag = true;
                    } else flag = false;
                }
            }
        }
        //判断成功还是失败
        if (flag) return true;
        return false;
    }

    public void findAll() {
        for (int i = 0; i < rooms.length; i++) {
            for (int j = 0; j < rooms.length; j++) {
                System.out.print(rooms[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        AdminRoom adminRoom = new AdminRoom();
        Scanner scanner = new Scanner(System.in);
        int n = 0;
        System.out.println("请输入：");
        System.out.println("1：查看所有房间状态");
        System.out.println("2：入住");
        System.out.println("3：退房");
        System.out.println("-1: 退出");
        while (n != -1) {
            n = scanner.nextInt();
            switch (n) {
                case 1:
                    adminRoom.findAll();
                    break;
                case 2:
                    System.out.println("入住房间号：");
                    boolean state = adminRoom.setRoom(scanner.nextInt());
                    if (state) System.out.println("入住成功！");
                    else System.out.println("入住失败！请检查输入的房间号！");
                    break;
                case 3:
                    System.out.println("退房房间号：");
                    boolean state1 = adminRoom.getRoom(scanner.nextInt());
                    if (state1) System.out.println("退房成功！");
                    else System.out.println("退房失败！请检查输入的房间号！");
                    break;
                case -1:
                    System.out.println("再见！");
                    break;
            }
        }

    }


}

public class Room {
    private Integer id;
    private String type;
    private RoomState roomState;

    public Room(Integer id, String type, RoomState roomState) {
        this.id = id;
        this.type = type;
        this.roomState = roomState;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "房间{" +
                "房间号=" + id +
                ", 房间类型='" + type + '\'' +
                ", 房间状态=" + roomState +
                '}';
    }

    public String getType() {
        return type;
    }

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

    public RoomState getRoomState() {
        return roomState;
    }

    public void setRoomState(RoomState roomState) {
        this.roomState = roomState;
    }
}

enum RoomState {
    FULL,EMPTY;
}