1
00:00:01,410 --> 00:00:03,150
Hola y bienvenidos a esta elección.

2
00:00:03,150 --> 00:00:07,400
A continuación vamos a estudiar el concepto de Barajas en Java están listos.

3
00:00:07,400 --> 00:00:13,700
Vamos bien lo primero que vamos a hacer es cerrar nuestro proyecto si tenemos alguno abierto damos clic

4
00:00:13,710 --> 00:00:22,430
derecho y Clowes ahora vamos a crear un nuevo proyecto damos un enfile mi proyecto seleccionamos Java

5
00:00:22,460 --> 00:00:25,700
huid Maiden posteriormente Java Application.

6
00:00:25,700 --> 00:00:29,070
Damos clic en Next y el nombre del proyecto se va a llamar.

7
00:00:29,070 --> 00:00:40,390
Ejemplo bar Alex de argumentos variables y lo depositamos en la carpeta de IAVA cursos diagonal Java

8
00:00:41,630 --> 00:00:45,540
el nombre del grupo es MX con de globalmente.

9
00:00:45,830 --> 00:00:55,490
La versión 1.0 y quitamos el nombre del paquete damos siguien finalizar y con esto ya se ha creado nuestro

10
00:00:55,490 --> 00:01:01,910
proyecto vamos a crear una nueva clase sobre los paquetes damos clic derecho Nioh seleccionamos Java

11
00:01:01,910 --> 00:01:11,950
class y el nombre de la clase va a ser ejemplo ejemplo bar Arx y el nombre del paquete va a ser test

12
00:01:13,220 --> 00:01:14,350
y damos clic en Finalizar

13
00:01:19,140 --> 00:01:27,430
quitamos estos comentarios y vamos a dar lo siguiente agregamos un método main Public Static void main

14
00:01:28,190 --> 00:01:32,550
y tecla de tabulador para que se genere de manera automática.

15
00:01:32,680 --> 00:01:39,190
Ahora vamos a declarar dos funciones una función que se llama imprimir números y otra que se va a llamar

16
00:01:39,310 --> 00:01:42,570
varios parámetros así que declaramos nuestra primera función

17
00:01:46,080 --> 00:01:55,530
imprimimos varios números así que declaramos la función imprimir números y esta función va a recibir

18
00:01:55,650 --> 00:02:01,350
una cantidad variable de números de tipo entero así que podemos agregar cualquier cantidad de números

19
00:02:06,340 --> 00:02:12,430
ya que precisamente el uso de Barac de argumentos variables nos permite enviar cualquier cantidad de

20
00:02:12,430 --> 00:02:16,680
números sin especificar el largo de estos elementos.

21
00:02:16,750 --> 00:02:22,570
Ahora vamos a crear esta función como podemos observar el IDE nos indica que quiere crear un método

22
00:02:22,570 --> 00:02:29,260
llamado imprimir números pero la cantidad de argumentos sí está definida según el número de argumentos

23
00:02:29,260 --> 00:02:35,440
de tipo entero que hemos utilizado va a ser la cantidad de argumentos que va a definir en este método.

24
00:02:35,440 --> 00:02:43,380
Entonces si damos girarme todo vamos a dar click quitamos esta línea con control e podemos observar

25
00:02:44,040 --> 00:02:50,400
que no se agregó una cierta cantidad de elementos de tipo entero según el número de la cantidad de argumentos

26
00:02:50,610 --> 00:02:52,200
que estamos proporcionando.

27
00:02:52,230 --> 00:02:58,620
Sin embargo precisamente para esto sirve el concepto de argumentos variables para no especificar la

28
00:02:58,620 --> 00:03:04,860
cantidad de elementos que vamos a recibir sino precisamente que podamos hacer variable esta cantidad

29
00:03:04,860 --> 00:03:11,790
de elementos así que la anotación va a ser la siguiente indicamos el tipo que vamos a recibir y posteriormente

30
00:03:11,850 --> 00:03:14,520
utilizamos tres puntos.

