1. Add build script for Java.

2. Add height limitation for code blocks in extra.css.
3. Fix "节点" to "结点".

docs/chapter_heap/heap.md

@@ -262,26 +262,14 @@ comments: true
     ```java title="my_heap.java"
     // 使用列表而非数组，这样无需考虑扩容问题
     List<Integer> maxHeap;
-    
-    /* 构造函数，建立空堆 */
-    public MaxHeap() {
-        maxHeap = new ArrayList<>();
-    }
-    
-    /* 获取左子结点索引 */
-    int left(int i) {
-        return 2 * i + 1;
-    }
-    
-    /* 获取右子结点索引 */
-    int right(int i) {
-        return 2 * i + 2;
-    }
-    
-    /* 获取父结点索引 */
-    int parent(int i) {
-        return (i - 1) / 2; // 向下整除
-    }
+
+    [class]{MaxHeap}-[func]{MaxHeap}
+
+    [class]{MaxHeap}-[func]{left}
+
+    [class]{MaxHeap}-[func]{right}
+
+    [class]{MaxHeap}-[func]{parent}
     ```
 
 === "C++"
@@ -407,10 +395,7 @@ comments: true
 === "Java"
 
     ```java title="my_heap.java"
-    /* 访问堆顶元素 */
-    public int peek() {
-        return maxHeap.get(0);
-    }
+    [class]{MaxHeap}-[func]{peek}
     ```
 
 === "C++"
@@ -505,28 +490,9 @@ comments: true
 === "Java"
 
     ```java title="my_heap.java"
-    /* 元素入堆 */
-    void push(int val) {
-        // 添加结点
-        maxHeap.add(val);
-        // 从底至顶堆化
-        siftUp(size() - 1);
-    }
-    
-    /* 从结点 i 开始，从底至顶堆化 */
-    void siftUp(int i) {
-        while (true) {
-            // 获取结点 i 的父结点
-            int p = parent(i);
-            // 若“越过根结点”或“结点无需修复”，则结束堆化
-            if (p < 0 || maxHeap.get(i) <= maxHeap.get(p))
-                break;
-            // 交换两结点
-            swap(i, p);
-            // 循环向上堆化
-            i = p;
-        }
-    }
+    [class]{MaxHeap}-[func]{push}
+
+    [class]{MaxHeap}-[func]{siftUp}
     ```
 
 === "C++"
@@ -694,38 +660,9 @@ comments: true
 === "Java"
 
     ```java title="my_heap.java"
-    /* 元素出堆 */
-    int poll() {
-        // 判空处理
-        if (isEmpty())
-            throw new EmptyStackException();
-        // 交换根结点与最右叶结点（即交换首元素与尾元素）
-        swap(0, size() - 1);
-        // 删除结点
-        int val = maxHeap.remove(size() - 1);
-        // 从顶至底堆化
-        siftDown(0);
-        // 返回堆顶元素
-        return val;
-    }
-    
-    /* 从结点 i 开始，从顶至底堆化 */
-    void siftDown(int i) {
-        while (true) {
-            // 判断结点 i, l, r 中值最大的结点，记为 ma
-            int l = left(i), r = right(i), ma = i;
-            if (l < size() && maxHeap.get(l) > maxHeap.get(ma))
-                ma = l;
-            if (r < size() && maxHeap.get(r) > maxHeap.get(ma))
-                ma = r;
-            // 若“结点 i 最大”或“越过叶结点”，则结束堆化
-            if (ma == i) break;
-            // 交换两结点
-            swap(i, ma);
-            // 循环向下堆化
-            i = ma;
-        }
-    }
+    [class]{MaxHeap}-[func]{poll}
+
+    [class]{MaxHeap}-[func]{siftDown}
     ```
 
 === "C++"
@@ -901,15 +838,7 @@ comments: true
 === "Java"
 
     ```java title="my_heap.java"
-    /* 构造函数，根据输入列表建堆 */
-    public MaxHeap(List<Integer> nums) {
-        // 将列表元素原封不动添加进堆
-        maxHeap = new ArrayList<>(nums);
-        // 堆化除叶结点以外的其他所有结点
-        for (int i = parent(size() - 1); i >= 0; i--) {
-            siftDown(i);
-        }
-    }
+    [class]{MaxHeap}-[func]{MaxHeap}
     ```
 
 === "C++"