1
00:00:00,510 --> 00:00:02,240
Hola y bienvenidos a esta elección.

2
00:00:02,250 --> 00:00:06,050
A continuación vamos a ver el tema de sentencias de control en Java.

3
00:00:06,330 --> 00:00:10,360
Vamos a comenzar con la sentencia de control y ellos están listos.

4
00:00:10,410 --> 00:00:15,000
Vamos vamos a seguir trabajando con nuestro proyecto.

5
00:00:15,240 --> 00:00:21,540
Vamos a limpiar el código y vamos a empezar con nuestras sentencias de control y normalmente con lo

6
00:00:21,540 --> 00:00:26,610
que hemos trabajado hasta el momento las sentencias que vamos agregando dentro de nuestro método main

7
00:00:26,880 --> 00:00:28,920
se van ejecutando una a una.

8
00:00:29,610 --> 00:00:35,700
Sin embargo para cambiar el flujo de ejecución de nuestro programa podemos utilizar la sentencia y de

9
00:00:35,700 --> 00:00:41,280
esta manera va a haber sentencias que se van a omitir dependiendo de la condición a evaluar.

10
00:00:41,760 --> 00:00:49,970
Así que tenemos lo siguiente vamos a encontrar la sentencia IF y recibimos una condición si esta condición

11
00:00:50,000 --> 00:00:53,540
es verdadera entonces se va a ejecutar esta parte del código

12
00:00:58,620 --> 00:01:05,430
pueden existir varias líneas de código dentro de esta condición y si la condición es falsa entonces

13
00:01:05,430 --> 00:01:06,440
se va a ejecutar.

14
00:01:06,540 --> 00:01:11,610
Esta segunda parte del código se va a omitir la primera parte de la ejecución de este código

15
00:01:14,340 --> 00:01:18,010
vamos a definir la variable condición para poner en práctica este ejercicio.

16
00:01:18,800 --> 00:01:19,850
Va a ser de tipo bar

17
00:01:23,100 --> 00:01:31,360
y vamos a comenzar con el valor de Chubb damos un formato guardamos cambios y ejecutamos

18
00:01:34,620 --> 00:01:40,320
y podemos observar que debido a que el valor de la condición es verdadero entonces únicamente se ejecutó

19
00:01:40,330 --> 00:01:41,710
esta línea de código.

20
00:01:41,770 --> 00:01:49,270
Por lo tanto la salida es condición verdadera y se omitió la parte del ELS pero si cambiamos el valor

21
00:01:49,270 --> 00:01:58,740
de la condición a fouls guardamos cambios y ejecutamos podemos observar que se ejecutó únicamente la

22
00:01:58,740 --> 00:02:00,030
parte del ELS.

23
00:02:00,300 --> 00:02:05,970
Así que con esto podemos cambiar el flujo de nuestra aplicación ya que únicamente se va a ejecutar parte

24
00:02:05,970 --> 00:02:13,190
del código que estamos observando De hecho la sentencia IF podría no contener la parte del ELS únicamente

25
00:02:13,190 --> 00:02:19,510
podríamos tener la condición del IFE y aún así seguiría funcionando nuestro programa sin ningún problema.

26
00:02:19,670 --> 00:02:25,100
Sin embargo en este caso debido a que la condición es falsa entonces no se ejecuta la parte del código

27
00:02:25,120 --> 00:02:26,490
IF.

28
00:02:26,690 --> 00:02:33,380
Otro detalle del bloque es que si únicamente dentro del bloque de código del IRPF o del es se tiene

29
00:02:33,380 --> 00:02:39,020
únicamente una línea de código como en este caso entonces podemos omitir las llaves

30
00:02:43,210 --> 00:02:46,620
así que sería opcional en este caso utilizar llaves.

31
00:02:46,720 --> 00:02:51,710
Sin embargo si el bloque en este caso por ejemplo es bloquees tiene varias líneas de código.

32
00:02:51,760 --> 00:02:58,210
Entonces sí es necesario englobar estas líneas de código entre llaves en este caso se pueden omitir

33
00:02:58,480 --> 00:03:02,080
ya que únicamente incluyen una línea de código.

34
00:03:02,080 --> 00:03:07,780
Como podemos observar en ambos casos bien así que de esta manera quedaría más simplificado nuestro código

35
00:03:10,080 --> 00:03:15,780
sin embargo podemos observar que si damos formato en automático el IDE por buena práctica le agrega

36
00:03:15,780 --> 00:03:18,890
las llaves ya que podríamos provocar problemas.

37
00:03:18,960 --> 00:03:25,350
En dado caso de que posteriormente agreguemos más líneas de código si no agregamos estas llaves entonces

38
00:03:25,440 --> 00:03:32,980
estaríamos rompiendo con el flujo del bloque y por eso es que en automático el IDE agrega estas llaves.

39
00:03:33,230 --> 00:03:39,470
Para prevenir este tipo de problemas bien vamos a ver ahora un ejemplo vamos a proporcionar un número

40
00:03:39,920 --> 00:03:45,590
y dependiendo del valor del número vamos a imprimir este valor a consola pero ahora en texto en lugar

41
00:03:45,590 --> 00:03:47,490
de imprimir únicamente el número.

42
00:03:47,510 --> 00:03:55,360
Así que definimos una variable número y le ponemos un valor por ejemplo en este caso el valor de 1 y

43
00:03:55,390 --> 00:04:02,750
empezamos a escribir el siguiente código revisamos si la variable número es igual a 1

44
00:04:08,960 --> 00:04:20,470
entonces imprimimos a consola el valor pero en texto número 1 si no ponemos

45
00:04:24,920 --> 00:04:28,670
valor desconocido guardamos cambios y ejecutamos

46
00:04:33,130 --> 00:04:42,150
y podemos ver que en este caso se está entrando a la condición del bloque if se imprime número 1 y podemos

47
00:04:42,170 --> 00:04:44,620
observar que ya no se imprime el valor desconocido.

48
00:04:44,720 --> 00:04:51,350
Pero qué pasa si tenemos más números si queremos comprobar por ejemplo si tenemos el número dos como

49
00:04:51,350 --> 00:04:52,670
entrada.

50
00:04:52,670 --> 00:05:01,990
Entonces podemos agregar el siguiente caso después del IFF podríamos agregar un bloque es If para poder

51
00:05:01,990 --> 00:05:10,970
comprobar más números dentro de este mismo ejemplo así comprobamos si el valor proporcionado no fue

52
00:05:10,970 --> 00:05:11,670
1.

53
00:05:11,720 --> 00:05:20,110
Entonces revisamos si el valor fue 2 y mandamos a imprimir número 2.

54
00:05:20,390 --> 00:05:22,010
Guardamos cambios y ejecutamos

55
00:05:25,770 --> 00:05:31,320
y podemos observar que en este caso únicamente se está imprimiendo número 2 y así podríamos agregar

56
00:05:31,320 --> 00:05:32,950
más condiciones.

57
00:05:32,970 --> 00:05:38,070
Por ejemplo si cambiamos el valor número 3 entonces agregamos otra condición

58
00:05:42,080 --> 00:05:45,220
y revisamos si el valor es igual a 3.

59
00:05:45,290 --> 00:05:53,150
Si el número proporcionado es igual a 3 entonces mandamos a imprimir número 3 guardamos cambios ejecutamos

60
00:05:53,960 --> 00:05:59,870
y podemos ver que únicamente se está ejecutando esta parte del bloque de código del bloque if todo lo

61
00:05:59,870 --> 00:06:04,040
demás está omitiendo ya que únicamente se van realizando las comprobaciones.

62
00:06:04,160 --> 00:06:11,980
Pero si no corresponde al número proporcionado entonces no se ejecuta esa parte de la condición ahora

63
00:06:11,980 --> 00:06:19,000
sí proporcionamos por ejemplo el número cero guardamos y ejecutamos podemos observar que nos despliega

64
00:06:19,030 --> 00:06:25,750
el valor desconocido ya que no entro a ninguna de estas condiciones por no corresponder el valor y se

65
00:06:25,750 --> 00:06:27,370
va hasta la última condición.

66
00:06:27,370 --> 00:06:31,300
Valor desconocido vamos a ejecutar paso a paso.

67
00:06:31,300 --> 00:06:37,120
Este ejemplo para que podamos observar qué es lo que ocurre cómo se realizan las validaciones y cómo

68
00:06:37,120 --> 00:06:43,300
se va omitiendo la ejecución de los bloques de código así que ponemos un punto de ruptura en la definición

