1
00:00:00,480 --> 00:00:02,200
Hola y bienvenidos a esta elección.

2
00:00:02,220 --> 00:00:06,670
A continuación vamos a estudiar el ciclo frizz en IAVA están listos.

3
00:00:06,780 --> 00:00:12,450
Vamos bien lo primero que vamos a hacer es cerrar este proyecto.

4
00:00:12,690 --> 00:00:13,860
Damos clic derecho Kloss

5
00:00:17,320 --> 00:00:19,930
y vamos a crear a continuación un nuevo proyecto.

6
00:00:19,930 --> 00:00:26,170
Damos clic en File ni proyecto seleccionamos Java with Mayrén posteriormente Application damos clic

7
00:00:26,170 --> 00:00:34,260
en Next y el nombre del proyecto se va a llamar frizz lo depositamos en la carpeta de cursos diagonal

8
00:00:34,290 --> 00:00:40,010
Java Group oiría MX con G.M. de Global mentoring.

9
00:00:40,150 --> 00:00:52,320
La versión 1.0 y el nombre del paquete lo vamos a dejar vació y damos clic en Finalizar.

10
00:00:52,390 --> 00:00:58,640
Ahora vamos a crear una nueva clase esta clase se va a llamar Fortich test así que damos clic derecho

11
00:00:58,640 --> 00:01:00,680
nio seleccionamos Java class

12
00:01:03,560 --> 00:01:09,470
y se llama for each test y la depositamos en el paquete de test damos fuguen finalizar

13
00:01:13,470 --> 00:01:14,880
quitamos estos comentarios

14
00:01:20,490 --> 00:01:22,220
y vamos a agregar un método.

15
00:01:22,600 --> 00:01:28,270
Recordemos que escribimos Public Static void main y presionamos tecla de tabulador y ahora vamos a agregar

16
00:01:28,270 --> 00:01:29,880
la siguiente sintaxis.

17
00:01:30,010 --> 00:01:37,700
En primer lugar vamos a declarar un arreglo de tipos enteros así que vamos a escribir Hint edades.

18
00:01:37,840 --> 00:01:43,630
Así se va a llamar el arreglo y posteriormente indicamos que es un tipo de arreglo y vamos a utilizar

19
00:01:43,630 --> 00:01:46,020
la sintaxis simplificada para inicializar.

20
00:01:46,030 --> 00:01:52,510
Este arreglo así que vamos a escribir igual utilizamos llaves para iniciar y cerrar nuestro arreglo

21
00:01:53,190 --> 00:01:55,070
y asignamos los siguientes valores.

22
00:01:55,270 --> 00:02:03,120
Podemos asignar por ejemplo el valor de 15 20 41 y 50 cualquier valor está bien.

23
00:02:04,310 --> 00:02:08,430
Y una vez que hemos declarado este arreglo vamos a intentarlo así que vamos a escribir lo siguiente.

24
00:02:09,510 --> 00:02:15,990
En lugar de utilizar un ciclo normal ahora vamos a utilizar un ciclo frizz así que escribimos for y

25
00:02:15,990 --> 00:02:21,630
el ciclo frizz se compone de dos elementos el primer elemento es la variable que va a recibir cada una

26
00:02:21,630 --> 00:02:28,440
de las iteraciones así que definimos una variable llamada edad y en esta variable vamos a almacenar

27
00:02:28,650 --> 00:02:34,560
cada uno de los elementos que vamos a iterar del arreglo y posteriormente después de dos puntos indicamos

28
00:02:34,590 --> 00:02:39,630
el nombre del arreglo cuando veamos el tema de colecciones.

29
00:02:39,710 --> 00:02:45,050
También vamos a poder observar que podemos indicar un arreglo o una colección cualquiera de los dos

30
00:02:45,050 --> 00:02:52,340
tipos podemos agregarlos en esta sintaxis abrimos nuestro bloque de código y cerramos el bloque de código

31
00:02:52,880 --> 00:02:58,400
y ahora ya dentro de este bloque de código frizz podemos acceder al elemento edad así que en este ejemplo

