Java 类初始化顺序在网上已经有很多文章了,这里不再谈那么多,仅仅谈下Java静态变量的初始化顺序,如果你是Java高手,并且自认为对这个顺序已经掌握到了炉火纯青的境界,请忽视这篇文章.
前天看了Y.BOY对AS程序员的《关于初始化静态变量的一些思考》,让我感觉这个东西很奇妙,他的问题也是从JAVA来的.然后我就做了些测试,发现与我想的很不一样.而且Java与AS的也不一样.今天就先将关于Java的记录下来.等日后再将AS的也记录下来。

简单规则

首先先看一段最普遍的JAVA代码：

/**
 * Java 测试代码 
 * Power by http://www.litefeel.com
 * @author lite3
 */public class Test
{
    public static Test1 t = new Test1();
    public static int a = 0;
    public static int b;

    public static void main(String[] arg)
    {
        System.out.println(Test.a);
        System.out.println(Test.b);
    }
}

class Test1
{
    public Test1()
    {
        Test.a++;
        Test.b++;
    }
}

这里先猜下控制台输出结果是什么?

OK, 或许你已经猜到下面了结果了,那么你还是熟悉Java的。

0 1

如果你不明白是为什么会输出上面的结果,那么我来告诉你。

Java静态变量初始化遵循以下规则:

1. 静态变量会按照声明的顺序先依次声明并设置为该类型的默认值，但不赋值为初始化的值。
2. 声明完毕后,再按声明的顺序依次设置为初始化的值，如果没有初始化的值就跳过。

看了这个就会明白,原来Test.a的值变化了三次。

声明时设置为0>>Test1::Test1里设置为1>>Test.a初始化为0

复杂规则

明白了这个，请再看下面的代码。

/**
 * Java 测试代码 
 * Power by http://www.litefeel.com
 * @author lite3
 */public class A
{
    public static int b = B.a;
    public static A plus =new A("A");
    public static final int finalInt = (int)(Math.random()*100);
    public static B p =  new B("A");

    public static final String finalStr = "finalStr";
    public static final Integer finalInteger = new Integer(10);
    public static int a = 1;
    public static B c = null;

    public A(String from)
    {
        System.out.println("----------- begin A::A ----------------");
        System.out.println("A::A, from="+from);
        System.out.println("A::A, A.b="+A.b);
        System.out.println("A::A, A.finalInt="+A.finalInt);
        System.out.println("A::A, B.a="+B.a);
        System.out.println("A::A, B.plus="+B.plus);
        System.out.println("----------- end A::A ----------------");
    }

    public static void main(String[] arg)
    {
        System.out.println("main, A.b="+A.b);
        System.out.println("main, B.t="+B.t);
        System.out.println("main, C.a="+C.a);
    }
}

class B
{
    public static int t = A.a;
    public static A plus = new A("B");
    public static int a = 1;

    public B(String from)
    {
        System.out.println("----------- begin B::B ----------------");
        System.out.println("B::B, from="+from);
        System.out.println("B::B, B.a="+B.a);
        System.out.println("B::B, A.a="+A.a);
        System.out.println("B::B, A.p="+A.p);
        System.out.println("B::B, A.plus="+A.plus);
        System.out.println("B::B, A.finalInt="+A.finalInt);
        System.out.println("B::B, A.finalInteger="+A.finalInteger);
        System.out.println("B::B, A.finalStr="+A.finalStr);
        System.out.println("----------- end B::B ----------------");
    }
}

class C
{
    public static final A a = new A("C");
}

这个你还能猜到输出结果吗? 我是在一边测试一边写的,所以我没猜出来.哈哈

控制台输出结果为：

----------- begin A::A ----------------
A::A, from=B
A::A, A.b=0
A::A, A.finalInt=0
A::A, B.a=0
A::A, B.plus=null
----------- end A::A ----------------
----------- begin A::A ----------------
A::A, from=A
A::A, A.b=1
A::A, A.finalInt=0
A::A, B.a=1
A::A, B.plus=A@a90653
----------- end A::A ----------------
----------- begin B::B ----------------
B::B, from=A
B::B, B.a=1
B::B, A.a=0
B::B, A.p=null
B::B, A.plus=A@1fb8ee3
B::B, A.finalInt=61
B::B, A.finalInteger=null
B::B, A.finalStr=finalStr
----------- end B::B ----------------
main, A.b=1
main, B.t=0
----------- begin A::A ----------------
A::A, from=C
A::A, A.b=1
A::A, A.finalInt=61
A::A, B.a=1
A::A, B.plus=A@a90653
----------- end A::A ----------------
main, C.a=A@61de33

这个结果你没猜到吧,哈哈.

要一句一句的讲解程序执行结果,还是要很到的篇幅的.这里就直接写出Java静态变量初始化遵循的规则了。

第一段的规则依然有效，只是不健全。

1. 只有主动请求一个类,这个类才会初始化,仅包含静态变量,函数,等静态的东西.
2. 继承关系时,先初始化父类,后初始化子类.
3. 静态变量会按照声明的顺序先依次声明并设置为该类型的默认值,但不赋值为初始化的值.
4. 声明完毕后,再按声明的顺序依次设置为初始化的值,如果没有初始化的值就跳过.
5. 当初始化A.b=B.a时,暂停初始化A.b,设置当前类为B,跳到步骤3,并执行.
6. 当初始化B.plus = new A时,暂停初始化B.plus,实例化A并赋值给B.plus.
7. 当A的构造函数里需要获得B.a的值时,B.a还初始化并处于暂停初始化状态,直接取B.a的当前值,不再等待B.a初始化.
8. final,静态常量其实是遵循普通静态变量的初始化的,但是在编译时,编译器会将不可变的常量值在使用的地方替换掉.可以用Java反编译工具查看.

何为主动请求一个类

主动请求一个类,有以下6种方式:

1. 调用类A的静态变量.
2. 实例化类A, 即 new A.
3. 继承类A.
4. 使用反射的方式获取类A.
5. 类A是程序的入口类(即main函数所在的类)

如果仅仅是声明类型为类A的变量,但不初始化,那么不是主动请求类A,也不会初始化类A.

以上仅仅是个人的一些看法,如果不正确的地方,希望能够被指正,也好共同进步.