java不定參數String... args

先看兩個簡單的例子,來感覺一下Java的不定長度參數 
第一個例子: 
數組

Java代碼  收藏代碼spa

  1. public class VariArgs {  .net

  2.   

  3.     public static void main(String[] args) {  blog

  4.         test();  字符串

  5.         test("aaa");  get

  6.         test("aaa""bbb");  編譯器

  7.         test("aaa""bbb""ccc");  it

  8.     }  編譯

  9.   

  10.     public static void test(String... args) {  class

  11.         System.out.println(args.getClass());  

  12.         for (String arg : args) {  

  13.             System.out.println(arg);  

  14.         }  

  15.     }  

  16. }  


第二個例子: 

Java代碼  收藏代碼

  1. public class VariArgs {  

  2.   

  3.     public static void main(String[] args) {  

  4.         test("aaa");  

  5.         test("aaa""bbb");  

  6.         test("aaa""bbb""ccc");  

  7.     }  

  8.   

  9.     public static void test(String arg, String... args) {  

  10.         System.out.println(arg);  

  11.         System.out.println("----------------");  

  12.         for (String s : args) {  

  13.             System.out.println(s);  

  14.         }  

  15.     }  

  16. }  


   讀者能夠本身運行一下,這個不定長度參數的類型爲String[],即字符串數組。 
從上面能夠看出,若是一個方法的參數定爲不定參數的話,這個參數能夠根據參數個數動態生成一個數組,而後傳入方法執行。 
    不過,不定參數有兩個規定第一,方法的參數列表中最多隻有一個不定長度的參數;第二,就是不定長度的數組的位置必須是最後一個參數。否則不能經過編譯。 
    對於第一個規定,是由於若是有多於一個不定長度的參數,當真正調用這個方法的時候,JVM、將不知道前面的不定長度參數有多長, 下一個參數是從哪裏開始. 
    對於第二個參數也是同樣,編譯器不知道不定長度參數的長度,沒法肯定從哪裏開始下一個參數。 
    如下是幾種不正確使用不定長度參數的例子,請不要這樣寫程序: 

Java代碼  收藏代碼

  1. public static void test(Object... objs, Object obj);  

  2.   

  3. public static void test(Object obj1, Object... objs, Object obj2);  

  4.   

  5. public static void test(Object... objs1, Object... objs2);  


   不定參數的方法能夠重載。(你們都知道,重載就是方法名相同,而方法的參數列表不一樣) 
   下面給出重載的示例: 

Java代碼  收藏代碼

  1. public class VariArgs {  

  2.   

  3.     public static void main(String[] args) {  

  4.         test("aaa");  

  5.         test("aaa""bbb");  

  6.         test("aaa""bbb""ccc");  

  7.     }  

  8.   

  9.     public static void test(Object... args) {  

  10.     }  

  11.   

  12.     public static void test(String arg, String... args) {  

  13.     }  

  14. }  


   讀者若是細心的話,能夠看出文章開頭給出的兩個例子的區別,就是第二個例子比第一個例子的test方法的參數多出了一個String arg,從感受上沒有太大的區別,這有點像編譯原理的*和+的區別。第一個test方法指能夠有0或N個String作參數,但第二個test方法指至少一個String作爲參數。 
   而後結合重載來看,把第一個例子和第二個例子合併成一個類,獲得如下代碼: 

Java代碼  收藏代碼

  1. public class VariArgs {  

  2.   

  3.     public static void main(String[] args) {  

  4.         test();  

  5.         test("aaa");  

  6.         test("aaa""bbb");  

  7.         test("aaa""bbb""ccc");  

  8.     }  

  9.   

  10.     public static void test(String... args) {  

  11.         System.out.println(args.getClass());  

  12.         for (String arg : args) {  

  13.             System.out.println(arg);  

  14.         }  

  15.     }  

  16.   

  17.     public static void test(String arg, String... args) {  

  18.         System.out.println(arg);  

  19.         System.out.println("----------------");  

  20.         for (String s : args) {  

  21.             System.out.println(s);  

  22.         }  

  23.     }  

  24. }  


    讀者能夠編譯下這個程序,結果是編譯不經過。爲何呢?程序編譯到第五行時,不能肯定test("aaa")該用第10行的test方法仍是第17行的方法,由於兩個方法均可以有相同的參數列表。都能精確匹配上參數列表,編譯器在這種狀況下只好報出編譯不能經過的錯誤。因此在重載這樣的方法時,注意參數列表,不要使兩個方法能夠有一樣的參數列表。

相關文章
相關標籤/搜索