JAVA程序执行顺序 ----收藏

本文转自：http://java-mzd.iteye.com/blog/838683

作者：java_mzd

文章分类:Java编程
本文主要介绍以下两块内容的执行顺序，熟悉的大虾可以直接飘过。

     一。JAVA中执行顺序

1.静态块
2.块
3.构造器
4.父类构造器

    二。JAVA中赋值顺序

1.      静态块直接赋值
2.      块直接赋值
3.      父类继承的属性已赋值
4.      静态变量声明时赋值
5.      成员变量声明时赋值
6.      构造器赋值

 

 第一部分很好测试，我们只需要写一个子类，类中定义一个静态块，一个普通块，一个构造器，它的父类

构造器，都打印一条语句，即可明白它们直接的执行顺序

 

Mastiff类

 

Java代码
1.<SPAN style="FONT-SIZE: medium">/** 
2. * 子类藏獒 
3. */ 
4.public class Mastiff extends Dog {  
5.    public Mastiff() {  
6.        System.out.println("Mastiff");  
7.    }  
8. 
9.    {  
10.        System.out.println("block");  
11.    }  
12.    static {  
13.        System.out.println("static block");  
14.    }  
15.      
16.    public static void  main(String[] args){  
17.        Mastiff mastiff=new Mastiff();  
18.          
19.    }  
20.}  
21.</SPAN> 
/**
 * 子类藏獒
 */
public class Mastiff extends Dog {
 public Mastiff() {
  System.out.println("Mastiff");
 }

 {
  System.out.println("block");
 }
 static {
  System.out.println("static block");
 }
 
 public static void  main(String[] args){
  Mastiff mastiff=new Mastiff();
  
 }
}
 

 

  DOG类

 

Java代码
1.<SPAN style="FONT-SIZE: medium">/** 
2. *DOG父类 
3. */ 
4.public class Dog {  
5.    public Dog() {  
6.        System.out.println("Dog");  
7.    }  
8.}  
9.</SPAN> 
/**
 *DOG父类
 */
public class Dog {
 public Dog() {
  System.out.println("Dog");
 }
}
 

运行结果为：

 

   static block
Dog
block
Mastiff
 
 
 

也就是说，在我们的程序中，实例化一个类对象的时候，运行顺序为：

1.  静态块
2.  父类构造器
3.  本类中的块
4.  本类的构造器
我们可以更进一步，如果在父类中也有块和静态块呢？

    DOG类改进后源码

Java代码
1.<SPAN style="FONT-SIZE: medium">/** 
2. *DOG父类 
3. */ 
4.public class Dog {  
5.    public Dog() {  
6.        System.out.println("Dog");  
7.    }  
8.    static{  
9.        System.out.println("super static block");  
10.    }  
11.      
12.    {  
13.        System.out.println("super block");  
14.    }  
15.}  
16.</SPAN> 
/**
 *DOG父类
 */
public class Dog {
 public Dog() {
  System.out.println("Dog");
 }
 static{
  System.out.println("super static block");
 }
 
 {
  System.out.println("super block");
 }
}
 

   Mastiff改进后源码

Java代码
1.<SPAN style="FONT-SIZE: medium">/** 
2. * 子类藏獒 
3. */ 
4.public class Mastiff extends Dog {  
5.    public Mastiff() {  
6.        System.out.println("Mastiff");  
7.    }  
8. 
9.    {  
10.        System.out.println("block");  
11.          
12.    }  
13.    static {  
14.        System.out.println("static block");  
15.    }  
16.      
17.    public static void  main(String[] args){  
18.        Mastiff mastiff=new Mastiff();        
19.    }  
20.}  
21.</SPAN> 
/**
 * 子类藏獒
 */
public class Mastiff extends Dog {
 public Mastiff() {
  System.out.println("Mastiff");
 }

 {
  System.out.println("block");
  
 }
 static {
  System.out.println("static block");
 }
 
 public static void  main(String[] args){
  Mastiff mastiff=new Mastiff();  
 }
}
 

运行的结果为：

super static block
static block
super block
Dog
block
Mastiff
 

 也就是说此时的运行顺序为：

