2. 程式人生 > >Java內部類載入問題探究

Java內部類載入問題探究

阿新 • • 發佈：2018-12-26

靜態內部類不持有外部類的引用

這個觀點是眾所周知的。雖然明白是因為其建構函式內沒有傳入外部類的引用。可是為什麼靜態類可以沒有傳入引用呢，靜態內部類的載入又是什麼樣的過程呢？

這幾天找到的答案，似乎都不能讓我有一種豁然開朗的感覺。於是一次新探索開始了~

╭(●｀∀´●)╯

一開始，我是這樣想的：

靜態類和靜態物件，靜態變數，靜態塊等等一樣，是在類初始化時就被載入的，所以可以不需要傳入當前類的引用。 
（關於非靜態內部類，就不需要多說，一定需要外部類先例項化後才會載入。）

通過網上一個程式碼的思路，我寫出了以下demo：

import java.util.Random;

public
 
 class OuterClass {
    public static long OUTER_DATE = System.currentTimeMillis();

    static {
        System.out.println("外部類靜態塊載入時間：" + System.currentTimeMillis());
    }

    public OuterClass() {
        timeElapsed();
        System.out.println("外部類建構函式時間：" + System.currentTimeMillis());
    }

    static
 
 class InnerStaticClass {
        public static long INNER_STATIC_DATE = System.currentTimeMillis();
    }

    class InnerClass {
        public long INNER_DATE = 0;
        public InnerClass() {
            timeElapsed();
            INNER_DATE = System.currentTimeMillis();
        }           
    }

    public
 
 static void main(String[] args) {
        OuterClass outer = new OuterClass();
        System.out.println("外部類靜態變數載入時間：" + outer.OUTER_DATE);
        System.out.println("非靜態內部類載入時間"+outer.new InnerClass().INNER_DATE);
        System.out.println("靜態內部類載入時間："+InnerStaticClass.INNER_STATIC_DATE);
    }

    //單純的為了耗時，來擴大時間差異
    private void timeElapsed() {
        for (int i = 0; i < 10000000; i++) {
            int a = new Random(100).nextInt(), b = new Random(100).nextInt();
            a = a + b;
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

假如我的推想沒有錯誤的話，我想應該會這樣的：

外部類常量載入時間 = 外部類靜態塊載入時間 = 靜態內部類載入時間 < 外部類建構函式時間< 非靜態內部類載入時間

Ok，我以為我離走到人生顛覆只差一個Run了 ! ✧(๑•̀ㅂ•́)و✧

結果卻是： 
這裡寫圖片描述

跪地…… ε(┬┬＿┬┬)3

不過，從上面我們可以分析出來結果是：

靜態內部類和非靜態內部類一樣，都是在被呼叫時才會被載入

不信的同學可以自己試試copy以上的程式碼。隨機調換main（）函式裡的方法呼叫順序，來驗證以上的規律。

後來我這麼想：

靜態內部類其實和外部類的靜態變數，靜態方法一樣，只要被呼叫了都會讓外部類的被載入。不過當只調用外部類的靜態變數，靜態方法時，是不會讓靜態內部類的被載入

嗯哼~還是來一個demo，不過是改動了點上面的東西：

import java.util.Random;

public class OuterClass {
    public static long OUTER_DATE = System.currentTimeMillis();
    public static int a = 1;
    static {
        System.out.println("外部類靜態塊載入時間：" + System.currentTimeMillis());
    }

    public OuterClass() {
        timeElapsed();
        System.out.println("外部類建構函式事件：" + System.currentTimeMillis());
    }

    static class InnerStaticClass {
        static {
            System.out.println("內部類靜態塊載入時間：" + System.currentTimeMillis());
        }
        public static double INNER_DATE = System.currentTimeMillis();

    }

    class InnerClass {
        public long INNER_DATE = 0;
        public InnerClass() {
            timeElapsed();
            INNER_DATE = System.currentTimeMillis();
        }           
    }

    public static void Hello(){System.out.println("Hello");}

    public static void main(String[] args) {
        //System.out.println("外部類常量載入時間：" + OuterClass.OUTER_DATE); 
        OuterClass.Hello();
        OuterClass outer = new OuterClass();
        System.out.println("外部類靜態變數載入時間：" + OuterClass.OUTER_DATE);
        System.out.println("外部類靜態變數載入時間：" + outer.OUTER_DATE);  
    }

    //單純的為了耗時而已
    private void timeElapsed() {
        for (int i = 0; i < 10000000; i++) {
            int a = new Random(100).nextInt(), b = new Random(100).nextInt();
            a = a + b;
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48

結果如下：

這裡寫圖片描述

觀點1：我說的沒錯吧~，呼叫外部類的靜態變數，靜態方法可以讓外部類得到載入，不過這裡靜態內部類沒有被載入

再看看下面的這段：

import java.util.Random;

public class OuterClass {
    public static long OUTER_DATE = System.currentTimeMillis();
    public static int a = 1;
    static {
        System.out.println("外部類靜態塊載入時間：" + System.currentTimeMillis());
    }

    public OuterClass() {
        timeElapsed();
        System.out.println("外部類建構函式事件：" + System.currentTimeMillis());
    }

    static class InnerStaticClass {
        static {
            System.out.println("內部類靜態塊載入時間：" + System.currentTimeMillis());
        }
        public static long INNER_STATIC_DATE = System.currentTimeMillis();

    }

    class InnerClass {
        public long INNER_DATE = 0;
        public InnerClass() {
            timeElapsed();
            INNER_DATE = System.currentTimeMillis();
        }           
    }

    public static void Hello(){System.out.println("Hello");}

    public static void main(String[] args) {
        System.out.println("內部類靜態變數載入時間：" + InnerStaticClass.INNER_STATIC_DATE );
        System.out.println("外部類靜態變數載入時間：" + OuterClass.OUTER_DATE );
    }

    //單純的為了耗時而已
    private void timeElapsed() {
        for (int i = 0; i < 10000000; i++) {
            int a = new Random(100).nextInt(), b = new Random(100).nextInt();
            a = a + b;
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45

結果： 
這裡寫圖片描述 
觀點2：可以看出，我們其實載入靜態內部類的時候，其實還會先載入外部類，才載入靜態內部類

由觀點1與觀點2聯立，以上論點得證！

好，迴歸主題，為什麼靜態內部類可以不傳入引用呢？

因為其本質就是針對外部類的內部類，而不是物件的內部類，不必用this來呼叫。 
於是接下來打算用口遁入手來說服大家： 
(“▔□▔)/(“▔□▔)/(“▔□▔)/

首先，從靜態的概念出發理解，靜態修飾過後的一切物件都只與類相關，不與物件引用相關

As we known，靜態變數，靜態方法，靜態塊等都是類級別的屬性，而不是單純的物件屬性。他們在類第一次被使用時被載入（記住，是一次使用，不一定是例項化）。我們可以簡單得用 類名.變數 或者 類名.方法來呼叫它們。與呼叫沒有被static 修飾過變數和方法不同的是：一般變數和方法是用當前物件的引用（即this）來呼叫的，靜態的方法和變數則不需要。從一個角度上來說，它們是共享給所有物件的，不是一個角度私有。這點上，靜態內部類也是一樣的。

有人說，靜態內部類可以當作一個頂級類來看，不過我在《Java的synthetic修飾詞》一文中也提到過，所有的內部類都是頂級類。所以我覺得以覺得“靜態內部類可以當作一個頂級類來看”這一說法，並不恰當。

其中更深層的東西，又涉及到JVM虛擬機器部分，我點一下，不明白的可以先看看《初探Java虛擬機器及其載入過程》：

針對非靜態內部類，堆中的每一個外部類的物件都各自持有一份非靜態內部類在方法區符號引用。而針對靜態內部類，堆中的所有的外部類物件都共同持有一份靜態內部類在方法區的符號引用。

以上純屬個人推測，如有指正，支付寶10元立轉!!!! \(￣▽￣)/

靜態內部類的載入過程：

靜態內部類的載入不需要依附外部類，在使用時才載入。不過在載入靜態內部類的過程中也會載入外部類。以上花了很多功夫來說明了

總結

耗時兩天，得以做完，期間查了很多資料，想了很多彎路。最後得以完成。也是謝天謝地。還是很開心的~，XD，這段時間先不研究這些編譯載入的方向了。感覺如果沒人給予指點的話，很容易思想走差，走火入魔，恰恰懂得人也不多…..

相關推薦

Java內部類載入問題探究

靜態內部類不持有外部類的引用 這個觀點是眾所周知的。雖然明白是因為其建構函式內沒有傳入外部類的引用。可是為什麼靜態類可以沒有傳入引用呢，靜態內部類的載入又是什麼樣的過程呢？ 這幾天找到的答案，似乎都不能讓我有一種豁然開朗的感覺。於是一次新探索開始了~ ╭(●｀∀´●)╯ 一開始，我是這樣想的

關於java內部類載入順序的問題

前面是看到某個論壇討論的內部類載入順序的問題，連結如下：http://www.oschina.net/question/2273217_217864#tags_nav 今天看了單例模式，對內部類的載入順序產生了疑問。所以來請教大家。 我們知道，java當中

朝花夕拾——Java靜態內部類載入

靜態內部類不持有外部類的引用 這個觀點是眾所周知的。雖然明白是因為其建構函式內沒有傳入外部類的引用。可是為什麼靜態類可以沒有傳入引用呢，靜態內部類的載入又是什麼樣的過程呢？ 這幾天找到的答案，似乎都不能讓我有一種豁然開朗的感覺。於是一次新探索開始

Java內部類引用外部類中的局部變量為何必須是final問題解析

lib soft 編譯器 art http word tail ace 軟件 今天編寫一個多線程程序，發現在方法內定義內部類時，如果內部類調用了方法中的變量，那麽該變量必須申明為final類型，百思不得其解，後來想到應該是生命周期的原因，因為方法內定義的變量是局部變量，

Java內部類之匿名內部類

urn nat 看到了 math 通過 rri 內部 test mat ??我們都知道Java中可以使用內部類，將一個類的定義放在另一個類的定義的內部，這就是內部類，但是匿名內部類往往使我們摸不著頭腦，因為它並沒有特定的名稱，那麽該如何使用它呢？ 定義一個匿名內部類 pu

Java內部類基本使用

add size sel 整體 object 方法 句柄 protected 基本使用 鏈接到外部類 ??創建內部類時，那個類的對象同時擁有封裝對象(封裝內部類的外部類)的一個鏈接，所以內部類可以訪問外部類的成員。??內部類擁有對外部類所有元素的訪問權限。??看如下代碼，內

Java內部類的使用小結

提示 key 內部 效果 com where out alt 文件 轉自：http://android.blog.51cto.com/268543/384844/ 內部類是指在一個外部類的內部再定義一個類。類名不需要和文件夾相同。 *內部類可以是靜態static的，也可

JAVA 內部類 （二）

匿名內部類 獨立 button strong 知識 desc ets .get xxx 一、為什麽要使用內部類 為什麽要使用內部類？在《Think in java》中有這樣一句話：使用內部類最吸引人的原因是：每個內部類都能獨立地繼承一個（接口的）實現，所以無論外

Java內部類持有外部類的引用詳細分析與解決方案

調用 lai urn star keyword inner android get sta 在Java中內部類的定義與使用一般為成員內部類與匿名內部類，他們的對象都會隱式持有外部類對象的引用，影響外部類對象的回收。 GC只會回收沒有被引用或者根集不可到達的對象（取決於GC算

java 內部類

所在 on() 定義變量 實現接口 特性 for sed prot ring 內部類(innerclasses) 一般情況，我們把類定義成獨立的單元。有些情況下，我們把一個類放在另一個類的內部定義，稱為內部類。 內部類的作用： 1. 內部類提供了更

Java內部類

局部內部類 參數 修飾 變量 default 參數傳遞 ted ati private 部類是指在一個外部類的內部再定義一個類。類名不需要和文件夾相同。 *內部類可以是靜態static的，也可用public，default，protected和private修飾。（而外部頂

Java內部類的使用小結 形參為什麽要用final

trac som 調用 匿名內部類 事情 ani 如果 method 方法 部類是指在一個外部類的內部再定義一個類。類名不需要和文件夾相同。 *內部類可以是靜態static的，也可用public，default，protected和private修飾。（而外部頂級類即類名和

java 內部類和閉包

ice end trac 定義 stat 常見 tostring change wan 內部類（inner class） public class Outer{ private String name; class Inner{ publi

java 內部類 嵌套類

seq hub 存在 邏輯 val blog ems 不能 pri 概述 java允許我們把一個類a定義在另一個類b裏面,那麽這個類a就叫做內部類。例如如下面： 如果內部類似Non-static的那麽被稱作內部類 class OuterClass { ... class

java內部類作用

修改 private end 之一 class 需要 sta bean sid 推薦一、 定義 放在一個類的內部的類我們就叫內部類。 二、 作用 1.內部類可以很好的實現隱藏 一般的非內部類，是不允許有 private 與protected權限的，但內部類可以

Java內部類(5)：應用例

ont 應用 情況 test 調用 sub() spa ren tro 例1-閉包(Closure) 閉包是一個可調用的對象(通過Callback)，它記錄了一些信息，這些信息來自於創建它的作用域 1 interface Incrementable { 2 v

java內部類之成員內部類

cte 對象 todo 定義 包括 類屬性 out pri int 內部類概念：顧名思義，就是將一個類定義在另一個個類內部。內部的類稱之為內部類 。 內部類的主要特點：1.內部類可以很好的實現隱藏，可以使用protected、private修飾符。2.內部類可以直接訪問外部

java內部類之成員內部類實例

out 成員內部類 出現 sys true .sh 同時 同名 一個 第一個是如何實現同時繼承兩個類 public class MultiExtendsDemo { public static void main(String[] args) { // TODO

java內部類之成員內部類之局部內部類

generated () 對象 靜態 pre rsh java內部類 cal pos 局部內部類特點：　　1.定義在代碼塊、方法體內的類叫局部內部類　　2.局部內部類訪問外部類的屬性和方法使用“外部類名.this.屬性名”和“外部類名.this.方法名（參數）”的形式　　3

java 內部類（inner class）詳解

ron isp https nerd 對象 重寫 prot print 元素 優點 ⒈ 內部類對象可以訪問創建它的對象的實現，包括私有數據； ⒉ 內部類不為同一包的其他類所見，具有很好的封裝性； ⒊ 使用內部類可以很方便的編寫事件驅動程序； ⒋ 匿名內部類可以方便的定義運行