32
00:02:58,400 --> 00:03:04,490
vamos a mandar imprimir la variable edad escribimos ese Alby tabulador y con eso se va a imprimir la

33
00:03:04,490 --> 00:03:07,310
variable edad guardamos cambios y ejecutamos

34
00:03:11,220 --> 00:03:18,030
y podemos observar en la salida el valor de 15 20:41 y 50 que son precisamente los valores que hemos

35
00:03:18,030 --> 00:03:20,390
declarado en el arreglo de edades.

36
00:03:20,700 --> 00:03:26,320
Ahora si ejecutamos paso a paso este ejercicio vamos a poner un punto de ruptura comenzando el ciclo

37
00:03:26,320 --> 00:03:32,410
Forth damos clic derecho posteriormente en lugar de rompibles seleccionamos de Buffy

38
00:03:36,400 --> 00:03:43,860
y para entrar al detalle de la ejecución de este ciclo frizz presionamos F8 ya estamos dentro de la

39
00:03:43,860 --> 00:03:54,690
primera iteración así que el arreglo de edades que tienen los valores de 15 20 41 y 50 en este momento

40
00:03:54,720 --> 00:04:01,170
el primer valor se le ha asignado a la variable edad así que la variable edad contiene el valor de 15.

41
00:04:01,200 --> 00:04:08,750
Esta es la primera vez que se le está asignando el valor a esta variable así que presionamos F8 vamos

42
00:04:08,760 --> 00:04:09,600
a la consola

43
00:04:16,970 --> 00:04:23,640
y podemos observar el primer valor edad igual a 15 y así vamos a seguir con los demás elementos.

44
00:04:23,730 --> 00:04:33,770
Si presionamos F8 ahora la variable edad contiene el segundo valor el valor de 20 y si lo mandamos a

45
00:04:33,770 --> 00:04:41,090
imprimir presionamos f8 de nueva cuenta y podemos observar el segundo valor y así podemos continuar

46
00:04:41,090 --> 00:04:43,790
con cada uno de los valores de este arreglo.

47
00:04:43,790 --> 00:04:45,980
Presionamos de nueva cuenta F8.

48
00:04:46,160 --> 00:04:54,900
Ahora la variable edad contiene el valor de 41 presionamos F8 y este valor se manda a imprimir a consola.

49
00:04:54,900 --> 00:05:01,160
Presionamos de nueva cuenta F8 y ahora la variable dades contiene el valor de 50 que es el último valor

50
00:05:02,780 --> 00:05:03,980
ejecutamos.

51
00:05:04,100 --> 00:05:10,400
Se imprime el valor de 50 y con eso se ha terminado nuestro ciclo ya que fue el último valor asignado

52
00:05:10,400 --> 00:05:11,490
a este arreglo.

53
00:05:11,630 --> 00:05:14,960
Presionamos F8 y termina la ejecución de nuestro programa

54
00:05:18,740 --> 00:05:23,120
así que frizz es una sintaxis simplificada del uso del ciclo.

55
00:05:23,570 --> 00:05:29,420
Sin embargo podemos observar uno de los detalles en ese ciclo frizz que no tenemos un contador asignado

56
00:05:29,930 --> 00:05:36,050
así que si necesitamos utilizar un contador en este ciclo frizz nosotros seríamos responsables de crear

57
00:05:36,050 --> 00:05:41,780
una variable Contador e incrementarla internamente para saber cuál es el índice que estamos ejecutando

58
00:05:42,020 --> 00:05:47,660
en cada uno de los pasos ya que en este momento esa sintaxis ya no incluye la sintaxis para declarar

59
00:05:47,840 --> 00:05:52,270
una variable Contador como lo tenía la sintaxis clásica del ciclo Forth.

60
00:05:52,610 --> 00:05:53,900
Así que es el único detalle.

61
00:05:53,960 --> 00:06:00,950
Cuando utilicemos el ciclo Fortich ahora como segundo paso no solamente podemos iterar valores de tipo

62
00:06:00,950 --> 00:06:07,190
primitivo sino que también podemos iterar elementos de tipo obvie así que vamos a crear una clase llamada

