Parámetros variables (Varargs) de Java

En este artículo, aprenderás sobre los parámetros variables (Varargs) en Java a través de ejemplos. También aprenderás cuándo usar varargs y cuándo no usarlos.

¿Qué es el varargs en Java?

Supongamos que estás creandoJava 方法. Pero no estás seguro de cuántos parámetros aceptará tu método. Para resolver este problema, Java 1.5Se ha introducido varargs.

Varargs es la abreviatura de parámetros variables. En Java, los parámetros de un método pueden aceptar cualquier cantidad de valores. El parámetro que puede aceptar una cantidad variable de valores se llama varargs.

La sintaxis para implementar varargs es la siguiente:

accessModifier methodName(datatype ... arg) {
　　　　//　Cuerpo del método
}

Para definir vararg, se utiliza ... (tres puntos) en los parámetros de la forma del método.

Los métodos que aceptan una cantidad variable de parámetros se denominan métodos de cantidad variable, o simplemente métodos varargs.

Primero, veamos un ejemplo sin usar 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));
　　　　}
}

Cuando ejecutes el programa, la salida será:

3
6

Como puedes ver, es necesario sobrecargar el método sumNumber() para que sea compatible con3parámetros.

si el usuario desea agregar5números o10o10¿Qué hacer si es 0?

El uso de varargs permite manejar este problema de manera concisa. Veamos un ejemplo de código:

Ejemplo: demostración del funcionamiento de los parámetros variables

class VarargExample {
　　　　public int sumNumber(int ... args){
　　　　　　　　System.out.println("Longitud del parámetro: ")　+　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);
　　　　}
}

Al ejecutar el programa, la salida es:

Longitud de parámetros:　2
sum2　=　6
Longitud de parámetros:　3
sum3　=　9
Longitud de parámetros:　4
sum4　=　16

Aquí, el método sumNumber() devuelve la suma de los parámetros int pasados (independientemente de la cantidad de parámetros).

Como puede ver, los varargs son muy útiles en ciertos casos. Pero, si está seguro de la cantidad de parámetros que se pasan al método, utilice la sobrecarga de métodos. Por ejemplo, si está seguro de que el método sumNumber() se utiliza solo para calcular2o3la suma total de los parámetros, utilice la sobrecarga como en el primer ejemplo.

Veamos otro ejemplo. El método format() definido en la biblioteca de Java acepta varargs. En JDK, el método format() se define como sigue:

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

Ejemplo: método format()

class Company {
　　　　public static void main(String[] args) {
　　　　　　　　String siteName = "oldtoolbag.com";
　　　　　　　　int empCount =　6;
　　　　　　　　String type = "Sitio web de tutorial";
　　　　　　　　System.out.println(
　　　　　　　　　　　　　　　　String.format(
　　　　　　　　　　　　　　　　　　　　　　　　"Nombre del sitio: %s, Emp Count: %d Tipo: %s"
　　　　　　　　　　　　　　　　　　　　　　　　siteName, empCount, type
　　　　　　　　　　　　　　　　)
　　　　　　　　);
　　　　}
}

Al ejecutar el programa, la salida es:

Nombre del sitio: oldtoolbag.com, Emp Count:　6　Tipo: Sitio web de tutorial

¿Cómo funcionan los parámetros variables en segundo plano?

Veamos el siguiente código pseudocódigo:

public int sumNumber(int ...nums) {
　　　　//　Cuerpo del método
}

... La sintaxis informa al compilador de Java de que se pueden usar cero o más parámetros para invocar este método. Como resultado, la variable nums se declara implícitamente como int [].ArrayPor lo tanto, dentro del método, se utiliza la sintaxis de array para acceder a la variable nums.

Si no hay parámetros, la longitud de nums es 0.

Sobrecarga de métodos Varargs

Al igual que con métodos típicos, puede sobrecargar métodos varargs.

Ejemplo: Sobrecarga de métodos 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");
　　　　}
}

Al ejecutar el programa, la salida es:

sum =　6
negate = false
args.length =　2

En el programa anterior, el método test() se sobrecarga cambiando la cantidad de parámetros aceptados.

Cosas que debe recordar al usar Varargs

Estas son algunas cosas que debe recordar al usar Java Varargs:

1.Al definir la firma del método, asegúrese deMantenerFinalmente, varargs.

Los parámetros variables deben ser el último parámetro传递 al método. Considere que ha llamado al siguiente método doSomething():

doSomething(1,　2,　3,　4);

Y, su método doSomething() se define como:

//Declaración de método incorrecta
public void doSomething(int ... nums, int p){
　　　　//　method body
}

En este caso, el compilador no puede determinar la cantidad de parámetros pasados a nums.

Pero, si se define el método como:

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

El compilador de Java asigna el primer parámetro a p, y el resto de parámetros int a nums.

2.Un método solo puede tener un parámetro varargs.

Por ejemplo, la declaración de este método no es correcta:

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

Varargs 方法重载中的歧义

让我们看一下这样的重载 test() 方法：

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

在上面的程序中，即使您尝试调用 test() 方法，即使 test() 方法已重载并且接受不同数量的参数，编译器也会感到困惑。

编译器不知道调用哪个方法。编译器可能会认为，您正在尝试使用 varargs 参数调用 test(int ... vargs)。同样，编译器可能会认为，您正在尝试使用传递给第一个参数的参数调用 test(int n, int ... vargs)，而第二个参数为空。

由于存在两种可能性，因此会引起歧义。因此，有时您可能需要使用两个不同的方法名称，而不是重载 varargs 方法。