69
00:06:43,300 --> 00:06:44,770
de la variable número.

70
00:06:44,770 --> 00:06:50,500
Recordemos que del lado izquierdo es donde ponemos el punto de ruptura dando un clic posteriormente

71
00:06:50,500 --> 00:06:55,550
para ejecutar paso a paso damos clic derecho y seleccionamos la opción de debug file

72
00:06:58,400 --> 00:07:03,890
en ese tabulador podemos ver la salida y en esa sección podemos ver las variables y aquí en la parte

73
00:07:03,890 --> 00:07:07,670
superior recordemos que podemos ir ejecutando paso a paso.

74
00:07:07,670 --> 00:07:14,170
De momento vamos a utilizar este botón el botón de este over para ejecutar una línea de código.

75
00:07:14,330 --> 00:07:22,190
Así quedamos F8 o presionamos este botón se ejecuta esta línea de código y se ha creado nuestra variable

76
00:07:22,190 --> 00:07:30,830
número de tipo entero con el valor inicial de cero y empezamos a revisar nuestra sentencia y es lo primero

77
00:07:30,830 --> 00:07:33,510
que sucede es que se revisa esta condición.

78
00:07:33,980 --> 00:07:40,610
Si la condición de número es igual a 1 entonces nos debería de regresar verdadero y se ejecutaría esta

79
00:07:40,610 --> 00:07:42,440
parte del bloque de código.

80
00:07:42,440 --> 00:07:49,420
Pero como podemos observar si seleccionamos esta parte de código la ventaja es que en este momento como

81
00:07:49,440 --> 00:07:54,890
está ejecutando esta línea de código podemos seleccionar esta expresión y en automático el ID de la

82
00:07:54,900 --> 00:08:01,550
evalua y podemos observar que en este caso la condición de número igual a 1 es igual a fouls debido

83
00:08:01,550 --> 00:08:06,750
a que el número proporcionado es cero y no 1 y como esta condición fue falsa.

84
00:08:07,000 --> 00:08:14,200
Entonces si ejecutamos de nueva cuenta la siguiente línea podemos observar que se saldó la ejecución

85
00:08:14,320 --> 00:08:22,360
de esta línea de código se omitió y no se mostró en consola y si revisamos la consola no hay ninguna

86
00:08:22,360 --> 00:08:24,030
salida todavía.

87
00:08:24,130 --> 00:08:31,690
Ahora pasamos al bloque el IFF para revisar la siguiente condición estamos en esta línea y podemos observar

88
00:08:31,690 --> 00:08:36,190
que debido a que el número es igual a cero entonces la evaluación de esa expresión también es igual

89
00:08:36,190 --> 00:08:42,930
a falso y podemos llevar aquí el resultado de evaluar esta expresión y de nueva cuenta si ejecutamos

90
00:08:43,330 --> 00:08:49,890
f 8 podemos observar que se saltó esta línea de código y así sucesivamente va a ir revisando cada una

91
00:08:49,890 --> 00:08:55,890
de las condiciones y ejecutamos F8 podemos observar que la condición tampoco fue número igual a tres

92
00:08:56,310 --> 00:09:02,370
ya que su valor inicial es cero se salta esta línea y podemos observar que ahora entro al bloque de

93
00:09:02,370 --> 00:09:06,850
código es ya que ninguna de las otras condiciones fue verdadero.

94
00:09:06,900 --> 00:09:13,290
Por lo tanto caí en la condición por default es y se va a ejecutar esta línea de código donde va a imprimir

95
00:09:13,350 --> 00:09:19,750
el valor desconocido a consola vamos a la consola y podemos ver en la consola.

96
00:09:19,750 --> 00:09:21,130
Todavía no se imprime.

97
00:09:21,130 --> 00:09:27,110
Volvemos a ejecutar y en este momento se ha impreso a la consola valor desconocido.

98
00:09:27,110 --> 00:09:33,230
Todavía no he terminado el programa pero si presionamos F8 se termina de ejecutar el método main y termina

99
00:09:33,230 --> 00:09:39,310
la ejecución del programa así que esta es la forma en que se ejecuta paso a paso nuestro programa.

100
00:09:39,530 --> 00:09:45,980
Ahora si proporcionamos otro valor por ejemplo el valor de número igual a dos volvemos a ejecutar paso

