1
00:00:01,000 --> 00:00:02,640
Hola y bienvenidos a esta elección.

2
00:00:02,650 --> 00:00:04,610
A continuación vamos a estudiar el ciclo.

3
00:00:04,660 --> 00:00:06,430
En Java están listos.

4
00:00:06,490 --> 00:00:06,970
Vamos

5
00:00:09,940 --> 00:00:16,210
bien vamos a quitar el contenido de nuestro método Moine y vamos a escribir el siguiente código.

6
00:00:16,490 --> 00:00:23,390
El ciclo joyel se compone de la palabra reservada Jail y posteriormente tenemos una condición esta condición

7
00:00:23,510 --> 00:00:25,790
debe de ser de tipo Juliano.

8
00:00:25,790 --> 00:00:31,720
Posteriormente abrimos un bloque de código utilizando llaves de apertura y de cierre.

9
00:00:31,820 --> 00:00:37,040
Estas llaves se pueden omitir siempre y cuando el contenido del ciclo únicamente incluya una línea de

10
00:00:37,040 --> 00:00:42,560
código pero si incluye más de una línea entonces se tiene que utilizar este bloque de código incluyendo

11
00:00:42,560 --> 00:00:48,560
las llaves bien posteriormente podemos agregar lo siguiente para poner en práctica esto

12
00:00:55,650 --> 00:00:58,650
damos formato y ejecutamos

13
00:01:02,300 --> 00:01:06,090
y podemos observar un ejemplo de ejecución de ciclo infinito.

14
00:01:06,320 --> 00:01:13,390
Se está repitiendo constantemente la impresión de la cadena ciclo infinito joyel así que está avanzando.

15
00:01:13,400 --> 00:01:19,580
Podemos observar que un ciclo básicamente lo que hace es repetir la instrucción que contiene dentro

16
00:01:19,580 --> 00:01:21,440
de su bloque de código.

17
00:01:21,440 --> 00:01:26,390
Sin embargo no es común que tengamos ciclos infinitos ya que esto podría bloquear la ejecución de nuestro

18
00:01:26,390 --> 00:01:27,280
programa.

19
00:01:27,320 --> 00:01:33,650
Lo común es que manejemos un tipo de contador para que podamos saber hasta qué punto ejecutar este ciclo

20
00:01:34,460 --> 00:01:40,160
Vamos a hacer esta modificación a nuestro código para manejar un ciclo detenemos la ejecución de nuestro

21
00:01:40,160 --> 00:01:43,410
programa presionando este botón.

22
00:01:43,700 --> 00:01:49,910
Ahora vamos a definir lo siguiente definimos una variable que nos va a servir para detener la ejecución

23
00:01:49,910 --> 00:01:50,880
en nuestro programa.

24
00:01:51,050 --> 00:01:56,480
Si llega a cierta condición nuestro programa así que esta variable se va a llamar Contador pero puede

25
00:01:56,480 --> 00:02:04,940
ser cualquier otro nombre y su valor va a iniciar en cero y este ciclo se va a ejecutar únicamente mientras

26
00:02:04,940 --> 00:02:10,320
el contador sea menor que el valor de tres.

27
00:02:10,340 --> 00:02:16,520
Sin embargo debemos de controlar el valor de este contador si ejecutamos este ciclo tal cual como está

28
00:02:16,520 --> 00:02:22,700
codificado entonces en ningún momento se está incrementando el valor del contador por lo tanto dentro

29
00:02:22,700 --> 00:02:29,860
del cuerpo del ciclo Jail lo común es que incrementemos el valor de este contador así que ponemos un

30
00:02:29,860 --> 00:02:36,920
contador más más para que cada vez que se ejecute una vez este ciclo Jail se incremente en 1 el valor

31
00:02:36,920 --> 00:02:43,430
del contador y así cada vez que se revise esta condición entonces el valor del contador se habrá incrementado

32
00:02:43,460 --> 00:02:45,560
en uno y cuando llegue a 3.

33
00:02:45,560 --> 00:02:51,190
Entonces esta condición va a pasar de verdadero a falso y se va a detener la ejecución del ciclo Juanele

34
00:02:51,740 --> 00:02:58,700
vamos a guardar cambios y ejecutamos y podemos observar que este ciclo Jail únicamente se imprimió tres

