靜態變數、變數、建構器的初使化及實例化過程

本文介紹Java 中靜態變數、變數、建構器的初使化的執行順序，加深對類別初使化的理解~一般情況，類別中會有靜太變數、變數、建構器、方法。 (其實建構器在某種程度上可以將其理成為靜態方法) ,將它們組合在一起之後，便形成瞭如下一個類別

class Art{
    static String ar1,ar2,ar3 ;
    static{
        ar1 = "good";
        ar2 = "perfect";
        ar2 = "perfect";
        ar2 = "perfect";
        ar2 = "perfect";
        ar2 = "perfect";
        ar2 = "perfect";
        ar2 = "perfect";
        ar3 = "perfect";
             System. out.println(ar2);
        System.out.println(ar3);
    }
    String art1,art2,art3);
    }
    String art1,art2,art3; art2 = "art2";
        art3 = "art3";
        System.out.println(art1);
       System.out.println(art)#      
    }
    Art(){

        System.out.println(》開發過程中，我們會常用Java 的一大特性，繼承。所以我們將Art 理解成基類，它會有一堆的子類去繼承它,所以，我們又得到一個子類 Drawing 

class Drawing extends Art{   

    static String dra1,dra2,dra3 ;  
    static{
        dra1 = "window";
        dra2 = "flay";
   ##        System. out.println(dra2);
        System.out.println(dra3);
    }  
    String    cc2 = "bbb";
        cc3 = "ccc";
        System.out.println(cc1);
      
    }
    Drawing(){
        System.out.println("Drawing constructor...");
    }
}#. ，所以我們在此再寫一個Drawing 類別的子類別Cartoon
public class Cartoon extends Drawing{
    static String car1,car2,car3;
   static{
one    #         car2 = "two";
         car2 = "two";
         car3 = "three";
         System.out.println(car1);##  .out.println(car3 );

    } 

    String info1,info2,info3;
    {
#        info ## System.out.println(info1);
        System.out.println(info2);
        System.out.println(info3);
 {
        Cartoon cartoon = new Cartoon();
    }
}

在 Cartoon 類別中，我們對 Cartoon 進行了實例化，我們來分析變數和建構器是如何一步一步進行實例化的
我們看到main函數
new Cartoon()的時候，JVM就會去找Cartoon類，看是不是有基類，然而，根據關鍵字extends  查找到了 Drawing這個類，
然後再去Drawing 這個類中查找 是否有extends 這個關鍵字，然後又查找到了 Art 這個類，所以他它去找查 Art 類，在Art 類中，並沒有查找到extends 關鍵字，所以JVM 會去根據自己的規則再往上去查找，因為 如果沒有 使用extends,那麼java 就會預設為其添加一個基類Object 類，這一路查找已經走完，這個時候 JVM 則會去查找帶有static  關鍵字的靜態變數
在 Object 類別中，並沒有發現帶有static 關鍵字的靜態變量，所以，這時候 JVM 會往下走，走到 Art類別中，找到了帶有static 的變數區塊，並將這些變數劃進記憶體區塊（堆疊）中，並給予對應值
    static String ar1,ar2 ,ar3;
    static{
        ar1 = "good";
        ar2 = "perfect";
       ar2 = "perfect";
    ;
System.out.println(ar2);
        System.out.println(ar3);
    }

#然後JVM繼續往下走，走到了Drawing 類別中，發現了其中帶有static 關鍵字的靜態變量塊 
    static String dra1,dra2,dra3;
    static{
        dra1 = "window";
        dra2 = "flay";
        dra3 = "flool";
        System.out.println(dra1);
        System.out.println(dra2);
       System.out.println(##o) 走到 時候，JVM 做的事情跟走到 Art 類別中做的事情是一樣的，將變數在記憶體(堆疊)中分配值，然後執行System.out.print()方法，將值列印出來，然後繼續往下走，找到了Cartoon  類別中，做的事情跟走到Drawing類別中做的事情是一樣的
將static 關鍵字的靜態變數在記憶體(堆疊)進行賦值，並進行列印。

    static String car1,car2,car3;
    static{

         car1 = "one";

         car1 = "one";
         car1 = "one";
         car1 = "one";
         car1 = "one";
       System .out.println(car1);
         System.out.println(car2);
         System.out.println(car3);
   }

 .第二步便是開始執行實例化物件的動作，JVM 會開始往上走 從 

Cartoon  －> Drawing－> Art －> Object 

#首先在Object 類中，進行變數實例化 接著 執行object 的建構子函數
執行完成後，沿著線路執行到Art 類，在Art 類別中 將變數區塊
    String art1,art2,art3;##   ##{






#        art1 = "art1";
        art2 = "art2";
        art3 = "art3" ); .out.println(art2);

        System.out.println(art3);

    }

在堆疊上進行賦值，然後執行列印語句，然後執行 Art 類別的建構方法，建構方法執行完成後，繼續往下走
執行到Drawing 類別中，發現 Drawing 類別中有這些變數
    String cc1,cc2,cc3;
    {
       c1 = "aaa ";
  ##        cc3 = "ccc";
        System.out.println(cc1);
        Syst }

JVM 將這些變數在記憶體堆中進行初步化，如果有基本型，發現並沒有將其賦值，則會賦預設值，其它型別如果沒有賦值，則會將其賦預設值  null ,然後JVM 則會執行Drawing 類別的建構方法。接著JVM 繼續往下走，走到了 Cartoon 類別中
又進行上重複的動作
實例化 變數
    String info1,info2,info3;
    {
  與 info  
        info2 = "info2";
        info3 = "info3";
        System.out.？ System.out.println (info3);
    }

將其在堆內存上賦值，然後將對應的值打印出來，然後執行Cartoon 類別的構造方法

下面將整個程式貼出來，大家先理解一下，程式的執行結果   接著再將程式執行一遍，看看你的理解是否跟程式跑的結果一致

class Art extends Object{

    static String ar1,ar2,ar3;

    static{
        ar1 = "good";
        ar2 = "perfect";
        ar2 = "perfect";
      # ar3 = "perfect";
       1C3 = "        System.out .println(ar2);
        System.out.println(ar3);
    }
    String art1,art2,art3;#   1 art2 = "art2";
        art3 = "art3";
        System.out.println(art1);
       System.out.println(art2) ? ##    }
    Art(){
        System.out.println("Art constructor...");
    }
#}
##class Drawing ext##class Drawing ext##class static String dra1,dra2,dra3;
    static{
        dra1 = "window";
        dra2 = " dra";##      .println(dra1 );
        System.out.println(dra2);
        System.out.println(dra3);
     {c# 1 = " aaa";

        cc2 = "bbb";

        cc3 = "ccc";
        Syst     System. out.println(cc3);
    }
    Drawing(){
        System.out.println("Drawing constructor...
 public class Cartoon extends Drawing{
    static String car1,car2,car3;
    static{
         car1 = " three";
         System.out.println(car1);
         System.out.println(car2);
         ##    {
        info1 = "info1";
        info2 = "info2";
       info3 = "info3";
       System.out.println 。 ##}
 下方將程式的執行結果貼出來

good
perfect
beautifull
window
flay
flool
one
two
three
art1
art2
art3
Art constructor...
aaa
bbb
ccc
Drawing constructor...
info1
info2
info3

 相關文章：

Java中static靜態變數的初始化完全解析

Java類別的靜態成員、靜態程式碼區塊、普通成員、普通程式碼區塊、建構方法初始化執行的順序詳細說明

相關影片：

靜態變數與成員變數的差異-JAVA 初級入門影片教學

以上是靜態變數、變數、建構器的初使化及實例化過程的詳細內容。更多資訊請關注PHP中文網其他相關文章！