Vamos a ver ahora el tema de frizz al manejar argumentos variables con lo que hemos visto hasta el momento
hemos utilizado un ciclo Ford para iterar cada uno de los elementos del arreglo varar.
Sin embargo existe una notación simplificada utilizando el ciclo Fortich el cual podemos utilizar para
iterar arreglos o colecciones.
Ese tema lo estudiaremos a detalle más adelante.
Sin embargo queremos mostrarles cómo simplificar la iteración de los elementos de un arreglo utilizando
este concepto de Fortich básicamente lo que hacemos es declarar un ciclo.
Pero a diferencia de un ciclo normal el cual tiene tres elementos a declarar un ciclo frizz sólo tiene
dos elementos a declarar que es la variable que va a recibir cada uno de los elementos del arreglo y
el arreglo que se va a iterar.
Todo lo anterior es el mismo código excepto este ciclo.
Así que podemos observar que declaramos por un lado la variable que va a contener cada uno de los elementos
y posteriormente el arreglo que vamos a utilizar para iterar cada uno de estos elementos y finalmente
mandamos a imprimir cada uno de los elementos del arreglo apoyándonos precisamente de la variable que
contiene cada uno de los elementos.
La única desventaja de esta notación es que si necesitamos conocer el índice del elemento que se está
alterando de este ciclo.
Esta sintaxis no nos va a servir ya que en ningún momento se ha declarado un contador que nos ayude
a saber cuál es el elemento que se está alterando ya que el ciclo frizz únicamente nos regresa el elemento
terrado pero no el índice que se está alterando.
Ese sería el único inconveniente a tener en cuenta pero por lo demás vemos claramente cómo la sintaxis
es más limpia y menos propensa a errores ya que no necesitamos declarar varios elementos para iterar
un arreglo por lo que es más simple y más seguro utilizar esta notación para recorrer los elementos
de un arreglo
varios argumentos.
En este código básicamente explicaremos una regla más del uso de argumentos variables la cual indica
que si vamos a utilizar el concepto de argumentos variables es necesario que sea el último de los argumentos
declarados en un método.
De esta manera al mandar a llamar la función no habrá confusión para el compilador ya que en cuanto
detecte que comienza el tipo de datos definido se comenzará a crear el arreglo de elementos enviados
a la función.
En pocas palabras el compilador de java detecta el número de elementos enviados y una vez que ha terminado
de asignar los elementos que no son de tipo bar ARC revisará si el último argumento declarado es de
tipo varar y así es como todos los valores restantes que sean del mismo tipo que el argumento var ha
definido los asignará al elemento de argumento variable.
Y como sabemos finalmente los convierte en una regla.
Esta regla es muy importante para el uso de varas ya que en ocasiones lo queremos combinar con varios
argumentos y aquí es donde debemos respetar esta regla.
Así que observamos que en un método podemos definir varios argumentos pero si vamos a utilizar argumentos
variables éste debe de ser el último argumento definido en el método y posteriormente cuando utilizamos
este método proporcionamos los argumentos y una vez que ya hemos terminado de proporcionar los argumentos
de inicio del método en este caso un string y un Juliano los siguientes valores corresponderán al tipo
de argumento variable
y de esta manera.
Estos últimos argumentos corresponderán al arreglo de argumentos variables que se va a crear en esta
posición.
A continuación vamos a crear un ejercicio para poner en práctica cada uno de estos ejemplos.