63
00:06:07,190 --> 00:06:09,780
persona sobre sus packages.

64
00:06:09,800 --> 00:06:16,980
Vamos a crear una nueva clase damos clic derecho Niebuhr ya va a clase la clave se llama persona y la

65
00:06:16,980 --> 00:06:18,870
depositamos en el paquete de entidad

66
00:06:21,780 --> 00:06:30,390
damos clic en Finalizar quitamos estos comentarios y vamos a llegar los siguientes valores a nuestra

67
00:06:30,390 --> 00:06:34,960
clase persona en primer lugar vamos a agregar un identificador una persona.

68
00:06:35,070 --> 00:06:42,740
Así que agregamos lo siguiente playboys final int y declaramos el atributo Heydi persona.

69
00:06:42,750 --> 00:06:46,600
Posteriormente definimos otra variable llamada nombre de tipo String.

70
00:06:46,740 --> 00:06:52,770
También es privada string y la variable se llama nombre nos marca un error debido a que la variable

71
00:06:53,040 --> 00:06:59,250
de persona la hemos declarado como final por lo tanto tenemos que asignarle un valor para poder utilizarla.

72
00:06:59,430 --> 00:07:04,410
Vamos a crear una tercer variable que va a ser el Contador de personas por cada objeto de tipo Persona

73
00:07:04,410 --> 00:07:05,120
que se cree.

74
00:07:05,190 --> 00:07:10,020
Vamos a crear esta variable estática para que pueda contabilizar el número de objetos que se ha creado

75
00:07:10,020 --> 00:07:14,520
de esta clase así que definimos la variable Static int

76
00:07:17,630 --> 00:07:23,080
llamada Contador personas y ahora vamos a agregar un constructor para inicializar la variable Eugui

77
00:07:23,100 --> 00:07:26,620
personan haciendo uso de esta variable Contador personas.

78
00:07:26,870 --> 00:07:27,520
Definimos.

79
00:07:27,530 --> 00:07:38,350
El constructor recibe en este caso el nombre de esta persona inicializar los el Heydi podemos utilizar

80
00:07:38,350 --> 00:07:38,710
Diz

81
00:07:42,030 --> 00:07:47,610
para acceder al atributo de la clase y utilizamos la variable Contador personas que se estatica para

82
00:07:47,610 --> 00:07:54,790
asignar el valor a la variable Heydi persona Contador personas punto y coma cualquier duda con esta

83
00:07:54,790 --> 00:08:01,330
sintaxis pueden revisar el tema de la palabra Static y posteriormente asignamos el valor que estamos

84
00:08:01,330 --> 00:08:02,740
recibiendo en este argumento

85
00:08:05,880 --> 00:08:14,240
le asignamos el valor del argumento nombre al atributo nombre y con ya tenemos definido el constructor

86
00:08:14,240 --> 00:08:15,340
de nuestra clase.

87
00:08:15,440 --> 00:08:20,930
Ahora vamos a agregar el método jet set para este atributo de nombre son los únicos métodos que vamos

88
00:08:20,930 --> 00:08:27,500
a necesitar así que definimos el método G.T que va a ser públic string nombre

89
00:08:31,200 --> 00:08:40,710
y hacemos un ratón nombre podemos utilizar dis para que sepamos de inmediato que es el atributo de nuestra

90
00:08:40,710 --> 00:08:41,700
clase.

91
00:08:41,790 --> 00:08:47,490
Posteriormente creamos el método set para este mismo atributo public void C Nombre

92
00:08:50,570 --> 00:08:59,260
recibimos el argumento de nombre y modificamos el valor de nuestro atributo le asignamos el argumento

93
00:08:59,260 --> 00:09:06,310
de nombre y con eso ya tenemos completa nuestra clase de persona aunque aquí nos marca un warning que

94
00:09:06,310 --> 00:09:08,380
la persona no está siendo utilizado.

95
00:09:08,380 --> 00:09:14,460
Esto no es correcto ya que el constructor de la clase se está asignando un nuevo valor al atributo de

