Object

##Object类

###一、简介

java.lang.Object，是Java所有类的父类，在你编写一个类的时候，若无指定父类（没有显式extends一个父类）,会默认的添加Object为该类的父类。
在JDK 6之前是编译器处理，即编译后的zclass字节码可以显示的看到 extends Object.JDK 7之后是虚拟机处理,class字节码已经看不到了,虚拟机执行代码会默认添加Object类为父类。
我们在编辑器里（IDE）打点时就能列出Object类下的方法，此时还没轮到编译器和jvm，编辑器就已经知道MyClass类的父类是Object类了，这是因为编辑器为我们做了一些智能处理.

Object类中的方法一共有13个，1个构造方法，1个私有方法，2个受保护方法，其余9个则是公有方法。

###二、Object中的方法

public class Object(){
	//native关键字标识的java方法为本地方法，底层是有c/c++编写的程序编译后dll文件，java加载dll文件后，可用通过本地方法调用dll中函数，如有疑问可用参考JNI使用方式
	static native void registerNatives();
	public final native class<?> getClass(); //返回此object的运行时类
	public native int hashCode();//  返回类的hash值
	protect native object clone() ;//throws CloneNotSupportedException;  克隆，是创建类的一种方式，object的clone方法是浅复制，如果想实现深拷贝，需要自己编写clone方法
	public final native void notify();//  唤醒在此对象监视器上等待的单个线程
	public final native void notifyAll();// 唤醒在此对象监视器上等待的所有线程
	public final native void wait(long timeout) throws InterruptedException;
	
	//final方法是不允许继承的子类覆盖的，换个说法，final方法是所有类都是一样的。
	public final native class<?> getClass() ;//返回此object的运行时类
	public final native void notify();
	public final void wait() throws InterruptedExceptiop;
	public final native void wait(long timeout) throws InterruptedException;
	final void wait(long timeout,int nanos);
}

####1、构造方法Object（）

Object类的构造方法在JDK源码中并没有直接书写出来，是一个默认的无参构造方法，可以直接通过关键字new来进行创建一个Object类型的对象。 例如：

Object object = new Object();

####2、registerNatives（）

这个方法是private的，是私有的，所以这个方法是Object类独有的方法，不会被其子类继承。
registerNatives() 方法独特的地方在于，使用了 ***native***关键字进行修饰，在java中，使用native关键字进行修饰，那就说明这个方法的底层实现，并不是由Java代码来进行编写的，而是调用了其他语言编写的接口来进行实现的。
我们可以从源码中发现：以下代码。通过一个静态代码块。也就是说，这个类实例化之前一定都会走这个static静态代码块

static {
    registerNatives();
}

####3、clone（）

clone（）方法是一个受保护的方法，作用是克隆一个对象。
但是像下面这种写法是错误的，因为clone（）是一个protected方法，无法直接调用。如果想要调用可以实现cloneable接口
注：clone（）方法克隆出来的对象，和原来的对象并不是同一个，而是重新创建了一个新的对象

public class Test{
	public static void main(String[] args) {
        Object ob = new Object();
		ob.clone();
	}	
}

####4、finalize（）
protected void finalize() throws Throwable { }

finalize()方法是一个和Java的垃圾回收机制有关的方法。
这个方法会在Java的垃圾回收机制回收对象所占内存之前被调用，即当一个对象被Java虚拟机宣告死亡时会先调用它finalize()方法，让这个对象处理它被回收前的最后事情。
如果我们在Java类中覆写了该方法，可以通过覆写的方法，摆脱本身被Java垃圾回收机制回收的命运。
对于这个方法，我们只限于了解，并不深究。

####5、getClass（）
public final native Class<?> getClass();

通过这个方法，可以获取Java对象的字节码对象，具体操作如下：

public class Test{
	public static void main(String[]args){
		Class clazz = user.getClass();
		User user = new User();
	}
}

####6、hashCode（）

获取java对象的哈希码值，

public native int hashCode();

####7、equals(Object obj)

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

equals(Object obj)方法，其实从源码不难发现，equals方法最底层还是调用了==运算符来实现的，也就是说Object类的equals方法和双等号运算符并没有什么区别。
也就是基本数据类型比较值是否相等，应用数据类型比较内存地址是否相等。
而String类型的equals方法之所以可以比较应用数据类的值是否相等，那是因为String类中重写了equals方法。

####8、toString()

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

toString()方法，在JavaBean中经常被覆写的方法，用于返回对象的字符串表示形式。
没有被覆写时结果为：（包名+引用内存地址）
当toString()方法被覆写时：（字符串形式为自己覆写的toString决定）

####9、notify（）

唤醒正在等待对象监视器的单个线程。

public final native void notify();

####10、notifyAll()

唤醒正在等待对象监视器的所有线程。

public final native void notifyAll();

####11、wait（）

导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。

public final void wait() throws InterruptedException { wait(0); }

####12、wait(long timeout)

导致当前线程等待，直到另一个线程调用 notify()方法或该对象的 notifyAll()方法，或者指定的时间已过。

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

####13、wait(long timeout, int nanos)

导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法，或者某些其他线程中断当前线程，或一定量的实时时间。

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);
}

##完整源码Object

package java.lang;

public class Object {

    private static native void registerNatives();
    static {
        registerNatives();
    }
    
    public final native Class<?> getClass();
    
    public native int hashCode();
    
    public boolean equals(Object obj) {
        return (this == obj);
    }
    
    protected native Object clone() throws CloneNotSupportedException;
    
    public String toString() {
        return getClass().getName() + "@" +Integer.toHexString(hashCode());
    }
    
    public final native void notify();
    
    public final native void notifyAll();
    
    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);
    }
    
    protected void finalize() throws Throwable { }
    
}