类的加载过程：初始化

1、类的加载过程初始化介绍上图表示类的生命周期,其中验证,准备,解析统称连接,而初始化位于类加载的最后一步,在准备阶段,主要 为类分配空间,并且初始化为默认值,而在初始化阶段,为类的静态变量赋予正确的初始值.比如public static final int a = 5;准备阶段为a分配空间并且初始化为0,整形的默认值都为0,然后在初始化阶段,将其赋值为5.条件并不是所有的类都会被初始化,需要满足几个要求(主动使用):遇到 new , getstatic , putstatic ,或invokestatic 这4条字节码指令时,如果类没有初始化,则需要先触发其初始化使用 java.lang.ref

2、lect 包的方法对类进行反射调用.当初始化一个类的时候,如果父类没初始化,则先触发其父类的初始化虚拟机启动用户指定的主类( main )使用 jdk1.7 的动态语言. 总结一下就是:创建类的实例访问某个接口或类的静态字段(被nal修饰,已在编译期吧结果放入到常量池的除外)访问类的静态方法反射调用类初始化一个类的子类JAVA 虚拟机启动时被表明为启动类的类我们接下来将对这几种情况进行演示,在此之前,我们需要了解nal关键字的作用修饰类:当用nal去修饰一个类的时候，表示这个类不能被继承。修饰方法:被nal修饰的方法不能被重写。修饰成员变量:如果修饰的成员变量是基本类型，则表示这个变量的值不能

3、改变.如果修饰的成员变量 是一个引用类型，则是说这个引用的地址的值不能修改，但是这个引用所指向的对象里面的内容还是可 以改变的。情况1:当类的成员变量被nal修饰public class Test01 public static void main(String args) System.out.println(FinalTest01.a);class FinalTest01public static final int a = 2; staticSystem.out.println(初始化test);结果只打印了2.情况2:当类的成员变量不被 final 修饰public class Tes

4、t02 public static void main(String args) System.out.println(FinalTest02.a);class FinalTest02public static int a = 2; staticSystem.out.println(初始化test);public class Test03 public static void main(String args) System.out.println(FinalTest03.a);class FinalTest03public static final int a = new Random().

5、nextInt(5); staticSystem.out.println(初始化test);结果打印了2同时执行了static 静态代码块. 情况3:结果:输出了一个随机值,同时也执行了静态代码块对3种情况进行分析:/ Source code recreated from a .class file by IntelliJ IDEA/ (powered by Fernflower decompiler)/package com.test; public class Test01 public Test01() public static void main(String args) Syste

6、m.out.println(2);/ Source code recreated from a .class file by IntelliJ IDEA/ (powered by Fernflower decompiler)/package com.test; class FinalTest public static final int a = 2;FinalTest() static System.out.println(初始化test);我们将使用IDEA的反编译将class文件编译为 java 来查看编译的代码. 情况1反编译代码:可以看出在Test01 类中System.out.pr

7、intln(FinalTest01.a); 被替换成System.out.println(2); 其中a为静态常量,所以编译器在编译期间将a直接放入到Test01 的代码中, 而不是从FinalTest 中获取,所以在程序运行期间,并不会使用FinalTest 类,就不会初始化,所以静态代码块不会执行,你可以删除FinalTest.class 文件,运行Test01.class 文件,程序不会出现报错.情况2反编译代码:/ Source code recreated from a .class file by IntelliJ IDEA/ (powered by Fernflower deco

8、mpiler)/package com.test; public class Test02 public Test02() public static void main(String args) System.out.println(FinalTest02.a);/ Source code recreated from a .class file by IntelliJ IDEA/ (powered by Fernflower decompiler)/package com.test; class FinalTest02 public static int a = 2; FinalTest0

9、2() static System.out.println(初始化test);可以看出在Test02 类中, System.out.println(FinalTest02.a); 没有被替换,而还是引用了FinalTest02 的a.所以 FinalTest02 被调用了,他将被初始化,静态代码块将被执行,这个时候,如果你删除FinalTest02.class 文件,运行Test002.class 文件,程序会出现报错.情况3反编译代码:/ Source code recreated from a .class file by IntelliJ IDEA/ (powered by Fernfl

10、ower decompiler)/package com.test; public class Test03 public Test03() public static void main(String args) System.out.println(FinalTest03.a);/ Source code recreated from a .class file by IntelliJ IDEA/ (powered by Fernflower decompiler)/package com.test; import java.util.Random; class FinalTest03 p

