Go语言视频零基础入门到精通

admin

在学习了前面几节的内容后，相信大家已经对java 虚拟机 加载类的过程有了一个认识和了解，那么本节，我们就继续进一步巩固前面所学知识和特殊点。
一、类的初始化回顾
类在初始化的时候，静态变量的声明语句以及静态代码块都被看作类的初始化语句，Java虚拟机会按照初始化语句在类文件中的先后顺序来依次加载它们。

上图中a的初始化其实经过了四步
1、a被初始化为默认值0
2、a被赋予正确的初始值1
3、执行静态代码块，将a的值赋为2
4、执行静态代码块，将a的值赋为4
因此最终的执行结果是4，一个类只能被一个ClassLoader加载一次，只有没有被加载过的类或者已经被卸载的类才可能被再次加载。类的初始化步骤如下：
1、假如这个类还没有被加载和连接，那就先进行加载和连接
2、假如存在直接的父类，并且这个父类还没有被初始化则先初始化直接的父类
3、假如类中存在初始化语句，那就依次执行初始化语句。
注意：Java虚 拟机在初始化一个类的时候要求它的父类已经被初始化，但是这条规则并不适应于接口！在初始化一个类的时候并不会初始化他所实现的接口！在初始化一个接口的 时候也不会去初始化他的父接口！因此一个父接口并不会因为他的实现类或者子接口的初始化而初始化，只有当程序使用该接口特定的静态变量的时候才会去初始化 这个接口！
我们上面的例子印证了第三点，对于前两点我们知道我们构造一个类的时候假设它有父类，就会默认调用父类的无参构造方法，然后就初始化了父类，而初始化之前必须进行加载和连接！
我们来看一个具体的程序来验证上面的结论,代码如下：

