2. 程式人生 > >Java類載入與例項化過程

Java類載入與例項化過程

阿新 • • 發佈：2019-02-08

0x00 背景知識

1、虛擬機器在首次載入Java類時，會對靜態初始化塊、靜態成員變數、靜態方法(下文將這三種統稱為靜態程式碼塊)進行一次初始化
具體過程是：
①裝(加)載類的載入指的是將類的.class檔案中的二進位制資料讀入到記憶體中，將其放在執行時資料區的方法區中，然後在堆區建立一個java.lang.Class物件，用來封裝類在方法區內的資料結構，之後可以用Class物件進行相關的反射操作。
②連線分為三個子步驟　　　　 

　　　　驗證：確保被載入的類的正確性

　　　　準備：為類的靜態變數分配記憶體，並將其初始化為預設值

　　　　解析： 把類中的符號引用轉換為直接引用

③初始化為為類的靜態變數賦予正確的初始值

2、類例項建立過程：按照父子繼承關係進行初始化，首先執行父類的初始化塊部分，然後是父類的構造方法；再執行本類繼承的子類的初始化塊，最後是子類的構造方法
3、類例項銷燬時候，首先銷燬子類部分，再銷燬父類部分

成員變數和靜態變數的區別：
1，成員變數所屬於物件。所以也稱為例項變數。
靜態變數所屬於類。所以也稱為類變數。
2，成員變數存在於堆記憶體中。
靜態變數存在於方法區中。
3，成員變數隨著物件建立而存在。隨著物件被回收而消失。
靜態變數隨著類的載入而存在。隨著類的消失而消失。
4，成員變數只能被物件所呼叫 。
靜態變數可以被物件呼叫，也可以被類名呼叫。
所以，成員變數可以稱為物件的特有資料，靜態變數稱為物件的共享資料。

靜態程式碼塊：就是一個有靜態關鍵字標示的一個程式碼塊區域。定義在類中。
作用：可以完成類的初始化。靜態程式碼塊隨著類的載入而執行，而且只執行一次（new 多個物件就只執行一次）。如果和主函式在同一類中，優先於主函式執行。（靜態成員就是靜態程式碼塊）

//靜態程式碼塊:在java中使用static關鍵字宣告的程式碼塊。靜態塊用於初始化類，為類的屬性初始化。每個靜態程式碼塊只會執行一次。由於JVM在載入類時會執行靜態程式碼塊，所以靜態程式碼塊先於主方法執行。
//如果類中包含多個靜態程式碼塊，那麼將按照"先定義的程式碼先執行，後定義的程式碼後執行"。
//注意：1 靜態程式碼塊不能存在於任何方法體內。2 靜態程式碼塊不能直接訪問靜態例項變數和例項方法，需要通過類的例項物件來訪問。
 



class Code{
    {
      System.out.println("Code的構造塊");
    }

    static{
        System.out.println("Code的靜態程式碼塊");
        }

    public Code(){
        System.out.println("Code的構造方法");
        }
    }


public class CodeBlock03{
     {
      System.out.println("CodeBlock03的構造塊");    
     }

     static{
        System.out.println("CodeBlock03的靜態程式碼塊");
        }

        public CodeBlock03(){
             System.out.println("CodeBlock03的構造方法");
            }

      public static void main(String[] args){
            System.out.println("CodeBlock03的主方法");
            new Code();
            new Code();
            new CodeBlock03();
            new CodeBlock03();
          }
    }
/*
CodeBlock03的靜態程式碼塊
CodeBlock03的主方法
Code的靜態程式碼塊
Code的構造塊
Code的構造方法
Code的構造塊
Code的構造方法
CodeBlock03的構造塊
CodeBlock03的構造方法
CodeBlock03的構造塊
CodeBlock03的構造方法
*/

構造程式碼塊：類中的獨立程式碼塊，與物件相關，物件呼叫一次就執行一次。
作用：給所有的物件進行初始化。

//構造塊：直接在類中定義且沒有加static關鍵字的程式碼塊稱為{}構造程式碼塊。構造程式碼塊在建立物件時被呼叫，每次建立物件都會被呼叫，並且構造程式碼塊的執行次序優先於類建構函式。

public class CodeBlock02{
    {
      System.out.println("第一程式碼塊");    
    }

    public CodeBlock02(){
        System.out.println("構造方法");
        }

        {
          System.out.println("第二構造塊");
        }
      public static void main(String[] args){
          new CodeBlock02();
          new CodeBlock02();
          new CodeBlock02();

    }
}    

/*
*
執行結果：
第一程式碼塊
第二構造塊
構造方法
第一程式碼塊
第二構造塊
構造方法
第一程式碼塊
第二構造塊
構造方法
*/

0x01先來幾個小測試：

測試一

class Singleton {
    private static Singleton sin = new Singleton();
    public static int counter1;
    public static int counter2 = 0;

    private Singleton() {
        counter1++;
        counter2++;
    }

    public static Singleton getInstance() {
        return sin;
    }
}

public class Test {
    public static void main(String[] args) {
        Singleton sin = Singleton.getInstance();
        System.out.println(sin.counter1);
        System.out.println(sin.counter2);
    }
}

測試二：

class Singleton {   
    public static int counter1;
    public static int counter2 = 0;
    private static Singleton sin = new Singleton();

    private Singleton() {
        counter1++;
        counter2++;
    }

    public static Singleton getInstance() {
        return sin;
    }
}

public class Test {
    public static void main(String[] args) {
        Singleton sin = Singleton.getInstance();
        System.out.println(sin.counter1);
        System.out.println(sin.counter2);
    }
}

測試三：

class Singleton {
    private static Singleton sin = new Singleton();
    public static int counter1;
    public static int counter2 = 0;

    public Singleton() {
        counter1++;
        counter2++;
    }

}

public class Test {
    public static void main(String[] args) {
        Singleton sin = new Singleton();
        System.out.println(sin.counter1);
        System.out.println(sin.counter2);
    }
}

測試四：

class Singleton {

    public static int counter1;
    public static int counter2 = 0;
    private static Singleton sin = new Singleton();

    {
        counter1=3;
    }

    public Singleton() {
        counter1++;
        counter2++;
    }

}

public class Test {
    public static void main(String[] args) {
        Singleton sin = new Singleton();
        System.out.println(sin.counter1);
        System.out.println(sin.counter2);
    }
}

結果：
測試一：1,0
測試二：1,1
測試三：2,1
測試四：4,2

0x02類載入

測試一分析：
按類載入的流程走一遍：
①裝(加)載類的載入指的是將類的.class檔案中的二進位制資料讀入到記憶體中，將其放在執行時資料區的方法區中，然後在堆區建立一個java.lang.Class物件，用來封裝類在方法區內的資料結構，之後可以用Class物件進行相關的反射操作。（都一樣）
②連線分為三個子步驟　
驗證：確保被載入的類的正確性
準備：為類的靜態變數分配記憶體，並將其初始化為預設值
測試一中：sin=NULL；counter1=0；counter2=0；
解析： 把類中的符號引用轉換為直接引用
③初始化為為類的靜態變數賦予正確的初始值
測試一中第一句：
private static Singleton sin = new Singleton();//執行後counter1=1；counter2=2；
第二句：public static int counter1;//執行後counter1=1;
第二句：public static int counter2 = 0;//執行counter2=0；
所以最後結果為1,0
測試二同理。

0x03類的例項化

類例項建立過程簡單總結一下就是（new一個類的時候到底發生了什麼？）：
預設初始化（對成員賦0或NULL）—>進建構函式—>super()【父類也是該過程】—>顯式初始化—>構造程式碼塊—>建構函式中其它程式碼

class Singleton {

    /*
     *靜態程式碼塊（靜態成員）
     */
    private static Singleton sin = new Singleton();
    public static int counter1;
    public static int counter2 = 0;

