1. 概念定義

自引用（Self-Referential Type） 是指：

在一個類的定義中，類的某個成員變量（或字段）類型就是該類自身。

這種定義使得類可以引用同類型的對象，從而構建出 遞歸數據結構（Recursive Data Structure），如：

• 鏈表（Linked List）
• 樹（Tree）
• 圖（Graph）
• 組織層級結構（Hierarchy）

? 舉個例子

class Node {
    int data;
    Node next; // 自引用：類型是當前類 Node
    Node(int data) {
        this.data = data;
    }
}

上例中的 Node 類中包含了一個字段 next，它的類型就是 Node 自身，這就是典型的 自引用結構。

2. 為什么可以“引用自己”

Java 的對象變量實際上是一個 引用（reference），而不是對象本身。

在 JVM 中：

• 對象實體存儲在 堆（Heap） 上；
• 局部變量和成員變量保存的是 引用（即指向堆中對象的邏輯地址）。

因此，當在類中聲明 Node next; 時：

• 并不會立即創(chuàng)建另一個 Node；
• 只是聲明了一個可以“指向另一個 Node 對象”的引用變量；
• 不會導致無限遞歸定義。

這正是自引用能夠成立的根本原因。

?? 注意對比：嵌套對象 vs 引用對象

3. 自引用的典型應用場景

1?? 單向鏈表（Singly Linked List）

class Node {
    int data;
    Node next; // 指向下一個節(jié)點
    Node(int data) {
        this.data = data;
    }
}

構建鏈表：

Node n1 = new Node(10);
Node n2 = new Node(20);
Node n3 = new Node(30);
n1.next = n2;
n2.next = n3;

邏輯結構：

n1 → n2 → n3 → null

2?? 二叉樹節(jié)點（Binary Tree Node）

class TreeNode {
    int value;
    TreeNode left;   // 指向左子節(jié)點
    TreeNode right;  // 指向右子節(jié)點
    TreeNode(int value) {
        this.value = value;
    }
}

樹狀結構自然形成遞歸關系，每個節(jié)點都可能再包含子節(jié)點。

3?? 圖節(jié)點（Graph Node）

import java.util.ArrayList;
import java.util.List;
class GraphNode {
    int val;
    List<GraphNode> neighbors;
    GraphNode(int val) {
        this.val = val;
        this.neighbors = new ArrayList<>();
    }
}

這里的 List<GraphNode> 就是自引用的集合形式，
它允許一個節(jié)點同時連接多個同類節(jié)點，從而構建圖結構。

4. 自引用的編譯原理與內存模型

（1）類加載與符號引用

當 Java 編譯器看到：

class Node {
    Node next;
}

時，它會將 next 的類型解析為符號引用（Symbolic Reference）：

LNode;

在類加載階段（Class Loading）：

• JVM 會把符號引用解析為實際的類型引用；
• 不需要在編譯時就擁有完整的類對象；
• 因此類可以安全地引用自身。

（2）JVM 內存布局

每個 Java 對象都存放在 堆（Heap） 中，由 JVM 自動分配和回收。

當執(zhí)行：

Node n1 = new Node(10);
Node n2 = new Node(20);
n1.next = n2;

內存布局如下：

[棧區(qū)]                     [堆區(qū)]
+--------+           +--------------------+
| n1 --->|---------->| data=10            |
|        |           | next -> (Node@b32) |
+--------+           +--------------------+
| n2 --->|---------->| data=20            |
|        |           | next -> null       |
+--------+           +--------------------+

說明：

• n1, n2 是棧變量；
• 它們的值是指向堆中 Node 對象的引用（reference）；
• next 字段本質上也保存一個引用。

（3）對象頭與引用機制

在 HotSpot JVM 中，每個對象頭包含：

• Mark Word：存放哈希值、鎖狀態(tài)、GC信息；
• Class Pointer：指向對象的類元數據；
• 實例數據：即類中聲明的字段；
• 填充字節(jié)：保證對象大小為 8 字節(jié)對齊。

當對象引用被賦值時（如 n1.next = n2）：

• 實際上只是復制了 n2 的“引用值”；
• 這是一種輕量級操作（非深拷貝）。

（4）為什么不是內存地址

如果打?。?/p>

System.out.println(n1);

輸出類似：

Node@1b6d3586

這里的 1b6d3586 并不是內存地址，而是：

Integer.toHexString(hashCode());

其中 hashCode() 來源于對象頭（Mark Word）計算結果，與真實內存地址無直接關系。

5. 自引用與遞歸（Recursion）的關系

自引用是一種 數據結構層面的遞歸定義，
而遞歸函數是一種 行為層面的遞歸調用。

兩者結合，可以優(yōu)雅地處理鏈表或樹結構。

void printList(Node node) {
    if (node == null) return;
    System.out.print(node.data + " ");
    printList(node.next); // 行為遞歸，利用結構自引用
}

輸出：

10 20 30

6. 自引用的注意事項與常見問題

?? 1. 無限遞歸創(chuàng)建

錯誤寫法：

class Node {
    Node next = new Node(); // 無限創(chuàng)建自身，棧溢出！
}

正確方式：

class Node {
    Node next; // 僅聲明引用，不立即實例化
}

?? 2. 循環(huán)引用導致邏輯死循環(huán)

n1.next = n2;
n2.next = n1; // 環(huán)狀結構

遍歷時若無判斷，會無限循環(huán)。
應通過 visited 集合或快慢指針檢測環(huán)。

?? 3. 打印對象時陷入遞歸

如果重寫 toString() 時遞歸引用：

@Override
public String toString() {
    return "Node[data=" + data + ", next=" + next + "]";
}

若鏈表有環(huán)，會導致 StackOverflowError。
解決方式是檢測 next 是否為 null 或限制深度。

7. 底層機制擴展：JVM 引用與 GC 行為

1?? 引用類型分類（JDK 1.2 起）

Node next 默認是強引用，
因此只要對象之間互相引用，GC 就不會釋放內存（除非形成不可達狀態(tài)）。

2?? 自引用與 GC 的安全性

Java 的 GC 通過 可達性分析（Reachability Analysis） 判斷對象是否存活。
即使存在自引用（如循環(huán)鏈表），只要外部沒有引用鏈指向該結構，它仍會被 GC 安全回收。

示例：

Node a = new Node(1);
Node b = new Node(2);
a.next = b;
b.next = a;  // 形成環(huán)
a = null;
b = null;    // 外部引用斷開

→ 整個環(huán)結構在下一次 GC 時被回收，無內存泄漏。

8. 與 C 語言的對比

9.總結與核心觀點

?? 一句話總結

Java 自引用是一種基于引用語義的遞歸結構定義機制。
它通過在類中引用同類對象實現邏輯自連接，構建出復雜的數據結構。
底層由 JVM 的“堆-棧分離模型”和“引用機制”支撐，實現了靈活與安全的統(tǒng)一。

到此這篇關于Java 中的自引用的文章就介紹到這了,更多相關java自引用內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論