java静态变量加载顺序_内部类为什么不能有静态

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

                                             静态内部类加载顺序

我们先来区分一下两个概念：类加载、加载。

类加载的过程包括加载，验证，解析，准备，初始化等五个过程。加载是类加载的一部分。

区分完这两个概念之后我们再来看下面的问题。

我们声明一个类，这个类有个内部静态类。还有主函数，当我们启动程序之后，运行java application程序。

运行结果是什么呢？

下面看个代码实现的例子：

package Test;

public class OuterClass {
	static {
		System.out.println("加载外部类");
	}
	static class InnerClass{
		public InnerClass() {}
		static {
			System.out.println("加载内部类");
		}
		static void innerMethod() {
			System.out.println("内部类的静态方法");
		}
		static int a;
	}

	public static void main(String[] args) {
		OuterClass out=new OuterClass();
		System.out.println("=============");
//		OuterClass.InnerClass.a=1;
	}

}

外部类的静态代码块执行了。内部类的静态代码块没有执行在外部类执行静态代码块之后执行，是因为内部类没有加载么？

其实不是这样的，一旦程序运行，所有该类涉及的类(包括内部类和从其他包导入的类)都会在类加载的过程中加载到

内存，因为在整个程序运行的过程中类加载只会发生一次，一旦某个类没有被加载，那么将不能再使用这个类。

注意我标出来的加载，这里是指在类加载过程中的加载，但是我们可以在网上了解或者在书上得知，只有当某个类

初始化之后，才会调用类的静态代码块。才会执行对应的。那么什么时候执行类加载过程中的类初始化呢？

只有当我们有对类的引用的时候，才会将类初始化。

比如我们new一个非静态类的对象，或者对某个静态类的成员(包括成员方法和域)或者调用有访问的时候

如果我们把最后一行的注释去掉，就会执行内部静态类的静态代码块(static{})。

或者有隐式的调用我们类的方法。为什么我们的外部类没有new的时候还会执行他的静态代码块呢？

是不是忘了还有个主函数在执行，这时候是调用了类的方法的，所以会初始化这个外部类。执行外部类的静态代码块。

关于静态代码块，代码块，类的构造函数执行顺序问题不态理解的同学可以看看我的博客：

Java面试题 类的构造函数的执行顺序问题

注意：内部静态类不会自动初始化，只有调用静态内部类的方法，静态域，或者构造方法的时候才会加载静态内部类。

利用这种特点我们可以实现一个单例模式

package Test;

public class Single {
	
	private Single() {}
	
	static class SingleHolder {
		
		private static final Single instance=new Single(); 
		
	}
	public static Single getinstance() {
		return SingleHolder.instance;
	}

	public static void main(String[] args) {
		
		Single a=Single.getinstance();
		Single b=Single.getinstance();
		Single c=Single.getinstance();
		System.out.println(a.toString());
		System.out.println(b.toString());
		System.out.println(c.toString());
	}

}

上面程序的运行结果：

当我们用的构造方法声明为private的时候，代表这个类只能被自己调用，就算同包下的类也不能实例化。

这并不是构造函数只会被调用一次，并且保证只会实例化一次类的原因。如果你把上面的构造函数变成public，

也是只生成一个对象。

上面的例子是说这个外部类的对象被内部类当成内部类的静态final域，所以只会有一个。