语法: (三点…)——>表示我们可以添加0个或多个对象，传递参数或传递object类型的数组。

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

定义: 1)对象…参数只是一个对象数组的引用。

2) ('String[]'或String…)它可以处理任意数量的字符串对象。在内部，它使用引用类型object的数组。

i.e. Suppose we pass an Object array to the ... argument - will the resultant argument value be a two-dimensional array - because an Object[] is itself an Object:

3)如果你想用一个参数调用方法，而它恰好是一个数组，你必须显式地将它包装起来

another. method(new Object[]{array}); 
OR 
method((Object)array), which will auto-wrap.

应用程序: 它主要用于参数数量是动态的(运行时知道的参数数量)和覆盖的情况。 一般规则-在方法中，我们可以传递任意类型和任意数量的参数。我们不能在任何特定参数之前添加object(…)参数。 即。

void m1(String ..., String s) this is a wrong approach give syntax error.
void m1(String s, String ...); This is a right approach. Must always give last order prefernces.   

可以说，它是语法糖的一个例子，因为它无论如何都是作为一个数组实现的(这并不意味着它是无用的)——我更喜欢传递一个数组以保持它的清晰，并声明具有给定类型的数组的方法。不过，与其说是回答，不如说是意见。

它是Varargs:)

varargs是可变长度参数的缩写，它允许方法接受可变数量的参数(零或更多)。使用可变参数，创建需要接受可变数量参数的方法变得很简单。Java 5中增加了变量参数的特性。

可变参数的语法

可变参数由数据类型后的三个省略号(三个点)表示，其一般形式为

return_type method_name(data_type ... variableName){
}  

需要可变参数

在Java 5之前，如果需要可变数量的参数，有两种方法来处理它

If the max number of arguments, a method can take was small and known, then overloaded versions of the method could be created. If the maximum number of arguments a method could take was large or/and unknown then the approach was to put those arguments in an array and pass them to a method which takes array as a parameter. These 2 approaches were error-prone - constructing an array of parameters every time and difficult to maintain - as the addition of new argument may result in writing a new overloaded method.

可变参数的优点

提供了一个更简单的选项。 更少的代码，因为不需要编写重载方法。

可变参数的例子

public class VarargsExample {
 public void displayData(String ... values){
  System.out.println("Number of arguments passed " + values.length);
  for(String s : values){
   System.out.println(s + " ");
  }
 }

 public static void main(String[] args) {
  VarargsExample vObj = new VarargsExample();
  // four args
  vObj.displayData("var", "args", "are", "passed");
  //three args
  vObj.displayData("Three", "args", "passed");
  // no-arg
  vObj.displayData();
 }
}
Output

Number of arguments passed 4
var 
args 
are 
passed 
Number of arguments passed 3
Three 
args 
passed 
Number of arguments passed 0

It can be seen from the program that length is used here to find the number of arguments passed to the method. It is possible because varargs are implicitly passed as an array. Whatever arguments are passed as varargs are stored in an array which is referred by the name given to varargs. In this program array name is values. Also note that method is called with different number of argument, first call with four arguments, then three arguments and then with zero arguments. All these calls are handled by the same method which takes varargs.

使用可变参数的限制

在方法中也可以使用其他参数，但在这种情况下，varargs参数必须是方法声明的最后一个参数。

void displayValues(int a, int b, int … values) // OK
   void displayValues(int a, int b, int … values, int c) // compiler error

使用可变参数的另一个限制是只能有一个可变参数。

void displayValues(int a, int b, int … values, int … moreValues) // Compiler error

重载可变参数方法

重载一个接受可变参数的方法是可能的。 可变参数方法可以通过-重载

其变量参数的类型可以不同。 通过添加其他参数。 重载可变参数方法的例子

public class OverloadingVarargsExp {
 // Method which has string vararg parameter
 public void displayData(String ... values){
  System.out.println("Number of arguments passed " + values.length);
  for(String s : values){
   System.out.println(s + " ");
  }
 }

