1
00:00:00,500 --> 00:00:07,320
Vale, voy a grabar esta clase, por lo tanto, si habláis, me dais vuestra autorización a grabar vuestra voz.

2
00:00:08,779 --> 00:00:17,940
Entonces, nosotros hasta ahora hemos visto principalmente expresiones y tipos de datos.

3
00:00:17,940 --> 00:00:33,899
A este momento, a hoy, a 7 de octubre de 2026, deberíais tener claro la diferencia entre tipos y cómo se declara una variable y qué tipos de operadores hay.

4
00:00:34,439 --> 00:00:40,000
Esta es la base que hemos visto hasta ahora y con eso hemos hecho algunos ejemplos.

5
00:00:40,000 --> 00:00:49,979
Hemos hecho ejercicios que han usado la suma, la resta, el módulo, hemos usado el operador ternario para ver sobre todo la parte booleana.

6
00:00:49,979 --> 00:01:01,039
Entonces hemos visto convicciones con el AND, con el OR, con el NOT, con el mayor, menor, comparación, igual, igual, not igual, etc.

7
00:01:01,039 --> 00:01:08,659
etcétera. En este momento vosotros deberíais saber estas cosas de aquí y cómo se utilizan.

8
00:01:08,659 --> 00:01:13,219
Cómo declarar una variable, qué quiere decir declarar una variable, qué diferencia hay entre

9
00:01:13,219 --> 00:01:18,319
declarar una variable y asignar una variable, qué son los tipos de datos, cuáles son los tipos de

10
00:01:18,319 --> 00:01:23,659
datos compatibles, cómo puede hacer un casting o sea una conversión desde un tipo a otro,

11
00:01:23,659 --> 00:01:28,659
cuáles son las conversiones automáticas, cuáles son las conversiones en vez que tengo que hacer

12
00:01:28,659 --> 00:01:34,540
explícitamente y cuáles son las conversiones que no puedo hacer esto es lo que hemos estado

13
00:01:34,540 --> 00:01:45,569
trabajando la última semana un poco más de las últimas vale cuando nosotros hemos utilizado

14
00:01:45,569 --> 00:02:04,090
un ternario vale que es el operador ternario existe porque valdrá la expresión que hay esto

15
00:02:04,090 --> 00:02:14,909
Es un operador, no un booleano, no necesariamente, pero ¿todo esto de aquí qué es en una palabra?

16
00:02:14,909 --> 00:02:15,909
No.

17
00:02:15,909 --> 00:02:16,909
¿Con disquete?

18
00:02:16,909 --> 00:02:17,909
No.

19
00:02:17,909 --> 00:02:20,280
¿Lo mismo que esto?

20
00:02:20,280 --> 00:02:21,280
¿O esto?

21
00:02:21,280 --> 00:02:22,280
No, no.

22
00:02:22,280 --> 00:02:23,280
Bueno, no.

23
00:02:23,280 --> 00:02:24,280
¿Qué son esto?

24
00:02:24,280 --> 00:02:26,849
¿Qué son esto?

25
00:02:26,849 --> 00:02:27,849
¿Qué son esto?

26
00:02:27,849 --> 00:02:28,849
¿Qué son esto?

27
00:02:28,849 --> 00:02:29,849
¿Qué son esto?

28
00:02:29,849 --> 00:02:31,849
Bueno, no.

29
00:02:31,849 --> 00:02:41,550
¿Qué son esto?

30
00:02:41,550 --> 00:02:43,550
Expresiones.

31
00:02:43,550 --> 00:02:45,550
Este señor de aquí es una expresión.

32
00:02:45,550 --> 00:02:47,550
¿Vale? En concreto es un

33
00:02:47,550 --> 00:02:49,550
operador, es un operador

34
00:02:49,550 --> 00:02:51,550
externario, pero, sustancialmente,

35
00:02:51,550 --> 00:02:53,550
esto es una expresión.

36
00:02:53,550 --> 00:02:55,550
Esto...

37
00:02:55,550 --> 00:03:00,460
¿Qué tipo tiene?

38
00:03:00,460 --> 00:03:02,460
Tres más cinco, ¿qué tipo tiene?

39
00:03:02,460 --> 00:03:04,460
¿Vale?

40
00:03:04,460 --> 00:03:11,479
T más cinco, ¿qué tipo tiene?

41
00:03:11,479 --> 00:03:17,780
¿Qué es? El tipo de C.

42
00:03:19,240 --> 00:03:21,280
Si C es un string, esto sería un string.

43
00:03:21,960 --> 00:03:23,680
Si C es un int, sería un int.

44
00:03:23,900 --> 00:03:25,300
Si C es un double, eso es un double.

45
00:03:26,639 --> 00:03:29,219
Entonces, muy probablemente tiene el tipo de C.

46
00:03:29,500 --> 00:03:30,599
¿Cuál es? No lo sé.

47
00:03:30,719 --> 00:03:32,780
No sé C, no lo he declarado, pues no lo sé.

48
00:03:33,400 --> 00:03:35,199
¿Vale? Pero sé que es el tipo de C.

49
00:03:35,780 --> 00:03:36,860
¿Qué tipo tiene esto?

50
00:03:45,830 --> 00:03:58,610
Entonces, tiene el tipo de la expresión que está aquí.

51
00:03:59,409 --> 00:03:59,909
Tipo T.

52
00:03:59,909 --> 00:04:04,000
si esa es una string

53
00:04:04,000 --> 00:04:06,599
pues todo esto se evaluará

54
00:04:06,599 --> 00:04:08,759
un string, si esto es un int

55
00:04:08,759 --> 00:04:10,419
pues todo esto se evaluará

56
00:04:10,419 --> 00:04:10,960
un int

57
00:04:10,960 --> 00:04:12,740
¿está claro?

58
00:04:13,659 --> 00:04:14,979
¿y esto qué tipo tiene?

59
00:04:20,509 --> 00:04:22,209
tiene que tener el mismo tipo

60
00:04:22,209 --> 00:04:23,790
no puede tener otro tipo

61
00:04:23,790 --> 00:04:25,990
si lo habéis probado

62
00:04:25,990 --> 00:04:28,750
si esto es verdadero devuelve un string

63
00:04:28,750 --> 00:04:30,389
si esto es falso devuelve un int

64
00:04:30,389 --> 00:04:31,870
se enfada, te dice no

65
00:04:31,870 --> 00:04:34,430
estas dos ramas tienen que tener

66
00:04:34,430 --> 00:04:37,069
expresiones distintas

67
00:04:37,069 --> 00:04:38,509
pero con el mismo tipo

68
00:04:38,509 --> 00:04:41,170
que cuando se evalúen estas expresiones

69
00:04:41,170 --> 00:04:42,730
obtengan el mismo tipo

70
00:04:42,730 --> 00:04:43,829
sea igual sea ese tipo

71
00:04:43,829 --> 00:04:46,970
si has metido string a un lado, pues el otro tiene que ser string

72
00:04:46,970 --> 00:04:49,310
si has metido un int a un lado, el otro tiene que ser un int

73
00:04:49,310 --> 00:04:50,870
si has metido double a un lado, el otro a un lado

74
00:04:50,870 --> 00:04:53,490
si has metido scanner a un lado

75
00:04:53,490 --> 00:04:54,910
el otro tiene que ser un scanner también

76
00:04:54,910 --> 00:04:56,589
¿sí?

77
00:04:57,009 --> 00:04:58,250
¿qué tipo tiene esto?

78
00:05:14,379 --> 00:05:15,040
aquí, ¿qué va?

79
00:05:15,040 --> 00:05:25,120
¿Qué tipo tiene?

80
00:05:26,240 --> 00:05:27,540
Es una expresión

81
00:05:27,540 --> 00:05:29,980
de tipo booleano

82
00:05:29,980 --> 00:05:37,339
¿Se entiende esto?

83
00:05:38,339 --> 00:05:39,759
Esta es una expresión

84
00:05:39,759 --> 00:05:41,339
de tipo T

85
00:05:41,339 --> 00:05:43,160
y esta es una expresión

86
00:05:43,160 --> 00:05:44,180
de tipo T

87
00:05:44,180 --> 00:05:47,600
Lo que quiero que quede claro

88
00:05:47,600 --> 00:05:49,399
porque luego es la diferencia con el

89
00:05:49,399 --> 00:05:50,720
hizo que veremos en breve

90
00:05:50,720 --> 00:05:54,920
es que aquí y aquí va una expresión.

91
00:05:56,519 --> 00:05:58,399
¿Entendéis qué es una expresión?

92
00:06:01,839 --> 00:06:03,879
System.org.tln

93
00:06:03,879 --> 00:06:05,839
Me gustan los gatos.

94
00:06:06,040 --> 00:06:06,839
¿Es una expresión?

95
00:06:09,360 --> 00:06:09,560
No.

96
00:06:10,660 --> 00:06:11,920
Es un comando.

97
00:06:12,980 --> 00:06:14,500
Es una instrucción.

98
00:06:15,660 --> 00:06:16,779
No es una expresión.

99
00:06:17,939 --> 00:06:19,540
¿Comillas me gustan los gatos?

100
00:06:19,720 --> 00:06:20,720
¿Comillas es una expresión?

101
00:06:23,240 --> 00:06:23,519
Sí.

102
00:06:23,519 --> 00:06:27,000
es un literal de tipo string

103
00:06:27,000 --> 00:06:28,740
y un literal es

104
00:06:28,740 --> 00:06:29,399
una expresión

105
00:06:29,399 --> 00:06:32,459
las expresiones son

106
00:06:32,459 --> 00:06:34,199
cosas que tú puedes

107
00:06:34,199 --> 00:06:36,879
evaluar y te dan un valor

108
00:06:36,879 --> 00:06:39,639
si te digo system.auto.println

109
00:06:39,639 --> 00:06:40,839
¿qué valor tiene?

110
00:06:41,500 --> 00:06:42,699
no tiene valor

111
00:06:42,699 --> 00:06:45,100
su gente tiene un valor

112
00:06:45,100 --> 00:06:46,620
pero como lo hemos visto nosotros

113
00:06:46,620 --> 00:06:48,779
no da un valor, hace una cosa

114
00:06:48,779 --> 00:06:51,180
ejecuta una instrucción

115
00:06:51,180 --> 00:06:52,579
hace un comando

116
00:06:52,579 --> 00:06:55,420
Pilla la expresión que me has dado

117
00:06:55,420 --> 00:06:57,180
Y la imprime en pantalla

118
00:06:57,180 --> 00:06:58,639
Pero por sí mismo

119
00:06:58,639 --> 00:07:00,540
No le puedo sumar 7

120
00:07:00,540 --> 00:07:03,480
No puedo hacer system.auto.println

121
00:07:03,480 --> 00:07:04,899
Algo más 7

122
00:07:04,899 --> 00:07:06,040
No sé si me explico

123
00:07:06,040 --> 00:07:07,699
Al system.out

124
00:07:07,699 --> 00:07:09,980
No puedo operar con él

125
00:07:09,980 --> 00:07:12,259
No puedo aplicar operadores

126
00:07:12,259 --> 00:07:13,779
Al system.auto.println

127
00:07:13,779 --> 00:07:15,079
Porque no es una expresión

128
00:07:15,079 --> 00:07:16,060
Es un comando

129
00:07:16,060 --> 00:07:22,629
Scan.nexint

130
00:07:22,629 --> 00:07:36,810
Es una expresión. Bueno, dejamos. Porque devuelve un valor. Dejamos por ahí. Eso no funciona.

131
00:07:36,810 --> 00:07:43,810
Estoy buscando, porque hemos hecho muy poco, otras cosas que podrían ser expresión.

132
00:07:43,810 --> 00:08:01,959
Si yo te digo int c es igual a 7, esta es una expresión. Esto. Int x es igual a c más 7. Esta es una expresión.

133
00:08:01,959 --> 00:08:08,459
No, es un coma, un coma de asignación.

134
00:08:09,220 --> 00:08:11,639
Esta es una expresión, ¿sí?

