java成员变量的初始化顺序

1：java中静态成员的初始化顺序

public class TestClassInitialize {

public static void main(String[] args) {

System.out.println("第一次调用：");
B b = new B();
System.out.println("第二次调用：");
b = new B();
}

}

class A {

private static int a = setA();
private int a1 = setA1();

static{
System.out.println("--父类静态代码块");
}

private static int setA() {
System.out.println("-父类静态变量……");
return 0;
}

public int setA1() {
System.out.println("---父类成员变量……非静态变量");
return 0;
}

public A() {
System.out.println("----父类构造函数");
}

}

class B extends A {

private static int b = setB();
private int b1 = setB1();

static{
System.out.println("--子类静态代码块");
}

private static int setB() {
System.out.println("-子类静态变量……");
return 0;
}

public int setB1() {
System.out.println("---子类成员变量……非静态变量");
return 0;
}

public B() {
System.out.println("----子类构造函数");
}
}

结果：

第一次调用：

-父类静态变量……

--父类静态代码块

-子类静态变量……

--子类静态代码块

---父类成员变量……非静态变量

----父类构造函数

---子类成员变量……非静态变量

----子类构造函数

第二次调用：

---父类成员变量……非静态变量

----父类构造函数

---子类成员变量……非静态变量

----子类构造函数

由此可见：java中正常的实例化顺序是：父类实例化--》成员变量--》构造函数。加入静态类型之后会初始化所有的静态类型（包括子类和父类），然后才是正常的初始化：父类静态类型--》子类静态类型--》父类实例化--》成员变量--》构造函数。静态类型的初始化顺序都是先变量后程序块。

在C#中类中，静态成员有：静态变量、静态函数和静态构造函数，而在java中是没有静态构造函数的，取而代之的是静态代码块。静态成员一般放在静态区，而且是属于类的，所以我们不用实例化对象，直接调用静态函数，比如工具类的方法一般声明为静态函数。C#和java静态成员的初始化顺序是不一样的。

1.c#中静态成员的初始化顺序

class A

{

    static int a = setA();//静态变量

    int a1 = setA1();//非静态变量

 

    private static int setA1()

    {

        Console.WriteLine("父类非静态变量");

        return 1;

    }

 

    public static int setA()

    {

        Console.WriteLine("父类静态变量");

        return 1;

    }

 

    public A()//构造函数

    {

        Console.WriteLine("父类构造函数");

    }

 

    static A()//静态构造函数

    {

        Console.WriteLine("父类静态构造函数");

    }

}

 

class B : A

{

    static int b = setB();//静态变量

    int b1 = setB1();//非静态变量

 

    private static int setB1()

    {

        Console.WriteLine("子类非静态变量");

        return 1;

    }

 

    public static int setB()

    {

        Console.WriteLine("子类静态变量");

        return 1;

    }

 

    public B()//构造函数

    {

        Console.WriteLine("子类构造函数");

    }

 

    static B()//静态构造函数

    {

        Console.WriteLine("子类静态构造函数");

    }

}

 

class Program

{

    static void Main(string[] args)

    {

        Console.WriteLine("第一次调用。。。");

        B b = new B();

        Console.WriteLine("第二次调用。。。");

        b = new B();

    }

}

结果如下：

第一次调用。。。

-子类静态变量

--子类静态构造函数

---子类非静态变量

----父类静态变量

-----父类静态构造函数

------父类非静态变量

--------父类构造函数

---------子类构造函数

第二次调用。。。

-子类非静态变量

--父类非静态变量

---父类构造函数

----子类构造函数

从这里我们可以看到，静态变量和静态构造函数只会在类的第一次实例化时进行初始化，第二次就是正常的初始化了。在正常实例化中，初始化的顺序是：成员变量 -> 父类实例化 -> 构造函数。如果有静态类型的话，就会先初始化静态类型，于是顺序就变成了：静态变量 -> 静态构造函数 -> 成员变量 -> 父类实例化 -> 构造函数。在父类实例化中，顺序也是这样的。

2.1.一道笔试题

classA

{

    publicstatic int X;

    staticA()

    {

        X = B.Y + 1;

    }

}

classB

{

    publicstatic int Y = A.X + 1;

    staticB() { }

    staticvoid Main()

    {

        Console.WriteLine("X={0},Y={1}", A.X, B.Y);

    }

}

程序会从B类中的Main()开始执行，所以先初始化静态变量Y，而Y要调用A.X，调用A类静态构造函数A()，此时B.Y未初始化默认为0，所以X=1，再回到B的静态变量初始化中Y就是2了。初始化完成后，进入Main()，打印X=1，Y=2。意外吧！

3.总结

c#的初始化顺序看起来比较有规律，父类在子类中初始化，先静态后常规；而java则是先初始化全部静态类型（先父后子），再父类实例化，最后子类。