Object源码阅读记录

public class Object {

    private static native void registerNatives();
    static {
        registerNatives();
    }

    /**
     * 返回对象的运行时类
     * 用例：Number n = 0
     * Class<? extends Number> c = n.getClass();
     */
    public final native Class<?> getClass();

    /**
     * 返回对象的hash值，本方法为支持哈希表提供了不少好处，例如:hashmap中
     * 1.当一个java应用执行时，一个相同的对象屡次调用hashcode方法，这个方法都会返回相同的
     * 整数
     * 2.根据equals方法，若是两个对象相等，则这两个对象调用hashcode方法必须生成一样的hash值
     * 3.根据equals方法，若是两个对象不相等，则这两个对象调用hashcode方法必将生成不一样的hash值,
     * 注意：两个对象的hashcode值相等，两个对象用equals比较并不必定相等
     * 程序员应该意识到，为不一样的对象生成不一样的hash值将会提升hash表的性能
     * @return  a hash code value for this object.
     * @see     java.lang.Object#equals(java.lang.Object)
     * @see     java.lang.System#identityHashCode
     */
    public native int hashCode();

    /**
     * 比较两个对象相等
     * 自反性（reflextive）：对于任何非空的引用值x，x.equals(x)都会返回true
     * 对称性（symmetric）：对于任何的非空引用值x和y,只有当y.equals(x)返回true时，x.equals(y)才为true
     * 传递性（transitive）：对于任何的非空引用值x和y、z，若是x.equals(y)返回true,y.equals(z)返回true,
     * 那么x.equals(z)也将返回true
     * 一致性（consistent）:对于任何非空的引用x和y,屡次调用x.equals(y)始终返回true或者false的前提是
     * equal比较中全部的信息未被修改
     * 对于任何的非空引用值x,x.equals(null)始终返回false
     * 只有当x,y指向同一个对象时，则x==y才会返回true
     * 若是必需要从新equals方法，那么一般也须要重写hashcode方法，根据hashcode方法的协议规范
     * 两个相同的对象必须具备相同的hash码
     * @param   obj   the reference object with which to compare.
     * @return  {@code true} if this object is the same as the obj
     *          argument; {@code false} otherwise.
     * @see     #hashCode()
     * @see     java.util.HashMap
     */
    public boolean equals(Object obj) {
        return (this == obj);
    }

    /**
     * 该克隆属于浅克隆
     * 建立并返回对象的一个副本，副本意味着依赖对对象的类
     * 一般的状况：对于任何一个对象x;若是表达式：
     * x.clone() != x 返回true
     * 那么 x.clone().getClass() == x.getClass()也将返回true
     * 但这不是绝对条件，通常状况下：
     * x.clone().equals(x)也将返回true
     * 依照约定，返回的对象应该经过调用super.clone()得到，若是
     * 若是一个类或者他的全部超类(除object)都遵循此约定，则
     * x.clone().getClass() == x.getClass()
     * 按照约定，此方法返回的对象应该独立于该对象(被克隆的对象)，要想实现这种独立性
     * 在supper.clone()返回以前修改他的一个或者多个字段，这一般意味着
     * 要复制包含正在被克隆对象的内部“深层结构”的全部可变对象，并使用对副本的引用
     * 替换对这些对象的引用，若是一个类只包含基本字段或者是引用的对象是不可变的，
     * 那么一般不须要修改super.clone()返回的对象
     * Object类的clone方法执行特定的克隆操做，若是一个类没有实现cloneable接口
     * 将会抛出CloneNotSupportedException.
     * 注意：全部对象都被视为实现了cloneable接口，不然，此方法会建立此对象的类的一个新实例，
     * 并像经过分配那样，严格使用此对象相应字段的内容初始化该对象的全部字段；
     * 这些字段的内容没有被自我克隆。因此，此方法执行的是该对象的“浅表复制”，而不“深层复制”操做
     * Object自己没有实现cloneable接口，所以自身调用object将会在运行时抛出异常
     *
     * @return     a clone of this instance.
     * @see java.lang.Cloneable
     */
    protected native Object clone() throws CloneNotSupportedException;

