Java / Argumentos variables

Bienvenidos sean a este post, hoy veremos una particularidad.

Esta particularidad son los argumentos variables (var-args), la cual fue implementada a partir de la JDK 1.5, que nos permite pasar un numero variable de argumentos del mismo tipo al metodo, su sintaxis es:

tipo metodo( nombreTipo ... argumento )

Al momento de declarar al metodo en los argumetos pasamos al nombre del tipo seguido de los tres puntos (…) y el nombre del argumento contenedor. Este tipo de argumento se puede usar con otros tipos de variables en conjunto pero este debe ser el ultimo utilizado y los demas siempre deben precederlo pero sobre esto hablaremos mas adelante. Veamos un ejemplo de este tipo:

ArgsVar.java

public class ArgsVar
{
  public static void main(String args[])
  {
     maximo(10,3,2,1,54.4,15.5,20.6);
     maximo(new double[]{1,2,5,3,4});
  }

  static void maximo( double ... num )
  {
     if(num.length == 0)
     {
        System.out.println("Sin argumentos");
        return;
     }
     double res = 0;
     for(int i=0; i < num.length; i++)
     {
        if (num[i] > res)
          res = num[i];
     }
     System.out.println("El valor maximo es " + res);
  }
}

Observen como enviamos los datos al metodo maximo, en el primer caso los enviamos directo y que el metodo se encargue de interpretarlo pero para el segundo caso enviamos un Array. Para ello, primero lo seteamos de la misma forma que espera el metodo, en este caso double, y luego entre llaves ({}) le pasamos los argumentos. Observen como declaramos al metodo, le pusimos en la lista de argumentos el tipo, double, luego los tres puntos (…) y por ultimo el nombre de lo que va a ser nuestra variable de estilo Array. El primer condicional verifica si esta variable es igual a cero, en caso de ser verdadero envia un mensaje y sale del metodo. Despues crearemos una variable de tipo double llamada res donde le asignaremos el valor de cero, este es para almacenar el valor maximo. Luego usaremos un bucle para hacer un ciclo donde chequearemos cada uno de los indices en nuestros argumentos variables (var-args). Dentro del for tendremos un condicional donde verificara si el indice de num actual es mayor al almacenado en res. En caso de ser verdadero procede a reemplazarlo, una vez terminado el ciclo nos mostrara un mensaje con el valor maximo almacenado en la serie, compilemos y probemos:

$ java ArgsVar
El valor maximo es 54.4
El valor maximo es 5.0
$

Observen como funciono correctamente, y nos devolvio los valores maximos almacenados. Vamos a trabajar con una conducta que mencionamos al inicio. Para ello, tomaremos el codigo anterior y hagamos el siguiente cambio:

public class ArgsVar
{
  public static void main(String args[])
  {
     maximo(100,3.5,2,1,54.4,15.5,20.6);
     maximo(10,6.3,new double[]{1,2,5,3,4});
  }

  static void maximo(int a, double b, double ... num )
  {
     if(num.length == 0)
     {
        System.out.println("Sin argumentos");
        return;
     }
     double res = 0;
     for(int i=0; i < num.length; i++)
     {
        if (num[i] > res)
          res = num[i];
     }
     System.out.println("a: " + a + " / b: " + b);
     System.out.println("El valor maximo es " + res);
  }
}

Hablemos sobre el primer cambio, y es sobre el metodo maximo. En este agregamos dos argumentos al inicio para poder recibir un valor de tipo int y otro de tipo double y luego los variables como antes. El resto de la funcion sigue siendo igual pero agregamos otra linea para mostrar los valores de las nuevas variables antes del valor maximo en num. La siguiente modificacion es al llamado de maximo en main. En la primera modificamos los dos primeros valores con respecto al ejemplo anterior pero luego sigue con los mismos valores. En el siguiente llamado agregamos dos valores antes del array double que teniamos antes. Un solo detalle mas, observen los nuevos valores antes de compilarlo y ejecutarlo. Que opinan? Seran los mismos valores de antes o apareceran los nuevos? Compilemos y ejecutemos para ver la salida:

$ java ArgsVar
a: 100 / b: 3.5
El valor maximo es 54.4
a: 10 / b: 6.3
El valor maximo es 5.0
$

Observen que tenemos los valores nuevos para los nuevos argumentos pero seguimos teniendo los mismos valores maximos pero por que? Porque trabajamos con num y no con las nuevas variables. Entonces el metodo, siempre tomara los primeros dos valores y los asignara a las primeras dos variables, y el resto de valores los asignara a num sin importar la cantidad. Esto es lo que mencionamos al inicio, la posibilidad de poder integrar esta manera de manejar argumentos de manera variable con otros fijos.

En resumen, hoy hemos visto a argumentos variables, que son, para que sirven, como se utilizan, y un par de ejemplos para aplicarlos, y una variante de como usarlo con otro tipo de argumentos. Espero les haya sido de utilidad y les dejo un link a GitHub donde estan los codigos creados hoy:

GitHub / var-args

Les dejo algunas de mis redes sociales para seguirme o recibir una notificacion cada vez que subo un nuevo post: