JAVA 基礎之Static關鍵字和類加載

 問題一  ： 類什么時候被加載/類加載時機？？？：

有如下幾個類，我先運行TestA，再運行TestB，那么：

         class A：

public class A {
    public static int a = 6;
}

 

class TestA：

public class TestA {
    public static void main(String args[]) {
       A a = new A();
       a.a++;
       System.out.println(a.a);
    }
}

 

class TestB：

public class TestB {
    public static void main(String args[]) {
       A b = new A();
       System.out.println(b.a);
    }
}

 

（1）運行TestA的時候輸出的結果是什么？

  7

（2）運行TestB的時候輸出的結果是什么？

 6

（3）運行TestA和TestB的結果為什么相同或不相同？

兩段程序入口都是main,程序進入mian 后開始開始加載A類，加載過程中會給 a賦值， main函數結束，程序結束，釋放內存，第二次又是一個新的類加載過程。

 

 注意，如下特殊情況：

如下代碼

Java代碼

package test01;     
    
class FinalStatic {     
    
    public static final int A = 4 + 4;     
    
    static {     
        System.out.println("如果執行了，證明類初始化了……");     
    }     
    
}     
    
public class MyTest03 {     
    
    /**    
     * @param args    
     */    
    public static void main(String[] args) {     
        System.out.println(FinalStatic.A);     
    }     
    
}    

 

結果是只打印出了8，證明類並沒有初始化。反編譯源碼發現class里面的內容是

public static final int A = 8;

也就是說編譯器很智能的、在編譯的時候自己就能算出4+4是8，是一個固定的數字。沒有什么未知的因素在里面。

將代碼稍微改一下

public static final int A = 4 + new Random().nextInt(10);

這個時候靜態塊就執行了，證明類初始化了。在靜態final變量在編譯時不定的情況下。如果客戶程序這個時候訪問了該類的靜態變量，那就會對類進行初始化，所以盡量靜態final變量盡量沒什么可變因素在里面1，否則性能會有所下降。

 

---

 

問題 2 ： 類加載內部機制 ？：

原文出處 ： http://www.blogjava.net/GavinMiao/archive/2011/09/01/357739.html

 http://www.open-open.com/lib/view/open1352161045813.html

 

---

 

一個java文件從被加載到被卸載這個生命過程，總共要經歷4哥階段：

加載（即生成Class對象）->鏈接（驗證+准備+解析）（即相當於jvm編譯，會給類靜態變量默認值）->初始化（使用前的准備，也是部分初始化JAVA代碼開始，如構造函數，和類靜態變量的初始值）->使用->卸載

 

其中加載（除了自定義加載）+鏈接的過程是完全由jvm負責的，什么時候要對類進行初始化工作（加載+鏈接在此之前已經完成了），jvm有嚴格的規定（四種情況）：

1.遇到new，getstatic，putstatic，invokestatic這4條字節碼指令時，加入類還沒進行初始化，則馬上對其進行初始化工作。

其實就是3種情況：

　　a .用new實例化一個類時

　　b.讀取或者設置類的靜態字段時（不包括被final修飾的靜態字段，因為他們已經被塞進常量池了）

　　特殊情況：public static final int A = 4 + new Random().nextInt(10);//靜態final變量在編譯時不定的情況

　　c.以及執行靜態方法的時候。

2.使用java.lang.reflect.*的方法對類進行反射調用的時候，如果類還沒有進行過初始化，馬上對其進行。

3.初始化一個類的時候，如果他的父親還沒有被初始化，則先去初始化其父親。（不同於子類的構造方法，默認包含Super()方法一樣。）

4.當jvm啟動時，用戶需要指定一個要執行的主類（包含static void main(String[] args)的那個類），則jvm會先去初始化這個類。

以上4種預處理稱為對一個類進行主動的引用，其余的其他情況，稱為被動引用，都不會觸發類的初始化。下面也舉了些被動引用的例子：

 * 被動引用情景1
 * 通過子類引用父類的靜態字段，不會導致子類的初始化
 * @author volador
 *
 */
class SuperClass{
    static{
        System.out.println("super class init.");
    }
    public static int value=123;
}

class SubClass extends SuperClass{
    static{
        System.out.println("sub class init.");
    }
}

public class test{
    public static void main(String[]args){
        System.out.println(SubClass.value);
    }
    
}

 

輸出結果是：super class init。

 * 被動引用情景2
 * 通過數組引用來引用類，不會觸發此類的初始化
 * @author volador
 *
 */
public class test{
    public static void main(String[] args){
        SuperClass s_list=new SuperClass[10];
    }
}

 

輸出結果：沒輸出

 * 被動引用情景3
 * 常量在編譯階段會被存入調用類的常量池中，本質上並沒有引用到定義常量類類，所以自然不會觸發定義常量的類的初始化
 * @author root
 *
 */
