JDK源码学习--java.lang.Object类

/**
 * java.lang.Object是所有类的父类，编写一个类时如果没有指定父类则编译器会默认
 * 添加Object为该类的父类
 */
public class Object {

    /**
     *   本地方法，由C/C++实现，Java通过JNI调用，主要作用是在C/C++中的方法和Java中的native方法之间形成映射
     */
    private static native void registerNatives();

    /**
     *  初始化执行registerNatives方法
     */
    static {
        registerNatives();
    }

    public final native Class<?> getClass();


    /**
     * 返回对象的哈希值
     * 其具有以下约定:
     * 如果两个对象相等,那么这两个对象调用hashCode()返回的哈希码也必须相等
     * 反之，两个对象调用hasCode()返回的哈希码相等，这两个对象不一定相等。
     * @return
     */
    public native int hashCode();

    /**
     *
     *  用来比较两个对象是否相等，默认的equals方法，直接调用==，比较对象地址。
     *  不同的子类，可以重写此方法。
     *  要注意的是如果重写了equals方法那么就要重写hashcode方法，因为约定是:
     *  如果两个对象相等，那么调用hashCode()返回的哈希码也必须相等。
     *  这个约定是针对集合类型的，主要是为了提高性能， 假设两个对象，重写了
     *  其equals方法，其相等条件是属性相等，就返回true。如果不重写hashcode
     *  方法，其返回的依然是两个对象的内存地址值，必然不相等。
     *  这就出现了equals方法相等，但是hashcode不相等的情况。
     *  所以保持这个约定，当向集合中添加元素的时候，直接调用其hashcode方法
     *  获取该对象保存的地址，然后通过equals比较是否相等，这样就不用从头到尾
     *  一个一个一个遍历了
     *
     */
    public boolean equals(Object obj) {
        return (this == obj);
    }

    /**
     * 用来实现对象的复制，注意clone生成的新对象与原对象的关系，如果2个对象存在
     * 相同的引用或对应的内存地址存在共用情况，若存在则该次clone为 “浅复制”，
     * 否则为“深复制”, 而且Object的clone方法是属于 “浅复制”，数组类型默认
     * 可以直接克隆，而其他对象实现clone需要先实现Cloneable接口，否则抛出
     * CloneNotSupportedException异常
     * @return
     * @throws CloneNotSupportedException
     */
    protected native Object clone() throws CloneNotSupportedException;


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

    /**
     * 用于唤醒一个因等待该对象（调用了wait方法）而处于等待状态的线程，该方法只能同步方法或同步块中调用
     */
    public final native void notify();

    /**
     * 用于唤醒所有因等待该对象（调用了wait方法）而处于等待状态的线程，该方法只能同步方法或同步块中调用
     */
    public final native void notifyAll();

    /**
     * 用于在线程调用中，使当前线程进入等待状态
     * @param timeout
     * @throws InterruptedException
     */
    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);
    }

    /**
     * 当jvm决定回收当前对象占用的内存时调用此方法，Object的finalize方法默认是什么都没有做，
     * 如果子类需要在对象被回收时执行一些逻辑处理，则可以重写finalize方法。
     */
    protected void finalize() throws Throwable { }
}