Java内部类加载问题探究

朝花夕拾——Java静态内部类加载

标签： java

2015-12-18 12:09 1566人阅读 评论(4) 收藏 举报

 分类：

Java（3） 

版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[+]

之前写《Java的synthetic修饰词》一文的过程中，提到了以下观点：

静态内部类不持有外部类的引用

这个观点是众所周知的。虽然明白是因为其构造函数内没有传入外部类的引用。可是为什么静态类可以没有传入引用呢，静态内部类的加载又是什么样的过程呢？

这几天找到的答案，似乎都不能让我有一种豁然开朗的感觉。于是一次新探索开始了~

╭(●｀∀´●)╯

---

一开始，我是这样想的：

静态类和静态对象，静态变量，静态块等等一样，是在类初始化时就被加载的，所以可以不需要传入当前类的引用。 
（关于非静态内部类，就不需要多说，一定需要外部类先实例化后才会加载。）

通过网上一个代码的思路，我写出了以下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，这段时间先不研究这些编译加载的方向了。感觉如果没人给予指点的话，很容易思想走差，走火入魔，恰恰懂得人也不多…..