135
00:08:12,279 --> 00:08:14,439
Esta la puede evaluar a un valor.

136
00:08:14,620 --> 00:08:17,860
No sé cuánto vale c, si el p vale 5, pues 5 más 7, 12,

137
00:08:18,240 --> 00:08:20,100
pues esto vale 12 y es un entero.

138
00:08:20,459 --> 00:08:21,120
Sí lo puede hacer.

139
00:08:21,420 --> 00:08:23,000
Pero si te digo, ¿y cuánto vale esto?

140
00:08:23,819 --> 00:08:24,519
No lo sé.

141
00:08:26,639 --> 00:08:31,720
Esto hasta lo podría pensar, decir, mira, x sí, x así,

142
00:08:31,720 --> 00:08:36,879
es una expresión, pero aquí yo estoy haciendo una declaración, en otros son muy tristes, ¿vale?

143
00:08:36,879 --> 00:08:43,500
Es, tenéis que entender la diferencia entre las instrucciones y comandos, que son lo que hacen

144
00:08:43,500 --> 00:08:51,700
hacer algo en mi programa, ¿vale? Que construirán pasito a pasito el algoritmo, y las expresiones,

145
00:08:51,700 --> 00:08:57,039
que son los valores, a lo mejor complejos, porque yo para sacar el valor no es sólo siete,

146
00:08:57,039 --> 00:09:04,039
el tema es, pilla la edad, multiplícala para dos y divídala para el número de árboles de...

147
00:09:04,039 --> 00:09:13,039
¿Para qué sirve? No lo sé. ¿Vale? Pero es una operación grande, pero es una expresión que luego se evaluará a un valor concreto.

148
00:09:13,039 --> 00:09:18,039
¿Entendéis la diferencia? ¿Dudas?

149
00:09:18,039 --> 00:09:31,539
Bueno, la diferencia fundamental entre el operador ternario, que es este de aquí, y el if, es que yo aquí, en el operador ternario, no puedo poner comandos.

150
00:09:32,120 --> 00:09:35,620
En el operador ternario, allí van expresiones.

151
00:09:36,919 --> 00:09:39,159
Sin embargo, en el if, van comandos.

152
00:09:41,519 --> 00:09:48,100
Yo puedo, en el if, en esta rama de aquí, en esta rama de aquí, poner un programa entero.

153
00:09:48,100 --> 00:09:51,860
Es decir, si tú me tecleas 1

154
00:09:51,860 --> 00:09:53,419
Entonces esta cosa aquí

155
00:09:53,419 --> 00:09:54,500
X es 1

156
00:09:54,500 --> 00:09:57,500
Pues entonces calcula la área del triángulo

157
00:09:57,500 --> 00:09:59,080
Y si X es 2

158
00:09:59,080 --> 00:10:01,620
Pues entonces abre un programa

159
00:10:01,620 --> 00:10:02,940
Para escribir el Quijote

160
00:10:02,940 --> 00:10:05,220
Dos cosas completamente distintas

161
00:10:05,220 --> 00:10:07,559
Que no tienen que ver con tipos distintos

162
00:10:07,559 --> 00:10:08,820
Y que hacen cosas distintas

163
00:10:08,820 --> 00:10:11,120
Dos algoritmos, dos programas completamente distintos

164
00:10:11,120 --> 00:10:13,240
Eso con un IFA lo puede hacer

165
00:10:13,240 --> 00:10:14,259
Con un

166
00:10:14,259 --> 00:10:17,120
Operador ternario

167
00:10:17,120 --> 00:10:17,639
No

168
00:10:17,639 --> 00:10:20,220
en un if aquí

169
00:10:20,220 --> 00:10:23,279
yo puedo tener 25 líneas

170
00:10:23,279 --> 00:10:23,820
de código

171
00:10:23,820 --> 00:10:27,399
aquí siempre tendré

172
00:10:27,399 --> 00:10:28,720
una expresión

173
00:10:28,720 --> 00:10:30,600
no puedo tener 6 expresiones ahí

174
00:10:30,600 --> 00:10:33,379
no puedo poner un system.out

175
00:10:33,379 --> 00:10:35,080
aquí dentro

176
00:10:35,080 --> 00:10:39,620
porque esto es un valor

177
00:10:39,620 --> 00:10:41,159
no una operación

178
00:10:41,159 --> 00:10:43,440
no le puedo decir si 3 es mayor que 4

179
00:10:43,440 --> 00:10:45,259
entonces escribe algo

180
00:10:45,259 --> 00:10:46,840
no lo hemos hecho nunca

181
00:10:46,840 --> 00:10:48,940
nosotros hemos dicho escribe

182
00:10:48,940 --> 00:10:50,899
y luego nos hemos preguntado, hemos dicho,

183
00:10:51,059 --> 00:10:52,899
si es mayor que 4, entonces escribe 7.

184
00:10:53,039 --> 00:10:56,039
Y si no escribe 9, le damos el valor que tiene que escribir.

185
00:10:56,700 --> 00:10:57,799
Pero no le hemos dicho nunca,

186
00:10:58,200 --> 00:11:01,620
si esto es verdadero, entonces escribe,

187
00:11:01,820 --> 00:11:03,000
y si no, no escribe, por ejemplo.

188
00:11:04,080 --> 00:11:05,259
Eso no lo hemos dicho nunca.

189
00:11:05,659 --> 00:11:06,759
Porque no lo podemos hacer.

190
00:11:06,919 --> 00:11:09,500
Porque es una expresión, no es un comando.

191
00:11:11,240 --> 00:11:11,879
¿Dudas hasta aquí?

192
00:11:13,639 --> 00:11:13,940
Vale.

193
00:11:14,340 --> 00:11:15,659
Esto es como previo para...

194
00:11:15,659 --> 00:11:17,700
Nosotros conocemos esto, no conocemos el otro.

195
00:11:17,700 --> 00:11:19,820
pues esta es la diferencia

196
00:11:19,820 --> 00:11:22,480
de por qué necesitamos el otro

197
00:11:22,480 --> 00:11:24,000
y no podemos seguir con este de aquí

198
00:11:24,000 --> 00:11:26,100
porque este es un poquito menos potente

199
00:11:26,100 --> 00:11:27,379
esto es un operador

200
00:11:27,379 --> 00:11:29,480
y el otro es un comando

201
00:11:29,480 --> 00:11:30,820
es una sentencia

202
00:11:30,820 --> 00:11:31,639
¿vale?

203
00:11:33,259 --> 00:11:33,899
entonces

204
00:11:33,899 --> 00:11:35,759
hoy lo que vamos a ver

205
00:11:35,759 --> 00:11:37,860
como nuevo elemento

206
00:11:37,860 --> 00:11:40,620
son las estructuras de control

207
00:11:40,620 --> 00:11:41,139
¿vale?

208
00:11:41,480 --> 00:11:42,379
hasta ahora

209
00:11:42,379 --> 00:11:44,379
nuestros programas

210
00:11:44,379 --> 00:11:46,919
han sido secuencias de instrucciones

211
00:11:46,919 --> 00:12:02,419
Yo empezaba desde el principio y seguía instrucción por instrucción hasta el final. En ningún momento he cambiado el flujo de ejecución de mi programa.

212
00:12:02,419 --> 00:12:05,299
He siempre estado desde la primera línea hasta la última.

213
00:12:06,539 --> 00:12:14,259
La cosa un poquito más compleja que quizá he hecho ha sido el ternario, ¿vale?

214
00:12:14,299 --> 00:12:19,500
Porque o hacía una cosa o hacía otra, pero era siempre ese comando.

215
00:12:19,639 --> 00:12:22,340
Yo ejecutaba esa línea de código, ¿vale?

216
00:12:22,399 --> 00:12:27,460
Y en esa línea de código hacía una cosa u otra dependiendo del valor que salía de ese ternario.

217
00:12:27,460 --> 00:12:41,559
Las estructuras de control son estructuras avanzadas para poder alterar, para poder cambiar el flujo de ejecución de mi programa.

218
00:12:42,299 --> 00:12:56,120
Es decir, que ahora en vez de decir que ejecuto todas las instrucciones desde la primera hasta la última, puede ser que en un determinado momento haga cambios en el orden con el que se ejecutan estas instrucciones.

219
00:12:56,120 --> 00:13:08,399
Cuidado, en cada momento el ordenador tiene que estar seguro al 100% de cuál es el comando que se va a ejecutar en ese momento.

220
00:13:08,899 --> 00:13:10,919
Seguimos en un estado determinista.

221
00:13:11,539 --> 00:13:22,899
No puedo decirle al ordenador, mira, si crees ejecuta esta operación y si no ejecuta otra, siéntetelo tú.

222
00:13:22,899 --> 00:13:24,159
Pues no, eso no existe.

223
00:13:24,519 --> 00:13:28,080
Tú al ordenador le tienes siempre que decir, haz esto, haz esto, haz esto, haz esto.

224
00:13:28,600 --> 00:13:28,779
¿Vale?

225
00:13:29,279 --> 00:13:32,240
Pero no en el orden que hemos visto hasta ahora.

226
00:13:32,360 --> 00:13:35,299
No desde el principio hasta el final, todas una seguida a otra.

227
00:13:35,679 --> 00:13:35,820
¿Vale?

228
00:13:36,320 --> 00:13:40,679
Puedo alterar este flujo de ejecución.

229
00:13:41,240 --> 00:13:41,360
¿Vale?

230
00:13:41,799 --> 00:13:47,299
Estudio de control, son elementos del lenguaje que nos permiten romper con el flujo lógico de ejecución de instrucciones.

231
00:13:47,500 --> 00:13:47,679
¿Vale?

232
00:13:48,059 --> 00:13:48,940
O sea, las entiendes.

233
00:13:48,940 --> 00:13:52,299
se domina flujo de ejecución

234
00:13:52,299 --> 00:13:54,580
el orden en el que se ejecutan

235
00:13:54,580 --> 00:13:56,360
un determinado conjunto de instrucciones

236
00:13:56,360 --> 00:13:58,279
o sentencias, hasta ahora nosotros

237
00:13:58,279 --> 00:14:00,500
hemos usado un orden secuencial

238
00:14:00,500 --> 00:14:02,080
¿vale? la secuencia

239
00:14:02,080 --> 00:14:04,320
de instrucciones es una

240
00:14:04,320 --> 00:14:06,179
estructura de control ¿vale?

241
00:14:06,299 --> 00:14:07,759
pero es la más válida, es

242
00:14:07,759 --> 00:14:10,120
he dado una lista, pues va desde la primera

243
00:14:10,120 --> 00:14:11,840
hasta la última, hace esta operación

244
00:14:11,840 --> 00:14:14,299
este comando, luego este comando, este comando

245
00:14:14,299 --> 00:14:15,740
este comando, este comando, ya está

246
00:14:15,740 --> 00:14:17,940
lo hemos utilizado, pero es

247
00:14:17,940 --> 00:14:20,200
digamos, el más natural. Hago las cosas

248
00:14:20,200 --> 00:14:21,340
en orden. Se acabó.

249
00:14:22,179 --> 00:14:23,740
El flujo lógico, es decir,

250
00:14:24,080 --> 00:14:25,740
que se asume, mientras

251
00:14:25,740 --> 00:14:28,019
no sería lo contrario, es de arriba

252
00:14:28,019 --> 00:14:29,259
abajo, de izquierda a la derecha.

253
00:14:30,279 --> 00:14:32,059
Si yo no digo nada y no

254
00:14:32,059 --> 00:14:34,139
le digo modifica el flujo, es

255
00:14:34,139 --> 00:14:35,720
empiezo desde el primer

256
00:14:35,720 --> 00:14:38,000
comando y voy hacia abajo.

257
00:14:38,460 --> 00:14:39,940
Y en el comando, si hubiese

258
00:14:39,940 --> 00:14:41,679
dos comandos en la misma línea,

259
00:14:42,080 --> 00:14:43,960
separado por punto y coma, haría primero el

260
00:14:43,960 --> 00:14:45,639
que está a la izquierda, luego el que está a la derecha.