35
00:02:58,700 --> 00:03:05,360
veces ya no es un ciclo infinito sino que ahora únicamente se está imprimiendo tres veces este ciclo

36
00:03:05,390 --> 00:03:05,700
Joey

37
00:03:08,600 --> 00:03:16,810
vamos a imprimir el valor de la variable Contador guardamos y ejecutamos así que podemos observar que

38
00:03:16,810 --> 00:03:19,620
el valor del contador va de 0 a 2.

39
00:03:19,690 --> 00:03:25,630
Esto quiere decir que se imprimió tres veces en total y ahora vamos a ejecutar paso a paso ese programa

40
00:03:25,870 --> 00:03:29,240
para que observemos cómo se ejecuta detalle este ciclo.

41
00:03:29,740 --> 00:03:35,770
Vamos a poner un punto de ruptura en la definición de esta variable la variable Contador damos clic

42
00:03:35,770 --> 00:03:44,750
derecho y seleccionamos de Buffalo presionamos F8 o el botón de step over con eso se define la variable

43
00:03:44,750 --> 00:03:49,290
Contador que es de tipo entero y su valor inicial es cero.

44
00:03:49,370 --> 00:03:56,480
Por lo tanto esta condición si nos posicionamos y seleccionamos este código podemos observar en este

45
00:03:56,480 --> 00:03:59,070
momento el valor del contador es cero.

46
00:03:59,120 --> 00:04:03,150
Por lo tanto será menor que 3 no regresa el valor de Chú.

47
00:04:03,320 --> 00:04:08,780
Por lo tanto mientras esta condición sea verdadera entonces lo que se va a hacer es que se va a ejecutar

48
00:04:08,960 --> 00:04:16,250
este bloque de código por lo tanto lo siguiente a hacer es ejecutar esta línea e incrementar el contador.

49
00:04:16,250 --> 00:04:22,370
Vamos a ver de nueva cuenta presionamos este over y podemos observar que se está ejecutando ya el bloque

50
00:04:22,370 --> 00:04:30,580
de código joyel vamos al tabulador de output para ver la salida presionamos de nueva cuenta F8 y podemos

51
00:04:30,590 --> 00:04:37,080
observar la primera impresión el valor del contador es igual a cero y la siguiente línea es que va a

52
00:04:37,080 --> 00:04:43,820
incrementar el valor del contador así que presionamos F8 y observamos que ahora el valor del contador

53
00:04:43,940 --> 00:04:51,650
ya es igual a 1 de nueva cuenta regresa a revisar la condición del ciclo cuál y en este caso uno menor

54
00:04:51,650 --> 00:04:52,430
qué tres.

55
00:04:52,520 --> 00:04:58,420
Entonces todavía la condición es verdadera así que vuelvo a ejecutar el bloque de código del ciclo Jail

56
00:04:59,370 --> 00:05:08,230
y ahora imprime el contador igual a 1 así que ya se incrementó el contador en 1 se imprimen y volvemos

57
00:05:08,230 --> 00:05:09,970
a incrementar el contador.

58
00:05:10,150 --> 00:05:17,510
En este momento el Contador ya tiene el valor de dos y la condición 2 menor que 3 todavía es verdadera

59
00:05:17,750 --> 00:05:26,140
así que se vuelve a ejecutar el ciclo cual se vuelve a imprimir el valor del contador y volvemos a incrementar

60
00:05:26,230 --> 00:05:34,930
este contador pero ahora la condición sería 3 menor que 3 y esto nos va a regresar el valor de falso

61
00:05:35,230 --> 00:05:39,170
ya que la condición de 3 menor que 3 es igual a falso.

62
00:05:39,220 --> 00:05:45,940
Por lo tanto ya no se ejecuta este bloque de código y termina la ejecución del ciclo Juanele y ya estamos

63
00:05:45,940 --> 00:05:47,440
en la última línea de nuestro método.

64
00:05:47,560 --> 00:05:51,790
Ejecutamos finalmente y termina la ejecución de nuestro programa.

65
00:05:51,790 --> 00:05:57,910
Si quisiéramos que incluyeran el valor de tres entonces tendríamos que utilizar menor o igual y en este

