Aque se debe la Programacion orientada a objetos
Enviado por Bryan Cadena • 19 de Octubre de 2015 • Documentos de Investigación • 3.636 Palabras (15 Páginas) • 95 Visitas
Java – Argumentos variables (VarArgs)
En Java existe la posibilidad de llamar a un método con un numero de argumentos variable, ósea un numero de argumentos indefinido o desconocido. Esta posibilidad del lenguaje se llama abreviada y en ingles: VarArgs, y no ah sido “oficialmente” posible hasta la salida de J2SE 5.0. Veamos el antes y el después.
Antes de J2SE 5.0
Cuando necesitamos de un método que acepte una cantidad indeterminada de valores podemos usar un arreglo u otro tipo de colección, veamos un ejemplo con un array:
1 2 3 4 5 6 7 8 9 10 11 | ... int sumar(int[] nums) { int total = 0;
for (int i=0 ; i < nums.length ; i++) { total += nums[i]; }
return total } ... |
Este método suma todos los números del arreglo pasado como argumento y nos retorna el resultado, podemos invocarlo de la siguiente forma:
1 2 3 4 | ... int[] array = { 1, 2, 3, 4, 5 }; sumar(array); ... |
Así que como vemos podríamos crear un arreglo con la cantidad de números que quisiéramos y pasárselos a nuestro método sumar(int[] nums) al cual no le importara cuantos argumentos lleguen.
Si no usáramos ni un arreglo o colección para esta tarea, que haríamos entonces?, podríamos crear un método y sobrecargarlo con un numero diferente de parámetros cuantas veces necesitemos:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | ... int sumar(int a, int b) { return (a + b); }
int sumar(int a, int b, int c) { return (a + b + c); }
int sumar(int a, int b, int c, int d) { return (a + b + c + d); }
int sumar(int a, int b, int c, int d, int e) { return (a + b + c + d + e); } ... |
No es una alternativa flexible, es limitada, ocupa mas espacio y es poco elegante. Sin duda nos quedamos con el arreglo.
Sin embargo el ejemplo visto de argumentos variables no es nada nuevo para nadie en Java, que tal el famoso método main (String[] args) ?, veamos:
1 2 3 4 5 6 7 8 9 10 | class EjemploMain {
public static void main(String[] args) { System.out.println("Lista de argumentos:");
for (int i = 0 ; i < args.length ; i++) { System.out.println(i + "- " + args[i]); } } } |
Luego de compilar este EjemploMain.java lo ejecutamos de la siguiente forma:
java -classpath [Ruta de clases (donde esta nuestro EjemploMain.class)] EjemploMain Hola a todo el Mundo
Si lo tenemos en un tarro (.jar) lo ejecutamos de la siguiente forma:
java -jar [Ruta del archivo jar] Hola a todo el Mundo
La salida es:
Lista de argumentos:
0- Hola
1- a
2- todo
3- el
4- Mundo
Como podemos observar, cualquier aplicación Java ejecutable puede recibir una cantidad de argumentos variable al ser invocada en su método main (String[] args).
Desde J2SE 5.0
Desde a partir de la versión J2SE 5.0 el lenguaje tiene oficialmente su truco de varargs el cual nos facilita un poco la tarea de pasar argumentos variables a un método, de hecho el SDK de Java hace uso de las varargs pudiéndose observar por ejemplo en el código fuente de java.lang.Class y en muchas otras clases.
Ahora veamos como aplicar la nueva sintaxis en el ejemplo visto anteriormente desumar (int[] nums):
1 2 3 4 5 6 7 8 9 10 11 | ... int sumar(int... nums) { int total = 0;
for (int i=0 ; i < nums.length ; i++) { total += nums[i]; }
return total; } ... |
Hasta aquí el único cambio que apreciamos es como quedan declarados los argumentos de nuestro método con el “…“:
1 2 3 | ... int sumar(int... nums) ... |
Sin embargo esta ves para llamar a nuestro método lo haremos de la siguiente manera:
1 2 3 | ... sumar(1, 2, 3, 4, 5); ... |
A partir de ahora lo que hacemos es ahorrarnos tener que crear el arreglo nosotros mismos, ya que ah quedado en manos del compilador gracias al “…“, la llamada que escribimos como: sumar(1, 2, 3, 4, 5), será convertida automáticamente por el compilador en el equivalente: sumar(new int[] {1, 2, 3, 4, 5}).
...