31
00:03:14,520 --> 00:03:21,000
Esto básicamente lo que va a hacer es construir un arreglo de tipo entero pero sin especificar la cantidad

32
00:03:21,000 --> 00:03:26,880
de elementos que vamos a recibir y posteriormente especificamos el nombre de la variable en este caso

33
00:03:26,880 --> 00:03:31,800
la variable se va a llamar números pero realmente lo que estamos haciendo aquí es construir un arreglo

34
00:03:33,440 --> 00:03:40,010
con esta cantidad de elementos que vamos a recibir y posteriormente para comprobar esto vamos a iterar

35
00:03:40,040 --> 00:03:41,060
estos elementos

36
00:03:45,040 --> 00:03:51,280
así que recorremos cada elemento del arreglo vamos a utilizar un ciclo for así que escribimos for y

37
00:03:51,280 --> 00:03:57,310
posteriormente tabulador para que nos genere la sintaxis del ciclo Forth de manera automática.

38
00:03:57,310 --> 00:04:03,320
Ya no se ha creado el contador y posteriormente y menor que 10 elementos.

39
00:04:03,370 --> 00:04:10,630
Sin embargo en este caso vamos a utilizar la variable números como hemos comentado se construye un arreglo.

40
00:04:10,720 --> 00:04:19,510
Por lo tanto tenemos acceso a la propiedad de length y posteriormente incrementamos el arreglo ahora

41
00:04:19,540 --> 00:04:22,820
vamos a acceder a cada uno de los elementos.

42
00:04:22,870 --> 00:04:31,160
Para ello declaramos la variable int recibimos el elemento y accedemos al elemento del arreglo que estamos

43
00:04:31,160 --> 00:04:38,610
trabajando en este momento así que para ello proporcionamos el valor del contador y con esto básicamente

44
00:04:38,610 --> 00:04:44,640
estamos accediendo al elemento en cuestión y lo estamos asignando a la variable elemento que es de tipo

45
00:04:44,640 --> 00:04:46,050
entero.

46
00:04:46,050 --> 00:04:48,720
Finalmente vamos a imprimir esta variable.

47
00:04:48,720 --> 00:04:56,490
Escribimos ese aleví y posteriormente tecla de tabulador para que nos imprima la variable elemento bien

48
00:04:56,510 --> 00:05:00,050
guardamos cambios y vamos a ejecutar damos el derecho ROM File

49
00:05:07,860 --> 00:05:15,360
y Podemos se en la salida que nos está imprimiendo los elementos de 15 1 4 6 20 y 60 que es precisamente

50
00:05:15,420 --> 00:05:23,760
el mismo orden en el que hemos proporcionado estos argumentos a la función de imprimir números así que

51
00:05:23,760 --> 00:05:29,970
básicamente estamos haciendo lo siguiente Estamos proporcionando esta cantidad de argumentos de tipo

52
00:05:29,970 --> 00:05:37,650
entero deben de ser del mismo tipo para que podamos utilizar varadas y posteriormente se asigna estos

53
00:05:37,650 --> 00:05:44,130
elementos de este mismo tipo al arreglo de números que se está declarando en esta función pero recordemos

54
00:05:44,130 --> 00:05:50,010
que si utilizamos la sintaxis de arreglo esto no va a funcionar ya que deberíamos especificar la cantidad

55
00:05:50,010 --> 00:05:52,590
de elementos que va a recibir el arreglo.

56
00:05:52,590 --> 00:05:56,440
En cambio esta sintaxis se conoce como argumentos variables.

57
00:05:56,520 --> 00:06:02,370
No es necesario especificar la cantidad de elementos que va a recibir esta función así que podríamos

58
00:06:02,370 --> 00:06:11,820
variar la cantidad de elementos ya sea enviando menos elementos o más elementos y si ejecutamos sigue

59
00:06:11,820 --> 00:06:19,420
funcionando sin ningún problema nuestro programa y estamos recibiendo los argumentos de 15 1 4 y 6 así

60
00:06:19,420 --> 00:06:25,330
que en este momento se creó un arreglo de cuatro elementos pero por ello es precisamente este es un