66
00:05:57,910 --> 00:06:05,860
caso si imprimiría también el valor de tres iría el contador de cero a tres así que ya dependiendo de

67
00:06:05,860 --> 00:06:09,840
la condición que necesitemos podemos utilizar menor o igual.

68
00:06:10,000 --> 00:06:16,300
Así que con esto podemos observar el uso de Juanele tenemos una variante en la cual podemos utilizar

69
00:06:16,420 --> 00:06:23,320
el ciclo conocido como Dujshebaev y básicamente la diferencia es que la primera vez que se ejecuta el

70
00:06:23,320 --> 00:06:26,830
bloque de código no se revisa la condición.

71
00:06:26,830 --> 00:06:35,540
Vamos a copiar este código así que podemos observar que el primero indica que se realice este código.

72
00:06:35,540 --> 00:06:41,360
El bloque de código sin necesidad de realizar ninguna comprobación y una vez que hemos ejecutado al

73
00:06:41,360 --> 00:06:51,070
menos una vez este bloque de código entonces se revisa la condición por ejemplo Contador menor que tres

74
00:06:52,120 --> 00:06:52,900
punto y coma

75
00:06:56,740 --> 00:06:58,210
vamos a poner entre comentarios.

76
00:06:58,240 --> 00:07:06,210
Este código presionamos este botón para que nos lo pongan entre comentarios y para quitar los comentarios

77
00:07:06,210 --> 00:07:13,920
simplemente volvemos a seleccionar y damos clic en el botón de quitar comentarios bien así que guardamos

78
00:07:13,920 --> 00:07:23,150
cambios y ejecutamos y podemos observar que el resultado es igual el valor del contador va de 0 a 2

79
00:07:23,540 --> 00:07:29,810
ya que no incluye el valor de 3 porque la comprobación no es menor igual sino únicamente Contador menor

80
00:07:29,810 --> 00:07:37,040
que 3 y básicamente la diferencia es que la primera vez se ejecuta este bloque de código sin revisar

81
00:07:37,040 --> 00:07:42,830
la condición y una vez que se ha ejecutado este bloque de código entonces se revisa la condición.

82
00:07:42,830 --> 00:07:49,070
Así que Jail podemos observar que desde el principio revisa la condición si la condición es verdadera

83
00:07:49,100 --> 00:07:54,470
entonces no se ejecuta este bloque de código pero en el caso del dibujo el primero se ejecuta el bloque

84
00:07:54,470 --> 00:08:00,560
de código así que por lo menos se ejecuta una vez y posteriormente se revisa la condición así que es

85
00:08:00,560 --> 00:08:03,660
raro que nuestros algoritmos utilicemos el ciclo de.

86
00:08:03,800 --> 00:08:09,740
Sin embargo es una variante que podemos utilizar en dado caso que así lo necesitemos y se les deja como

87
00:08:09,740 --> 00:08:13,840
ejercicio revisar paso a paso la ejecución de este ciclo de.

88
00:08:14,300 --> 00:08:19,520
Pero básicamente van a observar que la primera vez ejecuta este bloque de código y posteriormente se

89
00:08:19,520 --> 00:08:21,530
revisa la condición también.

90
00:08:21,540 --> 00:08:26,430
De igual manera que en el ciclo Jail debemos de controlar el contador.

91
00:08:26,450 --> 00:08:32,960
De lo contrario vamos a tener ciclos infinitos si no tenemos alguna condición que termine nuestro ciclo.

92
00:08:32,960 --> 00:08:38,390
Entonces esto va a ser un ciclo infinito y esto puede bloquear la ejecución de nuestro programa así

93
00:08:38,390 --> 00:08:44,000
que en ese tipo de ciclos tanto el modo cual debemos estar conscientes que debemos de tener control

94
00:08:44,090 --> 00:08:50,630
de la condición que va a detener el ciclo joyel ya sea utilizando una variable de tipo Contador o cualquier

95
00:08:50,630 --> 00:08:57,340
otra condición o evento que provoque que se detenga este ciclo joyel bien eso es todo por esta elección

96
00:08:57,570 --> 00:08:59,170
y nos vemos en el siguiente video.

97
00:08:59,300 --> 00:08:59,920
Saludos.