 // Method which has int vararg parameter
 public void displayData(int ... values){
  System.out.println("Number of arguments passed " + values.length);
  for(int i : values){
   System.out.println(i + " ");
  }
 }

 // Method with int vararg and one more string parameter
 public void displayData(String a, int ... values){
  System.out.println(" a " + a);
  System.out.println("Number of arguments passed " + values.length);
  for(int i : values){
   System.out.println(i + " ");
  }
 }

 public static void main(String[] args) {
  OverloadingVarargsExp vObj = new OverloadingVarargsExp();
  // four string args
  vObj.displayData("var", "args", "are", "passed");

  // two int args
  vObj.displayData(10, 20);

  // One String param and two int args
  vObj.displayData("Test", 20, 30);
 }
}
Output

Number of arguments passed 4
var 
args 
are 
passed 

Number of arguments passed 2
10 
20

 a Test
Number of arguments passed 2
20 
30 

可变参数和重载歧义

在某些情况下，当我们重载可变参数方法时，调用可能是模棱两可的。 让我们看一个例子

public class OverloadingVarargsExp {
 // Method which has string vararg parameter
 public void displayData(String ... values){
  System.out.println("Number of arguments passed " + values.length);
  for(String s : values){
   System.out.println(s + " ");
  }
 }

 // Method which has int vararg parameter
 public void displayData(int ... values){
  System.out.println("Number of arguments passed " + values.length);
  for(int i : values){
   System.out.println(i + " ");
  }
 }

 public static void main(String[] args) {
  OverloadingVarargsExp vObj = new OverloadingVarargsExp();
  // four string args
  vObj.displayData("var", "args", "are", "passed");

  // two int args
  vObj.displayData(10, 20);

  // This call is ambiguous
  vObj.displayData();
 }
}

在这个程序中，当我们调用没有任何参数的displayData()方法时，它会抛出错误，因为编译器不确定这个方法调用是否用于displayData(String…或者displayData(int…值)

同样，如果我们有重载方法，其中一个方法有一种类型的可变参数方法，而另一个方法有一个参数和同一类型的可变参数参数，那么我们也有歧义- As Exp - displayData (int…displayData(int a, int…)值)

这两个重载的方法总是有歧义。

这个特性叫做可变参数，是Java 5中引入的一个特性。这意味着函数可以接收多个String参数:

myMethod("foo", "bar");
myMethod("foo", "bar", "baz");
myMethod(new String[]{"foo", "var", "baz"}); // you can even pass an array

然后，你可以使用String变量作为数组:

public void myMethod(String... strings) {
    for (String whatever : strings) {
        // do what ever you want
    }

    // the code above is equivalent to
    for (int i = 0; i < strings.length; i++) {
        // classical for. In this case you use strings[i]
    }
}

这个答案很大程度上借鉴了kiswa和Lorenzo的……也来自Graphain的评论。

只要把它想象成c#中的关键字params，如果你来自那个背景的话:)

语法: (三点…)——>表示我们可以添加0个或多个对象，传递参数或传递object类型的数组。

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

定义: 1)对象…参数只是一个对象数组的引用。

2) ('String[]'或String…)它可以处理任意数量的字符串对象。在内部，它使用引用类型object的数组。

i.e. Suppose we pass an Object array to the ... argument - will the resultant argument value be a two-dimensional array - because an Object[] is itself an Object:

3)如果你想用一个参数调用方法，而它恰好是一个数组，你必须显式地将它包装起来

another. method(new Object[]{array}); 
OR 
method((Object)array), which will auto-wrap.

应用程序: 它主要用于参数数量是动态的(运行时知道的参数数量)和覆盖的情况。 一般规则-在方法中，我们可以传递任意类型和任意数量的参数。我们不能在任何特定参数之前添加object(…)参数。 即。

void m1(String ..., String s) this is a wrong approach give syntax error.
void m1(String s, String ...); This is a right approach. Must always give last order prefernces.