261
00:14:46,820 --> 00:14:47,779
¿Sí? Como se lee.

262
00:14:47,940 --> 00:14:55,139
Porque existen distintos tipos de sentencias de control.

263
00:14:55,820 --> 00:15:03,679
Por un lado están los condicionales, por otro lado están los iterativos y por último están las llamadas a métodos.

264
00:15:03,840 --> 00:15:14,779
Estos son tres grupos de estructuras que lo que hacen es modificar el flujo con el que van, el orden de ejecución.

265
00:15:14,779 --> 00:15:19,100
¿Se entiende eso? ¿Repetido ya cinco veces? ¿Os ha ocurrido lo suficiente?

266
00:15:20,659 --> 00:15:28,080
Los condicionales. Los condicionales me permiten elegir si un bloque lo ejecuto o no.

267
00:15:29,220 --> 00:15:35,679
Yo marcaré un bloque y le diré que si una condición es verdadera, entonces ejecútalo y si no, no.

268
00:15:36,679 --> 00:15:43,500
Eso es el ir más básico. Te marco un bloque y te digo, esto se ejecuta solo si la condición es verdadera.

269
00:15:43,500 --> 00:15:48,299
Si lo salto, estoy modificando

270
00:15:48,299 --> 00:15:51,620
El flujo de ejecución

271
00:15:51,620 --> 00:15:54,559
Porque yo he ejecutado los primeros comandos

272
00:15:54,559 --> 00:15:56,220
Llego a este if, este if es falso

273
00:15:56,220 --> 00:15:59,279
Me salto todos estos comandos que están dentro del bloque

274
00:15:59,279 --> 00:16:00,480
Y sigo con los otros

275
00:16:00,480 --> 00:16:03,759
He modificado, ya no estoy haciendo uno tras otro

276
00:16:03,759 --> 00:16:06,320
He hecho un salto, por eso está modificado

277
00:16:06,320 --> 00:16:11,519
Luego el if tiene versión if-else

278
00:16:11,519 --> 00:16:20,419
¿Vale? Ahora veremos qué es. Si esto es verdadero, haz este bloque. Si es falso, sáltate este bloque, pero ejecuta este otro.

279
00:16:21,779 --> 00:16:34,000
O sea, entonces me permite un vídeo, una... no sé, una... una elección, ¿vale? Gráficamente.

280
00:16:34,000 --> 00:16:36,740
si yo llego desde una

281
00:16:36,740 --> 00:16:37,840
estructura

282
00:16:37,840 --> 00:16:40,940
si yo llego aquí

283
00:16:40,940 --> 00:16:42,559
estoy ejecutando, estoy ejecutando

284
00:16:42,559 --> 00:16:43,740
cuando llega un if

285
00:16:43,740 --> 00:16:47,139
vale, si es un if

286
00:16:47,139 --> 00:16:49,000
a secas normal, me dice

287
00:16:49,000 --> 00:16:53,330
que si es verdadero

288
00:16:53,330 --> 00:16:54,909
ejecuta

289
00:16:54,909 --> 00:16:56,789
estas instrucciones de aquí, vale

290
00:16:56,789 --> 00:16:58,970
y luego sigues adelante, si no

291
00:16:58,970 --> 00:17:00,789
lo que hace es

292
00:17:00,789 --> 00:17:02,370
saltarte estas instrucciones

293
00:17:02,370 --> 00:17:04,309
y retomar de aquí

294
00:17:04,309 --> 00:17:07,230
Esto sería el if básico, ¿sí?

295
00:17:08,329 --> 00:17:29,599
En vez, el if else sería que cuando llega la información del if, aquí hay una condición, si es sí, elige esta vía de aquí y hace estas instrucciones, si es no, hace estas instrucciones de aquí y luego sigues adelante, ¿sí?

296
00:17:29,599 --> 00:17:32,259
el if básico normal

297
00:17:32,259 --> 00:17:34,059
estándar, lo que me dice es

298
00:17:34,059 --> 00:17:35,619
ejecuto este bloque

299
00:17:35,619 --> 00:17:38,640
si es verdadero y si no me lo salto

300
00:17:38,640 --> 00:17:40,140
no hago nada más, salto

301
00:17:40,140 --> 00:17:41,859
solo este bloque, lo salto

302
00:17:41,859 --> 00:17:43,900
no lo ejecuto, mientras

303
00:17:43,900 --> 00:17:46,440
el if else me dice si es verdadero

304
00:17:46,440 --> 00:17:48,119
hago así, si no es verdadero hago así

305
00:17:48,119 --> 00:17:50,420
esto es parecido

306
00:17:50,420 --> 00:17:51,299
al ternario

307
00:17:51,299 --> 00:17:54,279
la diferencia es que en el

308
00:17:54,279 --> 00:17:56,400
ternario aquí tenía expresiones

309
00:17:56,400 --> 00:17:58,539
sin embargo

310
00:17:58,539 --> 00:18:04,660
aquí ahora tengo comandos, tengo bloques de comandos. Tengo un bloque que abre aquí y que

311
00:18:04,660 --> 00:18:10,000
cierra aquí y todo lo que se hace aquí se ejecuta sólo si esta condición que he puesto aquí es

312
00:18:10,000 --> 00:18:23,380
verdadera. ¿Entiendes? El switch es una cosa que nos habría servido en algunos ejercicios que hemos

313
00:18:23,380 --> 00:18:29,900
hecho, que es sustancialmente igual al conditional, igual al if, ¿vale? Todo lo que se hace con el

314
00:18:29,900 --> 00:18:41,359
solo que en determinados casos esta es una sintaxis más cómoda cuando cuando yo tengo

315
00:18:41,359 --> 00:18:47,240
un valor una variable y tengo que comprobar si esta variable tiene algunos valores concretos

316
00:18:47,240 --> 00:18:54,019
vale imaginaos un menú típicamente en el que te dice que quieres hacer quieres sumar entonces

317
00:18:54,019 --> 00:18:58,319
pulsa 1, restar, pulsa 2, dividir, pulsa 3

318
00:18:58,319 --> 00:19:01,859
o multiplicar, pulsa 4. ¿Vale? Entonces, si ahora debería

319
00:19:01,859 --> 00:19:06,099
hacer, si lo que has puesto es 1, hace esto. Si lo que has puesto

320
00:19:06,099 --> 00:19:09,819
2, es este. Pues el switch me lo hace más sencillo. Me dice, a ver, mira,

321
00:19:09,920 --> 00:19:14,180
comprueba X. Cuando es 1, hace esto. Cuando es 2, hace esto. Cuando es 3,

322
00:19:14,279 --> 00:19:17,539
hace esto. ¿Vale? Sale más fácil de ver. Pero,

323
00:19:17,720 --> 00:19:21,980
sustancialmente, los dos hacen lo mismo. Cambian el

324
00:19:21,980 --> 00:19:23,940
flujo de ejecución de los comandos

325
00:19:23,940 --> 00:19:25,480
en base a una condición.

326
00:19:25,720 --> 00:19:27,680
Me dicen cuál bloque

327
00:19:27,680 --> 00:19:29,859
ejecutar o si ejecutarlo

328
00:19:29,859 --> 00:19:31,980
o no, en base a

329
00:19:31,980 --> 00:19:32,240
una

330
00:19:32,240 --> 00:19:35,000
condición.

331
00:19:36,420 --> 00:19:37,759
Evalúo la condición.

332
00:19:38,200 --> 00:19:39,759
La condición será una expresión

333
00:19:39,759 --> 00:19:41,519
booleana. Me dará true o false.

334
00:19:41,880 --> 00:19:43,839
En base a true o false, hago o no

335
00:19:43,839 --> 00:19:44,839
hago una determinada.

336
00:19:46,119 --> 00:19:47,220
¿Sí? Esta es la condición.

337
00:19:48,259 --> 00:19:48,819
¿Dudas?

338
00:19:51,259 --> 00:19:52,539
Luego están los iterativos.

339
00:19:52,539 --> 00:19:58,880
Los iterativos me permiten repetir muchas veces un mismo bloque de código.

340
00:20:00,019 --> 00:20:09,220
Entonces, llego al final del bloque de código y cuando llego al final puedo decidir de volver a saltar al principio de este bloque de código.

341
00:20:09,700 --> 00:20:15,680
Entonces estoy alterando otra vez el flujo de ejecución porque normalmente seguiría abajo.

342
00:20:15,680 --> 00:20:22,500
En vez de en determinado momento podría saltar arriba y ejecutarlo otra vez y volver a saltar arriba y ejecutarlo otra vez.

343
00:20:22,539 --> 00:20:29,660
¿Vale? Aquí normalmente hay dos interesantes, también el do while, pero es una versión del while.

344
00:20:30,180 --> 00:20:38,900
El while es que mientras una condición es verdadera, tú sigues ejecutando lo mismo, ¿vale?

345
00:20:39,019 --> 00:20:43,059
Mientras x sea positivo, pues haz x menos menos.

346
00:20:43,440 --> 00:20:48,460
Entonces, en cada ciclo, pues lo que estoy haciendo es reducir x un poquito, un poquito, un poquito,

347
00:20:48,460 --> 00:20:52,039
mientras que x sea positivo. Si x vale mil, lo haré mil veces.

348
00:20:52,039 --> 00:20:55,039
Si x vale 3, pues lo haré 3 veces.

349
00:20:55,420 --> 00:20:58,920
Pero estoy allí, dando vueltas, mientras que x sea positivo.

350
00:21:00,339 --> 00:21:05,359
El for, en vez de me sirve para decir unos límites, ¿vale?

351
00:21:05,400 --> 00:21:08,220
Normalmente digo desde 0 hasta 5.

352
00:21:08,599 --> 00:21:12,700
Pues, entonces, este bloque se repitirá 5 veces.

353
00:21:14,960 --> 00:21:17,240
Tienen algo de diferencia entre los dos,

354
00:21:17,599 --> 00:21:20,480
pero cambiando un poquito como se escribe,

355
00:21:20,480 --> 00:21:23,400
lo que hace un while se puede hacer con un for

356
00:21:23,400 --> 00:21:25,319
y lo que hace un for se puede hacer con un while

357
00:21:25,319 --> 00:21:26,519
¿vale? son

358
00:21:26,519 --> 00:21:29,400
más cómodos en determinados

359
00:21:29,400 --> 00:21:31,319
contextos, entonces veremos

360
00:21:31,319 --> 00:21:33,259
que a veces usamos el while, a veces usamos

361
00:21:33,259 --> 00:21:35,519
el for en base a algunas reglitas

362
00:21:35,519 --> 00:21:37,099
que nos daremos, pero

363
00:21:37,099 --> 00:21:39,400
en teoría el concepto es que hacen

364
00:21:39,400 --> 00:21:41,339
la iteratividad, o sea la posibilidad

365
00:21:41,339 --> 00:21:43,400
de repetir más de una vez

366
00:21:43,400 --> 00:21:44,480
un mismo bloque de código

367
00:21:44,480 --> 00:21:46,319
¿sí?

368
00:21:47,220 --> 00:21:49,839
y finalmente las llamadas a métodos

369
00:21:49,839 --> 00:21:57,079
O sea, yo puedo pillar un trozo de código, darle un nombre y ponerlo en algún lado.

370
00:21:58,259 --> 00:22:06,420
Y ahora en otro trozo de código, en mi main, para ejecutar ese trozo de código que le he dado un nombre, puedo llamar ese nombre.

371
00:22:07,700 --> 00:22:12,880
Entonces, cada vez que yo en mi código, que estoy yendo desde arriba abajo ordenadamente,

372
00:22:13,079 --> 00:22:18,500
encuentro este nombre con el que he llamado el bloque de código que he guardado por otro lado,

373
00:22:18,500 --> 00:22:21,720
salto desde donde estoy

374
00:22:21,720 --> 00:22:23,299
a ese bloque de código

375
00:22:23,299 --> 00:22:25,059
ejecuto ese bloque de código

376
00:22:25,059 --> 00:22:27,279
y vuelvo a donde estaba

377
00:22:27,279 --> 00:22:28,599
y sigo con la siguiente

