java程序执行顺序

淩亂°似流年 2023-02-17 11:07 18阅读 0赞

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

一。JAVA中执行顺序

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

二。JAVA中赋值顺序

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

第一部分很好测试，我们只需要写一个子类，类中定义一个静态块，一个普通块，一个构造器，它的父类构造器，都打印一条语句，即可明白它们直接的执行顺序

Mastiff类

**Java代码  ![收藏代码][format_png]**

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>

DOG类

**Java代码  ![收藏代码][format_png]**

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>

运行结果为：

<table> 
 <tbody> 
  <tr> 
   <td>static block<br> Dog<br> block<br> Mastiff</td> 
  </tr> 
 </tbody> 
</table>

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

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

我们可以更进一步，如果在父类中也有块和静态块呢？

DOG类改进后源码

**Java代码  ![收藏代码][format_png]**

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>

Mastiff改进后源码

**Java代码  ![收藏代码][format_png]**

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>

运行的结果为：

<table> 
 <tbody> 
  <tr> 
   <td>super static block<br> static block<br> super block<br> Dog<br> block<br> Mastiff</td> 
  </tr> 
 </tbody> 
</table>

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

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

<table> 
 <tbody> 
  <tr> 
   <td> <p style="margin-left:0px;"><span style="color:#ff0000;">&nbsp; 好了，知道了运行的顺序，那么这是为什么呢？</span></p> <p style="margin-left:0px;">&nbsp;</p> <p style="margin-left:0px;"><span style="color:#ff0000;">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;这就要从JVM中类的装载机制和实例化机制开始说起，这里因为主题原因，先不讨论，有兴趣的同学可以自己查资料。</span></p> </td> 
  </tr> 
 </tbody> 
</table>

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

1.  从父类继承该值（包括：1.作为父类的成员变量已经赋值  2.在父类的块中赋值  3.在父类的构造器中赋值）
2.  在构造器中对其进行赋值
3.  在块中进行赋值
4.  在方法调用中进行赋值

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

**Java代码  ![收藏代码][format_png]**

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>

**Java代码  ![收藏代码][format_png]**

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>

执行结果如下：

<table> 
 <tbody> 
  <tr> 
   <td>block---type---&gt;父类成员变量赋的值<br> 父类构造器--type--&gt;父类块赋的值<br> 父类构造器----type---&gt;父类构造器赋的值<br> block---type---&gt;成员变量赋的值<br> 构造器---type---&gt;块赋的值<br> say---type----&gt;构造器赋的值</td> 
  </tr> 
 </tbody> 
</table>

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

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

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

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

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

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

静态块>>块

所以，程序的赋值步骤为

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

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly93d3cuaXRleWUuY29tL2ltYWdlcy9pY29uX3N0YXIucG5n?x-oss-process=image/format,png