java源码阅读Object

1 类注释

Class {@code Object} is the root of the class hierarchy.
Every class has {@code Object} as a superclass. All objects, including arrays, implement the methods of this class.

Object类是类层次结构的根，是每一个类的父类。所有的对象（包括数组）都是实现了object类的方法。

2 outline（大纲）

outline中图标的含义可以看博客http://blog.csdn.net/frankarmstrong/article/details/61520279

这里有7个native方法：registerNatives()、getClass()、hashCode()、clone()、notify()、notifyAll()、wait(long)

什么是native方法？官方给的说明是"A native method is a Java method whose implementation is provided by non-java code."

简单的说，native表示该方法的实现java本身并没有完成，而是有c/c++来完成，放在.dll动态库文件中。

这里我们不关注本地方法的具体，我们可以看看其注释和声明，知道这些方法是干什么的。

（1）registerNatives()

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

该方法源码中并没有任何注释说明，而且在静态块中调用了方法。首先明确在类初始化的时候，这个方法被调用执行了。

至于该方法的做用，请看native方法的c代码实现：

这里是相关的C代码（来自OpenJDK6）：

static JNINativeMethod methods[] = {

　　{“hashCode”, “()I”, (void *)&JVM_IHashCode},

　　{“wait”, “(J)V”, (void *)&JVM_MonitorWait},

　　{“notify”, “()V”, (void *)&JVM_MonitorNotify},

　　{“notifyAll”, “()V”, (void *)&JVM_MonitorNotifyAll},

　　{“clone”, “()Ljava/lang/Object;”, (void *)&JVM_Clone},

};

JNIEXPORT void JNICALL

Java_java_lang_Object_registerNatives(JNIEnv *env, jclass cls)
{
　　(*env)->RegisterNatives(env, cls,methods, sizeof(methods)/sizeof(methods[0]));
}

详细的说：通常情况下，为了使JVM发现您的本机功能，他们被一定的方式命名。例如，对于java.lang.Object.registerNatives，对应的C函数命名为Java_java_lang_Object_registerNatives。通过使用registerNatives（或者更确切地说，JNI函数RegisterNatives），您可以命名任何你想要你的C函数。(来自：https://www.linuxidc.com/Linux/2015-06/118676.htm)

简单的说：就是对几个本地方法进行注册(也就是初始化java方法映射到C的方法)。

细心的读者可能发现这里为什么没有getClass()方法的注册？因为它不需要被注册，它有一个Java_java_lang_Object_getClass的“标准”名称。

（2）getClass()

    /**
     * Returns the runtime class of this {@code Object}. The returned
     * {@code Class} object is the object that is locked by {@code
     * static synchronized} methods of the represented class.
     *
     * <p><b>The actual result type is {@code Class<? extends |X|>}
     * where {@code |X|} is the erasure of the static type of the
     * expression on which {@code getClass} is called.</b> For
     * example, no cast is required in this code fragment:</p>
     *
     * <p>
     * {@code Number n = 0;                             }<br>
     * {@code Class<? extends Number> c = n.getClass(); }
     * </p>
     *
     * @return The {@code Class} object that represents the runtime
     *         class of this object.
     * @jls 15.8.2 Class Literals
     */
    public final native Class<?> getClass();

返回Object的运行时class对象，返回的对象是被静态同步方法锁定的对象（这意味着，该类的所有对象中，同时只有一个对象可以获得锁）。而且实际上返回的class对象是多态的，可以是调用者的子类（注释中Number的例子解释了这一内容）。

（3）hashCode()

 1     /**
 2      * Returns a hash code value for the object. This method is
 3      * supported for the benefit of hash tables such as those provided by
 4      * {@link java.util.HashMap}.
 5      * <p>
 6      * The general contract of {@code hashCode} is:
 7      * <ul>
 8      * <li>Whenever it is invoked on the same object more than once during
 9      *     an execution of a Java application, the {@code hashCode} method
10      *     must consistently return the same integer, provided no information
11      *     used in {@code equals} comparisons on the object is modified.
12      *     This integer need not remain consistent from one execution of an
13      *     application to another execution of the same application.
14      * <li>If two objects are equal according to the {@code equals(Object)}
15      *     method, then calling the {@code hashCode} method on each of
16      *     the two objects must produce the same integer result.
17      * <li>It is <em>not</em> required that if two objects are unequal
18      *     according to the {@link java.lang.Object#equals(java.lang.Object)}
19      *     method, then calling the {@code hashCode} method on each of the
20      *     two objects must produce distinct integer results.  However, the
21      *     programmer should be aware that producing distinct integer results
22      *     for unequal objects may improve the performance of hash tables.
23      * </ul>
24      * <p>
25      * As much as is reasonably practical, the hashCode method defined by
26      * class {@code Object} does return distinct integers for distinct
27      * objects. (This is typically implemented by converting the internal
28      * address of the object into an integer, but this implementation
29      * technique is not required by the
30      * Java&trade; programming language.)
31      *
32      * @return  a hash code value for this object.
33      * @see     java.lang.Object#equals(java.lang.Object)
34      * @see     java.lang.System#identityHashCode
35      */
36     public native int hashCode();

hashCode()也是一个native方法，该方法返回调用对象的hash码。hashCode必须满足以下协议：

在一个Java应用中，对同一个对象多次调用hashCode()方法，必须返回相同的值。在对象被修改时，不提供equals方法的比较信息。（我的理解：不可以将hashCode值作为equals方法相等的充要条件，同一对象hashCode值肯定相等，不同对象hashCode值不一定不相等）
如果两个对象通过equals方法相等，那么两个对象的hashCode返回值必须要相等。
如果两个对象通过equals方法不相等，两个对象的hashCode返回值不一定不相等。但是程序员应该知道，不相等的对象若返回不想等的hash值，有助于提高hash表的性能。

（4）equals(Object obj)

 1  /**
 2      * Indicates whether some other object is "equal to" this one.
 3      * <p>
 4      * The {@code equals} method implements an equivalence relation
 5      * on non-null object references:
 6      * <ul>
 7      * <li>It is <i>reflexive</i>: for any non-null reference value
 8      *     {@code x}, {@code x.equals(x)} should return
 9      *     {@code true}.
10      * <li>It is <i>symmetric</i>: for any non-null reference values
11      *     {@code x} and {@code y}, {@code x.equals(y)}
12      *     should return {@code true} if and only if
13      *     {@code y.equals(x)} returns {@code true}.
14      * <li>It is <i>transitive</i>: for any non-null reference values
15      *     {@code x}, {@code y}, and {@code z}, if
16      *     {@code x.equals(y)} returns {@code true} and
17      *     {@code y.equals(z)} returns {@code true}, then
18      *     {@code x.equals(z)} should return {@code true}.
19      * <li>It is <i>consistent</i>: for any non-null reference values
20      *     {@code x} and {@code y}, multiple invocations of
21      *     {@code x.equals(y)} consistently return {@code true}
22      *     or consistently return {@code false}, provided no
23      *     information used in {@code equals} comparisons on the
24      *     objects is modified.
25      * <li>For any non-null reference value {@code x},
26      *     {@code x.equals(null)} should return {@code false}.
27      * </ul>
28      * <p>
29      * The {@code equals} method for class {@code Object} implements
30      * the most discriminating possible equivalence relation on objects;
31      * that is, for any non-null reference values {@code x} and
32      * {@code y}, this method returns {@code true} if and only
33      * if {@code x} and {@code y} refer to the same object
34      * ({@code x == y} has the value {@code true}).
35      * <p>
36      * Note that it is generally necessary to override the {@code hashCode}
37      * method whenever this method is overridden, so as to maintain the
38      * general contract for the {@code hashCode} method, which states
39      * that equal objects must have equal hash codes.
40      *
41      * @param   obj   the reference object with which to compare.
42      * @return  {@code true} if this object is the same as the obj
43      *          argument; {@code false} otherwise.
44      * @see     #hashCode()
45      * @see     java.util.HashMap
46      */
47     public boolean equals(Object obj) {
48         return (this == obj);
49     }

判断两个对象是不是相等。该方法遵循如下性质：

自反性：对于任意非空引用x，则x.equals(x)返回true。
对称性：对于任意非空引用x、y，若x.equals(y)返回true，则y.equals(x)返回true。
传递性：对于任意非空引用x、y、z，若x.equals(y)返回true且y.equals(z)返回true，则x.equals(z)返回true。
对于任何非空引用值x和y，多次调用x.equals（y）始终返回true或者始终返回false，没有提供任何信息进行相等比较的对象被修改。
对于任意非空引用x，则x.equals(null)返回false。

重写equals方法必须重写hashCode方法来保证对任意两个对象equals返回值true时，他们的hashCode返回值必须相等。

请注意源码中的实现是“==”号，必要时请重写该方法！

（5）clone()

 1  /**
 2      * Creates and returns a copy of this object.  The precise meaning
 3      * of "copy" may depend on the class of the object. The general
 4      * intent is that, for any object {@code x}, the expression:
 5      * <blockquote>
 6      * <pre>
 7      * x.clone() != x</pre></blockquote>
 8      * will be true, and that the expression:
 9      * <blockquote>
10      * <pre>
11      * x.clone().getClass() == x.getClass()</pre></blockquote>
12      * will be {@code true}, but these are not absolute requirements.
13      * While it is typically the case that:
14      * <blockquote>
15      * <pre>
16      * x.clone().equals(x)</pre></blockquote>
17      * will be {@code true}, this is not an absolute requirement.
18      * <p>
19      * By convention, the returned object should be obtained by calling
20      * {@code super.clone}.  If a class and all of its superclasses (except
21      * {@code Object}) obey this convention, it will be the case that
22      * {@code x.clone().getClass() == x.getClass()}.
23      * <p>
24      * By convention, the object returned by this method should be independent
25      * of this object (which is being cloned).  To achieve this independence,
26      * it may be necessary to modify one or more fields of the object returned
27      * by {@code super.clone} before returning it.  Typically, this means
28      * copying any mutable objects that comprise the internal "deep structure"
29      * of the object being cloned and replacing the references to these
30      * objects with references to the copies.  If a class contains only
31      * primitive fields or references to immutable objects, then it is usually
32      * the case that no fields in the object returned by {@code super.clone}
33      * need to be modified.
34      * <p>
35      * The method {@code clone} for class {@code Object} performs a
36      * specific cloning operation. First, if the class of this object does
37      * not implement the interface {@code Cloneable}, then a
38      * {@code CloneNotSupportedException} is thrown. Note that all arrays
39      * are considered to implement the interface {@code Cloneable} and that
40      * the return type of the {@code clone} method of an array type {@code T[]}
41      * is {@code T[]} where T is any reference or primitive type.
42      * Otherwise, this method creates a new instance of the class of this
43      * object and initializes all its fields with exactly the contents of
44      * the corresponding fields of this object, as if by assignment; the
45      * contents of the fields are not themselves cloned. Thus, this method
46      * performs a "shallow copy" of this object, not a "deep copy" operation.
47      * <p>
48      * The class {@code Object} does not itself implement the interface
49      * {@code Cloneable}, so calling the {@code clone} method on an object
50      * whose class is {@code Object} will result in throwing an
51      * exception at run time.
52      *
53      * @return     a clone of this instance.
54      * @throws  CloneNotSupportedException  if the object's class does not
55      *               support the {@code Cloneable} interface. Subclasses
56      *               that override the {@code clone} method can also
57      *               throw this exception to indicate that an instance cannot
58      *               be cloned.
59      * @see java.lang.Cloneable
60      */
61     protected native Object clone() throws CloneNotSupportedException;

创建和返回一个对象的复制。注意以下几点：

x.clone() != x 是true

一个对象可以被克隆的前提是该对象代表的类实现了Cloneable接口，否者会抛出一个CloneNotSupportedException异常。

调用clone方法时，分配的内存和源对象（即调用clone方法的对象）相同，然后再使用原对象中对应的各个域，填充新对象的域，填充完成之后，clone方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部。

克隆是浅复制。（详情：http://www.importnew.com/22035.html）

思考：如何进行深拷贝？

（6）toString()

 1 /**
 2      * Returns a string representation of the object. In general, the
 3      * {@code toString} method returns a string that
 4      * "textually represents" this object. The result should
 5      * be a concise but informative representation that is easy for a
 6      * person to read.
 7      * It is recommended that all subclasses override this method.
 8      * <p>
 9      * The {@code toString} method for class {@code Object}
10      * returns a string consisting of the name of the class of which the
11      * object is an instance, the at-sign character `{@code @}', and
12      * the unsigned hexadecimal representation of the hash code of the
13      * object. In other words, this method returns a string equal to the
14      * value of:
15      * <blockquote>
16      * <pre>
17      * getClass().getName() + '@' + Integer.toHexString(hashCode())
18      * </pre></blockquote>
19      *
20      * @return  a string representation of the object.
21      */
22     public String toString() {
23         return getClass().getName() + "@" + Integer.toHexString(hashCode());
24     }

返回一个表示该对象的字符串，默认实现是：类名@Integer.toHexString(hashCode())

建议子类重写该方法。

（6）notify()、notifyAll()、wait()、wait(long)、wait(long,int)

这几个方法是多线程编程里面常用的方法，这里不多解释。

（7）finalize()

 1  /**
 2      * Called by the garbage collector on an object when garbage collection
 3      * determines that there are no more references to the object.
 4      * A subclass overrides the {@code finalize} method to dispose of
 5      * system resources or to perform other cleanup.
 6      * <p>
 7      * The general contract of {@code finalize} is that it is invoked
 8      * if and when the Java&trade; virtual
 9      * machine has determined that there is no longer any
10      * means by which this object can be accessed by any thread that has
11      * not yet died, except as a result of an action taken by the
12      * finalization of some other object or class which is ready to be
13      * finalized. The {@code finalize} method may take any action, including
14      * making this object available again to other threads; the usual purpose
15      * of {@code finalize}, however, is to perform cleanup actions before
16      * the object is irrevocably discarded. For example, the finalize method
17      * for an object that represents an input/output connection might perform
18      * explicit I/O transactions to break the connection before the object is
19      * permanently discarded.
20      * <p>
21      * The {@code finalize} method of class {@code Object} performs no
22      * special action; it simply returns normally. Subclasses of
23      * {@code Object} may override this definition.
24      * <p>
25      * The Java programming language does not guarantee which thread will
26      * invoke the {@code finalize} method for any given object. It is
27      * guaranteed, however, that the thread that invokes finalize will not
28      * be holding any user-visible synchronization locks when finalize is
29      * invoked. If an uncaught exception is thrown by the finalize method,
30      * the exception is ignored and finalization of that object terminates.
31      * <p>
32      * After the {@code finalize} method has been invoked for an object, no
33      * further action is taken until the Java virtual machine has again
34      * determined that there is no longer any means by which this object can
35      * be accessed by any thread that has not yet died, including possible
36      * actions by other objects or classes which are ready to be finalized,
37      * at which point the object may be discarded.
38      * <p>
39      * The {@code finalize} method is never invoked more than once by a Java
40      * virtual machine for any given object.
41      * <p>
42      * Any exception thrown by the {@code finalize} method causes
43      * the finalization of this object to be halted, but is otherwise
44      * ignored.
45      *
46      * @throws Throwable the {@code Exception} raised by this method
47      * @see java.lang.ref.WeakReference
48      * @see java.lang.ref.PhantomReference
49      * @jls 12.6 Finalization of Class Instances
50      */
51     protected void finalize() throws Throwable { }

这是一个被垃圾收集器调用的方法，当一个对象没有被其他引用指向时，垃圾回收器会清理该对象，在回收该对象之前会调用finalize方法。子类一般会重写该方法做一些系统资源清理工作。一个对象只会被调用一次finalize方法。如果finalize方法抛出异常，这个对象的终结将会停止。