Object class - the father of ten thousand classes

Object Class is a special class , Is the parent of all classes .

Because of this relationship ,Object Generic methods in classes （ function ） Can be used by subclasses .

public final native Class<?> getClass()
//native Method , Used to return the current runtime object Class object , Used final Keyword modification , Therefore, subclasses are not allowed to override .
public native int hashCode() 
//native Method , Hash code used to return the object , It is mainly used in hash table , such as JDK Medium HashMap.
public boolean equals(Object obj)
// For comparison 2 Whether the memory addresses of objects are equal ,String Class to override the method, and the user compares the string values for equality .
protected native Object clone() throws CloneNotSupportedException
//naitive Method , Used to create and return a copy of the current object . In general , For any object  x, expression  x.clone() != x  by true,x.clone().getClass() == x.getClass()  by true.Object It didn't come true Cloneable Interface , So don't rewrite clone Method and make the call CloneNotSupportedException abnormal .
public String toString()
// Returns the name of the class @ Instance's hash code 16 Base string . Suggest Object All subclasses override this method .
public final native void notify()
//native Method , And it can't be rewritten . Wake up a thread waiting on this object monitor ( Monitor is equivalent to the concept of lock ). If there are multiple threads waiting, only one of them will wake up .
public final native void notifyAll()
//native Method , And it can't be rewritten . Follow notify equally , The only difference is that it wakes all threads waiting on this object monitor , Not a thread .
public final native void wait(long timeout) throws InterruptedException
//native Method , And it can't be rewritten . Pause thread execution . Be careful ：sleep Method does not release lock , and wait Method releases the lock  .timeout It's waiting time .
public final void wait(long timeout, int nanos) throws InterruptedException
// More nanos Parameters , This parameter represents the extra time （ In nanoseconds , The scope is  0-999999）.  So the overtime time needs to be added nanos millisecond .
public final void wait() throws InterruptedException
// Just like before 2 individual wait The method is the same , It's just that the method has been waiting for , There's no concept of overtime 
protected void finalize() throws Throwable {
     }
// The action triggered when an instance is collected by the garbage collector