101
00:09:45,980 --> 00:09:54,810
a paso damos clic derecho de Buffy y empezamos a revisar la condición de número es igual a 1.

102
00:09:54,930 --> 00:10:01,200
En este caso es igual a falsa por lo tanto pasa a la siguiente condición y en este caso esta expresión

103
00:10:01,200 --> 00:10:09,890
si la seleccionamos podemos observar que el valor de evaluar esta expresión es igual a tu por lo tanto

104
00:10:09,890 --> 00:10:15,200
va a ejecutar este bloque de código todo lo que esté contenido dentro de este bloque de código es lo

105
00:10:15,200 --> 00:10:23,490
que va a ejecutar y es lo único que va a ejecutar de este bloque y de nueva cuenta ejecutamos F8 vamos

106
00:10:23,490 --> 00:10:30,360
a Lovett para que veamos la impresión de este valor de nueva cuenta F8 y podemos llevar que nos imprime

107
00:10:30,360 --> 00:10:37,890
a consola el valor número dos y en automático terminó de ejecutar este bloque de código y podemos ver

108
00:10:37,890 --> 00:10:43,920
que se va hasta el final de la función debido a que todas las demás condiciones ya no se van a evaluar.

109
00:10:43,920 --> 00:10:50,100
Esto es porque ya se ejecutó la condición que sí correspondió a la revisión que estamos realizando así

110
00:10:50,100 --> 00:10:52,280
que termina de ejecutar todo este bloque.

111
00:10:53,190 --> 00:11:00,340
Y en este caso ya termina también el método main Damos Siguiente y termina la ejecución de nuestro programa

112
00:11:01,210 --> 00:11:07,600
así que de esta forma es como funciona el bloque de código y se va revisando cada una de las condiciones

113
00:11:07,870 --> 00:11:13,570
y dependiendo de la condición que coincida entonces se omite todo lo demás y únicamente se ejecuta la

114
00:11:13,570 --> 00:11:19,900
parte de la condición que dio verdadero y todo lo demás se omite bien quitamos nuestro punto de ruptura

115
00:11:20,500 --> 00:11:23,400
y vamos a hacer una pequeña mejora a este código.

116
00:11:23,530 --> 00:11:30,640
Esta cadena vamos a asignar a una variable en lugar de imprimir la directamente definimos una variable

117
00:11:31,450 --> 00:11:41,020
que se llame número texto y su valor por default es número desconocido y entonces en cada una de estas

118
00:11:41,020 --> 00:11:48,820
sentencias vamos a hacer lo siguiente la variable número texto le vamos asignando los valores por ejemplo

119
00:11:48,820 --> 00:11:51,620
en este caso número 1

120
00:11:57,570 --> 00:12:00,810
en este caso número 2 y así sucesivamente

121
00:12:08,100 --> 00:12:09,930
asignamos el valor de número tres

122
00:12:19,000 --> 00:12:25,380
y aunque ya tenemos el valor de número desconocido vamos a asignar simplemente para que no rompamos

123
00:12:25,380 --> 00:12:26,760
el flujo de nuestra aplicación.

124
00:12:29,040 --> 00:12:36,710
Valor desconocido y una vez que terminado de hacerse esta revisión entonces podemos mandar a imprimir

125
00:12:36,860 --> 00:12:43,580
pero ahora imprimimos el valor de la variable número texto así que solamente tenemos un sistema Punto

126
00:12:43,580 --> 00:12:45,140
a Punto LN.

127
00:12:45,250 --> 00:12:51,170
En toda esta revisión del bloque fails y solamente lo que estuvimos modificando fue el valor de la variable

128
00:12:51,230 --> 00:12:57,860
número texto conforme íbamos haciendo cada una de las revisiones así que guardamos cambios y ejecutamos

129
00:12:59,430 --> 00:13:04,770
y podemos observar que en este caso tenemos el número dos y el texto que nos imprime es precisamente

130
00:13:05,040 --> 00:13:07,360
el texto número 2.

131
00:13:07,660 --> 00:13:14,250
Así que con esto hemos formalizado el uso de la sentencia y eso es todo por esta elección y nos vemos

132
00:13:14,250 --> 00:13:15,480
en el siguiente vídeo.

133
00:13:15,540 --> 00:13:16,230
Saludos.
