# 一、Object簡述

原始碼註釋：Object類是所有類層級關係的Root節點，作為所有類的超類，包括陣列也實現了該類的方法，注意這裡說的很明確，指類層面。

所以在Java中有一句常說的話，一切皆物件，這話並不離譜。

**1、顯式擴充套件**

**結論驗證**

既然Object作為所有類的父級別的類，則不需要在顯式的新增繼承關係，`Each01`編譯期就會提示移除冗餘。

```java
public class Each01 extends Object {
    public static void main(String[] args) {
        System.out.println(new Each01().hashCode()+";"+new ObjEa02().hashCode());
    }
}
class ObjEa02 {}
class ObjEa03 extends ObjEa02{}
```

這裡`Each01`與`ObjEa02`物件例項都有Object類中的`hashCode`方法，這裡對既有結論的驗證。

**編譯檔案**

再從JVM編譯層面看下位元組碼檔案，是如何載入，使用`javap -c`命令檢視編譯後的檔案，注意Jdk版本`1.8`；

```
javap -c Each01.class
Compiled from "Each01.java"
public class com.base.object.each.Each01 {
  public com.base.object.each.Each01();
    Code:
       0: aload_0
       1: invokespecial #1 // Method java/lang/Object."<init>":()V
       4: return
}

javap -c ObjEa02.class 
Compiled from "Each01.java"
class com.base.object.each.ObjEa02 {
  com.base.object.each.ObjEa02();
    Code:
       0: aload_0
       1: invokespecial #1 // Method java/lang/Object."<init>":()V
       4: return
}

javap -c ObjEa03.class 
Compiled from "Each01.java"
class com.base.object.each.ObjEa03 extends com.base.object.each.ObjEa02 {
  com.base.object.each.ObjEa03();
    Code:
       0: aload_0
       1: invokespecial #1 // Method com/base/object/each/ObjEa02."<init>":()V
       4: return
}
```

**invokespecial命令**：可以檢視Jvm的官方文件中的指令說明，呼叫例項化方法，和父類的初始化方法呼叫等，這裡透過三個類的層級關係，再次說明Object超類不需要顯式繼承，即使顯式宣告但編譯後原始碼依舊會清除冗餘。

**2、引用與物件**

通常把下面過程稱為：建立一個object物件；

```java
Object object = new Object() ;
```

細節描述：宣告物件引用`object`；透過`new`關鍵字建立物件並基於預設構造方法初始化；將物件引用`object`指向建立的物件。

這一點可以基於Jvm執行流程去理解，所以當物件一旦失去全部引用時，會被標記為垃圾物件，在垃圾收集器執行時清理。

**接受任意資料型別物件的引用**

既然Object作為Java中所有物件的超類，則根據繼承關係的特點，以及向上轉型機制，Object可以接受任意資料型別物件的引用，例如在集合容器或者傳參過程，不確定物件型別時可以使用Object：

```java
public class Each02 {
    public static void main(String[] args) {
        // 向上轉型
        Object obj01 = new Each02Obj01("java") ;
        System.out.println(obj01);
        // 向下轉型
        Each02Obj01 each02Obj01 = (Each02Obj01)obj01;
        System.out.println("name="+each02Obj01.getName());
    }
}
class Each02Obj01 {
    private String name ;
    public Each02Obj01(String name) { this.name = name; }
    @Override
    public String toString() {
        return "Each02Obj01{" +"name='" + name +'}';
    }
    public String getName() { return name; }
}
```

這裡要強調一下這個向上轉型的過程：

```java
Object obj01 = new Each02Obj01("java") ;
```

透過上面流程分析，這裡建立一個父類引用`obj01`，並指向子類`Each02Obj01`物件，所以在輸出的時候，呼叫的是子類的`toString`方法。

# 二、基礎方法

**1、getClass**

在程式執行時獲取物件的例項類，進而可以獲取詳細的結構資訊並進行操作：

```java
public final native Class> getClass();
```

該方法在泛型，反射，動態代理等機制中有很多場景應用。

**2、toString**

返回物件的字串描述形式，Object提供的是類名與無符號十六進位制的雜湊值組合表示，為了能返回一個資訊明確的字串，子類通常會覆蓋該方法：

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

在Java中，列印物件的時候，會執行`String.valueOf`轉換為字串，該方法的底層依舊是物件的`toString`方法：