class ConstClass{
    static{
        System.out.println("ConstClass init.");
    }
    public final static String value="hello";
}

public class test{
    public static void main(String[] args){
        System.out.println(ConstClass.value);
    }
}

 

輸出結果：hello（tip：在編譯的時候，ConstClass.value已經被轉變成hello常量放進test類的常量池里面了）

---

 

1. Classloader的作用，概括來說就是將編譯后的class裝載、加載到機器內存中，為了以后的程序的執行提供前提條件。

package test01;     
    
class Singleton {     
    
    public static Singleton singleton = new Singleton();     
    public static int a;     
    public static int b = 0;     
    
    private Singleton() {     
        super();     
        a++;     
        b++;     
    }     
    
    public static Singleton GetInstence() {     
        return singleton;     
    }     
    
}     
    
public class MyTest {     
    
    /**    
     * @param args    
     */    
    public static void main(String[] args) {     
        Singleton mysingleton = Singleton.GetInstence();     
        System.out.println(mysingleton.a);     
        System.out.println(mysingleton.b);     
    }     
    
}    

一般不假思索的結論就是，a=1,b=1。給出的原因是：a、b都是靜態變量，在構造函數調用的時候已經對a和b都加1了。答案就都是1。但是運行完后答案卻是a=1,b=0。

 

下面我們將代碼稍微變一下

Java代碼

 

1. public static Singleton singleton = new Singleton();     
2. public static int a;     
3. public static int b = 0;    

 

的代碼部分替換成

Java代碼

 

1. public static int a;     
2. public static int b = 0;     
3. public static Singleton singleton = new Singleton();    

 

效果就是剛才預期的a=1,b=1。

為什么呢，這3句無非就是靜態變量的聲明、初始化，值的變化和聲明的順序還有關系嗎?Java不是面向對象的嗎?怎么和結構化的語言似地，順序還有關系。這個就是和Java虛擬機JVM加載類的原理有着直接的關系。

1. 類在JVM中的工作原理

要想使用一個Java類為自己工作，必須經過以下幾個過程

1)：類加載load：從字節碼二進制文件——.class文件將類加載到內存，從而達到類的從硬盤上到內存上的一個遷移，所有的程序必須加載到內存才能工作。將內存中的class放到運行時數據區的方法區內，之后在堆區建立一個java.lang.Class對象，用來封裝方法區的數據結構。這個時候就體現出了萬事萬物皆對象了，干什么事情都得有個對象。就是到了最底層究竟是雞生蛋，還是蛋生雞呢?類加載的最終產物就是堆中的一個java.lang.Class對象。

2)：連接：連接又分為以下小步驟

驗證：出於安全性的考慮，驗證內存中的字節碼是否符合JVM的規范，類的結構規范、語義檢查、字節碼操作是否合法、這個是為了防止用戶自己建立一個非法的XX.class文件就進行工作了，或者是JVM版本沖突的問題，比如在JDK6下面編譯通過的class(其中包含注解特性的類)，是不能在JDK1.4的JVM下運行的。

准備：將類的靜態變量進行分配內存空間、初始化默認值。(對象還沒生成呢，所以這個時候沒有實例變量什么事情)

新分配的空間中，所有的原始類型將被置0（int類型為0，boolean類型為false等等），引用類型將被置成null;所以singleton 也是一個屬性,也被默認值為null

這階段會為類變量（指那些靜態變量）分配內存並設置類比那輛初始值的階段，這些內存在方法區中進行分配。這里要說明一下，這一步只會給那些靜態變量設置一個初始的值，而那些實例變量是在實例化對象時進行分配的。這里的給類變量設初始值跟類變量的賦值有點不同，比如下面：

public static int value=123;

在這一階段，value的值將會是0，而不是123，因為這個時候還沒開始執行任何java代碼，123還是不可見的，而我們所看到的把123賦值給value的putstatic指令是程序被編譯后存在於<clinit>()，所以，給value賦值為123是在初始化的時候才會執行的。

這里也有個例外：

public static final int value=123;

這里在准備階段value的值就會初始化為123了。這個是說，在編譯期，javac（還是JVM?答案：http://blog.csdn.net/cutesource/article/details/5904542）會為這個特殊的value生成一個ConstantValue屬性，並在准備階段jm就會根據這個ConstantValue的值來為value賦值了。即編譯的時候，就將該值或者是對象放入常量池。

注：java程序要運行需要兩次編譯，一次是javac,而次是jvm。第一次也是過程中就包含常量池。

解析：把類的符號引用轉為直接引用(保留)

3)：類的初始化： 將類的靜態變量賦予正確的初始值，這個初始值是開發者自己定義時賦予的初始值，而不是默認值。