1. class Parent{
3.     static int a=1;
5.     static{
7.        System.out.println("Parent"s static block");
9.     }
11. }
14. class Child extends Parent{
16.     static int b=2;
18.     static{
20.        System.out.println("Child"s static block");
22.     }
24. }
27. public class InitTestCase {
29.     static{
31.        System.out.println("InitTestCase"s static block");
33.     }
35.     public static void main(String[] args) {
37.        System.out.println(Child.b);
39.     }
41. }

复制代码

这个程序很简单，我们一猜就能知道结果，因为是InitTestCase启动类，因此优先初始化！然后调用子类Child的b静态变量，Child继承自Parent，因此先初始化父类Parent，所以运行结果是：

修改代码如下：

1. class Parent{
3.     static int a=1;
5.     static{
7.        System.out.println("Parent"s static block");
9.     }
11. }
14. class Child extends Parent{
16.     static int b=2;
18.     static{
20.        System.out.println("Child"s static block");
22.     }
23. }
27. public class InitTestCase {
29.     static{
31.        System.out.println("InitTestCase"s static block");
33.     }
35.     public static void main(String[] args) {
37.        Parent parent;
39.        System.out.println("===== split line =====");
41.        parent=new Child();
43.        System.out.println(Parent.a);
45.        System.out.println(Child.b);
47.     }
49. }

复制代码

为了能够看清楚parent具体的初始化状态，我们加入split line来隔开程序段，这样又会返回怎样的结果呢？
刚开始的Parent是否会初始化？
我们之前已经说的很清楚了，只有主动使用的6种情况会导致类的初始化，因此刚开始parent不会初始化，因为InitTestCase是启动类，所以最先初始化，然后是分隔符，然后初始化子类Child，初始化Child的时候发现继承了Parent，所以先初始化Parent，然后初始化Child，然后再次调用parent的静态变量，因为Parent已经初始化了，一个类只能被一个ClassLoader初始化一次，所以不会初始化Parent，直接输出Parent.a的数据，Child同理，因此最终执行结果是：

  
这里也再次强调类初始化的实际为：
只有一下6种主动使用的情况会导致类的初始化，其他任何情况都被视为是被动使用，不会导致类的初始化！
1、创建类的实例
2、访问某个类或接口的静态变量，或者对该静态变量赋值
3、调用类的静态方法
4、反射（如Class.forName(“com.yhj.JVM.classloader.finalTest.TestCase”)）
5、初始化一个类的子类
6、Java虚拟机启动时被标明为启动类的类（Java Test）
除了以上6种情况都属于被动使用，不会导致类的初始化。
再来看一段代码：

1. class StaticClassTest{
3.     public static int staticValue = 2 / 1;
5.     static{
7.        System.out.println("StaticClassTest"s static block!");
9.     }
11. }
14. public class TestCase {
16.     public static void main(String[] args) {
18.        System.out.println(StaticClassTest.staticValue);
20.     }
22. }

复制代码

很显然属于调用类的静态成员变量，类会被初始化，初始化就会执行执行静态初始化语句块，就会执行System.out.println("StaticClassTest"s static block!");语句，因此运行结果如下：

但是如果这个类的静态成员是常量呢？
如下代码：

1. class StaticClassTest{
3.     public static int staticValue = 2 / 1;
5.     static{
7.        System.out.println("StaticClassTest"s static block!");
9.     }
11. }
13. //===================================================================
17. class StaticFinalTest1{
19.     public final static int staticValue = 2 / 1;
21.     static{
23.        System.out.println("StaticFinalTest1"s static block!");
25.     }
27. }
29. //===================================================================
33. class StaticFinalTest2{
35.     public final static int staticValue = new Random().nextInt(10);
37.     static{
39.        System.out.println("StaticFinalTest2"s static block!");
41.     }
43. }
45. //===================================================================
48. public class TestCase {
50.     public static void main(String[] args) {
52.        System.out.println(StaticClassTest.staticValue);
54.        System.out.println(StaticFinalTest1.staticValue);
56.        System.out.println(StaticFinalTest2.staticValue);
58.     }
60. }

复制代码

第一个我们已经知道了，会执行静态代码块，那第二个和第三个呢？他们的区别是第二个是在第一个的基础之上将staticValue变为了final，第三个对于第二个的区别是第三个static不是一个计算的具体值，而是0-10之间的一个随机数！又有什么样的区别呢？我们先来看一下运行结果！

  
二、编译时常量
看了上面的结果，应该很好奇，为什么没有输出：StaticFinalTest1"s static block!
StaticFinalTest1的静态代码块没有执行，即StaticFinalTest1类并没有被初始化，而StaticFinalTest2被初始化了！
这是为什么呢？我们再来看一下他们的区别：StaticFinalTest1的静态常量值是2/1=2，对于这种值在编译的时候JVM就会把结果计算出来放进class文件中，相当于StaticFinalTest1=2，而StaticFinalTest2在编译的时候并不知道具体的数值是多少，需要运行的时候才会被赋值，所以我们可以看出，调用编译时的静态常量并不会初始化这个类（即不属于主动使用），而调用运行时的静态常量是会初始化该类的！
我们再来改动一下上面父子类的程序

1. class Parent{
3.     static int a=1;
5.     static{
7.        System.out.println("Parent"s static block");
9.     }
11. }
15. class Child extends Parent{
17.     static int b=2;
19.     static{
21.        System.out.println("Child"s static block");
23.     }
25. }
29. public class InitTestCase {
33.     public static void main(String[] args) {
35.        System.out.println(Child.a);
37.     }
39. }

复制代码

这样执行结果有什么呢？我们直接调用子类中父类定义的a会怎样呢？
按照我们之前的理论，执行结果应该是调用子类，先初始化父类，我们看下执行结果：

我们看到子类好像没有被初始化，不对，是确实没有被初始化！所以我们一定要注意：JVM规范规定只有当程序访问的静态变量或静态方法确实在当前类或当前接口中定义时，才可以认为是对类或接口的主动使用，所以我们直接调用Child中没有定义的a不属于对Child的主动使用，因此没有初始化Child！
三、ClassLoader
调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化。
我们来看一下loadClass的API文档：

根据二进制名称来加载类，返回该类的Class对象的实例！那什么是二进制名称？

二进制名称我们可以理解为类的全称，如上图中的类、内部类、匿名内部类等！以前我们写的类都是通过启动类或者Web容器帮我们加载的，这里我们可以看到ClassLoader可以直接加载载这个类，但是我们看到这个类ClassLoader是抽象类。

也就是说我们无法通过new的方法创建实例，那我们该怎么做呢？
我们知道如果这个类不能实例化，我们可以通过他的静态方法访问这个类，我们来看一下ClassLoader的一个静态方法getSysytemClassLoader()这个方法

  
看一段程序：

1. class Test{
3.     static{
5.        System.out.println("Test"s static block");
7.     }
9. }
13. public class ClassLoaderTestCase {
17.     public static void main(String[] args) throws ClassNotFoundException {
19.        ClassLoader classLoader=ClassLoader.getSystemClassLoader();
21.        System.out.println("ClassLoader:"+classLoader);
23.        Class<?> testClass=classLoader.loadClass("com.yhj.jvm.classloader.finalTest.Test");
25.        System.out.println("using class.forName("com.yhj.jvm.classloader.finalTest.Test")");
27.        testClass=Class.forName("com.yhj.jvm.classloader.finalTest.Test");
29.     }
31. }

复制代码

这段程序执行下来，我们来看下运行结果

很显然，这段程序当调用loadClass的时候没有对类Test进行初始化，而当调用Class.forName的时候才被初始化，因此调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化！只有主动使用的6种情况才会初始化该类！

从加载到连接到初始化，我们看到loadClass只做加载和连接的操作，只有主动使用的6种才会对类进行初始化！
  
参考资料：
圣思园张龙老师深入Java虚拟机系列