Skip to main content
 首页 » 编程设计

java 静态内部类何时初始化

2022年07月18日23www_RR

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

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

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


一开始,我是这样想的:

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

通过网上一个代码的思路,我写出了以下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; } } }

假如我的推想没有错误的话,我想应该会这样的:

外部类常量加载时间 = 外部类静态块加载时间 = 静态内部类加载时间 < 外部类构造函数时间< 非静态内部类加载时间

Ok,我以为我离走到人生颠覆只差一个Run了 ! ✧(๑•̀ㅂ•́)و✧

结果却是: 
这里写图片描述

不过,从上面我们可以分析出来结果是:

静态内部类和非静态内部类一样,都是在被调用时才会被加载

不信的同学可以自己试试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:我说的没错吧~,调用外部类的静态变量,静态方法可以让外部类得到加载,不过这里静态内部类没有被加载

再看看下面的这段:

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; } } }

结果: 
这里写图片描述 
观点2:可以看出,我们其实加载静态内部类的时候,其实还会先加载外部类,才加载静态内部类

由观点1与观点2联立,以上论点得证!


好,回归主题,为什么静态内部类可以不传入引用呢?

因为其本质就是针对外部类的内部类,而不是对象的内部类,不必用this来调用。 

首先,从静态的概念出发理解,静态修饰过后的一切物件都只与类相关,不与对象引用相关

As we known,静态变量,静态方法,静态块等都是类级别的属性,而不是单纯的对象属性。他们在类第一次被使用时被加载(记住,是一次使用,不一定是实例化)。我们可以简单得用 类名.变量 或者 类名.方法来调用它们。与调用没有被static 修饰过变量和方法不同的是:一般变量和方法是用当前对象的引用(即this)来调用的,静态的方法和变量则不需要。从一个角度上来说,它们是共享给所有对象的,不是一个角度私有。这点上,静态内部类也是一样的。


静态内部类的加载过程:

静态内部类的加载不需要依附外部类,在使用时才加载。不过在加载静态内部类的过程中也会加载外部类。以上花了很多功夫来说明了


 


本文参考链接:https://www.cnblogs.com/maohuidong/p/7843807.html