2. 類的主動使用與被動使用

以下是視為主動使用一個類，其他情況均視為被動使用!

1)：初學者最為常用的new一個類的實例對象(聲明不叫主動使用)

2)：對類的靜態變量進行讀取、賦值操作的。(靜態,final且值確定是常量,是編譯時確定的，調用的時候直接用，不會加載對應的類)

3)：直接調用類的靜態方法。

4)：反射調用一個類的方法。

5)：初始化一個類的子類的時候，父類也相當於被程序主動調用了(如果調用子類的靜態變量是從父類繼承過來並沒有復寫的，那么也就相當於只用到了父類的東東，和子類無關，所以這個時候子類不需要進行類初始化)。

6)：直接運行一個main函數入口的類。

所有的JVM實現(不同的廠商有不同的實現，有人就說IBM的實現比Sun的要好……)在首次主動調用類和接口的時候才會初始化他們。

 

 

 

 

1. 類的加載方式

1)：本地編譯好的class中直接加載

2)：網絡加載：java.net.URLClassLoader可以加載url指定的類(即網絡下載字節碼，並加載)

3)：從jar、zip等等壓縮文件加載類，自動解析jar文件找到class文件去加載util類

4)：從java源代碼文件動態編譯成為class文件（動態生成字節碼）

2. 類加載器

JVM自帶的默認加載器

1)：根類加載器：bootstrap，由C++編寫，所有Java程序無法獲得。

2)：擴展類加載器：由Java編寫。

3)：系統類、應用類加載器：由Java編寫。

用戶自定義的類加載器：java.lang.ClassLoader的子類，用戶可以定制類的加載方式。每一個類都包含了加載他的ClassLoader的一個引用——getClass().getClassLoader()。如果返回的是null，證明加載他的ClassLoader是根加載器bootstrap。

如下代碼

 

 

這里面的指針就是C++的指針

1. 回顧那個詭異的代碼

從入口開始看

Singleton mysingleton = Singleton.GetInstence();

是根據內部類的靜態方法要一個Singleton實例。

這個時候就屬於主動調用Singleton類了。

之后內存開始加載Singleton類

1)：對Singleton的所有的靜態變量分配空間，賦默認的值，所以在這個時候，singleton=null、a=0、b=0。注意b的0是默認值，並不是咱們手工為其賦予的的那個0值。

2)：之后對靜態變量賦值，這個時候的賦值就是我們在程序里手工初始化的那個值了。此時singleton = new Singleton();調用了構造方法。構造方法里面a=1、b=1。之后接着順序往下執行。

3)：

 

1. public static int a;  
2.  
3.     public static int b = 0;  

 

a沒有賦值，保持原狀a=1。b被賦值了，b原先的1值被覆蓋了，b=0。所以結果就是這么來的。類中的靜態塊static塊也是順序地從上到下執行的。

---

2. 編譯時常量、非編譯時常量的靜態變量

如下代碼

Java代碼

1. package test01;     
2.     
3. class FinalStatic {     
4.     
5.     public static final int A = 4 + 4;     
6.     
7.     static {     
8.         System.out.println("如果執行了，證明類初始化了……");     
9.     }     
10.     
11. }     
12.     
13. public class MyTest03 {     
14.     
15.     /**    
16.      * @param args    
17.      */    
18.     public static void main(String[] args) {     
19.         System.out.println(FinalStatic.A);     
20.     }     
21.     
22. }    

 

結果是只打印出了8，證明類並沒有初始化。反編譯源碼發現class里面的內容是

public static final int A = 8;

也就是說編譯器很智能的、在編譯的時候自己就能算出4+4是8，是一個固定的數字。沒有什么未知的因素在里面。

將代碼稍微改一下

public static final int A = 4 + new Random().nextInt(10);//靜態final變量在編譯時不定的情況

//思考　什么是常量？　什么樣的靜態變量被放進常量池？　

//java文件編譯成class　再編譯成本機可執行的代碼。

同時分析下　:

用final修飾就是代表常量，當常量被設定后，一般情況下就不允許再進行更改

public static final int A = 4 + new Random().nextInt(10);（變量，類常亮）（JVM編譯階段，不會進入常量池）

public final int A = 4 + new Random().nextInt(10);（變量，對象常量）（JVM編譯階段，不會進入常量池）

public final int A = 4 + 4;（恆量，無論程序運行多少次，。值都不變）（JVM編譯階段，會進入常量池）

 

這個時候靜態塊就執行了，證明類初始化了。在靜態final變量在編譯時不定的情況下。如果客戶程序這個時候訪問了該類的靜態變量，那就會對類進行初始化，所以盡量靜態final變量盡量沒什么可變因素在里面1，否則性能會有所下降。

1. ClassLoader的剖析