96
00:09:14,470 --> 00:09:21,320
persona así que podemos ignorar este comentario ahora como siguiente paso vamos a nuestra clase de prueba

97
00:09:21,530 --> 00:09:24,070
y vamos a crear una regla para poder iterar.

98
00:09:24,290 --> 00:09:29,720
Un arreglo de objetos de tipo persona para que veamos que también es posible con esta sintaxis de frizz

99
00:09:29,960 --> 00:09:36,170
que podemos iterar no solamente arreglos de tipo primitivo sino también arreglos de tipo obvie así que

100
00:09:36,170 --> 00:09:45,090
vamos a crear nuestro arreglo de tipo personal declaramos nuestra variable que es un arreglo de objetos

101
00:09:45,090 --> 00:09:46,610
de tipo personal.

102
00:09:46,860 --> 00:09:52,110
La variable se llama personas y vamos a utilizar la sintaxis simplificada para asignar cada uno de los

103
00:09:52,110 --> 00:09:52,920
valores.

104
00:09:53,160 --> 00:09:58,640
Así que abrimos nuestras llaves y vamos a asignar solamente dos elementos dos objetos de tipo personal.

105
00:09:58,800 --> 00:10:06,410
Así creamos nuestro primer objeto recordemos que el constructor recibe el nombre de esta persona así

106
00:10:06,410 --> 00:10:16,030
que pasamos el valor de Juan y posteriormente creamos el segundo objeto y recibimos el valor de Carla.

107
00:10:16,030 --> 00:10:22,040
Cualquier nombre es correcto sin embargo debemos de importar esta clase ya que se encuentra en otro

108
00:10:22,040 --> 00:10:28,040
paquete así que damos clic sobre este icono que nos está mostrando nos muestra el error e importamos

109
00:10:28,040 --> 00:10:36,080
la clase entidad persona a corregir el nombre de la clase solamente es persona ya había puesto personas

110
00:10:36,500 --> 00:10:41,110
bien ya está corregido esto esto ya estamos usando nuestro arreglo de tipo persona.

111
00:10:41,150 --> 00:10:46,400
Sin embargo tenemos un detalle no está marcando un error de que el constructor de la clase persona no

112
00:10:46,400 --> 00:10:52,460
es público así que debido a que estamos en otro paquete este constructor de la clase persona debe de

113
00:10:52,460 --> 00:10:57,890
ser público así que hacemos público este constructor y con eso ya podemos crear los objetos de tipo

114
00:10:57,890 --> 00:11:01,060
Persona desde otra clase sin ningún problema.

115
00:11:01,070 --> 00:11:06,320
Ahora vamos a agregar un salto de línea y vamos a recorrer cada uno de los elementos de este arreglo

116
00:11:06,320 --> 00:11:07,930
de tipo personal.

117
00:11:08,000 --> 00:11:10,070
De igual manera la sintaxis del ciclo frizz.

118
00:11:10,160 --> 00:11:16,160
Primero establecemos la variable que va a recibir cada uno de los elementos de nuestro arreglo así que

119
00:11:16,160 --> 00:11:20,300
definimos una variable llamada persona.

120
00:11:20,420 --> 00:11:25,580
Este nombre de esta variable puede ser cualquiera pero el tipo sí debe de ser la variable persona.

121
00:11:25,640 --> 00:11:27,750
Por ejemplo podría ser únicamente P.

122
00:11:27,830 --> 00:11:31,230
El nombre de la variable que va a recibir cada uno de los elementos.

123
00:11:31,250 --> 00:11:37,510
Posteriormente escribimos dos puntos y finalmente el nombre del arreglo o la lista que vamos a iterar

124
00:11:39,630 --> 00:11:45,840
abrimos el bloque de código y con eso ya tenemos acceso a nuestra variable P Y la variable P Va a contener

125
00:11:45,840 --> 00:11:52,350
cada uno de los elementos que va iterar del arreglo personas así que podemos hacer lo siguiente mandamos

126
00:11:52,350 --> 00:11:59,310
a imprimir la variable persona bien conocida tenemos todo nuestro código guardamos cambios y ejecutamos.