378
00:22:28,599 --> 00:22:30,579
entonces hago saltos

379
00:22:30,579 --> 00:22:33,180
hacia funciones, hacia trozos de código

380
00:22:33,180 --> 00:22:34,279
que están en otro lado

381
00:22:34,279 --> 00:22:35,380
por ejemplo

382
00:22:35,380 --> 00:22:48,410
el scan

383
00:22:48,410 --> 00:22:49,609
por ejemplo

384
00:22:49,609 --> 00:22:52,230
yo tengo mi programa

385
00:22:52,230 --> 00:22:54,730
se ejecuta aquí

386
00:22:54,730 --> 00:22:57,190
las varias ejecuciones

387
00:22:57,190 --> 00:22:57,789
bla bla bla

388
00:22:57,789 --> 00:22:59,609
De repente me encuentro

389
00:22:59,609 --> 00:23:01,930
un system.auto.println

390
00:23:01,930 --> 00:23:02,990
¿Qué es este println?

391
00:23:07,029 --> 00:23:08,809
Eso es un método, es una función.

392
00:23:09,329 --> 00:23:11,029
Es decir, que es un trozo de código

393
00:23:11,029 --> 00:23:13,710
escrito por otra persona

394
00:23:13,710 --> 00:23:15,910
en algún lado del multiverso

395
00:23:15,910 --> 00:23:17,069
¿Qué es esto?

396
00:23:18,289 --> 00:23:18,849
println

397
00:23:18,849 --> 00:23:20,930
que hace cosas

398
00:23:20,930 --> 00:23:23,210
¿Vale? Aquí estará su if

399
00:23:23,210 --> 00:23:25,509
su while, su retorno

400
00:23:25,509 --> 00:23:27,250
lo que sea. Es un código que no he

401
00:23:27,250 --> 00:23:29,170
escrito yo y que alguien ha llamado

402
00:23:29,170 --> 00:23:31,009
como println. Cuando

403
00:23:31,009 --> 00:23:39,890
Cuando yo aquí me encuentro un system.auto.println, lo que estoy diciendo es, para aquí la ejecución,

404
00:23:39,890 --> 00:23:46,589
vete aquí, ejecuta este código y cuando has acabado, vuelve aquí y sigues con la

405
00:23:46,589 --> 00:23:51,970
siguiente.

406
00:23:51,970 --> 00:23:57,890
Entonces estoy interrumpiendo otra vez el normal flujo de ejecución de este programa.

407
00:23:57,890 --> 00:24:02,309
Este sería uno tras otro, pero cuando llego aquí hago un salto al println que a lo mejor

408
00:24:02,309 --> 00:24:06,789
Ahora aquí dentro tiene if, tiene while, hasta aquí un 15 minutos haciendo cosas.

409
00:24:07,250 --> 00:24:12,410
Cuando ha acabado esta llamada de método, esta llamada de función, esta llamada de procedura,

410
00:24:12,490 --> 00:24:17,730
llamada como os da la gana, vuelve a quien lo ha llamado, a la línea donde se había llamado,

411
00:24:17,950 --> 00:24:19,430
y empieza por la línea siguiente.

412
00:24:20,150 --> 00:24:27,529
Si vuelvo a hacer otro println, desde aquí saltaré otra vez aquí, lo re-ejecuto,

413
00:24:27,529 --> 00:24:28,869
y cuando acabo vuelvo aquí.

414
00:24:31,500 --> 00:24:32,920
Esa es una llamada de método.

415
00:24:32,920 --> 00:24:51,660
Yo puedo crear mis métodos, ¿vale? Puedo darle, por ejemplo, cuando hemos hecho calcular ala del triángulo, calcular ala del cuadrado, pues podría llamar esos trocitos de código con un nombre, con un nombre de función y tenerlos a un lado y reutilizarlo todas las veces que yo quiera.

416
00:24:51,660 --> 00:24:54,599
¿Se entiende más o menos?

417
00:24:55,500 --> 00:24:59,319
Entonces, no los damos por vistos, ¿vale?

418
00:24:59,480 --> 00:25:01,779
Estos de aquí todavía tenemos que trabajar con ellos.

419
00:25:01,900 --> 00:25:03,400
Hoy empezaremos con estos de aquí.

420
00:25:03,400 --> 00:25:07,440
Pero lo que me interesa es que tú, como sentencias de control,

421
00:25:08,000 --> 00:25:14,579
tienes tres formas de alterar la ejecución básica secuencial de mi programa.

422
00:25:15,059 --> 00:25:17,519
O decidiendo si hacer una cosa o no.

423
00:25:17,519 --> 00:25:19,880
segunda opción, repitiendo

424
00:25:19,880 --> 00:25:21,720
un bloco de código una cierta

425
00:25:21,720 --> 00:25:23,559
vez mientras una condición sea

426
00:25:23,559 --> 00:25:24,839
verdadera, o

427
00:25:24,839 --> 00:25:27,940
irte a otro lado, ejecutar

428
00:25:27,940 --> 00:25:29,559
otro trozo de código que

429
00:25:29,559 --> 00:25:31,420
tú has llamado de alguna forma, y luego volver.

430
00:25:31,660 --> 00:25:31,759
¿Vale?

431
00:25:33,759 --> 00:25:35,279
Nosotros hemos dado el punto, ¿no?

432
00:25:35,339 --> 00:25:37,339
Hemos hecho scan.nextInt.

433
00:25:37,700 --> 00:25:38,559
Pues era esta cosa.

434
00:25:41,920 --> 00:25:44,500
O system.out.println.

435
00:25:44,819 --> 00:25:46,000
Más esta cosa. ¿Vale?

436
00:25:46,099 --> 00:25:47,720
Luego veremos qué son los métodos.

437
00:25:48,400 --> 00:25:49,799
En el mundo de la

438
00:25:49,799 --> 00:25:56,420
Programación orientada a objetos se suele llamar de métodos, estos son métodos, Java son métodos.

439
00:25:56,420 --> 00:26:06,180
En el mundo de la programación estructurada normal, pues eso se suele llamar funciones si te devuelven

440
00:26:06,180 --> 00:26:14,019
un valor o proceduras si no devuelven ningún valor. Nosotros los llamaremos métodos. Ahora,

441
00:26:14,019 --> 00:26:17,259
Si tú tienes un lenguaje de programación

442
00:26:17,259 --> 00:26:18,420
¿Qué hace?

443
00:26:18,680 --> 00:26:20,019
Lo que hemos visto hasta ahora

444
00:26:20,019 --> 00:26:21,400
O sea, declaración de variables

445
00:26:21,400 --> 00:26:23,720
Ejecución, una tras otra, cosas por el estilo

446
00:26:23,720 --> 00:26:28,299
Y tiene estas tres opciones

447
00:26:28,299 --> 00:26:29,000
¿Vale?

448
00:26:29,059 --> 00:26:31,660
O sea, tiene comandos para hacer condicionales

449
00:26:31,660 --> 00:26:32,900
Iterativos y llamadas en método

450
00:26:32,900 --> 00:26:34,960
Se llama Turing equivalente

451
00:26:34,960 --> 00:26:37,220
O sea, que puede hacer todo

452
00:26:37,220 --> 00:26:40,059
Lo que haga otro lenguaje de programación

453
00:26:40,059 --> 00:26:41,279
Con las mismas cosas

454
00:26:41,279 --> 00:26:42,440
¿Vale?

455
00:26:42,440 --> 00:26:47,579
y sustancialmente es un 95% de lo que se puede hacer en programación.

456
00:26:48,460 --> 00:26:51,660
Lo que se añade, la programación de unidad de objetos y cosas así,

457
00:26:51,980 --> 00:26:56,440
es para que esto funcione de forma más eficiente

458
00:26:56,980 --> 00:27:00,339
y pueda hacer programas y proyectos más grandes.

459
00:27:01,319 --> 00:27:01,380
¿Vale?

460
00:27:01,619 --> 00:27:05,200
Porque técnicamente todos los proyectos se podrían hacer con estos elementos de aquí,

461
00:27:05,759 --> 00:27:08,119
saldría un infierno, pero se podría hacer.

462
00:27:08,720 --> 00:27:09,400
¿Sí?

463
00:27:09,400 --> 00:27:11,720
las programaciones orientadas a objetos

464
00:27:11,720 --> 00:27:13,900
mejora la forma

465
00:27:13,900 --> 00:27:15,759
con que se usan estas cosas y cómo se

466
00:27:15,759 --> 00:27:17,740
estructura el código para que sea

467
00:27:17,740 --> 00:27:19,740
más fácil utilizarlos en proyectos

468
00:27:19,740 --> 00:27:21,140
complejos y sobre todo

469
00:27:21,140 --> 00:27:23,579
reutilizarlos. No tener

470
00:27:23,579 --> 00:27:25,619
cada vez que tener que

471
00:27:25,619 --> 00:27:27,759
reimplementar las mismas funciones

472
00:27:27,759 --> 00:27:29,819
si estas funciones ya las he implementado

473
00:27:29,819 --> 00:27:31,759
anteriormente. Simplemente importo

474
00:27:31,759 --> 00:27:33,680
las clases que necesito

475
00:27:33,680 --> 00:27:35,680
y las uso. Como nosotros no

476
00:27:35,680 --> 00:27:37,880
hemos tenido que implementar el system.org

477
00:27:37,880 --> 00:27:41,200
lo hemos importado de forma nativa

478
00:27:41,200 --> 00:27:42,819
en nuestros programas

479
00:27:42,819 --> 00:27:44,019
y lo hemos utilizado

480
00:27:44,019 --> 00:27:46,500
nosotros no sabemos como se escribe en pantalla

481
00:27:46,500 --> 00:27:48,019
¿sabéis vosotros como se escribe en pantalla?

482
00:27:48,599 --> 00:27:50,519
ni idea, usamos un printerln

483
00:27:50,519 --> 00:27:51,859
que es un código complejo

484
00:27:51,859 --> 00:27:54,200
que se hablará con el

485
00:27:54,200 --> 00:27:57,059
con el driver

486
00:27:57,059 --> 00:27:58,039
de la pantalla

487
00:27:58,039 --> 00:27:59,900
por algún lado

488
00:27:59,900 --> 00:28:01,519
y allí sacará la información

489
00:28:01,519 --> 00:28:03,619
son cosas de bajo nivel

490
00:28:03,619 --> 00:28:06,039
que nosotros hemos tapado

491
00:28:06,039 --> 00:28:08,279
con un lenguaje de alto nivel

492
00:28:08,279 --> 00:28:10,039
que nos permite hacer las cosas

493
00:28:10,039 --> 00:28:12,079
sin tener que trastear con los

494
00:28:12,079 --> 00:28:14,259
ceros y los unos o los drivers de la

495
00:28:14,259 --> 00:28:14,660
pantalla.

496
00:28:16,700 --> 00:28:17,259
¿Entiendes?

497
00:28:18,339 --> 00:28:19,839
Exactamente, nosotros queremos poder

498
00:28:19,839 --> 00:28:21,279
ser cómodos.

499
00:28:22,480 --> 00:28:23,420
¿Tú das hasta aquí?

500
00:28:25,819 --> 00:28:26,380
Entonces,

501
00:28:28,279 --> 00:28:29,180
empezamos

502
00:28:29,180 --> 00:28:31,099
con los condicionales, ¿vale?

503
00:28:31,259 --> 00:28:33,660
Vamos a ver, lo que he dicho

504
00:28:33,660 --> 00:28:35,539
ahora era todo lo que hay que saber.

505
00:28:35,920 --> 00:28:37,460
¿Vale? Ya sabes, estamos listos,

506
00:28:37,460 --> 00:28:42,279
para el examen, pero vamos a verlo un poquito más en detalle y luego hacemos ejemplo.

507
00:28:43,200 --> 00:28:47,819
Entonces, los condicionales sirven para proporcionar distintos caminos lógicos de ejecución y

508
00:28:47,819 --> 00:28:52,380
después continuar con el programa, ¿vale? Es decir, las estructuras que he dibujado

