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
     }