JAVA基础1---Object类解析

1.Object简介

众所周知，Object类是Java所有类的万类之源，所有Java类都是继承之Object类，而默认就直接忽略了extends Object这段代码。

2.Object类的源码

话不多说，源码先贴为敬，源码如下：

package java.lang;

public class Object {
    //本地方法,通过JNI调用
    private static native void registerNatives();
    static {//对象初始化时调用
        registerNatives();
    }
    //返回object在运行时的类对象
    public final native Class<?> getClass();
    //获取object对象的hashcode
    public native int hashCode();
    //比较对象的内存地址
    public boolean equals(Object obj) {
        return (this == obj);
    }
    //本地的clone方法，用于对象的copy
    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 { }
}

3.Object类的方法

Object类方法如下

getClass()方法：

public final native Class<?> getClass();

final类型的本地方法，通过JNI调用，返回对象在运行时的Class对象，如：

User user = new User();

Class c = user.getClass();

返回的是User的Class类对象

hashCode()方法

public native int hashCode();

返回该对象的哈希值，可以重写hashCode方法，但是重写了hashCode一般也需要重写equals方法，必须满足

obj1.equals(obj2)==true，则obj1.hashCode()==obj2.hashCode();但是反过来两个对象的hashCode一直不一定两个对象equals

equals(Object obj)方法

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

Object类的equals默认和“==”比较结果一样，比较的是两个对象的内存地址是否一致，所以默认obj1.equals(obj2)=true则obj==obj2也为true；

由于比较的是内存地址，所以即使两个对象的值完全一样，返回的也是false；而我们最常用的String类由于重写了equlas方法，所以只要String的值一样就返回true，String的方法如下：

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        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的equals方法是将字符串的每个字符挨个比较，只要每个字符都一样则返回true；

和String情况类似，Integer和Long等也重写了equals方法，如Integer的equals方法源码如下:

 public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
    }

//TODO

具体需不需要重写equals，视情况而定，建议是不重写；

toString()方法

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

返回一个字符串，默认有对象的类名+@+对象哈希值的无符号十六进制表示，建议重写；

clone()方法

protected native Object clone() throws CloneNotSupportedException;

projected修饰的本地方法，实现了对象的浅复制，只有实现了Cloneable接口的对象才可调用此方法；

notify()方法

public final native void notify();

final类型的本地方法，用于唤醒在等待该对象锁的某个线程

notifyAll()方法

public final native void notifyAll();

final类型的本地方法，用于唤醒在等待该对象锁的全部线程

wait()方法

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

wait(long timeout)方法

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

wait(long timeout,int nanos)方法

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

可以看出这三个wait方法最终都是调用了wait(long timeout)方法，这也是个final类型的本地方法；

该方法的作用是让当前线程放弃该对象的对象锁进入等待状态，前提是当前线程已经获取到了该对象的锁。一直等待直到timeout时间到或其他线程调用了该对象的notify()或notifyAll()方法；

finalize()方法

 protected void finalize() throws Throwable { }

用于垃圾回收时调用，详情可参看垃圾回收机制；

4.注意事项

1.Integer类和Long类都重写了equals方法，所以比较Integer类型和Long类型的值是否相同是需要使用equals方法，而不建议使用==；

而int和long由于是基本数据类型，没有equals方法，所以比较值相等必须使用==，Integer和Long则不可以，如下例子：

    public static void main(String[] args){
        Integer i = 200;
        Integer j = 200;
        System.out.println(i==j);//输出结果为:false
    }