509
00:28:52,380 --> 00:28:58,160
antes. Yo puedo pasar por este camino o por este otro en base a una condición y entonces

510
00:28:58,160 --> 00:29:04,559
ejerceré o no una parte, una serie de comandos, si esta condición es verdadera o no, ¿vale?

511
00:29:04,559 --> 00:29:06,680
se evaluará una condición

512
00:29:06,680 --> 00:29:08,900
y en base al resultado se ejecutan

513
00:29:08,900 --> 00:29:10,319
instrucciones u otras

514
00:29:10,319 --> 00:29:14,390
este es el dibujito mejor hecho

515
00:29:14,390 --> 00:29:15,869
por expectantes, vale

516
00:29:15,869 --> 00:29:18,029
esto es en ifasecas

517
00:29:18,029 --> 00:29:20,150
si esta condición es verdadera

518
00:29:20,150 --> 00:29:22,269
entonces hay un bloque de código

519
00:29:22,269 --> 00:29:24,589
ejecútalo y luego sigue con el programa

520
00:29:24,589 --> 00:29:26,690
si la condición que he ponido aquí

521
00:29:26,690 --> 00:29:28,569
es falsa, pues salta

522
00:29:28,569 --> 00:29:30,630
de este bloque de código y sigue adelante

523
00:29:30,630 --> 00:29:32,450
¿qué irá en condición?

524
00:29:38,720 --> 00:29:39,339
expresión

525
00:29:39,339 --> 00:29:42,309
incompleta

526
00:29:42,309 --> 00:29:57,029
¿Expresión? Boolean. Aquí tengo que poner una expresión compleja cuantos da la gana, pero el resultado tiene que ser true o false. En base a true o false, si es true, voy para aquí, si es false, voy para acá.

527
00:29:57,029 --> 00:30:00,349
¿Qué tengo que poner aquí?

528
00:30:03,539 --> 00:30:04,539
Lo que me da la gana

529
00:30:04,539 --> 00:30:06,519
Es un bloque de código

530
00:30:06,519 --> 00:30:08,640
Lo que necesito para resolver mi programa

531
00:30:08,640 --> 00:30:09,319
¿Vale?

532
00:30:09,319 --> 00:30:11,039
Pero aquí podría poner

533
00:30:11,039 --> 00:30:12,980
Una secuencia de instrucciones

534
00:30:12,980 --> 00:30:14,880
Podría poner otro is

535
00:30:14,880 --> 00:30:16,680
Podría poner un while

536
00:30:16,680 --> 00:30:18,579
Podría poner una llamada método

537
00:30:18,579 --> 00:30:21,119
Podría llamar todos los anteriores juntos

538
00:30:21,119 --> 00:30:23,859
Aquí haré lo que tengo que hacer

539
00:30:23,859 --> 00:30:25,859
En base a la condición que me ha dicho

540
00:30:25,859 --> 00:30:27,079
¿Ve?

541
00:30:27,900 --> 00:30:29,099
Ahora, si en vez de

542
00:30:29,099 --> 00:30:33,259
Esto es, sustancialmente me está preguntando, ¿este bloque lo ejecuto o no?

543
00:30:35,299 --> 00:30:38,460
Si en vez de no tengo un bloque que tengo que ejecutar o no,

544
00:30:38,539 --> 00:30:44,119
tengo que hacer cosas distintas en base de si es verdadero o falso la condición,

545
00:30:44,559 --> 00:30:45,859
entonces tengo el IFELS.

546
00:30:46,839 --> 00:30:51,279
El IFELS me dice que si es verdadero, esto es el bloque que tienes que ejecutar.

547
00:30:51,680 --> 00:30:54,299
Si es falso, hay un bloque distinto.

548
00:30:54,720 --> 00:30:57,660
Estos dos bloques son exclusivos.

549
00:30:57,660 --> 00:31:10,420
O es que ejecuto uno, o ejecuto el otro. No puede ejecutar los dos, ¿ves?

550
00:31:10,420 --> 00:31:16,420
Ejemplo del instrumento número uno. Int x es igual a 5, si x es menor que 5,

551
00:31:16,420 --> 00:31:21,420
System.app.println es menor que 5. System.app.println es fin.

552
00:31:21,420 --> 00:31:30,200
¿Qué me escribe esto? ¿Por qué por pantalla sale fin?

553
00:31:30,200 --> 00:31:36,089
Porque yo te digo, x es menor que 5.

554
00:31:37,029 --> 00:31:37,250
No.

555
00:31:39,329 --> 00:31:40,589
¿Puede ser menor o igual? Sí.

556
00:31:40,890 --> 00:31:42,529
Pero así es falso.

557
00:31:43,450 --> 00:31:45,150
Esto sería el bloque true.

558
00:31:46,009 --> 00:31:48,730
Me lo salto y voy al bloque este de aquí.

559
00:31:49,150 --> 00:31:50,250
Pero esto no es el bloque else.

560
00:31:50,869 --> 00:31:52,069
Esto se ejecuta siempre.

561
00:31:52,549 --> 00:31:53,670
Si aquí le pongo 7,

562
00:31:54,470 --> 00:31:56,890
si aquí le pongo 3, ¿qué me escribe?

563
00:31:59,730 --> 00:32:01,029
Me pone menor que 5, fin.

564
00:32:02,109 --> 00:32:02,890
Me pone los dos.

565
00:32:02,890 --> 00:32:11,559
ahora normalmente

566
00:32:11,559 --> 00:32:13,559
esto es un poquito

567
00:32:13,559 --> 00:32:15,220
confuso porque me dicen

568
00:32:15,220 --> 00:32:18,380
pero por qué ejecuta esto

569
00:32:18,380 --> 00:32:20,539
esto no estaba

570
00:32:20,539 --> 00:32:21,079
en el bloque

571
00:32:21,079 --> 00:32:24,200
yo quiero que si esto es verdadero

572
00:32:24,200 --> 00:32:26,420
escriba estas dos cosas y si es falso

573
00:32:26,420 --> 00:32:27,460
no escriba nada

574
00:32:27,460 --> 00:32:28,700
¿cómo lo hago?

575
00:32:29,440 --> 00:32:31,259
tengo que marcar los bloques

576
00:32:31,259 --> 00:32:32,700
y esto siempre

577
00:32:32,700 --> 00:32:35,160
si yo no fijo aquí un bloque

578
00:32:35,160 --> 00:32:36,720
el if solo se

579
00:32:36,720 --> 00:32:39,180
se refiere al primer

580
00:32:39,180 --> 00:32:41,160
comando que encuentra. Solo

581
00:32:41,160 --> 00:32:42,920
un comando. Pero

582
00:32:42,920 --> 00:32:45,140
normalmente, los

583
00:32:45,140 --> 00:32:47,019
if pillan un bloque.

584
00:32:47,140 --> 00:32:48,940
¿Os acordáis de los delimitadores que vimos

585
00:32:48,940 --> 00:32:50,539
y decimos, pero no sirven de mucho?

586
00:32:50,960 --> 00:32:52,380
Ahora empiezan a servir.

587
00:32:53,740 --> 00:32:55,180
Entonces, si esto

588
00:32:55,180 --> 00:32:57,259
es verdadero, ejecutas

589
00:32:57,259 --> 00:32:58,920
todo este bloque. Si no,

590
00:32:59,059 --> 00:33:01,119
te saltas este bloque y vas aquí directamente.

591
00:33:03,200 --> 00:33:05,339
Entonces aquí, x es 5,

592
00:33:05,440 --> 00:33:06,599
5 es menos que 6.

593
00:33:06,720 --> 00:33:14,140
Sí. Por lo tanto, entro aquí dentro y escribo resultado dos puntos menor que seis y luego fin.

594
00:33:15,420 --> 00:33:21,460
Y si yo pusiera X7, escribiría.

595
00:33:23,299 --> 00:33:24,200
Solo fin.

596
00:33:25,119 --> 00:33:30,660
Entro aquí, esto es falso, me salto todo este bloque, voy aquí y escribo este de aquí.

597
00:33:30,819 --> 00:33:32,680
Esto está fuera del bloque, esto se ejecuta siempre.

598
00:33:33,099 --> 00:33:35,420
Esto está aquí.

599
00:33:36,680 --> 00:33:38,480
Mi fin está aquí.

600
00:33:38,859 --> 00:33:45,799
Me he saltado el bloque de información y me he ido allí directamente.

601
00:33:45,799 --> 00:33:48,200
¿Qué pasa si no pongo esta de aquí?

602
00:33:48,200 --> 00:33:52,119
El mismo ejercicio, este de aquí, quito las paréntesis.

603
00:33:52,119 --> 00:33:55,960
¿Qué me escribe?

604
00:33:55,960 --> 00:33:59,799
Escribe menor que 6 y 5.

605
00:33:59,799 --> 00:34:03,319
No, escribe exactamente lo mismo.

606
00:34:03,319 --> 00:34:07,960
5 es menor que 6, entonces me escribiría esto,

607
00:34:07,960 --> 00:34:10,360
luego escribiría esto y luego escribiría esto.

608
00:34:10,360 --> 00:34:16,829
Sin problema. Pero si ahora le pongo x igual a 7, ¿qué escribiría?

609
00:34:16,829 --> 00:34:20,829
O sea, quito las paréntesis y pongo estas 7.

610
00:34:20,829 --> 00:34:24,829
Ahora me pondría menor que 6.

611
00:34:24,829 --> 00:34:28,829
Fin. Se saltaría sólo esta línea aquí, porque el if

612
00:34:28,829 --> 00:34:32,829
afectaría esta línea. Como idea,

613
00:34:32,829 --> 00:34:36,829
siempre que usáis un if, un while, un cualquier cosa,

614
00:34:36,829 --> 00:34:40,829
marcad el bloque. Siempre utilizad

615
00:34:40,829 --> 00:34:51,650
estas paréntesis. No se os ocurra nunca no ponerlas. Hasta si es una línea sola, poned una

616
00:34:51,650 --> 00:35:00,710
llave aquí y una llave allá. No cambia nada, son seis segundos de vida, no, tres segundos de vida,

617
00:35:00,710 --> 00:35:07,829
pero os sirve para evitar errores de que luego se aplique solo a esta línea y no a la siguiente.

618
00:35:07,829 --> 00:35:09,710
¿Sí? ¿Dudas hasta aquí?

619
00:35:16,880 --> 00:35:17,460
¿Qué hace esto?

620
00:35:30,039 --> 00:35:31,340
Esto es un if-else.

621
00:35:32,179 --> 00:35:34,380
Entonces me dice, aquí hay dos opciones.

622
00:35:34,659 --> 00:35:37,699
O este bloque de aquí, o este bloque de aquí.

623
00:35:38,519 --> 00:35:38,739
¿Vale?

624
00:35:39,019 --> 00:35:43,599
Y ejecutaré o uno o el otro, nunca los dos a la vez,

625
00:35:44,019 --> 00:35:46,460
dependiendo del valor de esta expresión booleana.

626
00:35:46,980 --> 00:35:50,360
Evalúo la expresión booleana, 5 es menor que 5, falso.

627
00:35:50,360 --> 00:35:54,440
por lo tanto me salto el bloque true y escribo solo el bloque

628
00:35:54,440 --> 00:35:58,320
falso. Si esto fuera verdadero, escribo el bloque

629
00:35:58,320 --> 00:36:02,340
verdadero y salto el bloque falso. En este caso

630
00:36:02,340 --> 00:36:06,440
como 5 no es menor que 5, me iría a leerse, escribiría mayor o igual

631
00:36:06,440 --> 00:36:10,239
que 5 y luego fin, porque fin está fuera del bloque if

632
00:36:10,239 --> 00:36:12,480
y por lo tanto lo escribiría siempre.

633
00:36:20,170 --> 00:36:21,210
Paréntesis pequeña.

634
00:36:21,210 --> 00:36:29,969
Ahora que empezamos a utilizar los bloques, ¿os acordáis que era el ámbito de una variable, los Q?

635
00:36:33,059 --> 00:36:38,820
Y las variables solo existen dentro del bloque en que la creo.

