Paramètres variables Java (Varargs)

Dans cet article, vous apprendrez les arguments variables (Varargs) en Java à travers des exemples. Vous découvrirez également quand utiliser les varargs et quand ne pas les utiliser.

Qu'est-ce que les varargs en Java ?

Supposons que vous créiezJava Methods. Mais vous ne savez pas combien de paramètres votre méthode recevra. Pour résoudre ce problème, Java 1.5Les varargs ont été introduits.

Varargs est l'abréviation de "variable arguments". En Java, les paramètres d'une méthode peuvent accepter un nombre quelconque de valeurs. Un paramètre acceptant un nombre variable de valeurs est appelé varargs.

La syntaxe pour implémenter les varargs est la suivante :

accessModifier methodName(datatype… arg) {
　　　　//　Corps de la méthode
}

Pour définir un vararg, utilisez des points (…) dans les paramètres de la méthode.

Les méthodes acceptant un nombre variable de paramètres sont appelées méthodes à paramètres variables, ou simplement varargs.

D'abord, regardons un exemple sans utiliser de varargs :

class NoVararg {
　　　　public int sumNumber(int a, int b){
　　　　　　　　return a+b;
　　　　}
　　　　public int sumNumber(int a, int b, int c){
　　　　　　　　return a+b;+c;
　　　　}
　　　　public static void main( String[] args ) {
　　　　　　　　NoVararg obj = new NoVararg();
　　　　　　　　System.out.println(obj.sumNumber(1,　2));
　　　　　　　　System.out.println(obj.sumNumber(1,　2,　3));
　　　　}
}

Lorsque vous exécutez ce programme, la sortie sera :

3
6

Comme vous le voyez, il est nécessaire de redéfinir la méthode sumNumber() pour qu'elle soit applicable à3paramètres.

si l'utilisateur souhaite ajouter5un nombre ou10ou10Que faire si on a 0 ?

L'utilisation des varargs permet de résoudre ce problème de manière concise. Voici un exemple de code :

Exemple : démonstration de l'utilisation des arguments variables

class VarargExample {
　　　　public int sumNumber(int ... args){
　　　　　　　　System.out.println("Longueur des paramètres : "　+　args.length);
　　　　　　　　int sum = 0;
　　　　　　　　for(int x: args){
　　　　　　　　　　　　sum　+=
　　　　　　　　}
　　　　　　　　return sum;
　　　　}
　　　　public static void main( String[] args ) {
　　　　　　　　VarargExample ex = new VarargExample();
　　　　　　　　int sum2　=2,　4);
　　　　　　　　System.out.println("sum2　=　+　sum2);
　　　　　　　　int sum3　=1,　3,　5);
　　　　　　　　System.out.println("sum3　=　+　sum3);
　　　　　　　　int sum4　=1,　3,　5,　7);
　　　　　　　　System.out.println("sum4　=　+　sum4);
　　　　}
}

Lors de l'exécution du programme, la sortie est :

Longueur des paramètres :　2
sum2　=　6
Longueur des paramètres :　3
sum3　=　9
Longueur des paramètres :　4
sum4　=　16

Ici, la méthode sumNumber() retourne la somme des paramètres int passés (indépendamment du nombre de paramètres passés).

Comme vous le voyez, les varargs sont très utiles dans certains cas. Mais si vous êtes sûr du nombre de paramètres passés à la méthode, utilisez plutôt la surcharge de méthode. Par exemple, si vous êtes sûr que la méthode sumNumber() est utilisée uniquement pour calculer2ou3somme des paramètres, utilisez la surcharge comme dans le premier exemple.

Voici un autre exemple. La méthode format() définie dans la bibliothèque Java accepte des varargs. Dans JDK, la méthode format() est définie comme suit :

public static String format(Locale l, String format, Object... args) {
　　　　//　corps
}

Exemple : méthode format()

