許多Java新人在看到下面的這段程式碼的時候，都會問一個問題：dealArray方法裡那三個小點點是什麼啊？

1. publicclass TestVarArgus {  
2.     publicstaticvoid dealArray(int... intArray){  
3.     }  
4.     publicstaticvoid main(String args[]){  
5.     }  
6. }  

這就是今天這篇blog的主角：可變的引數型別，也稱為不定引數型別。英文縮寫是varargus，還原一下就是variable argument type。通過它的名字可以很直接地看出來，這個方法在接收引數的時候，個數是不定的。那麼好，現在就先來呼叫下這個方法。請看程式碼和輸出：

1. publicclass TestVarArgus {  
2.     publicstaticvoid dealArray(int... intArray){  
3.         for (int i : intArray)  
4.             System.out.print(i +" ");  
5.         System.out.println();  
6.     }  
7.     publicstaticvoid main(String args[]){  
8.         dealArray();  
9.         dealArray(1);  
10.         dealArray(1
    , 2, 3);  
11.     }  
12. }  

輸出：

1. 1
2. 123

通過main方法裡的呼叫，可以看出來這個可變引數既可以是沒有引數（空引數），也可以是不定長的。看到這裡估計都能明白，這個不定長的引數其實和陣列引數挺像的。事實上，也確實是這麼回事兒。編譯器會在悄悄地把這最後一個形參轉化為一個數組形參，並在編譯出的class檔案裡作上一個記號，表明這是個實參個數可變的方法。請看程式碼：

1. dealArray(); //dealArray(int[] intArray{});
2.         dealArray(1); //dealArray(int[] intArray{1});
3.         dealArray(1
   , 2, 3); //dealArray(int[] intArray{1, 2, 3});

說到這裡，那麼可以來驗證一下，看看是不是這個可變引數就是陣列類引數？看程式碼：

1. publicclass TestVarArgus {  
2.     publicstaticvoid dealArray(int... intArray){  
3.         for (int i : intArray)  
4.             System.out.print(i +" ");  
5.         System.out.println();  
6.     }  
7.     publicstaticvoid dealArray(int[] intArray){//會有Duplicate method dealArray(int[]) in type TestVarArgus的錯誤
8.         for (int i : intArray)  
9.             System.out.print(i +" ");  
10.         System.out.println();  
11.     }  
12.     publicstaticvoid main(String args[]){  
13.         dealArray();   
14.         dealArray(1);  
15.         dealArray(1, 2, 3);  
16.     }  
17. }  

從上面這段程式碼可以看出，這兩個方法是衝突的，是無法過載的。到這裡，再來做一個有意思的實驗：

1. publicclass TestVarArgus {  
2.     publicstaticvoid dealArray(int... intArray){  
3.         for (int i : intArray)  
4.             System.out.print(i +" ");  
5.         System.out.println();  
6.     }  
7.     publicstaticvoid main(String args[]){  
8.         int[] intArray = {1, 2, 3};  
9.         dealArray(intArray);  //通過編譯，正常執行
10.     }  
11. }  

1. publicclass TestVarArgus {  
2.     publicstaticvoid dealArray(int[] intArray){  
3.         for (int i : intArray)  
4.             System.out.print(i +" ");  
5.         System.out.println();  
6.     }  
7.     publicstaticvoid main(String args[]){  
8.         dealArray(1, 2, 3);  //編譯錯誤
9.     }  
10. }  

從上面這兩段程式碼可以看出來，可變引數是相容陣列類引數的，但是陣列類引數卻無法相容可變引數。其實對於第二段程式碼而言，編譯器並不知道什麼可變不可變，在它看來，需要定義一個dealArray(int, int, int）類的方法。所以，自然就無法去匹配陣列類引數的dealArray方法了。

寫不完了，吃完午飯，下午繼續...

吃好午飯，睡了一會兒，繼續上午的話題，接下來談一下Java的可變引數。

既然Java方法接收可變引數，那麼接下來我們再來看一下下面的程式碼：

1. publicclass TestVarArgus {  
2.     publicstaticvoid dealArray(int count, int... intArray){  
3.     }  
4.     publicstaticvoid dealArray(int... intArray, int count){//編譯報錯，可變引數型別應該作為引數列表的最後一項
5.     }  
6.     publicstaticvoid main(String args[]){  
7.     }  
8. }  

這段程式碼說明了，可變引數型別必須作為引數列表的最後一項，而不能放在定長引數的前面。估計你會想到一個詞“優先順序”。因為沒有確切的說明，只是這樣一種規定，這裡可以借用“優先順序”這個詞來理解一下，請看下面的程式碼：

1. publicclass TestVarArgus {  
2.     publicstaticvoid dealArray(int... intArray){  
3.         System.out.println("1");  
4.     }  
5.     publicstaticvoid dealArray(int count, int count2){  
6.         System.out.println("2");  
7.     }  
8.     publicstaticvoid main(String args[]){  
9.         dealArray(1, 2);  
10.     }  
11. }  

程式碼貼出來估計都知道是輸出2，而不是1。記住：能匹配定長的方法，那麼優先匹配該方法。含有不定引數的那個過載方法是最後被選中的。

最後，大家都知道main方法的引數就是一個數組型別的，那麼它其實也是可以改成不定引數型別。試一試吧，看看有沒有編譯錯誤。