636
00:36:39,460 --> 00:36:46,780
Entonces, si yo digo, si X es menor que 5, pongamos que es verdadero, entro aquí dentro y aquí creo una variable,

637
00:36:47,539 --> 00:36:51,179
esa variable fuera, donde está el fin, ya no existe.

638
00:36:51,179 --> 00:36:55,300
Si creo una variable dentro de un bloque

639
00:36:55,300 --> 00:36:57,860
Cuando salgo de ese bloque ya no existirá

640
00:36:57,860 --> 00:36:58,840
¿Vale?

641
00:36:59,139 --> 00:37:00,960
Entonces ahora el ámbito de la variable

642
00:37:00,960 --> 00:37:02,800
Empieza a tener un poquito más de sentido

643
00:37:02,800 --> 00:37:04,599
Antes era todo el mismo bloque

644
00:37:04,599 --> 00:37:06,320
¿Sí?

645
00:37:10,079 --> 00:37:10,679
¿Es esto?

646
00:37:30,179 --> 00:37:32,420
¿Es esto es como antes hacíamos

647
00:37:32,420 --> 00:37:34,659
Un ternario dentro de un ternario?

648
00:37:35,059 --> 00:37:36,500
Pues esto es un if dentro de un if

649
00:37:36,500 --> 00:37:38,679
El primer if es el azul

650
00:37:38,679 --> 00:37:39,219
¿Vale?

651
00:37:39,219 --> 00:37:41,219
Que pones esta cosa es verdadera

652
00:37:41,219 --> 00:37:42,480
Entonces hace esto de aquí

653
00:37:42,480 --> 00:37:44,760
si no, hace esta otra cosa.

654
00:37:45,019 --> 00:37:46,619
Y en esta otra cosa he metido

655
00:37:46,619 --> 00:37:48,460
un if. ¿Vale?

656
00:37:48,840 --> 00:37:50,619
Esto sería un bloque que empieza aquí

657
00:37:50,619 --> 00:37:52,679
y acaba aquí, y dentro está otro if

658
00:37:52,679 --> 00:37:54,199
que dice, oye, pero si es igual,

659
00:37:54,400 --> 00:37:56,960
entonces, por lo que es igual, y si no,

660
00:37:57,280 --> 00:37:58,619
este else es de este if

661
00:37:58,619 --> 00:38:00,219
de aquí. ¿Veis?

662
00:38:03,090 --> 00:38:04,909
Tened cuidado que a veces

663
00:38:04,909 --> 00:38:06,570
esto lía un poquito

664
00:38:06,570 --> 00:38:08,210
las cosas, porque este else requiere

665
00:38:08,210 --> 00:38:11,010
selección de este if, o de este if, o de este cual.

666
00:38:11,710 --> 00:38:12,349
¿Vale? Entonces,

667
00:38:12,750 --> 00:38:14,050
puede que os liéis un poquito.

668
00:38:14,489 --> 00:38:28,989
Aún así, esto en realidad es el SIF. Existe una forma de escribirlo juntos para que es como si es esto, si no, si es esto, si no, si es esto, si no, si es esto, pero por ahora no nos compliquemos mucho.

669
00:38:30,250 --> 00:38:52,230
¿Qué hace esto? Es lo mismo que antes, ¿vale? Solo que esta vez lo he delimitado con las llaves, ¿vale? Para que se vea que esto es otra cosa, ¿vale?

670
00:38:52,230 --> 00:38:59,110
aquí funciona lo mismo porque esto dice este else se aplicaría solo al siguiente comando y

671
00:38:59,110 --> 00:39:05,309
todo este de aquí es un comando es un comando solo es un comando if por lo tanto funciona

672
00:39:05,309 --> 00:39:16,260
pero quizás así se vea un poco más grande al menos a nuestro nivel esto

673
00:39:16,260 --> 00:39:39,940
después de recreo la solución. Entonces, antes de recreo estamos aquí. ¿Qué hace este programa?

674
00:39:39,940 --> 00:40:02,949
Mi if es menor que uno. Hace lo del is. El problema de esto es cuando no usáis las

675
00:40:02,949 --> 00:40:15,449
las llaves, es este else, es hijo de este if, o es hijo de este if. O sea, este else es si este

676
00:40:15,449 --> 00:40:25,050
if menos de 1 hace esta cosa aquí y si no hace esta otra, o esto es un if plano sin else y dentro

677
00:40:25,050 --> 00:40:35,130
tiene un infeliz. Cuidado con lo que hacéis. Por eso os he dicho, intentad poner siempre las

678
00:40:35,130 --> 00:40:44,570
llaves porque así definís vosotros cómo se tiene que comportar el programa. Si no, tengo que saber

679
00:40:44,570 --> 00:40:51,789
bien cómo funcionaría Java interiormente en estas cosas de aquí y a ver qué pasa. En este caso

680
00:40:51,789 --> 00:40:58,510
concreto y según lo que está escrito aquí debajo, en principio escribiría nada, ¿vale?

681
00:40:58,510 --> 00:41:04,090
Porque esto sería un if y esto sería una sentencia if-else, entonces todo este if-else

682
00:41:04,090 --> 00:41:10,469
sería como si estuviera en un bloque, ¿vale? Y entonces el esto no es verdad saldría y ya está.

683
00:41:11,710 --> 00:41:16,090
Pero claro, cuando esto lo hago muchas veces mezclado así, pues a lo mejor cuando lo leo

684
00:41:16,090 --> 00:41:26,090
rápidamente, medio. Ponéis siempre las llaves, ¿vale? Y dentro tenéis, debajo tenéis la, es útil.

685
00:41:26,090 --> 00:41:40,090
Vale, ¿y esto era LIFS? ¿Te queda claro LIFS? Sencillo, ¿vale? Muy parecido al otro. La diferencia está siempre en esta cosa de aquí.

686
00:41:40,090 --> 00:41:43,550
aquí son solo system.out

687
00:41:43,550 --> 00:41:44,849
no hace grandes

688
00:41:44,849 --> 00:41:46,909
aprietos, vale, la diferencia con lo que

689
00:41:46,909 --> 00:41:49,110
utilizamos antes es que en estas ramas

690
00:41:49,110 --> 00:41:50,550
de aquí, if-else, vale

691
00:41:50,550 --> 00:41:53,570
antes aquí podíamos poner solo expresiones

692
00:41:53,570 --> 00:41:55,150
mientras ahora no estamos

693
00:41:55,150 --> 00:41:56,489
poniendo expresiones, estamos poniendo

694
00:41:56,489 --> 00:41:58,610
programas, estamos poniendo

695
00:41:58,610 --> 00:42:00,789
llamadas a métodos, podemos poner while

696
00:42:00,789 --> 00:42:02,750
podemos poner otros if

697
00:42:02,750 --> 00:42:04,730
podemos poner lo que nos da la gana, vale

698
00:42:04,730 --> 00:42:07,230
estas son comandos, son líneas

699
00:42:07,230 --> 00:42:09,070
de instrucciones, más que una, pueden estar

700
00:42:09,070 --> 00:42:11,110
cinco líneas se me da la gana, ¿vale?

701
00:42:11,429 --> 00:42:13,250
Sin embargo, en el

702
00:42:13,250 --> 00:42:15,170
operador condicional, eso es un operador

703
00:42:15,170 --> 00:42:17,409
que devuelve

704
00:42:17,409 --> 00:42:19,070
un tipo y que se puede evaluar.

705
00:42:19,409 --> 00:42:21,409
Esto no se evalúa, esto se ejecuta.

706
00:42:22,269 --> 00:42:23,489
¿Sí? ¿Me entienden?

707
00:42:26,289 --> 00:42:26,769
Siguiente

708
00:42:26,769 --> 00:42:28,969
condicional que vamos

709
00:42:28,969 --> 00:42:31,170
a ver es el switch case, ¿vale?

710
00:42:31,670 --> 00:42:32,690
El switch case

711
00:42:32,690 --> 00:42:34,849
es siempre un condicional,

712
00:42:35,110 --> 00:42:37,030
siempre es un tercer condicional, y todo

713
00:42:37,030 --> 00:42:39,050
lo que se puede hacer con el switch case

714
00:42:39,050 --> 00:42:43,190
se puede hacer con un if. Eso de if-else, if-else, if-else, if-else,

715
00:42:43,269 --> 00:42:46,289
o el si-else, el si-else, el si-else, pues se puede hacer

716
00:42:46,289 --> 00:42:51,050
la misma cosa. Solo que en determinadas circunstancias, si lo hago con if-else,

717
00:42:51,170 --> 00:42:55,030
me saldría un if dentro de un if, dentro de un if, dentro de un if,

718
00:42:55,110 --> 00:42:58,750
dentro de un if, entonces saldría una cosa bastante compleja de leer.

719
00:42:59,170 --> 00:43:02,409
Mientras este de aquí, en las situaciones en que se usa el switch case,

720
00:43:02,809 --> 00:43:06,530
lo hace más fácil de leer. Está claro que en otras situaciones,

721
00:43:06,530 --> 00:43:10,969
Usar el switch case es relativamente imposible, no se podría, ¿vale?

722
00:43:12,769 --> 00:43:17,530
Esta es la sentencia condicional que permite comparar una determinada variable con varios valores posibles.

723
00:43:18,250 --> 00:43:22,030
Dependiendo del valor de dicha variable, esto tendremos un bloque, o no, ¿vale?

724
00:43:22,530 --> 00:43:27,949
Se puede hacer lo mismo con varios x vanidados, esto hemos ya dicho, ¿vale?

725
00:43:28,090 --> 00:43:29,969
Esto es un switch case, ¿vale?

726
00:43:30,250 --> 00:43:33,210
La idea es esta, ¿sí?

727
00:43:33,210 --> 00:43:38,949
Entonces, si yo tengo una variable, ¿vale?

728
00:43:38,949 --> 00:43:49,050
No sé qué valor tiene esta variable, pero esta variable debería tener un cierto número finido de posibles valores, ¿vale?

729
00:43:49,309 --> 00:43:50,809
Típicamente un menú, ¿vale?

730
00:43:51,210 --> 00:43:55,030
Yo tengo un menú, digo, la opción 1 es esta, la opción 2 es esta, la opción 3 es esta.

731
00:43:55,110 --> 00:43:57,769
Entonces tengo tres posibles valores, 1, 2 y 3.

732
00:43:58,230 --> 00:44:02,409
Tengo cuatro posibles valores, 1, 2 y 3, y cualquier otra cosa, ¿vale?

733
00:44:02,409 --> 00:44:04,170
Cualquier otra cosa me valdría como

734
00:44:04,170 --> 00:44:05,349
Te has equivocado

735
00:44:05,349 --> 00:44:09,030
1, 2 y 3 tengo que hacer cosas concretas

736
00:44:09,030 --> 00:44:11,150
Entonces pillo esta variable

737
00:44:11,150 --> 00:44:12,449
Y voy a comprobar

738
00:44:12,449 --> 00:44:13,369
¿Vale o no?

739
00:44:13,889 --> 00:44:16,050
¿Vale un valor concreto?

740
00:44:16,469 --> 00:44:18,269
Si vale ese valor concreto

741
00:44:18,269 --> 00:44:19,969
Entonces ejecute este código

742
00:44:19,969 --> 00:44:21,130
¿Vale?

743
00:44:21,550 --> 00:44:23,650
Vale 2, ejecute este código

744
00:44:23,650 --> 00:44:25,389
Vale 3, ejecute este código

745
00:44:25,389 --> 00:44:27,269
En base a

746
00:44:27,269 --> 00:44:30,329
¿Cuál pillo de estas?

747
00:44:30,489 --> 00:44:31,670
O sea, ¿Cuál es salida de estas?

748
00:44:31,670 --> 00:44:33,789
de true, ¿vale?

749
00:44:34,250 --> 00:44:35,489
Puede hacer dos cosas.

750
00:44:35,909 --> 00:44:37,849
O ejecutar este bloque

751
00:44:37,849 --> 00:44:39,849
de consentencias y todos

