Java 基础 | Object 源码解析

今天药忘吃喽~ 2021-11-01 06:38 416阅读 0赞

![Object源码解析][Object]

Java 是一门面向对象的语言，在 Java 里面一切都可以看作是一个对象，而 Java 里面所有的对象都默认继承于 Object 类，所以狗哥今天就复习了一遍这个类。

![Object 方法概览][Object 1]

上图看出 Object 一共有 12 个方法，其中 registerNatives() 是由 C 语言实现的，这个不在研究范围内。

#### 1、getClass ####

/**java * Returns the runtime class of this {@code Object}. The returned * {@code Class} object is the object that is locked by {@code * static synchronized} methods of the represented class. */
    public final native Class<?> getClass();

这个方法的作用就是返回某个对象的运行时类，它的返回值是 Class 类型，Class c = obj.getClass()；通过对象 c ，我们可以获取该对象的所有成员方法，每个成员方法都是一个 Method 对象；我们也可以获取该对象的所有成员变量，每个成员变量都是一个 Field 对象；同样的，我们也可以获取该对象的构造函数，构造函数则是一个 Constructor 对象。这个方法在反射时会常用到。

#### 2、hashCode ####

/** * Returns a hash code value for the object. This method is * supported for the benefit of hash tables such as those provided by * {@link java.util.HashMap}. */
        public native int hashCode();

这个方法的注释比较长，就不放出来了。注释指出：

*  hashCode 方法返回散列值。
 *  返回值默认是由对象的地址转换而来的。
 *  同一个对象调用 hashCode 的返回值是相等的。
 *  两个对象的 equals 相等，那 hashCode 一定相等。
 *  两个对象的 equals 不相等，那 hashCode 也不一定相等。

#### 3、equals ####

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

equals 的实现非常简单，它的作用就是比较两个对象是否相等，而比较的依据就是二者的内存地址。除此之外，equals 还遵循以下几个原则：

1、自反性：x.equals(x);  // true
    2、对称性：x.equals(y) == y.equals(x);  // true
    3、传递性：if (x.equals(y) && y.equals(z))
                x.equals(z); // true;
    
    4、一致性，只要对象没有被修改，多次调用 equals() 方法结果不变：
    x.equals(y) == x.equals(y); // true 
    
    5、非空性，对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false ：
    x.equals(null); // false;

为什么要重写 hashcode 和 equals ？

