1
00:00:10,220 --> 00:00:16,550
Vamos a ver ahora el tema de frizz al manejar argumentos variables con lo que hemos visto hasta el momento

2
00:00:16,820 --> 00:00:22,040
hemos utilizado un ciclo Ford para iterar cada uno de los elementos del arreglo varar.

3
00:00:22,160 --> 00:00:28,880
Sin embargo existe una notación simplificada utilizando el ciclo Fortich el cual podemos utilizar para

4
00:00:28,880 --> 00:00:31,370
iterar arreglos o colecciones.

5
00:00:31,520 --> 00:00:34,210
Ese tema lo estudiaremos a detalle más adelante.

6
00:00:34,220 --> 00:00:40,760
Sin embargo queremos mostrarles cómo simplificar la iteración de los elementos de un arreglo utilizando

7
00:00:40,820 --> 00:00:47,420
este concepto de Fortich básicamente lo que hacemos es declarar un ciclo.

8
00:00:47,870 --> 00:00:54,410
Pero a diferencia de un ciclo normal el cual tiene tres elementos a declarar un ciclo frizz sólo tiene

9
00:00:54,410 --> 00:01:00,860
dos elementos a declarar que es la variable que va a recibir cada uno de los elementos del arreglo y

10
00:01:00,860 --> 00:01:03,380
el arreglo que se va a iterar.

11
00:01:03,440 --> 00:01:06,810
Todo lo anterior es el mismo código excepto este ciclo.

12
00:01:07,400 --> 00:01:14,300
Así que podemos observar que declaramos por un lado la variable que va a contener cada uno de los elementos

13
00:01:14,630 --> 00:01:20,930
y posteriormente el arreglo que vamos a utilizar para iterar cada uno de estos elementos y finalmente

14
00:01:20,930 --> 00:01:28,190
mandamos a imprimir cada uno de los elementos del arreglo apoyándonos precisamente de la variable que

15
00:01:28,190 --> 00:01:30,710
contiene cada uno de los elementos.

16
00:01:30,710 --> 00:01:36,890
La única desventaja de esta notación es que si necesitamos conocer el índice del elemento que se está

17
00:01:36,890 --> 00:01:38,910
alterando de este ciclo.

18
00:01:39,380 --> 00:01:45,770
Esta sintaxis no nos va a servir ya que en ningún momento se ha declarado un contador que nos ayude

19
00:01:45,770 --> 00:01:52,790
a saber cuál es el elemento que se está alterando ya que el ciclo frizz únicamente nos regresa el elemento

20
00:01:52,870 --> 00:01:56,410
terrado pero no el índice que se está alterando.

21
00:01:56,420 --> 00:02:02,780
Ese sería el único inconveniente a tener en cuenta pero por lo demás vemos claramente cómo la sintaxis

22
00:02:02,840 --> 00:02:09,350
es más limpia y menos propensa a errores ya que no necesitamos declarar varios elementos para iterar

23
00:02:09,410 --> 00:02:16,000
un arreglo por lo que es más simple y más seguro utilizar esta notación para recorrer los elementos

24
00:02:16,000 --> 00:02:16,690
de un arreglo

25
00:02:20,180 --> 00:02:21,820
varios argumentos.

26
00:02:21,890 --> 00:02:28,070
En este código básicamente explicaremos una regla más del uso de argumentos variables la cual indica

27
00:02:28,070 --> 00:02:33,920
que si vamos a utilizar el concepto de argumentos variables es necesario que sea el último de los argumentos

28
00:02:33,920 --> 00:02:35,680
declarados en un método.

29
00:02:35,690 --> 00:02:41,660
De esta manera al mandar a llamar la función no habrá confusión para el compilador ya que en cuanto

30
00:02:41,660 --> 00:02:49,550
detecte que comienza el tipo de datos definido se comenzará a crear el arreglo de elementos enviados

31
00:02:49,550 --> 00:02:50,960
a la función.

32
00:02:51,020 --> 00:02:57,020
En pocas palabras el compilador de java detecta el número de elementos enviados y una vez que ha terminado

33
00:02:57,020 --> 00:03:02,780
de asignar los elementos que no son de tipo bar ARC revisará si el último argumento declarado es de

34
00:03:02,780 --> 00:03:09,150
tipo varar y así es como todos los valores restantes que sean del mismo tipo que el argumento var ha

35
00:03:09,240 --> 00:03:13,580
definido los asignará al elemento de argumento variable.

36
00:03:13,580 --> 00:03:16,570
Y como sabemos finalmente los convierte en una regla.

37
00:03:17,150 --> 00:03:22,550
Esta regla es muy importante para el uso de varas ya que en ocasiones lo queremos combinar con varios

38
00:03:22,550 --> 00:03:26,020
argumentos y aquí es donde debemos respetar esta regla.

39
00:03:26,150 --> 00:03:32,120
Así que observamos que en un método podemos definir varios argumentos pero si vamos a utilizar argumentos

40
00:03:32,120 --> 00:03:38,630
variables éste debe de ser el último argumento definido en el método y posteriormente cuando utilizamos

41
00:03:38,720 --> 00:03:44,960
este método proporcionamos los argumentos y una vez que ya hemos terminado de proporcionar los argumentos

42
00:03:45,080 --> 00:03:52,160
de inicio del método en este caso un string y un Juliano los siguientes valores corresponderán al tipo

43
00:03:52,340 --> 00:03:53,630
de argumento variable

44
00:03:56,920 --> 00:03:57,740
y de esta manera.

45
00:03:57,740 --> 00:04:04,010
Estos últimos argumentos corresponderán al arreglo de argumentos variables que se va a crear en esta

46
00:04:04,010 --> 00:04:05,690
posición.

47
00:04:05,690 --> 00:04:10,130
A continuación vamos a crear un ejercicio para poner en práctica cada uno de estos ejemplos.