752
00:44:39,849 --> 00:44:41,530
los otros que vienen por debajo.

753
00:44:42,530 --> 00:44:43,670
O salir

754
00:44:43,670 --> 00:44:45,570
con el break. El break

755
00:44:45,570 --> 00:44:47,789
me devolvería al final

756
00:44:47,789 --> 00:44:49,849
del switch. ¿Qué quiere decir?

757
00:44:50,789 --> 00:44:51,530
Mirámoslo aquí.

758
00:44:51,969 --> 00:44:53,449
¿Vale? Entonces yo tengo

759
00:44:53,449 --> 00:44:55,670
switch una variable, x,

760
00:44:55,909 --> 00:44:57,469
¿vale? Case,

761
00:44:57,469 --> 00:44:59,409
en el caso en que valga 1,

762
00:44:59,849 --> 00:45:00,889
pues aquí pongo 1,

763
00:45:00,889 --> 00:45:03,489
ejecutaría esta sentencia

764
00:45:03,489 --> 00:45:04,449
las sentencias 1

765
00:45:04,449 --> 00:45:07,170
si le pongo el break

766
00:45:07,170 --> 00:45:09,769
quiere decir que una vez ejecutada

767
00:45:09,769 --> 00:45:11,510
las sentencias 1

768
00:45:11,510 --> 00:45:13,449
saldría al final del

769
00:45:13,449 --> 00:45:15,449
switch case y seguiría adelante

770
00:45:15,449 --> 00:45:17,349
si no le pongo el break

771
00:45:17,349 --> 00:45:19,469
ejecutaría las sentencias

772
00:45:19,469 --> 00:45:21,570
1 y también las sentencias

773
00:45:21,570 --> 00:45:23,510
2 independientemente de si

774
00:45:23,510 --> 00:45:24,829
el case vale 2 o no

775
00:45:24,829 --> 00:45:27,469
una vez que yo he seleccionado

776
00:45:27,469 --> 00:45:28,530
cuál es el caso

777
00:45:28,530 --> 00:45:31,409
ejecutaré

778
00:45:31,409 --> 00:45:32,869
esas sentencias

779
00:45:32,869 --> 00:45:34,989
y todas las que vienen debajo

780
00:45:34,989 --> 00:45:36,449
hasta llegar a un break

781
00:45:36,449 --> 00:45:38,070
si llega a un break

782
00:45:38,070 --> 00:45:40,809
salgo del switch

783
00:45:40,809 --> 00:45:50,039
si, diría

784
00:45:50,039 --> 00:45:52,280
un ejemplo, así

785
00:45:52,280 --> 00:45:53,800
vale

786
00:45:53,800 --> 00:45:56,460
por ejemplo, me han dado una nota

787
00:45:56,460 --> 00:45:58,219
si, nota

788
00:45:58,219 --> 00:46:00,159
7, pues quiero

789
00:46:00,159 --> 00:46:02,380
transformar este 7 en

790
00:46:02,380 --> 00:46:04,400
suspenso, aprobado

791
00:46:04,400 --> 00:46:06,340
notable, cosas por el estilo

792
00:46:06,340 --> 00:46:07,900
entonces tengo este switch

793
00:46:07,900 --> 00:46:10,559
digo, pillo nota

794
00:46:10,559 --> 00:46:12,079
la variable nota

795
00:46:12,079 --> 00:46:13,699
y miro sus casos

796
00:46:13,699 --> 00:46:16,719
si es 5, en el caso en que sea 5

797
00:46:16,719 --> 00:46:18,820
escribes aprobado

798
00:46:18,820 --> 00:46:20,039
y sales

799
00:46:20,039 --> 00:46:22,079
acabo

800
00:46:22,079 --> 00:46:24,639
en el caso en que

801
00:46:24,639 --> 00:46:26,480
sea 6, pues escribes

802
00:46:26,480 --> 00:46:27,880
bien y sales

803
00:46:27,880 --> 00:46:30,480
en el caso en que sea

804
00:46:30,480 --> 00:46:32,480
7, no hagas nada

805
00:46:32,480 --> 00:46:35,320
pero tampoco el break

806
00:46:35,320 --> 00:46:36,659
¿lo veis?

807
00:46:37,519 --> 00:46:39,119
y en el caso que sea 8

808
00:46:39,119 --> 00:46:41,119
escribe notable

809
00:46:41,119 --> 00:46:42,219
y sale

810
00:46:42,219 --> 00:46:45,079
esto me hace que tanto 7 como 8

811
00:46:45,079 --> 00:46:46,400
me escriberá notable

812
00:46:46,400 --> 00:46:47,960
¿entendéis?

813
00:46:49,420 --> 00:46:49,820
¿entendéis?

814
00:46:49,960 --> 00:46:52,179
yo tengo un 7, saldría aquí

815
00:46:52,179 --> 00:46:55,179
no ejecuto nada, pero ejecuto todo lo que viene

816
00:46:55,179 --> 00:46:56,559
debajo hasta el break

817
00:46:56,559 --> 00:46:59,099
por lo tanto ejecutaría también esto notable

818
00:46:59,099 --> 00:47:00,880
y al break saldría

819
00:47:00,880 --> 00:47:08,389
¿Sí? Entonces, si yo tengo varios casos que harían lo mismo, puedo hacer esto.

820
00:47:09,090 --> 00:47:11,989
Caso 7, 8, 9, 10 y 9, hace esta cosa aquí.

821
00:47:12,130 --> 00:47:14,630
Caso 20, 30, 40, 50, hace esta otra.

822
00:47:16,030 --> 00:47:16,510
¿Entienden?

823
00:47:17,869 --> 00:47:22,250
Fijaos, pero que aquí no estoy preguntándome si es menor, mayor, si es entre unidad.

824
00:47:22,510 --> 00:47:25,070
Pues eso lo hace el IF. Esto es un valor concreto.

825
00:47:25,289 --> 00:47:28,110
Cuando nota, vale ese valor. Ese es el caso.

826
00:47:28,110 --> 00:47:35,909
caso 9 sobresaliente caso 10 matrícula de honor y luego está este de aquí que

827
00:47:35,909 --> 00:47:41,789
viene aquí que me ha saltado vale que es el default el default es un método es un

828
00:47:41,789 --> 00:47:48,690
valor que te dice en todos los otros casos si no has encontrado un caso que

829
00:47:48,690 --> 00:47:52,809
te vale pues aplica el default

830
00:47:53,090 --> 00:47:57,949
si yo no he puesto break antes el default se ejecutará siempre si yo he

831
00:47:57,949 --> 00:48:07,070
puesto break pues entonces sólo en el caso en el que no sea un valor entre entre 5 y 10 en cualquier

832
00:48:07,070 --> 00:48:16,550
otro caso de dar suspecho por aquí se me da 11 pues el suspecho 120 suspecho menos 7 suspecho

833
00:48:16,550 --> 00:48:31,670
¿Entendéis? Y este es el fich. Un ejemplo, es así, hay que probarlo y ver un poquito

834
00:48:31,670 --> 00:48:38,329
cómo funciona. Entonces, lo que vamos a hacer ahora es un poco de código, hago algunos

835
00:48:38,329 --> 00:48:42,789
ejemplos, probamos un poco de IFA, probamos un switch case y cosas por el estilo y luego

836
00:48:42,789 --> 00:48:52,309
como no una banda de 30 artistas la mañana vale entonces sabramos el eclipse

837
00:48:52,309 --> 00:49:15,219
me creo un nuevo

838
00:49:15,219 --> 00:49:16,119
package

839
00:49:16,119 --> 00:49:19,280
con la fecha de hoy

840
00:49:19,280 --> 00:49:20,519
lección

841
00:49:20,519 --> 00:49:23,079
2026

842
00:49:23,079 --> 00:49:24,539
10.07

843
00:49:24,539 --> 00:49:29,000
y aquí dentro creo

844
00:49:29,000 --> 00:49:30,940
un ejemplo

845
00:49:30,940 --> 00:49:33,179
ejemplo if a uno

846
00:49:33,179 --> 00:49:41,739
vale, entonces

847
00:49:41,739 --> 00:49:44,900
la sintaxis del if es sencilla

848
00:49:44,900 --> 00:49:46,860
vale, entonces en base

849
00:49:46,860 --> 00:49:48,500
a un valor que me dan

850
00:49:48,500 --> 00:49:50,559
pues hago algo, vale

851
00:49:50,559 --> 00:49:53,159
casi todos los ejercicios

852
00:49:53,159 --> 00:49:54,699
que os he dado que usan

853
00:49:54,699 --> 00:49:57,199
un ternario

854
00:49:57,199 --> 00:49:58,880
se pueden volver

855
00:49:58,880 --> 00:50:00,480
a rehacer con un if

856
00:50:00,480 --> 00:50:02,920
vale, sería prácticamente lo mismo

857
00:50:02,920 --> 00:50:06,760
Vamos a hacer uno de los ejercicios sencillos de lo que hemos visto.

858
00:50:06,960 --> 00:50:10,719
Dame un número y dime si es par en par.

859
00:50:12,179 --> 00:50:18,579
Entonces, scannerScan es igual a newScannerDeSystem.int

860
00:50:18,579 --> 00:50:20,400
para poder leer.

861
00:50:21,260 --> 00:50:23,139
Si eso lee un número.

862
00:50:26,139 --> 00:50:29,800
intX es igual a scan.nextInt.

863
00:50:29,800 --> 00:50:31,440
He leído un número.

864
00:50:31,440 --> 00:50:59,530
Y ahora me pregunto, si este número es módulo 2 es 0, misma cosa que escribíamos antes, entonces si yo es par, el se, y yo no es par.

865
00:50:59,530 --> 00:51:15,110
En una situación como esta, casi el otro era más compacto, porque al fin y al cabo te daba un string que tú escribías solo una vez un system.out.entendent.

866
00:51:15,269 --> 00:51:21,050
Para estos ejercicios tan sencillos, el otro puede ser una alternativa válida.

867
00:51:21,369 --> 00:51:28,710
Está claro que si yo aquí no te estoy preguntando solo si es par o impar, más te digo, si es par, haz toda una serie de operaciones.

868
00:51:28,710 --> 00:51:33,210
Y si es impar a todo otro ser eliger, pues allí ya es una otra versión.

869
00:51:33,349 --> 00:51:35,429
Allí el otro no lo puedo usar, tengo que utilizar eliger.

870
00:51:43,619 --> 00:51:44,699
Esto es un ejemplo.

871
00:51:47,300 --> 00:51:47,820
Modificámoslo.

872
00:51:48,079 --> 00:51:49,119
Entonces, sí.

873
00:52:00,309 --> 00:52:05,050
Dime si es par o impar, pero también si es positivo o negativo.

874
00:52:10,539 --> 00:52:12,760
Entonces, una forma de hacerlo.

875
00:52:13,340 --> 00:52:15,219
Con esto yo sé si es par o impar.

876
00:52:16,539 --> 00:52:26,539
Cuando digo que es par, y ahora aquí dentro, dentro de este bloque que sé que es par, me pregunto si es positivo o negativo, pero lo podría hacer aquí fuera.

877
00:52:26,539 --> 00:52:34,539
Antes digo si es par o impar, y luego hago otro if para decir si es positivo o negativo.

878
00:52:34,539 --> 00:52:42,539
Pero lo quiero hacer de otra forma. Quiero en una sola cadena decir que es par positivo o par negativo o cosa por el estilo.

879
00:52:42,539 --> 00:52:44,579
de estilo, no sé si me explico, ¿vale? Para forzar

880
00:52:44,579 --> 00:52:45,920
a que el if esté aquí dentro.

881
00:52:47,099 --> 00:52:48,300
¿Sí? Entonces,

882
00:52:48,940 --> 00:52:50,659
yo si estoy en esta rama de aquí,

883
00:52:51,059 --> 00:52:52,659
estoy seguro que es

884
00:52:52,659 --> 00:52:54,920
par, ¿vale? Entonces me vuelvo a preguntar

885
00:52:54,920 --> 00:52:55,380
si