61
00:06:25,420 --> 00:06:30,880
argumento variable ya que el largo de este arreglo se crea según la cantidad de elementos que estamos

62
00:06:30,880 --> 00:06:35,530
enviando a esta función bien vamos a poner en práctica un segundo ejemplo

63
00:06:42,580 --> 00:06:46,330
ahora qué pasa si en una función queremos enviar diferentes tipos.

64
00:06:46,450 --> 00:06:53,630
La regla es que el tipo varar debe de ser el último parámetro del método que vamos a definir vamos a

65
00:06:53,630 --> 00:07:01,580
imprimir un salto de línea y ahora vamos a mandar a llamar un método llamado varios parámetros vamos

66
00:07:01,580 --> 00:07:09,360
a enviar un string posteriormente un valor de tipo bullían y el tercer parámetro va a ser el parámetro

67
00:07:09,420 --> 00:07:10,020
de.

68
00:07:10,950 --> 00:07:20,710
Entonces enviamos los valores de 14 2 y 5 podemos enviar más elementos aquí simplemente estamos enviando

69
00:07:21,040 --> 00:07:27,640
tres elementos de tipo entero y este va a ser el parámetro de varar los valores de varar deben de ser

70
00:07:27,640 --> 00:07:34,300
los últimos parámetros ya que si los ponemos al inicio el compilador no va a saber asignar y combinar

71
00:07:34,390 --> 00:07:40,140
los parámetros que se están enviando y la única forma de saber que el tipo varar comienza en la llamada

72
00:07:40,150 --> 00:07:45,430
Nuestra función es detectando que va a ser el último elemento y considera el tipo.

73
00:07:45,430 --> 00:07:52,060
Una vez identificado el tipo entonces comienza a crear el arreglo a partir de ese momento hasta el final.

74
00:07:52,060 --> 00:07:58,450
La cantidad en este caso un arreglo de tres elementos de tipo entero creamos el método va a ser privado

75
00:07:58,930 --> 00:08:06,460
de tipo Static no va a regresar nada y se va a llamar varios parámetros y vamos a definir los parámetros

76
00:08:06,670 --> 00:08:14,290
primero va a recibir un instrumento que se va a llamar nombre o posteriormente reciben un tipo bullían

77
00:08:15,250 --> 00:08:19,080
que se vaya a amar bandera y finalmente recibe el tipo varal

78
00:08:22,120 --> 00:08:28,620
que se va a llamar tambien numeros y en este caso vamos a imprimir la variable nombre

79
00:08:32,550 --> 00:08:35,280
imprimimos primero la variable nombre el argumento del nombre.

80
00:08:35,820 --> 00:08:44,430
Posteriormente el argumento de bandera y finalmente recorremos los elementos del arreglo de varar de

81
00:08:44,430 --> 00:08:45,000
numeros

82
00:08:49,380 --> 00:08:56,980
pero lo recorremos hasta el largo de elementos que tengan la variable de numeros y podemos acceder directamente

83
00:08:56,980 --> 00:09:01,510
al elemento que se está alterando escribimos ese Alvy

84
00:09:04,240 --> 00:09:09,520
pero vamos a imprimir directamente el elemento en cuestión así que vamos a hacer lo siguiente escribimos

85
00:09:09,520 --> 00:09:16,520
numeros y accederemos al elemento que estamos esperando en este momento para no tener que hacer lo mismo

86
00:09:16,730 --> 00:09:22,850
que hicimos en la función anterior donde extrajimos primero el elemento del arreglo y posteriormente

87
00:09:22,850 --> 00:09:24,350
se imprimió.

88
00:09:24,350 --> 00:09:31,380
En este caso podemos imprimir directamente el elemento que estamos recorriendo así que guardamos cambios

89
00:09:31,560 --> 00:09:35,000
y vamos a ejecutar un derecho romboide

90
00:09:39,570 --> 00:09:45,020
y podemos saber que en el segundo caso estamos accediendo al nombre de Juan bandera.

91
00:09:45,360 --> 00:09:53,790
El elemento de 14 2 y 5 respectivamente ya que dos son los valores que estamos enviando 14 2 y 5 respectivamente