    /**
     * 对象以字符串形式返回，结果是易读的，推荐全部的子类都从新该方法
     * Object的toString方法返回一个字符串，该字符串有类名+@+此对象哈希码的无符号十六进制表示组成
     * 换句话说，此方法返回的值等价于：
     * getClass().getName()+'@'+Integer.toHexString(hashCode())
     * @return  a string representation of the object.
     */
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    /**
     * 唤醒在此对象上监听等待单个线程，若是全部线程都在这个对象上等待，
     * 他们中的其中一个会被唤醒，选择是任意性的，并在实现作出决定时发生，
     * 一个线程经过调用wait方法，在对象的监听器上等待
     * 直到当前的线程的放弃在该对象上的锁，被唤醒的线程将以常规方式与该对象上的其余线程竞争
     * 例如，唤醒的线程在做为锁定此对象的下一个线程方面没有可靠的特权或劣势。
     * 此方法只应由做为此对象监视器的全部者的线程来调用。经过如下三种方法之一，线程能够成为此对象监视器的全部者：
     * 经过执行此对象的同步 (Sychronized) 实例方法。
     * 经过执行在此对象上进行同步的 synchronized 语句的正文。
     * 对于 Class 类型的对象，能够经过执行该类的同步静态方法。
     * 一次只能有一个线程拥有对象的监视器。
     *
     * @exception  IllegalMonitorStateException  if the current thread is not
     *               the owner of this object's monitor.
     * @see        java.lang.Object#notifyAll()
     * @see        java.lang.Object#wait()
     */
    public final native void notify();

    /**
     * 唤醒在此对象监听器上等待的全部线程，线程经过调用wait方法在该对象的监听器上
     * 等待，被唤醒的线程不能直接执行，直到当前的线程放弃在该对象上的锁。
     * 例如，唤醒的线程在做为锁定此对象的下一个线程方面没有可靠的特权或劣势。 
     * 此方法只应由做为此对象监视器的全部者的线程来调用。经过如下三种方法之一，线程能够成为此对象监视器的全部者： 
     * 经过执行此对象的同步 (Sychronized) 实例方法。 * 经过执行在此对象上进行同步的 synchronized 语句的正文。
     *
     */
    public final native void notifyAll();

    /**
     * 致使线程等待，直到其余的线程条用该对象上的notify()或者是notifyAll()方法，或者是超过指定的时间
     * 当前的线程必须拥有此对象的监听器
     * 此方法致使当前线程（称之为 T）将其自身放置在对象的等待集中，
     * 而后放弃此对象上的全部同步要求。出于线程调度目的，线程 T 被禁用，且处于休眠状态，直到发生如下四种状况之一：
     * 其余一些线程调用该对象的notify方法，而且线程T被任选为被唤醒线程
     * 其余一些线程调用该对象的notifyAll()方法
     * 其余一些线程中断线程T
     *
     * @param      timeout   等待时间.
     */
    public final native void wait(long timeout) throws InterruptedException;

    /**
     *
     * @param      timeout   须要等待的时间.
     * @param      nanos     额外时间, in nanoseconds range
     *                       0-999999.
     * @exception  IllegalArgumentException      if the value of timeout is
     *                      negative or the value of nanos is
     *                      not in the range 0-999999.
     * @exception  IllegalMonitorStateException  if the current thread is not
     *               the owner of this object's monitor.
     * @exception  InterruptedException if any thread interrupted the
     *             current thread before or while the current thread
     *             was waiting for a notification.  The <i>interrupted
     *             status</i> of the current thread is cleared when
     *             this exception is thrown.
     */
    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 >= 500000 || (nanos != 0 && timeout == 0)) {
            timeout++;
        }

        wait(timeout);
    }

    /**
     * 默认的wait方法
     */
    public final void wait() throws InterruptedException {
        wait(0);
    }

    /**
     * 当垃圾收集器肯定该对象没有被更多引用时，有该对象的垃圾回收器调用
     * 子类重写改方法已配置资源或者执行其余清除操做
     * finalize 的常规协定是：当 JavaTM 虚拟机已肯定还没有终止的任何线程没法再经过任何方法访问此对象时，
     * 将调用此方法，除非因为准备终止的其余某个对象或类的终结操做执行了某个操做。
     * finalize 方法能够采起任何操做，其中包括再次使此对象对其余线程可用；
     * 不过，finalize 的主要目的是在不可撤消地丢弃对象以前执行清除操做。
     * 例如，表示输入/输出链接的对象的 finalize 方法可执行显式 I/O 事务，以便在永久丢弃对象以前中断链接。
     * Object 类的 finalize 方法执行非特殊性操做；它仅执行一些常规返回。Object 的子类能够重写此定义。
     * Java 编程语言不保证哪一个线程将调用某个给定对象的 finalize 方法。
     * 但能够保证在调用 finalize 时，调用 finalize 的线程将不会持有任何用户可见的同步锁定。
     * 若是 finalize 方法抛出未捕获的异常，那么该异常将被忽略，而且该对象的终结操做将终止。
     * 在启用某个对象的 finalize 方法后，将不会执行进一步操做，
     * 直到 Java 虚拟机再次肯定还没有终止的任何线程没法再经过任何方法访问此对象，
     * 其中包括由准备终止的其余对象或类执行的可能操做，在执行该操做时，对象可能被丢弃。
     * 对于任何指定对象java虚拟机只调用一次finalize()方法
     * @throws Throwable the {@code Exception} raised by this method
     */
    protected void finalize() throws Throwable { }
}