127
00:11:59,310 --> 00:12:04,260
Así que si mandamos a imprimir el objeto persona nos mostrará la dirección de memoria de cada uno de

128
00:12:04,260 --> 00:12:07,350
los objetos guardamos cambios y ejecutamos

129
00:12:12,090 --> 00:12:17,230
y podemos observar las dos variables que estamos definiendo de objetos de tipo personal pero nos está

130
00:12:17,230 --> 00:12:22,500
mostrando la dirección de memoria donde se encuentra cada objeto así que vamos a agregar el método string

131
00:12:22,570 --> 00:12:26,310
a nuestra clase persona para que se muestren los valores de esta clase.

132
00:12:26,410 --> 00:12:33,340
En este caso el atributo de nombre así que definimos el método públic va a regresar un string llamado

133
00:12:33,340 --> 00:12:45,340
tubes string no reciben ningún argumento y hacemos un gritón concatenando el valor del atributo de nombre

134
00:12:45,450 --> 00:12:47,190
es todo lo que vamos a mandar a consola

135
00:12:50,600 --> 00:12:56,530
bien con esto guardamos cambios ya tenemos la definición del método string guardamos cambios y volvemos

136
00:12:56,530 --> 00:13:02,350
a ejecutar damos clic derecho romboide y podemos ver que ya nos muestra ahora el nombre de Juan y el

137
00:13:02,350 --> 00:13:04,050
nombre de Carla respectivamente

138
00:13:07,860 --> 00:13:13,140
ahora también podremos modificar el método string para imprimir el elemento Airi de cada uno de los

139
00:13:13,140 --> 00:13:19,890
objetos que estamos creando así que vamos a quitar este método de string y vamos a sobreescribir utilizando

140
00:13:20,100 --> 00:13:27,620
la ayuda de Lide damos un derecho insert Coupet seleccionamos método string y en este caso seleccionamos

141
00:13:27,620 --> 00:13:34,490
los dos atributos Heydi persona y nombre damos clic en generar y Podemos se va que ya se ha generado

142
00:13:34,700 --> 00:13:40,990
el método string donde va a imprimir el valor de hoy de persona y también el atributo de nombre bien

143
00:13:41,040 --> 00:13:48,640
con esto vamos a guardar cambios y ejecutamos damos clic derecho romboide y podemos llevar los valores

144
00:13:48,730 --> 00:13:49,950
en la persona.

145
00:13:49,990 --> 00:13:55,000
El primer objeto que se ha creado se le asignó el valor de 1 debido a la variable Contador personas

146
00:13:55,000 --> 00:14:00,850
que es de tipo estático así que esta variable estática va a llevar el conteo de cada uno de los objetos

147
00:14:01,090 --> 00:14:07,370
que se crea cada objeto de tipo Persona posteriomente el segundo objeto tiene el valor de 2 y así por

148
00:14:07,370 --> 00:14:13,100
cada objeto que creemos se le va a asignar un nuevo Heydi persona y podemos observar el nombre del primer

149
00:14:13,100 --> 00:14:13,730
objeto.

150
00:14:13,820 --> 00:14:19,340
El nombre de Juan y el segundo el valor de Carla así que con eso estamos observando la sintaxis del

151
00:14:19,340 --> 00:14:24,650
ciclo frizz podemos observar que es bastante más sencillo iterar cada uno de los elementos de nuestro

152
00:14:24,650 --> 00:14:25,330
arreglo.

153
00:14:25,520 --> 00:14:31,100
Sin embargo debemos de tomar en cuenta que no tenemos acceso al contador así que si necesitamos de un

154
00:14:31,100 --> 00:14:36,590
contador para saber qué elementos ya que estamos iterar en cierto momento nosotros tendríamos que declarar

155
00:14:36,620 --> 00:14:43,000
ese contador y llevar ese control manualmente es el único detalle cuando trabajamos con este ciclo frizz

156
00:14:43,770 --> 00:14:47,180
bien eso es todo por esta elección y nos vemos en el siguiente video.

157
00:14:47,180 --> 00:14:47,810
Saludos.