这个问题之前分享过旧文：[https://mp.weixin.qq.com/s/iIoAnneaeHdQYrj9sd\_yZA][https_mp.weixin.qq.com_s_iIoAnneaeHdQYrj9sd_yZA]

#### 4、clone ####

protected native Object clone() throws CloneNotSupportedException;

clone() 是 Object 的 protected 方法，它不是 public，一个类不显式去重写 clone()，其它类就不能直接去调用该类实例的 clone() 方法。此外，Clone 的注释中还提到比较重要的几点：

*  克隆的对象必须要实现 Cloneable 接口并重写 clone 方法，否则会报 CloneNotSupportedException 异常
 *  clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一个 protected 方法。Cloneable 接口只是规定，如果一个类没有实现 Cloneable 接口又调用了 clone() 方法，就会抛出 CloneNotSupportedException。
 *  浅拷贝：拷贝对象和原始对象的引用类型引用同一个对象。
 *  深拷贝：拷贝对象和原始对象的引用类型引用不同对象。

关于浅拷贝与深拷贝的详解，请看这篇旧文：  
[https://mp.weixin.qq.com/s/I6Gq1shyfKigPp1\_hyb0sg][https_mp.weixin.qq.com_s_I6Gq1shyfKigPp1_hyb0sg]

#### 5、toString ####

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

这个方法应该没什么好讲的，原生的 toString 方法仅仅返回，对象名 + 它的 hashCode ，但做过开发的都知道，原生的 toString 作用不大。我们需要重写 toString 一般是因为方便调试，需要知道对象的属性值，而不仅仅是 hashCode 。所以，应该像下面这样重写：

public class Student { 
    
        private int age;
    
        private String name;
    
        // 省略 get、set
    
        @Override
        public String toString() { 
            return "Student{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

#### 6、notify 和 wait ####

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

首先是 notify ，注释就不贴出来了，notify 的作用就是随机唤醒在等待队列的某个线程，而 notifyAll 就是唤醒在等待队列的所有线程。

public final void wait() throws InterruptedException { 
         wait(0);
    }
    
    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);
    }

然后是 wait ，wait 的作用是让当前线程进入等待状态，同时，wait() 也会让当前线程释放它所持有的锁。直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，当前线程被唤醒进入就绪状态。

wait(long timeout) （以毫秒为单位）让当前线程处于等待(阻塞)状态，直到其他线程调用此对象的notify() 方法或 notifyAll() 方法，或者超过指定的时间量，当前线程被唤醒进入就绪状态。

wait(long timeout, int nanos) 和 wait(long timeout) 功能一样，唯一的区别是这个可以提供更高的精度。总超时时间（以纳秒为单位）计算为 1000000 \*timeout+ nanos。By the way ，wait(0,0) 和 wait(0) 效果一样。

除此之外，notify 和 wait 的注释中还有这么一段：

* <p>
         * This method should only be called by a thread that is the owner
         * of this object's monitor. A thread becomes the owner of the
         * object's monitor in one of three ways:
         * <ul>
         * <li>By executing a synchronized instance method of that object.
         * <li>By executing the body of a { @code synchronized} statement
         *     that synchronizes on the object.
         * <li>For objects of type { @code Class,} by executing a
         *     synchronized static method of that class.
         * </ul>
    * <p>

看到这英文，刚过四级的我瑟瑟发抖。以上注释主要就是描述了，notify 和 wait 方法的使用规范。意思就是这二者必须在 synchronized 修饰的同步方法或同步代码中使用。

*  为什么 wait() 必须在同步 (Synchronized) 方法/代码块中调用？

答：调用 wait() 就是释放锁，释放锁的前提是必须要先获得锁，先获得锁才能释放锁。

*  为什么 notify()、notifyAll() 必须在同步 (Synchronized) 方法/代码块中调用？

答：notify()、notifyAll() 是将锁交给含有 wait() 方法的线程，让其继续执行下去，如果自身没有锁，怎么叫把锁交给其他线程呢？（本质是让处于入口队列的线程竞争锁）

详细解释请参考这篇博文：[https://blog.csdn.net/qq\_42145871/article/details/81950949][https_blog.csdn.net_qq_42145871_article_details_81950949]

*  Thread.sleep() 和 Object.wait() 有什么区别？

首先，二者都可以暂停当前线程，释放 CPU 控制权。主要的区别在于 Object.wait()在释放 CPU 同时，释放了对象锁的控制。而 Thread.sleep() 没有对锁释放。换句话说 sleep 就是耍流氓，占着茅坑不拉屎。

**推荐阅读：**

[1、java | 什么是动态代理][1_java _]

[2、SpringBoot | 启动原理][2_SpringBoot _]

[3、SpringBoot | 自动配置原理][3_SpringBoot _]

![一个优秀的废人][aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8zMjgyMTM0LTU1NTk1NDFkMWM4Y2ZiNmQ]

[Object]: /images/20211101/989805af01b14dd59b8c48de4c67c334.png
[Object 1]: /images/20211101/95b75d823e974e248f4e5e05bd726992.png
[https_mp.weixin.qq.com_s_iIoAnneaeHdQYrj9sd_yZA]: https://mp.weixin.qq.com/s/iIoAnneaeHdQYrj9sd_yZA
[https_mp.weixin.qq.com_s_I6Gq1shyfKigPp1_hyb0sg]: https://mp.weixin.qq.com/s/I6Gq1shyfKigPp1_hyb0sg
[https_blog.csdn.net_qq_42145871_article_details_81950949]: https://blog.csdn.net/qq_42145871/article/details/81950949
[1_java _]: http://mp.weixin.qq.com/s?__biz=MzU2MDY0NDA1MQ==&mid=2247483991&idx=1&sn=9e975618909b78006aaa9a3f001959f1&chksm=fc05a8ebcb7221fd4d9e7e8b645a5b1bd2536bc49a3eaf34eb18c1f7bcc33337ecd98af54e98&scene=21#wechat_redirect
[2_SpringBoot _]: http://mp.weixin.qq.com/s?__biz=MzU2MDY0NDA1MQ==&mid=2247484325&idx=1&sn=ef09f84b1597285896adad51a019e33d&chksm=fc05a919cb72200f0c6bcd3ce0832e3b7954d79b7529e07c133c394de9e9153813acd623fbcc&scene=21#wechat_redirect
[3_SpringBoot _]: http://mp.weixin.qq.com/s?__biz=MzU2MDY0NDA1MQ==&mid=2247483960&idx=1&sn=0f84bbb92c5cb5298388056bef405aff&chksm=fc05a884cb722192e33ea62ad1febdc79e2a101d4ca2e8171760c1dda14cab940320209a088a&scene=21#wechat_redirect
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8zMjgyMTM0LTU1NTk1NDFkMWM4Y2ZiNmQ]: /images/20211101/8852c65fc0ef46e4be4ffbcbfdec3f71.png