    /*
     *構造程式碼塊
     */
    {
        counter1=3;
    }

    /*
     *造函式
     */
    public Singleton() {
        //類Singleton 的super class為object
        super();

        //建構函式中其它程式碼
        counter1++;
        counter2++;
    }

}

public class Test {
    public static void main(String[] args) {
        Singleton sin = new Singleton();
        System.out.println(sin.counter1);
        System.out.println(sin.counter2);
    }
}

根據上面總結的流程走一遍：

類載入階段：跟測試一一樣，該階段結束後counter1=1；counter2=0；
類例項化階段：
預設初始化（對成員賦0或NULL）//沒有普通成員
—>進建構函式//開始進入Singleton()
—>super()【父類也是該過程】//進入super()，即Object載入
—>顯式初始化//super()執行完後開始顯示為成員賦值，本測試中沒有普通的非static成員
—>構造程式碼塊 //沒有
—>建構函式中其它程式碼//       counter1++;counter2++;結束時counter1=2，counter2=1

測試四也走一遍：

類載入階段：跟測試一一樣，該階段結束後counter1=1；counter2=1；
類例項化階段：
預設初始化（對成員賦0或NULL）//沒有普通成員
—>進建構函式//開始進入Singleton()
—>super()【父類也是該過程】//進入super()，即Object載入
—>顯式初始化//super()執行完後開始顯示為成員賦值，本測試中沒有普通的非static成員
—>構造程式碼塊 //counter1=3；
—>建構函式中其它程式碼//       counter1++;counter2++;結束時counter1=4，counter2=2

0x04 自測題

public class Farther
{
    static
    {
        System.out.println("靜態程式碼塊      farther");
    }

    {
        System.out.println("構造程式碼塊  farther");
    }
    public Farther()
    {
        System.out.println("call farther counter1="+Singleton.counter1+"  counter2="+Singleton.counter2);

        Singleton.counter1++;
    }

}

class Singleton extends Farther {   

    static
    {
        System.out.println("靜態程式碼塊1  counter1="+Singleton.counter1 +"  counter2="+Singleton.counter2);
    }

    public static int counter1;
    public static int counter2 = 1;

    static
    {
        System.out.println("靜態程式碼塊2  counter1="+counter1 +"  counter2="+counter2);
    }

    private static Singleton sin = new Singleton();
    static
    {
        System.out.println("靜態程式碼塊3  counter1="+counter1 +"  counter2="+counter2);
    }

    {
        counter1++;
        System.out.println("構造程式碼塊  counter1="+counter1+"  counter2="+counter2);
    }

    public Singleton() {
        System.out.println("call Singleton");
        counter1++;
        counter2++;
    }

}

public class Test {
    public static void main(String[] args) {
        //Singleton sin = Singleton.getInstance();
        Singleton sin = new Singleton();
        System.out.println("counter1="+sin.counter1);
        System.out.println("counter2="+sin.counter2);

    }
}
/*
靜態程式碼塊      farther
靜態程式碼塊1  counter1=0  counter2=0
靜態程式碼塊2  counter1=0  counter2=1
構造程式碼塊  farther
call farther counter1=0  counter2=1
構造程式碼塊  counter1=2  counter2=1
call Singleton
靜態程式碼塊3  counter1=3  counter2=2
構造程式碼塊  farther
call farther counter1=3  counter2=2
構造程式碼塊  counter1=5  counter2=2
call Singleton
counter1=6
counter2=3

*/

