java静态方法加载顺序_java中静态变量，静态代码块，静态方法，实例变量，匿名代码块等的加载顺序...

转自：http://blog.csdn.net/mrzhoug/article/details/51581994

一.在Java中，使用”{}”括起来的代码称为代码块，代码块可以分为以下四种：

1.普通代码块:就是类中方法的方法体

public void xxx(){

//code

}

2.构造块:用{}裹起来的代码片段，构造块在创建对象时会被调用，每次创建对象时都会被调用，并且优先于类构造函数执行。 构造块中定义的变量是局部变量。

{

//code

}

3.静态块:用static{}裹起来的代码片段，只会被执行一次(第一次加载此类时执行,比如说用Class.forName("")加载类时就会执行static  block)，静态块优先于构造块执行。

static{

//code

}

4.同步代码块:使用synchronized(obj){}裹起来的代码块，在多线程环境下，对共享数据进行读写操作是需要互斥进行的，否则会导致数据的不一致性。常见的是synchronized用来修饰方法，其语义是任何线程进入synchronized需要先取得对象锁如果被占用了，则阻塞，实现了互斥访问共享资源。而synchronized也是有代价的。一个常见的场景是,一个冗长的方法中，其实只有一小段代码需要访问共享资源，这时使用同步块，就只将这小段代码裹在synchronized  block，既能够实现同步访问，也能够减少同步引入的开销。 同步代码块须写在方法中。

synchronized(obj){

//code

}

public class test { //1.第一步，准备加载类

public static void main(String[] args) {

new test(); //4.第四步，new一个类，但在new之前要处理匿名代码块

}

static int num = 4; //2.第二步，静态变量和静态代码块的加载顺序由编写先后决定

{

num += 3;

System.out.println("b"); //5.第五步，按照顺序加载匿名代码块，代码块中有打印

}

int a = 5; //6.第六步，按照顺序加载变量

{ // 成员变量第三个

System.out.println("c"); //7.第七步，按照顺序打印c

}

test() { // 类的构造函数，第四个加载

System.out.println("d"); //8.第八步，最后加载构造函数，完成对象的建立

}

static { // 3.第三步，静态块，然后执行静态代码块，因为有输出，故打印a

System.out.println("a");

}

static void run() // 静态方法，调用的时候才加载// 注意看，e没有加载

{

System.out.println("e");

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

一般顺序：静态块(静态变量)——>成员变量——>构造方法——>静态方法

1、静态代码块(只加载一次) 2、构造方法(创建一个实例就加载一次)3、静态方法需要调用才会执行，所以最后结果没有e

public class Print {

public Print(String s){

System.out.print(s + " ");

}

}

1

2

3

4

5

6

1

2

3

4

5

6

public class Parent{

public static Print obj1 = new Print("1");

public Print obj2 = new Print("2");

public static Print obj3 = new Print("3");

static{

new Print("4");

}

public static Print obj4 = new Print("5");

public Print obj5 = new Print("6");

public Parent(){

new Print("7");

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

public class Child extends Parent{

static{

new Print("a");

}

public static Print obj1 = new Print("b");

public Print obj2 = new Print("c");

public Child (){

new Print("d");

}

public static Print obj3 = new Print("e");

public Print obj4 = new Print("f");

public static void main(String [] args){

Parent obj1 = new Child ();

Parent obj2 = new Child ();

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

执行main方法，程序输出顺序为： 1 3 4 5 a b e 2 6 7 c f d 2 6 7 c f d

1

1

输出结果表明，程序的执行顺序为：

如果类还没有被加载：

1、先执行父类的静态代码块和静态变量初始化，并且静态代码块和静态变量的执行顺序只跟代码中出现的顺序有关。

2、执行子类的静态代码块和静态变量初始化。

3、执行父类的实例变量初始化

4、执行父类的构造函数

5、执行子类的实例变量初始化

6、执行子类的构造函数

如果类已经被加载：

则静态代码块和静态变量就不用重复执行，再创建类对象时，只执行与实例相关的变量初始化和构造方法。