1.   父类静态块
2.   自身静态块
3.   父类块
4.   父类构造器
5.   自身块
6.   自身构造器

 

  好了，知道了运行的顺序，那么这是为什么呢？

         这就要从JVM中类的装载机制和实例化机制开始说起，这里因为主题原因，先不讨论，有兴趣的同

学可以自己查资料。
 

 

我们再来讨论第二个问题，一个变量的值，它有可能在哪些地方确定呢？？

1.从父类继承该值（包括：1.作为父类的成员变量已经赋值  2.在父类的块中赋值  3.在父类的构造器中赋

值）
2.在构造器中对其进行赋值
3.在块中进行赋值
4.在方法调用中进行赋值

  现在假设在我们刚刚的例子中，有一个变量type，表示狗的品种

 

Java代码
1.<SPAN style="FONT-SIZE: medium">/** 
2. *DOG父类 
3. */ 
4.public class Dog {  
5.    public String type="父类成员变量赋的值";  
6.    public Dog() {  
7.        System.out.println("父类构造器--type-->"+type);  
8.        type="父类构造器赋的值";  
9.                   System.out.println("父类构造器----type--->"+type);  
10.    }  
11.      
12.    {  
13.        System.out.println("block---type--->"+type);  
14.        type="父类块赋的值";  
15.    }  
16.}  
17.</SPAN> 
/**
 *DOG父类
 */
public class Dog {
 public String type="父类成员变量赋的值";
 public Dog() {
  System.out.println("父类构造器--type-->"+type);
  type="父类构造器赋的值";
                   System.out.println("父类构造器----type--->"+type);
 }
 
 {
  System.out.println("block---type--->"+type);
  type="父类块赋的值";
 }
}
 

  

Java代码
1.<SPAN style="FONT-SIZE: medium">/** 
2. * 子类藏獒 
3. */ 
4.public class Mastiff extends Dog {  
5.    public String type="成员变量赋的值";  
6.    public Mastiff() {  
7.        System.out.println("构造器---type--->"+type);  
8.        type="构造器赋的值";  
9.    }  
10.      
11.    public void say(){  
12.        System.out.println("say---type---->"+type);  
13.    }  
14. 
15.    {  
16.        System.out.println("block---type--->"+type);  
17.        type="块赋的值";  
18.          
19.    }  
20.      
21.    public static void  main(String[] args){  
22.        Mastiff mastiff=new Mastiff();  
23.        mastiff.say()</SPAN><SPAN style="FONT-SIZE: medium">;</SPAN><SPAN style="FONT-SIZE:

medium">          
24.    }  
25.}  
26.</SPAN> 
/**
 * 子类藏獒
 */
public class Mastiff extends Dog {
 public String type="成员变量赋的值";
 public Mastiff() {
  System.out.println("构造器---type--->"+type);
  type="构造器赋的值";
 }
 
 public void say(){
  System.out.println("say---type---->"+type);
 }

 {
  System.out.println("block---type--->"+type);
  type="块赋的值";
  
 }
 
 public static void  main(String[] args){
  Mastiff mastiff=new Mastiff();
  mastiff.say();  
 }
}
  

 

 执行结果如下：

   block---type--->父类成员变量赋的值
父类构造器--type-->父类块赋的值
父类构造器----type--->父类构造器赋的值
block---type--->成员变量赋的值
构造器---type--->块赋的值
say---type---->构造器赋的值
 
 
 

答案很明显，赋值顺序为：

1.父类成员变量赋值
2.父类块赋值
3.父类构造器赋值
4.自身成员变量赋值
5.自身块赋值
6.自身构造器赋值
 

 

 结合我们前面说的程序中的执行顺序，这个显然是很好理解的：

   1.成员变量赋值>>>块赋值>>>构造器赋值

   2.父类的块>>父类构造器>>自身块>>自身构造器

 

 又因为一个成员变量是不可能在静态变量中赋值的，而且又前面程序执行顺序可知

    静态块>>块

 

 

所以，程序的赋值步骤为

1.父类的静态变量赋值
2.自身的静态变量赋值
3.父类成员变量赋值
4.父类块赋值
5.父类构造器赋值
6.自身成员变量赋值
7.自身块赋值
8.自身构造器赋值