Object

package java.lang;

import jdk.internal.HotSpotIntrinsicCandidate;

public class Object {


    /**
     * 该方法被关键字native所修饰，表明该方法的实现是一个非java方法，是C或者其他语言的系统本地方法。
     * 作用是加载类时注册该类中所包含的除了registerNatives()方法以外的所有系统本地方法。
     */
    private static native void registerNatives();
    static {
        registerNatives();
    }


    /**
     * 被@HotSpotIntrinsicCandidate标注的方法,在HotSpot（虚拟机）中都有一套高效的实现
     * 该高效实现基于CPU指令，运行时，HotSpot维护的高效实现会替代JDK的源码实现 
     * 无参构造器
     */
    @HotSpotIntrinsicCandidate
    public Object() {}


    /**
     * 每一个类都有一个Class对象。该方法返回此 Object的运行时类，在多态情况下可以获取准确的运行时类
     * 可以通过Class对象获取该类的相关信息
     */
    @HotSpotIntrinsicCandidate
    public final native Class<?> getClass();


    /**
     * 每个对象都有一个默认的散列码，其值为对象的存储地址,即hashCode。
     * 如果重新定义equals方法，就必须重新定义hashCode方法，以便用户可以将对象插入散列表中
     * equals与hashCode的定义必须一致：如果x.equals(y)返回true，那么x.hashCode()就必须与y.hashCode()具有相同的值
     * 
     */
    @HotSpotIntrinsicCandidate
    public native int hashCode();


    /**
     * 对比的是两个对象是否是同一个，即this与obj是否指向同一个内存地址
     * String类重写了equals，对比的是内容
     */
    public boolean equals(Object obj) {
        return (this == obj);
    }


    /**
     * 权限为protected,在子类与同一package下的类可以调用。
     * 因此自己创建的对象，虽然继承了Object，如果在类外部也是无法调用clone方法的，除非重写clone方法
     * 重写的clone方法需要 1、throws CloneNotSupportedException，2、类需要implements Cloneable
     * 深度克隆，返回的是独立的对象。可以用toString方法证明，当hashCode不一样时，指向的是不同对象
     *
     */
    @HotSpotIntrinsicCandidate
    protected native Object clone() throws CloneNotSupportedException;


    /**
     * 返回值是对象的"运行时"类名 + @ + hashCode的十六进制表现形式
     * Integer.toHexString：无符号整数基数为16的整数参数的字符串表示形式
     */
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }


    /**
     * 方法final，不可覆盖。
     * 随机唤醒一个处于等待状态的线程获取线程锁
     */
    @HotSpotIntrinsicCandidate
    public final native void notify();


    /**
     * 方法final，不可覆盖。
     * 唤醒所有处于等待状态的线程抢夺线程锁
     */
    @HotSpotIntrinsicCandidate
    public final native void notifyAll();


    /**
     * 拥有当前锁的线程会释放该线程锁，并处于等待状态
     * 线程会被系统挂起，失去cpu时间片，得不到调度，即阻塞
     * 0L为等待时间，当0时，不会自动唤醒，需等待
     */
    public final void wait() throws InterruptedException {
        wait(0L);
    }


    /**
     * 拥有当前锁的线程会释放该线程锁，并处于等待状态,timeoutMillis后自动唤醒，去【争夺】锁
     * 唤醒 != 获得锁
     * 在时间结束前也可以由其他线程唤醒
     * timeoutMillis 以毫秒为单位
     */
    public final native void wait(long timeoutMillis) throws InterruptedException;


    /**
     * timeoutMillis：等待时间。以毫秒为单位
     * 在时间结束前也可以由其他线程唤醒
     * nanos：额外时间。以纳秒为单位，范围是 0-999999
     * 1毫秒 = 1000微秒 = 1000 000 纳秒
     * 该方法作用目前并不清楚。不成熟小想法：计算机做不到纳秒级别的处理，所以做近似处理，加一毫秒。
     */
    public final void wait(long timeoutMillis, int nanos) throws InterruptedException {
        if (timeoutMillis < 0) {
            throw new IllegalArgumentException("timeoutMillis value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0 && timeoutMillis < Long.MAX_VALUE) {
            timeoutMillis++;
        }

        wait(timeoutMillis);
    }


    /**
     * 注解：Deprecated：若某类或某方法加上该注解之后，表示此方法或类不再建议使用。调用时也会出现删除线，但并不代表不能用，不推荐使用。
     * since: 元素指定已注解的API元素已被弃用的版本
     * forRemoval: 元素表示注解的 API 元素在将来的版本中被删除，应该迁移API
     * 空方法，由各子类覆盖
     * 作用：当这个对象的内存不再被使用时，GC在收集垃圾时就会调用这个方法，是一个对象死亡之前的回调。GC在内存不足时才会回收。
     *       GC只收集new关键字开辟的内存空间，非new出来的对象回收时需要该方法回收
     */
    @Deprecated(since="9")
    protected void finalize() throws Throwable { }
}