執行過程就是：
1.先載入 Farther
列印了：“靜態程式碼塊 farther”
2.後加載Singleton
先列印了：“靜態程式碼塊1 counter1=0 counter2=0“
”靜態程式碼塊2 counter1=0 counter2=1”
靜態程式碼塊： private static Singleton sin = new Singleton();呼叫了Singleton的建構函式，
先執行super(),所以“call farther counter1=0 counter2=1”被列印；
再執行構造程式碼塊，所以“構造程式碼塊 counter1=2 counter2=1”被列印
再執行建構函式中其他的程式碼，所以“call Singleton”被列印，建構函式呼叫結束。
接著執行靜態程式碼塊，所以“靜態程式碼塊3 counter1=3 counter2=2”被列印。
3.在main函式中呼叫Singleton sin = new Singleton();
預設初始化
—>進建構函式
—>super()【父類也是該過程，可看做該過程的一次遞迴】，//所以“構造程式碼塊 farther”和“call farther counter1=3 counter2=2”被列印
—>顯式初始化
—>構造程式碼塊 //所以“構造程式碼塊 counter1=5 counter2=2”被列印
—>建構函式中其它程式碼 //所以“call Singleton”被列印
最後列印：counter1=6
counter2=3

相關推薦

Java類載入與例項化過程

0x00 背景知識 1、虛擬機器在首次載入Java類時，會對靜態初始化塊、靜態成員變數、靜態方法(下文將這三種統稱為靜態程式碼塊)進行一次初始化 具體過程是： ①裝(加)載類的載入指的是將類的.class檔案中的二進位制資料讀入到記

java類載入和例項化：靜態程式碼塊、初始化程式碼塊、構造方法的執行順序