```java
public void println(Object x) {
    String s = String.valueOf(x);
}
public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}
```

**3、equals與hashCode**

- equals：判斷兩個物件是否相等；
- hashCode：返回物件的雜湊碼值；

```java
public native int hashCode();
public boolean equals(Object obj) {
    return (this == obj);
}
```

`equals`判斷方法需要考量實際的場景與策略，例如常見的公民註冊後分配的身份ID是不能修改的，但是名字可以修改，那麼就可能存在這樣的場景：

```java
EachUser eachUser01 = new EachUser(1,"A") ;
EachUser eachUser02 = new EachUser(1,"B") ;
class EachUser {
    private Integer cardId ;
    private String name ;
}
```

從程式本身看，這確實是建立兩個物件，但是放在場景下，這的確是描述同一個人，所以這時候可以在`equals`方法中定義比較規則，如果ID相同則視為同一個物件：

```java
@Override
public boolean equals(Object obj) {
    if (obj != null){
        EachUser compareObj = (EachUser)obj ;
        return this.cardId.intValue()==compareObj.cardId ;
    }
    return Boolean.FALSE ;
}
```

這裡還要注意值型別和引用型別的區別，如果出現`null`比較情況，要返回false。

通常在子類中會同時覆蓋這兩個方法，這樣做法在集合容器的設計上已經體現的淋漓盡致。

**4、thread相關**

- wait：執行緒進入waiting等待狀態，不會爭搶鎖物件
- notify：隨機通知一個在該物件上等待的執行緒；
- notifyAll：喚醒在該物件上所有等待的執行緒；

```java
public final native void wait(long timeout) throws InterruptedException;
public final native void notify();
public final native void notifyAll();
```

注意這裡：`native`關鍵字修飾的方法，即呼叫的是原生函式，也就是常說的基於C/C++實現的本地方法，以此提高和系統層面的互動效率降低互動複雜程度。

**5、clone**

返回當前物件的複製：

```java
protected native Object clone() throws CloneNotSupportedException;
```

關於該方法的細節規則極度複雜，要注意下面幾個核心點：

- 物件必須實現Cloneable介面才可以被克隆；
- 資料型別：值型別，String型別，引用型別；
- 深淺複製的區別和與之對應的實現流程；
- 在複雜的包裝型別中，組合的不同變數型別；

**6、finalize**

當垃圾收集器確認該物件上沒有引用時，會呼叫finalize方法，即清理記憶體釋放資源：

```java
protected void finalize() throws Throwable { }
```

通常子類不會覆蓋該方法，除非在子類中有一些其他必要的資源清理動作。

# 三、生命週期

**1、作用域**

在下面main方法執行結束之後，無法再訪問`Each05Obj01`的例項物件，因為物件的引用`each05`丟失：

```java
public class Each05 {
    public static void main(String[] args) {
        Each05Obj01 each05 = new Each05Obj01 (99) ;
        System.out.println(each05);
    }
}
```

這裡就會存在一個問題，引用丟失導致物件無法訪問，但是物件在此時可能還是存在的，並沒有釋放記憶體的佔用。

**2、垃圾回收機制**

Java透過new建立的物件會在堆中開闢記憶體空間儲存，當物件失去所有引用時會被標記為垃圾物件，進而被回收；

這裡涉及下面幾個關鍵點：

- Jvm中垃圾收集器會監控建立的物件 ；
- 當判斷物件不存在引用時，會執行清理動作；
- 完成物件清理後會重新整理記憶體空間；

這裡存在一個很難理解的概念，即**物件不存在引用的判斷**，也就是常說的**可達性分析演算法**：基於物件到根物件的引用鏈是否可達來判斷物件是否可以被回收；GC-Roots根引用集合，也可以變相理解為存活物件的集合。(詳見JVM系列)

透過Object物件的分析，結合Java方方面面的機制和設計，可以去意會一些所謂的程式設計思想。

# 四、原始碼地址

```
GitEE·地址
https://gitee.com/cicadasmile/java-base-parent
Wiki·地址
https://gitee.com/cicadasmile/butte-java-note/wikis
```

![](http://img.blog.itpub.net/blog/2021/08/31/2ba925260c7ac1e5.png?x-oss-process=style/bb)</init></init></init>

理解Java中物件基礎Object類

相關文章