Java, 3 points dans les paramètres

Cela signifie que zéro, un ou plusieurs objets de Chaîne (ou un tableau d'entre eux) peut être passé comme argument(s) pour cette méthode.

Voir le "Nombre Arbitraire d'Arguments" article ici: http://java.sun.com/docs/books/tutorial/java/javaOO/arguments.html#varargs

Dans votre exemple, vous pouvez l'appeler comme les suivantes:

myMethod(); //Likely useless, but possible
myMethod("one", "two", "three");
myMethod("solo");
myMethod(new String[]{"a", "b", "c"});

Remarque importante: L'argument(s) passée dans cette voie est toujours un tableau - même si il y a juste un. Assurez-vous de le traiter de cette façon dans le corps de la méthode.

Note importante 2: L'argument qui obtient le ... doit être le dernier de la signature de la méthode. Donc, myMethod(int i, String... strings) est correct, mais myMethod(String... strings, int i) n'est pas correct.

Grâce à Vash'pour les précisions dans son commentaire.

C'est Varargs 🙂

Les varargs court de longueur variable d'arguments est une fonctionnalité qui permet à la méthode d'accepter un nombre variable d'arguments (zéro ou plus). Avec varargs, il est devenu simple de créer des méthodes qui ont besoin de prendre un nombre variable d'arguments. La fonction de la variable d'argument a été ajoutée dans Java 5.

Syntaxe de varargs

Un vararg est secified par trois points de suspension (trois points) après le type de données, sa forme générale est

return_type method_name(data_type ... variableName){
}  

Besoin pour varargs

Avant Java 5, dans le cas où il était nécessaire de nombre variable d'arguments, il y avait deux façons de le gérer

Si le nombre maximum d'arguments, une méthode peut prendre était de petite taille et connue, puis des versions surchargées de la méthode pourrait être créé.
Si le nombre maximal d'arguments d'une méthode pourrait prendre soit de grande ou/et de l'inconnu, alors l'approche a été de mettre ces arguments dans un tableau et de les transmettre à une méthode qui prend du tableau comme paramètre.
Ces 2 approches sont sujettes à l'erreur - la construction d'un tableau de paramètres à chaque fois et difficile à maintenir - l'ajout de nouvelles argument peut entraîner à l'écriture d'une nouvelle méthode surchargée.

Avantages de varargs

Offre beaucoup plus simple option.
Moins de code que pas besoin d'écrire des méthodes surchargées.

Exemple de varargs

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

Il peut être vu à partir du programme que la longueur est utilisée ici pour trouver le nombre d'arguments passés à la méthode. Il est possible que parce que varargs sont implicitement passé comme un tableau. Quels que soient les arguments sont passés comme varargs sont stockées dans un tableau qui est désigné par le nom donné à varargs. Dans ce programme, le nom du tableau sont les valeurs.
Notez également que la méthode est appelée avec un nombre différent de l'argument, le premier appel avec quatre arguments, puis trois arguments, puis avec des arguments zéro. Tous ces appels sont gérés par la même méthode qui prend varargs.

De Restriction avec les varargs

Il est possible d'avoir d'autres paramètres avec des varargs paramètre d'une méthode, mais dans ce cas, varargs paramètre doit être le dernier paramètre déclaré par la méthode.

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

Un autre restriction avec varargs est qu'il doit y avoir un seul varargs paramètre.

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

Surcharge varargs Méthodes

Il est possible de surcharger une méthode qui prend varargs paramètre.
Varargs méthode peut être surchargé par

Types de son vararg paramètre peut être différent.
En ajoutant d'autres paramètres.
Exemple de surcharge varargs méthode

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 

Varargs et la surcharge de l'ambiguïté

Dans certains cas, l'appel peut être ambiguë, alors que nous avons surchargé varargs méthode.
Voyons un exemple

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();
 }
}

Dans ce programme lorsque nous faisons un appel à displayData() la méthode sans paramètre, il déclenche une erreur, car le compilateur n'est pas sûr que l'appel de cette méthode est pour displayData(String ... values) ou displayData(int ... values)

Même façon, si nous avons des méthodes surchargées où l'on a le vararg méthode d'un type et d'une autre méthode a un paramètre et vararg paramètre du même type, puis nous avons aussi de l'ambiguïté -
Comme Exp -
displayData(int ... values) et displayData(int a, int ... values)

Ces deux méthodes surchargées aura toujours de l'ambiguïté.

Sans doute, c'est un exemple du sucre syntaxique, puisqu'il est mis en œuvre comme un tableau de toute façon (ce qui ne veut pas dire que c'est inutile) - je préfère le passage d'un tableau à tenir à l'écart, et également déclarer les méthodes avec des tableaux de type donné. Plutôt un avis qu'une réponse, si.

Également à jeter un peu de lumière, il est important de savoir que var-arg paramètres sont limités à un seul et vous ne pouvez pas avoir plusieurs var-art params. Par exemple c'est illigal:

public void myMethod(String... strings, int ... ints){
//method body
}

String... est le même que String[]

import java.lang.*;

        public class MyClassTest {

        //public static void main(String... args) { 

        public static void main(String[] args) {
        for(String str: args) {
        System.out.println(str);

        }
        }
        }