11、ublic static final int a = (new Random().nextInt(5);FinalTest03() static System.out.println(初始化test);情况1与情况3唯一的不同就是,情况1的a可以再类的加载过程中确定下来,而情况3无法确定,必须运行期 间才能知道结果,所以静态代码块执行了.3.主动使用创建类的实例public class Test04 public static void main(String args) System.out.println(new FinalTest04_1().a);class FinalTest04_1

12、public static int a = 3; staticSystem.out.println(初始化FinalTest04_1);结果:初始化FinalTest04_1 3Test04 反编译代码:/ Source code recreated from a .class file by IntelliJ IDEA/ (powered by Fernflower decompiler)/package com.test;import java.io.PrintStream; public class Test04 public Test04() public static void ma

13、in(String args) PrintStream var10000 = System.out; new FinalTest04_1(); var10000.println(FinalTest04_1.a);汇编:/ Field com/test/FinalTest04_1.a:I/ Method14: invokevirtual #6 java/io/PrintStream.println:(I)V17: return7: invokespecial #4/ Method com/test/FinalTest04_1.:()V10: pop11: getstatic#5/ class c

14、om/test/FinalTest04_1#33: new6: duppublic static void main(java.lang.String); Code:0: getstatic#2/ Fieldjava/lang/System.out:Ljava/io/PrintStream;可以看出对FinalTest04_1 使用了new ,满足初始化条件访问某个类或接口的静态变量（运行期常量），或者对静态变量（运行期常量）赋值类public class Test05 public static void main(String args) System.out.println(MyPare

15、nt5_1.c);class MyParent5_1public static final int c = new Random().nextInt(5); staticSystem.out.println(MyParent5_1);结果:MyParent5_1 4/ Source code recreated from a .class file by IntelliJ IDEA/ (powered by Fernflower decompiler)/package com.test; public class Test05 public Test05() public static voi

16、d main(String args) System.out.println(MyParent5_1.c);其中c无法在编译期赋值,为运行期常量,所以c不会移动到Test05 的常量池中. 反编译代码:可以看出,直接引用了MyParent5_1.c汇编:/ Field com/test/MyParent5_1.c:I/ Method6: invokevirtual #4 java/io/PrintStream.println:(I)V9: returnpublic static void main(java.lang.String); Code:0: getstatic#2/ Field ja

17、va/lang/System.out:Ljava/io/PrintStream;3: getstatic#3对MyParent5_1 使用了getstatic ,满足初始化条件接口public class Test06 public static void main(String args) System.out.println(MyParent6.c);interface MyParent6public static final int c = new Random().nextInt(5); Thread thread = new Thread()System.out.println(My

18、Parent6初始化);结果:MyParent6初始化1反编译代码:/ Source code recreated from a .class file by IntelliJ IDEA/ (powered by Fernflower decompiler)/package com.test; public class Test06 public Test06() public static void main(String args) System.out.println(MyParent6.c);直接引用了MyParent6.c汇编:/ Field com/test/MyParent6.c

19、:I/ Method6: invokevirtual #4 java/io/PrintStream.println:(I)V9: returnpublic static void main(java.lang.String); Code:0: getstatic#2/ Field java/lang/System.out:Ljava/io/PrintStream;3: getstatic#3对MyParent6 使用了getstatic ,满足初始化条件访问类的静态方法public class Test07 public static void main(String args) MyPare

20、nt7.test();class MyParent7 staticSystem.out.println(初始化MyParent7);static void test() System.out.println(调用静态方法);结果:初始化MyParent7 调用静态方法反编译代码:/ Source code recreated from a .class file by IntelliJ IDEA/ (powered by Fernflower decompiler)/package com.test; public class Test07 public Test07() public sta

21、tic void main(String args) MyParent7.test();直接引用了MyParent7.test();汇编:public static void main(java.lang.String); Code:0: invokestatic#2/ Method com/test/MyParent7.test:()V3: return对MyParent7 使用了invokestatic ,满足初始化条件反射调用类public class Test08 public static void main(String args) throws ClassNotFoundExce

22、ption Class clazz = Class.forName(com.test.MyParent8);class MyParent8 staticSystem.out.println(初始化MyParent8);结果:初始化MyParent8初始化一个类的子类public class Test09 public static void main(String args) throws ClassNotFoundException new Children9();class MyParent9 staticSystem.out.println(初始化MyParent8);class Chi

23、ldren9 extends MyParent9结果:初始化MyParent8JAVA虚拟机启动时被表明为启动类的类public class Test10 staticSystem.out.println(初始化Test10);public static void main(String args) throws ClassNotFoundException System.out.println(运行Main);结果:初始化Test10 运行Main4.被动使用通过子类引用父类的静态字段,不会导致子类初始化public class Test11 public static void main(String args) throws ClassNotFoundException System.out.println(Children.a);class Parentpublic static int a = 1;staticSystem.out.println(初始化Parent);class Children extends Parent staticSystem.out.println(初始化Children);结果:初始化Parent 1通过数组定义来引用类,不会触发此类