886
00:52:55,380 --> 00:52:58,800
x es mayor que 0,

887
00:53:01,300 --> 00:53:02,000
entonces

888
00:53:02,000 --> 00:53:07,619
es par positivo.

889
00:53:10,130 --> 00:53:10,750
Si no,

890
00:53:18,510 --> 00:53:19,869
es par negativo.

891
00:53:22,579 --> 00:53:22,659
¿Sí?

892
00:53:23,840 --> 00:53:25,980
Es que en esta zona

893
00:53:25,980 --> 00:53:34,019
aquí estoy seguro que es par y aquí me pregunto si es positivo o negativo y lo mismo tendré que

894
00:53:34,019 --> 00:53:49,800
volver a hacer aquí. Aquí sé que es impar, por lo tanto es impar, pero si es mayor que cero es impar

895
00:53:49,800 --> 00:54:00,699
positivo y si es... esto lo he puesto de error. Entonces ahora yo tengo un programa que le digo

896
00:54:00,699 --> 00:54:11,699
el número. Número 7 es en par positivo. Número menos 8 es par negativo. ¿Vale? Número cero

897
00:54:11,699 --> 00:54:29,130
que me da par positivo. Par negativo. Porque le he puesto un escrito mayor que cero. ¿Vale?

898
00:54:29,130 --> 00:54:36,150
Si quisiera que fuera par positivo, le pongo mayor o igual y ahora es cero, es par positivo.

899
00:54:36,150 --> 00:54:43,239
¿Sí? Este es un ejemplo de un if dentro de un if.

900
00:54:52,550 --> 00:54:55,710
¿Mismo ejercicio de otra forma?

901
00:55:07,760 --> 00:55:08,900
Voy a preguntar.

902
00:55:09,280 --> 00:55:22,500
Si es par y mayor que cero, entonces es par positivo.

903
00:55:35,719 --> 00:55:36,139
¿Justo?

904
00:55:36,139 --> 00:55:39,340
Y ahora me pregunto.

905
00:55:39,579 --> 00:55:47,650
¿El se if es así?

906
00:55:47,650 --> 00:56:29,920
pero es menor, entonces es par negativo. El 6, si es 1 o es distinto de 0, como queráis, y es mayor que 0, entonces es impar positivo.

907
00:56:29,920 --> 00:56:40,300
y si no, si es distinto

908
00:56:40,300 --> 00:56:48,219
y menor que cero, es impar.

909
00:56:48,619 --> 00:56:55,889
Negativo. Todo esto ya no me sirve. Fuera.

910
00:56:56,750 --> 00:57:04,519
Se quedaría una cosa así. ¿Vale? Estoy usando

911
00:57:04,519 --> 00:57:08,239
el sí, el sí, el sí, el sí. Hace lo mismo que antes. ¿Vale?

912
00:57:08,300 --> 00:57:11,219
Simplemente estoy comprobando las cuatro opciones.

913
00:57:17,619 --> 00:57:20,360
Yo debería hacer más o menos lo mismo.

914
00:57:20,360 --> 00:57:22,739
7

915
00:57:22,739 --> 00:57:24,300
par positivo

916
00:57:24,300 --> 00:57:26,159
menos 8

917
00:57:26,159 --> 00:57:27,440
par positivo

918
00:57:27,440 --> 00:57:30,320
pero par positivo

919
00:57:30,320 --> 00:57:39,159
no sé cuál gusta más

920
00:57:39,159 --> 00:57:40,880
o los parezca más

921
00:57:40,880 --> 00:57:43,039
claro si este de aquí

922
00:57:43,039 --> 00:57:45,039
o este de aquí

923
00:57:45,039 --> 00:57:46,099
pero

924
00:57:46,099 --> 00:57:49,280
en realidad

925
00:57:49,280 --> 00:57:52,199
esto también me da

926
00:57:52,199 --> 00:57:57,250
es como decir

927
00:57:57,250 --> 00:58:09,250
Si esto, esto, si no, si esto, esto, si no, si esto, esto, en cualquier otro caso, el último caso que me queda es el que no vale ninguno de estos tres, entonces allí sé que es impar negativo.

928
00:58:09,250 --> 00:58:27,510
¿Sí? ¿Dudas? Estos son. ¿Queréis hacer un ejercicio? ¿Me diréis vosotros qué hacer y yo lo hago?

929
00:58:27,510 --> 00:58:36,340
Siempre os doy los ejercicios yo, unir. Si no, pues hacemos un switch.

930
00:58:36,340 --> 00:58:43,760
Hacemos un switch y luego los ejercicios los hacemos después.

931
00:58:43,760 --> 00:58:48,760
Ejemplo, switch.

932
00:58:48,760 --> 00:58:59,400
Copio esto para pillar un número, ¿vale?

933
00:58:59,400 --> 00:59:07,099
Esta parte aquí es la misma. Hagamos un pequeño menú. Hagamos una calculadora.

934
00:59:07,099 --> 00:59:29,449
calculadora. Entonces, ¿qué hago? Pillo tres números. Dame num1, num2, n2, n1. ¿Vale?

935
00:59:29,449 --> 00:59:48,179
Y finalmente, un operador. Operador lo leo como número. ¿Vale? Para hacerlo más sencillo.

936
00:59:48,179 --> 01:00:02,000
1 suma, 2 resta y leo int operador es igual a scan.nexit.

937
01:00:04,440 --> 01:00:08,920
Entonces, aquí estoy leyendo un número, un otro número y luego te pregunto, ¿qué quiero hacer?

938
01:00:09,039 --> 01:00:10,179
¿Sumar o restar?

939
01:00:10,599 --> 01:00:11,420
¿O multiplicar?

940
01:00:11,559 --> 01:00:14,519
Venga, 3 multiplicar.

941
01:00:14,519 --> 01:00:20,860
No pongo la división porque se complica un programa.

942
01:00:21,239 --> 01:00:21,940
No mantengo nada.

943
01:00:22,519 --> 01:00:22,719
¿Vale?

944
01:00:23,239 --> 01:00:29,739
Ok, perfecto. Entonces, en base al valor de esto, yo tendré que hacer cosas distintas de estas.

945
01:00:30,380 --> 01:00:31,679
Entonces, lo que hago es un switch.

946
01:00:32,380 --> 01:00:35,820
Switch sobre operador.

947
01:00:35,820 --> 01:00:47,320
Y me digo, en el caso en que sea 1, si eso, num1 más num2.

948
01:00:51,530 --> 01:00:54,010
N1 más N2.

949
01:00:54,010 --> 01:01:19,730
Se me olvida el break. Case dos, dos puntos, siso, n, n1, menos n2. Case tres, dos puntos, siso, n1, multiplicado n2.

950
01:01:19,730 --> 01:01:26,130
Entonces lanzo esto y le digo

951
01:01:26,130 --> 01:01:28,690
¿Cuál es el número uno? Dos

952
01:01:28,690 --> 01:01:31,110
¿Cuál es el número dos? Tres

953
01:01:31,110 --> 01:01:33,409
¿Qué quieres hacer? Multiplicar

954
01:01:33,409 --> 01:01:36,769
Seis, perfecto, funciona fenomenal

955
01:01:36,769 --> 01:01:39,269
Entrego esto y saco un

956
01:01:39,269 --> 01:01:41,610
No, seis

957
01:01:41,610 --> 01:01:44,130
¿Por qué?

958
01:01:44,789 --> 01:01:47,409
Porque si ahora le digo, vale, número cuatro

959
01:01:47,409 --> 01:01:50,030
3, súmalos

960
01:01:50,030 --> 01:01:51,650
el resultado sería 7

961
01:01:51,650 --> 01:01:53,809
y él me escribe 7, 1, 12

962
01:01:53,809 --> 01:01:55,949
¿por qué?

963
01:01:56,750 --> 01:01:57,929
porque él entra

964
01:01:57,929 --> 01:02:00,210
en este

965
01:02:00,210 --> 01:02:02,030
case y como

966
01:02:02,030 --> 01:02:04,190
no hay break, él ejecutará

967
01:02:04,190 --> 01:02:06,050
esto, esto y esto

968
01:02:06,050 --> 01:02:08,349
entonces hace las 3 operaciones

969
01:02:08,349 --> 01:02:10,869
¿entiendes?

970
01:02:12,940 --> 01:02:14,420
entonces aquí le pongo un break

971
01:02:14,420 --> 01:02:21,929
ya está

972
01:02:21,929 --> 01:02:25,389
entonces ahora si le pongo

973
01:02:25,389 --> 01:02:40,260
Muestres suma. Ahora recuerdo la cara malvada de un italiano medianamente alto que me enseñaba

974
01:02:40,260 --> 01:02:47,300
programación y siempre me ha dicho pon las llaves en los bloques. Entonces le pongo llaves en los

975
01:02:47,300 --> 01:02:59,989
bloques para que sepas cada caso donde piensa y donde acaba. Y si quiero lo puedo poner así,

976
01:02:59,989 --> 01:03:15,230
si lo veis mejor vale esto no cambia nada desde la perspectiva de cómo funciona cuando son pocos

977
01:03:15,230 --> 01:03:22,010
como en este caso que sólo escribir y hacer break hasta en una línea sola no no da problema si se

978
01:03:22,010 --> 01:03:28,769
ve bien cuando aquí hay que meter 25 líneas de código pues entonces está bien que sea marcado

979
01:03:28,769 --> 01:03:39,630
con él con este aquí y te diga aquí empezó a casa 3 aquí acaba a mí me gusta más así vale yo lo veo

980
01:03:39,630 --> 01:03:48,869
más claro pero como mi mente que ha aprendido a programar en 2000 pues lo ve vale luego él le

981
01:03:48,869 --> 01:04:13,119
gusta más así. Vale, entrego esto y saco 5,5. Aprobado. Está muy bien. ¿Por qué? Porque quedan

982
01:04:13,119 --> 01:04:23,440
cosillas feas, como por ejemplo si pongo 6 y 5 y 6. No hace nada. Pongámosles algo. Mira que estás

983
01:04:23,440 --> 01:04:37,690
equivocado pues entonces aquí le pongo default en cualquier otro caso siso operación no admitida

984
01:04:37,690 --> 01:05:15,590
Entonces 1, 2 y le pongo... Ya está, ya tengo un 6. ¿Dudas? Sí. Código es esto.

985
01:05:15,590 --> 01:05:27,730
¿Esto se puede hacer con un if? Claramente, sí. op es igual a igual a 1, hace esto. else if op

986
01:05:27,730 --> 01:05:37,909
2, hace esto, o dice, a ver, else, etc. Es un if-else. Solo que cuando la opción es,

987
01:05:38,150 --> 01:05:43,849
pilla un número y compáralo en varios valores, ponga que es en cien valores, pues esta cosa

988
01:05:43,849 --> 01:05:53,670
de aquí suele parecer más estructurada, más fácil de leer con respecto a poner un if-else,

989
01:05:53,670 --> 01:05:55,250
y flex, y flex, y flex, y flex.

990
01:05:58,489 --> 01:06:00,170
¿Esto funciona solo con enteros?

991
01:06:02,260 --> 01:06:03,780
No. Funciona también con char,

992
01:06:03,900 --> 01:06:05,440
con double, con lo que te da la gana.

993
01:06:05,860 --> 01:06:07,239
Funciona también con string.

994
01:06:08,039 --> 01:06:09,780
¿Vale? La string que ponga

995
01:06:09,780 --> 01:06:11,880
aquí se equivalerá aquí con

996
01:06:11,880 --> 01:06:13,619
no igual, igual,

997
01:06:13,719 --> 01:06:14,539
más un punto de igual.

998
01:06:15,739 --> 01:06:16,380
Todo funciona.

999
01:06:17,699 --> 01:06:17,920
¿Vale?

1000
01:06:19,099 --> 01:06:21,639
Con otros objetos no lo he probado

1001
01:06:21,639 --> 01:06:22,059
en mi vida.

1002
01:06:22,059 --> 01:06:29,429
¿Duras?

1003
01:06:33,920 --> 01:06:34,280
Vale.