java中第一次例項化一個物件時，靜態程式碼塊、初始化塊、屬性的初始化、構造方法，再加上如果父類也有這些東西，天，到底執行順序是什麼？ 來一段程式碼試一試就知道了： public class LoadingTest { public static void main(

類載入與例項化

類載入與例項化 基本步驟 類裝載分為以下 5 個步驟： 載入：根據查詢路徑找到相應的 class 檔案然後匯入 檢查：檢查載入的 class 檔案的正確性 準備：給類中的靜態變數分配記憶體空間 解析：虛擬機器將常量池中的符號引用替換成直接引用的過程。符號引用理解為一個標示，而直接引用直接指向記憶體中的地址

java之面向物件：子類物件的例項化過程詳解

在子類建構函式中，發現，訪問子類建構函式時，父類也運行了。原因是什麼呢？ 在子類的建構函式裡第一行有一個預設的隱式語句：super() ExtendsDemo.java class Fu { Fu() { System.out.println("fu run")

JAVA new流程（例項化過程）

1.首先去JVM 的方法區中區尋找類的class物件，如果能找到，則按照定義生成物件，找不到則轉2 2.載入類定義：類載入器（classLoader）尋找該類的 .class檔案，找到後對檔案進行分析轉換為class物件存入方法區方便以後呼叫。     其中jdk 的cla

淺談Java類載入的初始化階段

類載入的初始化階段對類變數賦予正確的值。主要有兩種初始化方式，一種是通過類變數初始化語句；一種是靜態初始化語句。如下述程式碼所示，前者是類變數初始化語句，後者是靜態初始化語句。 public class Example1 { static int

深入理解Java物件的建立過程：類的初始化與例項化

摘要： 　　在Java中，一個物件在可以被使用之前必須要被正確地初始化，這一點是Java規範規定的。在例項化一個物件時，JVM首先會檢查相關型別是否已經載入並初始化，如果沒有，則JVM立即進行載入並呼叫類構造器完成類的初始化。在類初始化過程中或初始化完畢後，根據具體情況才會

Java類載入過程和物件例項化詳解

Java虛擬機器類載入過程 類載入時機 類載入過程 –載入 –驗證 –準備 –解析 –初始化 1、類載入時機         類從被載入虛擬機器記憶體中開始，到卸載出記憶體為止，他的整個生命週期包括：載入、驗證、準備、解析、初始化、

深入學習Java物件建立的過程：類的初始化與例項化

　　在Java中，一個物件在可以被使用之前必須要被正確地初始化，這一點是Java規範規定的。在例項化一個物件時，JVM首先會檢查相關型別是否已經載入並初始化，如果沒有，則JVM立即進行載入並呼叫類構造器完成類的初始化。在類初始化過程中或初始化完畢後，根據具體情況才會去對類進行例項化。本文試圖對JVM執行類初始

java類的載入與初始化

https://blog.csdn.net/u013349237/article/details/71076617     1在命令列啟動虛擬機器jvm進行載入， 2用class.forname()方法進行動態載入； 3用ClassLoader.loadClass（）進行動態載入

JVM總括四-類載入過程、雙親委派模型、物件例項化過程 JVM思考-init和clinit區別

JVM總括四-類載入過程、雙親委派模型、物件例項化過程 目錄：JVM總括：目錄 一、 類載入過程 類載入過程就是將.class檔案轉化為Class物件，類例項化的過程，（User user = new User(); 這個過程是物件例項化的過程）; 一個.class檔案只有一個Class物件（位元

JVM思考-init和clinit區別 JVM總括四-類載入過程、雙親委派模型、物件例項化過程

JVM思考-init和clinit區別 目錄：JVM總括：目錄 clinit和init的區別其實也就是Class物件初始化物件初始化的區別，詳情看我上一篇部落格：  JVM總括四-類載入過程、雙親委派模型、物件例項化過程 一、init和clinit方法執行時機不同 　　init是物件構

JVM總括四-類載入過程、雙親委派模型、物件例項化過程

JVM總括四-類載入過程、雙親委派模型、物件例項化過程 目錄：JVM總括：目錄 一、 類載入過程 類載入過程就是將.class檔案轉化為Class物件， 類例項化 的過程 ，（User user = new User(); 這個過程是 物件例項化 的

Java類載入過程&&靜態程式碼塊的初始化過程

問題的引入        還是老規矩，先說說自己遇到的問題。 最近看到了一個比較有意思的Java程式，初次看到這段程式執行的結果還是挺讓我意外的，話不多說先上程式，大家也可以揣摩一下（大神自行略過......） class Singleton{

類載入過程(clinit())，物件例項化過程(init())

類載入過程： 1、類載入就是執行Java程式編譯之後在位元組碼檔案中生成的clinit()方法(稱之為類構造器)，clinit()方法由靜態變數和靜態程式碼塊組成。 2、子類的載入首先需要先載入父類，如果父類為介面。則不會呼叫父類的clinit方法。一個類中可以沒有clinit方法。 3、clinit方

Java子父類中的建構函式例項化過程

其實我們發現子類繼承父類操作很簡單，如果要是去深入的研究下會發現，例項化過程並非是我們看到的那樣，我們就以程式碼舉例來說明； 問大家，以下程式碼執行會輸出什麼呢？ package com.oop; /** * 定義動物物件 * @author

java類載入時機與過程

 “載入”(Loading)階段是“類載入”(Class Loading)過程的第一個階段，在此階段，虛擬機器需要完成以下三件事情：        1、 通過一個類的全限定名來獲取定義此類的二進位制位元組流。        2、 將這個位元組流所代表的靜態儲存結構轉化為方法區的執行時資料結構。  

Java類載入過程後，成員變數的初始化。

Java類的載入和成員變數初始化，建立物件的順序。 class X { Y b=new Y(); X() { System.out.println("X"); } } class Y { Y() { System.out.println("Y");

從一道面試題來認識java類載入時機與過程

說明:本文的內容是看了《深入理解Java虛擬機器：JVM高階特性與最佳實踐》後為加印象和理解，便記錄了重要的內容。 1  開門見山 以前曾經看到過一個java的面試題,當時覺得此題很簡單，可是自己把程式碼執行起來,可是結果並不是自己想象的那樣。題目如下: class SingleTon {

java中類載入與靜態變數、靜態方法與靜態程式碼塊詳解與初始化順序

我們知道java中類的生命週期為裝載、連線、初始化、使用和解除安裝五個過程，如下圖所示：1.載入     我們編寫一個java類的程式碼，經過編譯之後生成一個字尾名為.class的檔案，java虛擬機器就能識別這種檔案。java的生命週期就是class檔案從載入到消亡的過程。