JDK源码分析系列_Object

package java.lang;

//类Object是类层次结构的根类，每个类都是Object的子类，所有对象（包括数组）都实现了这个类的方法
public class Object {
    //把C/C++中的方法映射到Java中的native方法
    private static native void registerNatives();
    static {
        registerNatives();
    }

    //返回Object类运行时的类型
    public final native Class<?> getClass();

    /*
    hashCode可以保证Set集合的元素不可重复
    向Set集合添加元素时，根据元素计算hashCode，如果hashCode不冲突，直接放入，如果冲突再接着比较是否equals，这比直接依次
    equals效率高很多
    ==比较的是两个对象的内存地址是否相同
    equals比较的是两个对象的字面值是否相同
    hashCode比较的是两个对象的哈希值是否相同
     */
    public native int hashCode();

    //注意，无论何时重写这个方法都应重写hashCode方法，来保证hashCode方法的约定，即相等的对象必须有相等的哈希值。
    public boolean equals(Object obj) {
        return (this == obj);
    }

    /*
    必须实现Cloneable接口，否则会抛出CloneNotSupportedException异常
    public class ObjectTest implements Cloneable {
        private int i;
        public static void main(String[] args) {
            ObjectTest o=new ObjectTest();
            try {
                ObjectTest clone= (ObjectTest) o.clone();
                System.out.println(o==clone);//false 说明clone不是起别名，而是真正的复制了一份
                System.out.println(o.i==clone.i);//true 栈上的数据共享
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
        }
    }
     */
    protected native Object clone() throws CloneNotSupportedException;
    
    //System.out.println(x);当x不是String类型时，会自动调用x的toString方法，建议所有子类都要重写这个方法。
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    /*
    notify唤醒单个线程，notifyAll唤醒全部线程,都不释放锁，
    wait线程等待，释放锁，wait、notify及notifyAll用于线程间通信，且必须放在synchronized里面
     */
    public final native void notify();
    
    public final native void notifyAll();

    public final native void wait(long timeout) throws InterruptedException;
    
    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

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

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }
    
    public final void wait() throws InterruptedException {
        wait(0);
    }

    /*
    垃圾收集器准备释放内存时，会调用finalize方法，
    1.对象不一定会被回收
    2.垃圾回收不是析构函数
    3.垃圾回收只与内存有关
    4.垃圾回收和finalize都是靠不住的，只要JVM还没有快到耗尽内存的地步，它是不会浪费时间进行垃圾回收的
     */
    protected void finalize() throws Throwable { }
}