92
00:09:54,610 --> 00:09:59,670
asi que podemos observar que esto funciona sin ningún problema sin embargo si quisiéramos mandar primero

93
00:09:59,730 --> 00:10:02,910
estos valores vamos a intentar hacer esta prueba

94
00:10:05,560 --> 00:10:09,820
invirtiendo el orden de los argumentos y poner primero varar

95
00:10:19,580 --> 00:10:25,070
podemos observar que esto no funciona ya que nos está comentando que el tipo requerido en primer lugar

96
00:10:25,250 --> 00:10:27,550
es un arreglo de tipo entero.

97
00:10:27,560 --> 00:10:33,370
Esto significa que ya tendriamos que especificar el largo de este arreglo para recibir estos elementos.

98
00:10:33,470 --> 00:10:39,770
De lo contrario no podremos almacenar estos elementos en el arreglo que se está definiendo y esto nos

99
00:10:39,770 --> 00:10:45,230
limitaría a especificar la cantidad de elementos que vamos a recibir hace que ya no cumpliría con la

100
00:10:45,230 --> 00:10:51,320
función de argumentos variables y aunque podríamos corregir esto no es la idea de manejar argumentos

101
00:10:51,320 --> 00:10:52,040
variables.

102
00:10:52,040 --> 00:10:57,350
Por lo tanto argumentos variables si no queremos especificar ni limitar la cantidad de elementos que

103
00:10:57,350 --> 00:11:03,440
vamos a enviar a una función entonces tiene que ser el último parámetro así que vamos a presionar Control

104
00:11:03,440 --> 00:11:05,450
Z para regresar los cambios

105
00:11:08,600 --> 00:11:12,090
y con esto ya tenemos nuestro código de argumentos variables.

106
00:11:12,090 --> 00:11:17,910
Si ejecutamos paso a paso esta función de varios parámetros vamos a poner un punto de ruptura.

107
00:11:17,910 --> 00:11:19,930
Damos clic derecho de Buffy al

108
00:11:26,970 --> 00:11:28,890
voy a presionar el botón de este quinto

109
00:11:32,570 --> 00:11:34,720
vamos a ver las variables que inicializar.

110
00:11:36,070 --> 00:11:43,110
Si damos clic en variables podemos observar que se creó el argumento de nombre con el valor de Juan.

111
00:11:43,120 --> 00:11:46,880
Bandera con el valor de Chum y la variable de números.

112
00:11:46,980 --> 00:11:52,660
Y podemos observar que esta variable de números es un arreglo de tipo entero y si entramos al detalle

113
00:11:52,660 --> 00:11:59,350
de este arreglo podemos observar que se creó un arreglo de tres elementos en el índice cero se asignó

114
00:11:59,350 --> 00:12:03,900
el valor de 14 ya que fue el primer valor que proporcionamos de tipo entero.

115
00:12:04,030 --> 00:12:12,160
Posteriormente en el índice 1 se asignó el valor de 2 y en el índice 2 se asignó el valor de 5 así que

116
00:12:12,160 --> 00:12:14,650
podemos observar que funciona sin ningún problema.

117
00:12:14,650 --> 00:12:20,110
El uso de argumentos variables voy a detener la ejecución paso a paso ya que lo demás es lo mismo

118
00:12:24,030 --> 00:12:29,100
bien así que con esto hemos puesto en práctica el concepto de argumentos variables y vimos que podemos

119
00:12:29,100 --> 00:12:34,550
utilizar simplemente un argumento de tipo variable o podemos combinar varios parámetros.

120
00:12:34,740 --> 00:12:40,350
Pero el argumento de tipo variable en dado caso de que tengamos varios tipos debe de ser el último tipo

121
00:12:40,530 --> 00:12:45,070
que se va a utilizar en el paso de parámetros de algún método.

122
00:12:45,110 --> 00:12:47,970
Eso es todo por esta elección y nos vemos en el siguiente vídeo.

123
00:12:48,000 --> 00:12:48,600
Saludos.