class Company {
　　　　public static void main(String[] args) {
　　　　　　　　String siteName = "oldtoolbag.com";
　　　　　　　　int empCount =　6;
　　　　　　　　String type = "Site de tutoriel";
　　　　　　　　System.out.println(
　　　　　　　　　　　　　　　　String.format(
　　　　　　　　　　　　　　　　　　　　　　　　"Nom du site : %s, Emp Count: %d Type: %s",
　　　　　　　　　　　　　　　　　　　　　　　　siteName, empCount, type
　　　　　　　　　　　　　　　　)
　　　　　　　　);
　　　　}
}

Lors de l'exécution du programme, la sortie est :

Nom du site : oldtoolbag.com, Emp Count :　6　Type : Site de tutoriel

Comment fonctionne un paramètre variable en arrière-plan ?

Voyons le pseudo-code suivant :

public int sumNumber(int ... nums) {
　　　　//　Corps de la méthode
}

... La syntaxe indique au compilateur Java qu'il peut utiliser zéro ou plusieurs paramètres pour appeler cette méthode. En conséquence, la variable nums est implicitement déclarée comme int [].TableauPar conséquent, à l'intérieur de la méthode, utilisez la syntaxe d'array pour accéder à la variable nums.

Si il n'y a pas de paramètres, la longueur de nums est de 0.

Surcharge de méthode Varargs

Comme pour une méthode typique, vous pouvez surcharger une méthode vararg.

Exemple : surcharge de méthode Varargs

class VarargOverload {}}
　　　　private void test(int ... args){
　　　　　　　　int sum = 0;
　　　　　　　　for (int i: args) {
　　　　　　　　　　　　sum　+= i;
　　　　　　　　}
　　　　　　　　System.out.println("sum = "　+　sum);
　　　　}
　　　　private void test(boolean p, String ... args){
　　　　　　　　boolean negate = !p;
　　　　　　　　System.out.println("negate = "　+　negate);
　　　　　　　　System.out.println("args.length = "+　args.length);
　　　　}
　　　　public static void main( String[] args ) {
　　　　　　　　VarargOverload obj = new VarargOverload();
　　　　　　　　obj.test(1,　2,　3);
　　　　　　　　obj.test(true, "hello", "world");
　　　　}
}

Lors de l'exécution du programme, la sortie est :

sum =　6
negate = false
args.length =　2

Dans le programme ci-dessus, la méthode test() est surchargée en changeant le nombre de paramètres acceptés.

Ce sont les choses à retenir lors de l'utilisation de Varargs

Voici quelques choses à retenir lors de l'utilisation de Java Varargs :

1.Assurez-vous d'indiquer, lors de la définition de la signature de la méthode, queConserverEnfin, varargs.

Les paramètres variables doivent être le dernier paramètre passé à la méthode. Considérez, par exemple, que vous avez appelé la méthode doSomething() suivante :

doSomething(1,　2,　3,　4);

Et, la définition de votre méthode doSomething() est :

//Déclaration de méthode incorrecte
public void doSomething(int ... nums, int p){
　　　　//　method body
}

Dans ce cas, le compilateur ne peut pas déterminer le nombre de paramètres passés à nums.

Mais si la méthode est définie comme suit :

public void doSomething(int p, int ... nums) {
　　　　//　method body
}

Le compilateur Java attribue le premier paramètre à p, et les autres paramètres int à nums.

2Une méthode ne peut avoir qu'un seul paramètre varargs.

Par exemple, la déclaration de cette méthode est incorrecte :

int doSomething(int p, float ... floatNums, double ... doubleNums) {
　　　　//　code
}

Ambiguity in Varargs Method Overloading

Let's look at such an overloaded test() method:

class Demo {　
　　
　　　　static void test(int ... vargs) {
　　　　　　　　//　method body
　　　　}
　　　　
　　　　static void test(int n, int ... vargs) {
　　　　　　　　//　method body
　　　　}
}

In the above program, even if you try to call the test() method, even if the test() method is overloaded and accepts a different number of parameters, the compiler may be confused.

The compiler does not know which method to call. The compiler may think that you are trying to call test(int ... vargs) using a varargs parameter. Similarly, the compiler may think that you are trying to call test(int n, int ... vargs) using the parameters passed to the first argument, while the second argument is empty.

Due to two possibilities, ambiguity may arise. Therefore, you may need to use two different method names instead of overloading varargs methods.