Object 类

java.lang.Object 类

1 个默认的构造方法
1 个私有（private）的方法：registerNatives().
2 个受保护（protected）的方法：clone()、finalize().
9 个公共（public）的方法

5 个可以重写的方法：equals()、hashCode()、toString()、clone()、finalize()

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

用 native 关键字修饰的函数表明该方法的实现并不是在 Java 中去完成，而是由 C/C++ 去完成，并被编译成了 .dll 文件，由 Java 去调用。
registerNatives() 方法的作用是将 C/C++ 中的方法映射到 Java 中的 native 方法，实现方法命名的解耦。

一、构造方法：

public Object() {} // 默认的构造方法

二、Java 的监视器方法：

public final native void wait(long timeout) throws InterruptedException;

public final void wait() throw InterruptedException {
  wait(0); // timeout 为 0 表示无线等待
}

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");
  }
  
  // 1毫秒 = 1000 微秒 = 1000 000 纳秒
  // 为了更加精确地控制时间，也防止时间很小到纳秒级的时候 timeout 无法表示，只能为 0 ，而为0却是进入无限循环
  if (nanos > 0) {
	timeout++;
  }
  
  wait(timeout);
}

public final native notify();
public final native notifyAll();

三、其他

public final native Class<?> getClass();

public boolean equals(Object obj) {
  return (this == obj);
}

public native int hashCode(); // 默认情况下，Object中的hashCode() 返回对象的32位jvm内存地址

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

protected native Object clone() throws CloneNotSupportedException; // 一个类重写了 Object 内定义的 clone() ，需要同时实现 Cloneable 接口（虽然这个接口内并没有定义 clone() 方法），否则在调用 clone() 时会报 CloneNotSupportedException 异常

protected void finalize() throws Throwable {}

四、equals()与 hashCode()
1、原则
两个对象：
equals()相等，hashCode()一定相同；
hashCode()不相等，equals()一定不相等;
equals()不相等，hashCode()可能相同，但保证不相同能提高哈希性能；
hashCode()相同，equals()不一定相等。

2、重写 equals()和 hashCode()的步骤：
（1）用 == 判断是否为同一对象；
（2）用 instanceof 判断比较的对象是否为该类或其子类的一个实例；
（3）比较成员变量是否一致（值相等，引用指向同一对象）；
（4）重写 hashCode()方法。

3、Java 中重写了 equals()和 hashCode()的类：
java.lang.String
java.lang.Byte
java.lang.Short
java.lang.Character
java.lang.Integer
java.lang.Long

4、java.lang.Stirng 对 equals()和 hashCode()的重写：

private final char[] value;
private int hash;

public boolean equals(Object anObject) {
	// 同一个对象直接返回true
        if (this == anObject) {
            return true;
        }
		
	// 判断比较的对象是否是String类的实例
        if (anObject instanceof String) {
            String anotherString = (String) anObject;
            int n = value.length;
	  // 判断字符串长度是否相等
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
		// 判断字符串内容是否相同
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

/*
 * 如果String对象为空（""），则其hash值为0，否则，在第一次调用String对象的hashCode()时计算hash值
 */
public int hashCode() {
    int h = hash;
    // 第一次调用String对象的hashCode()时如果该对象不为空对hash赋值
    if (h == 0 && value.length > 0) { 
        char val[] = value;

	// val[0]*31^val.length-1 + val[1]*31^val.length-2 + ... + val[i-1]*31^1 + val[i]*31^0，即31进制数转化为10进制数
	// 选31原因：1、奇质数，降低哈希碰撞概率；2、31 * i == (i << 5) - i，JVM能自动完成这个优化
        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
	
	// 第二次调用实例的hashCode()或String对象为空（""）时直接返回hash
    return h;
}

五、重写 clone()
1、深拷贝

2、浅拷贝

3、重写 clone()方法的步骤
（1）继承 cloneable 接口；
（2）覆盖 clone()方法，访问修饰符设为 public（Object 里是 protected 是因为所有类都是他的子类当然可以调用，但你覆盖了要保证所有类可以调用就要 public 了）；
（3）方法中调用 super.clone()方法得到需要的复制对象；
（4）

@Override 
public Object clone() {  
  Student stu = null; 

  try {  
	stu = (Student)super.clone();
	....
  } catch(CloneNotSupportedException e) {  
	e.printStackTrace();  
  } 
  return stu;  
}

4、序列化方式解决多层克隆问题

public class Outer implements Serializable{
  private static final long serialVersionUID = 369285298572941L;  //最好是显式声明ID
  public Inner inner;
　//Discription:[深度复制方法,需要对象及对象所有的对象属性都实现序列化]　
  public Outer myclone() {
      Outer outer = null;
      try { // 将该对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝
          ByteArrayOutputStream baos = new ByteArrayOutputStream();
          ObjectOutputStream oos = new ObjectOutputStream(baos);
          oos.writeObject(this);
　　　　　　// 将流序列化成对象
          ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
          ObjectInputStream ois = new ObjectInputStream(bais);
          outer = (Outer) ois.readObject();
      } catch (IOException e) {
          e.printStackTrace();
      } catch (ClassNotFoundException e) {
          e.printStackTrace();
      }
      return outer;
  }
}

public class Inner implements Serializable{
  private static final long serialVersionUID = 872390113109L; //最好是显式声明ID
  public String name = "";

  public Inner(String name) {
      this.name = name;
  }

  @Override
  public String toString() {
      return "Inner的name值为：" + name;
  }
}

参考：
java.lang.Object 源码
http://www.cnblogs.com/lwbqqyumidi/p/3693015.html
https://stackoverflow.com/questions/1010645/what-does-the-registernatives-method-do
http://www.cnblogs.com/Qian123/p/5710533.html#_label1