免费视频淫片aa毛片_日韩高清在线亚洲专区vr_日韩大片免费观看视频播放_亚洲欧美国产精品完整版

     一。JAVA中執(zhí)行順序

1. 靜態(tài)塊
2. 塊
3. 構造器
4. 父類構造器

    二。JAVA中賦值順序

1.       靜態(tài)塊直接賦值
2.       塊直接賦值
3.       父類繼承的屬性已賦值
4.       靜態(tài)變量聲明時賦值
5.       成員變量聲明時賦值
6.       構造器賦值

 第一部分很好測試，我們只需要寫一個子類，類中定義一個靜態(tài)塊，一個普通塊，一個構造器，它的父類構造器，都打印一條語句，即可明白它們直接的執(zhí)行順序

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>  

  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>  

運行結果為：

也就是說，在我們的程序中，實例化一個類對象的時候，運行順序為：

1.   靜態(tài)塊
2.   父類構造器
3.   本類中的塊
4.   本類的構造器 

我們可以更進一步，如果在父類中也有塊和靜態(tài)塊呢？

    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>  

   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>  

運行的結果為：

 也就是說此時的運行順序為：

1.    父類靜態(tài)塊
2.    自身靜態(tài)塊
3.    父類塊
4.    父類構造器
5.    自身塊
6.    自身構造器 

我們再來討論第二個問題，一個變量的值，它有可能在哪些地方確定呢？？

1. 從父類繼承該值（包括：1.作為父類的成員變量已經(jīng)賦值  2.在父類的塊中賦值  3.在父類的構造器中賦值）
2. 在構造器中對其進行賦值
3. 在塊中進行賦值
4. 在方法調用中進行賦值

  現(xiàn)在假設在我們剛剛的例子中，有一個變量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>  

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>  

 執(zhí)行結果如下：

答案很明顯，賦值順序為：

1. 父類成員變量賦值
2. 父類塊賦值
3. 父類構造器賦值
4. 自身成員變量賦值
5. 自身塊賦值
6. 自身構造器賦值

 結合我們前面說的程序中的執(zhí)行順序，這個顯然是很好理解的：

   1.成員變量賦值>>>塊賦值>>>構造器賦值

   2.父類的塊>>父類構造器>>自身塊>>自身構造器

 又因為一個成員變量是不可能在靜態(tài)變量中賦值的，而且又前面程序執(zhí)行順序可知

    靜態(tài)塊>>塊

所以，程序的賦值步驟為

1. 父類的靜態(tài)變量賦值
2. 自身的靜態(tài)變量賦值
3. 父類成員變量賦值
4. 父類塊賦值
5. 父類構造器賦值
6. 自身成員變量賦值
7. 自身塊賦值
8. 自身構造器賦值