Parametri variabili Java (Varargs)

In questo articolo, imparerai Java varargs attraverso esempi. Inoltre, imparerai quando utilizzare varargs e quando non farlo.

Cos'è varargs in Java?

Supponiamo che tu stia creandoMetodi JavaMa non sei sicuro di quante argomenti il tuo metodo accetterà. Per risolvere questo problema, Java 1.5 ha introdotto varargs.

Varargs è l'abbreviazione di parametri variabili. In Java, i parametri di un metodo possono accettare un numero qualsiasi di valori. Il parametro che accetta una quantità variabile di valori è chiamato varargs.

La sintassi per implementare i varargs è la seguente:

accessModifier methodName(datatype … arg) {
　　　　// Corpo del metodo
}

Per definire un vararg, usare i tre punti (...) nei parametri della forma del metodo.

Un metodo che accetta una quantità variabile di parametri si chiama metodo a variabili numerose, o semplicemente metodo varargs.

Prima di tutto, diamo un'occhiata a un esempio senza l'uso dei 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));
　　　　}
}

Quando eseguite il programma, l'output sarà:

3
6

Come potete vedere, è necessario sovraccaricare il metodo sumNumber() per renderlo compatibile con 3 parametri.

Cosa fare se l'utente vuole aggiungere 5 numeri o 10 o 100?

L'uso dei varargs permette di affrontare questo problema in modo conciso. Vediamo un esempio di codice:

Esempio: dimostrazione del funzionamento dei parametri variabili

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

Quando si esegue il programma, l'output è:

Lunghezza dei parametri: 2
sum2 = 6
Lunghezza dei parametri: 3
sum3 = 9
Lunghezza dei parametri: 4
sum4 = 16

In questo caso, il metodo sumNumber() restituisce la somma dei parametri int passati a lui (indipendentemente dal numero di parametri passati).

Come puoi vedere, i varargs sono molto utili in alcuni casi. Tuttavia, se sei sicuro del numero di parametri da passare al metodo, usa il sovraccarico del metodo. Ad esempio, se sei sicuro che il metodo sumNumber() viene utilizzato solo per calcolare la somma di 2 o 3 parametri, utilizza il sovraccarico come nel primo esempio.

Prendiamo un altro esempio. Il metodo format() definito nella libreria Java accetta parametri variabili. Nel JDK, il metodo format() è definito come segue:

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

Esempio: metodo format()

class Company {
　　　　public static void main(String[] args) {
　　　　　　　　String siteName = "oldtoolbag.com";
　　　　　　　　int empCount = 6;
　　　　　　　　String type = "sito web di tutorial";
　　　　　　　　System.out.println(
　　　　　　　　　　　　　　　　String.format(
　　　　　　　　　　　　　　　　　　　　　　　　"Nome del sito: %s, Numero di dipendenti: %d Tipo: %s",
　　　　　　　　　　　　　　　　　　　　　　　　siteName, empCount, type
　　　　　　　　　　　　　　　　)
　　　　　　　　);
　　　　}
}

Quando si esegue il programma, l'output è:

Nome del sito: oldtoolbag.com, Numero di dipendenti: 6 Tipo: sito web di tutorial

Come lavorano i parametri variabili in background?

Guardiamo il seguente pseudocodice:

public int sumNumber(int ...nums) {
　　　　// Corpo del metodo
}

La sintassi ... dice al compilatore Java che può utilizzare zero o più parametri per chiamare questo metodo. Di conseguenza, la variabile nums viene implicitamente dichiarata come int [].ArrayQuindi, all'interno del metodo, usa la sintassi dell'array per accedere alla variabile nums.

Se non ci sono parametri, la lunghezza nums è 0.

Sovraccarico dei metodi Varargs

Simile a un metodo tipico, puoi sovraccaricare un metodo vararg.

Esempio: sovraccarico dei metodi 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");
　　　　}
}

Quando si esegue il programma, l'output è:

sum = 6
negate = false
args.length = 2

Nel programma sopra, il metodo test() viene sovraccaricato cambiando il numero di parametri accettati.

Cose da ricordare quando si utilizza Varargs

Queste sono alcune cose da ricordare quando si utilizza Java Varargs:

1. Assicurati di definire correttamente la firma del metodo quando:MantieniInfine, i variabili.

I parametri variabili devono essere l'ultimo parametro passato al metodo. Considera, hai chiamato il metodo doSomething() come segue:

doSomething(1, 2, 3, 4);

E, la tua definizione di metodo doSomething() è:

// Dichiarazione del metodo errata
public void doSomething(int ... nums, int p){
　　　　// corpo del metodo
}

In questo caso, il compilatore non può determinare il numero di parametri passati a nums.

Ma se definisci il metodo come:

public void doSomething(int p, int ... nums) {
　　　　// corpo del metodo
}

Il compilatore Java assegna il primo parametro a p, gli altri parametri int a nums.

2. Un metodo può avere solo un parametro varargs.

Ad esempio, la dichiarazione del metodo non è corretta:

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

Ambiguità nel sovvraccarico di metodi varargs

Vediamo un esempio di metodo test() sovvraccaricato:

class Demo {　
　　
　　　　static void test(int ... vargs) {
　　　　　　　　// corpo del metodo
　　　　}
　　　　
　　　　static void test(int n, int ... vargs) {
　　　　　　　　// corpo del metodo
　　　　}
}

Nel programma sopra, anche se cerchi di chiamare il metodo test(), anche se il metodo test() è sovvraccaricato e accetta un numero diverso di parametri, il compilatore potrebbe essere confuso.

Il compilatore non sa quale metodo chiamare. Il compilatore potrebbe pensare che stai cercando di chiamare test(int ... vargs) utilizzando un parametro varargs. Allo stesso modo, il compilatore potrebbe pensare che stai cercando di chiamare test(int n, int ... vargs) utilizzando i parametri passati al primo parametro e il secondo parametro vuoto.

Poiché ci sono due possibilità, può causare ambiguità. A volte potresti dover utilizzare due nomi di metodo diversi invece di sovvraccaricare il metodo varargs.