1
00:00:00,000 --> 00:00:06,980
Voy a grabar esta clase, por lo tanto, si habláis, me autorizáis a grabar vuestra voz, ¿vale?

2
00:00:07,160 --> 00:00:13,220
Entonces, hemos acabado la primera parte de Java básico, ¿vale?

3
00:00:13,339 --> 00:00:16,280
Hemos dado los primeros pasitos en Java.

4
00:00:16,679 --> 00:00:22,640
En realidad, hemos hecho un paso bastante grande con el operador ternario.

5
00:00:23,000 --> 00:00:26,699
El operador ternario ya nos ha abierto el mundo a muchos ejercicios.

6
00:00:26,699 --> 00:00:30,199
Es la razón de por qué la mayoría de los ejercicios luego se resolvían con un ternario.

7
00:00:30,579 --> 00:00:38,159
Porque la informática sin un condicional, sin un si esto hace esto y si no hace este otro, es muy pobre, hace poco.

8
00:00:38,780 --> 00:00:43,939
Por eso cuando hemos visto algo que podía darnos una alternativa, pues de ahí hemos sacado muchas cosas.

9
00:00:44,780 --> 00:00:52,219
Ahora, la cosa positiva es que la primera parte de estructura y control que vamos a ver es sustancialmente lo mismo.

10
00:00:52,219 --> 00:00:57,899
Si habéis entendido el operador ternario, el IF es muy fácil.

11
00:00:58,539 --> 00:01:07,959
La única cosa que tenéis que entender profundamente es que el operador ternario no es una estructura de control.

12
00:01:08,560 --> 00:01:10,719
El operador ternario es una expresión.

13
00:01:11,760 --> 00:01:17,239
Yo evalúo el operador ternario y al final tengo un valor, tengo un literal de algo.

14
00:01:18,140 --> 00:01:20,680
Sin embargo, el IF no se evalúa.

15
00:01:20,680 --> 00:01:24,519
el if se ejecuta

16
00:01:24,519 --> 00:01:27,560
dentro de un

17
00:01:27,560 --> 00:01:30,099
condicional, de un operador ternario

18
00:01:30,099 --> 00:01:32,719
yo tenía una condición y luego dos expresiones

19
00:01:32,719 --> 00:01:36,079
estas expresiones, que tenían que ser del mismo tipo

20
00:01:36,079 --> 00:01:39,079
y cosas por el estilo, no podían ser un comando

21
00:01:39,079 --> 00:01:41,799
yo no podía, podía poner ahí dentro

22
00:01:41,799 --> 00:01:44,439
3 más 5, operación, expresión

23
00:01:44,439 --> 00:01:47,959
pero no podía poner system.auto.println

24
00:01:47,959 --> 00:01:50,599
y nos puede decir, si esto es así, pues

25
00:01:50,599 --> 00:01:52,400
escríbeme algo. ¿Vale?

26
00:01:52,840 --> 00:01:54,540
Porque el operador ternario

27
00:01:54,540 --> 00:01:56,719
no es una operación, no es una

28
00:01:56,719 --> 00:01:58,140
estructura de control. Es

29
00:01:58,140 --> 00:02:00,700
una expresión y se

30
00:02:00,700 --> 00:02:02,200
evalúa. Tiene que dar un valor.

31
00:02:02,579 --> 00:02:04,719
Y System.Auto.Println no da un

32
00:02:04,719 --> 00:02:04,980
valor.

33
00:02:06,219 --> 00:02:08,719
¿Se entiende? Pues ahora vamos a

34
00:02:08,719 --> 00:02:10,080
ver una cosa que es igual,

35
00:02:10,620 --> 00:02:12,240
solo que en las dos ramas,

36
00:02:12,500 --> 00:02:14,979
si es verdadero o si es falso,

37
00:02:15,560 --> 00:02:16,780
sí puedo

38
00:02:16,780 --> 00:02:18,080
poner un programa entero.

39
00:02:19,560 --> 00:02:20,560
¿Sí? Es decir,

40
00:02:20,599 --> 00:02:22,759
que en vez de decir, si esta condición

41
00:02:22,759 --> 00:02:23,599
es verdadera,

42
00:02:24,400 --> 00:02:25,560
hazme una expresión,

43
00:02:26,020 --> 00:02:29,080
si esa expresión es verdadera, haz un conjunto

44
00:02:29,080 --> 00:02:30,639
de

45
00:02:30,639 --> 00:02:33,639
programas,

46
00:02:33,840 --> 00:02:36,240
de comandos, de instrucciones.

47
00:02:36,819 --> 00:02:38,120
Y si es falsa,

48
00:02:38,379 --> 00:02:40,060
haz otro conjunto de instrucciones,

49
00:02:40,060 --> 00:02:41,680
que pueden ser una, dos,

50
00:02:41,860 --> 00:02:43,419
cincuenta, siete mil.

51
00:02:44,800 --> 00:02:45,919
¿Sí? Es sustantivamente

52
00:02:45,919 --> 00:02:47,379
un bloque de instrucciones.

53
00:02:47,659 --> 00:02:49,319
En un futuro se pueden llamar métodos.

54
00:02:49,319 --> 00:02:51,280
puede hacer un montón de cosas

55
00:02:51,280 --> 00:02:52,759
¿sí? entonces

56
00:02:52,759 --> 00:02:55,159
¿IF y operador alternado

57
00:02:55,159 --> 00:02:57,020
son la misma cosa? no

58
00:02:57,020 --> 00:02:59,439
¿tienen cosas parecidas?

59
00:02:59,819 --> 00:03:01,379
sí ¿usan los dos

60
00:03:01,379 --> 00:03:03,259
una expresión booleana para indicar

61
00:03:03,259 --> 00:03:04,860
si hacen una cosa u otra? sí

62
00:03:04,860 --> 00:03:07,419
¿se pueden usar para las mismas cosas?

63
00:03:08,060 --> 00:03:08,419
no

64
00:03:08,419 --> 00:03:11,419
¿es más potente el IF o es más

65
00:03:11,419 --> 00:03:12,099
potente el otro?

66
00:03:13,520 --> 00:03:15,419
el IF probablemente es más potente

67
00:03:15,419 --> 00:03:16,939
¿vale? pero

68
00:03:16,939 --> 00:03:24,560
grosso modo se usan para cosas distintas esto como introducción ahora vamos a

69
00:03:24,560 --> 00:03:30,550
hablar de esto que es una estructura de control una estructura de control son

70
00:03:30,550 --> 00:03:35,469
elementos del lenguaje que nos permiten romper el flujo lógico de ejecución de

71
00:03:35,469 --> 00:03:40,409
instrucción si os acordáis cuando vimos una de las

72
00:03:40,409 --> 00:03:45,210
primeras transparencias estamos hablando del lenguaje estructurado vale en un

73
00:03:45,210 --> 00:03:51,509
lenguaje imperativo como el nuestro, decíamos que necesitaba algunos elementos para poder

74
00:03:51,509 --> 00:03:59,229
funcionar, ¿vale? Que eran los condicionales, eran los iterativos y eran las secuencias, ¿vale?

75
00:03:59,229 --> 00:04:06,530
Y un lenguaje, o sea, un programa normal, básico, como los que hemos hecho ahora más o menos,

76
00:04:07,909 --> 00:04:14,610
es secuencial. Empieza desde el principio y ejecuta todas las instrucciones una tras otra.

77
00:04:14,610 --> 00:04:16,990
hasta cuando yo tengo un operador

78
00:04:16,990 --> 00:04:19,149
ternario, que una parte de este operador

79
00:04:19,149 --> 00:04:20,870
no la ejecuto, no la evalúo

80
00:04:20,870 --> 00:04:23,129
pero en realidad estoy evaluando esa línea

81
00:04:23,129 --> 00:04:25,129
ese comando, cada comando

82
00:04:25,129 --> 00:04:27,129
se ejecuta

83
00:04:27,970 --> 00:04:28,750
uno tras otro

84
00:04:28,750 --> 00:04:31,129
hasta ahora todos nuestros ejercicios

85
00:04:31,129 --> 00:04:32,889
han sido secuenciales

86
00:04:32,889 --> 00:04:35,170
estábamos en la primera de las tres características

87
00:04:35,170 --> 00:04:36,430
que hemos visto

88
00:04:36,430 --> 00:04:38,790
todo es secuencial

89
00:04:38,790 --> 00:04:40,769
empieza desde la primera línea del main

90
00:04:40,769 --> 00:04:43,069
y acaba en la última línea del main

91
00:04:43,069 --> 00:04:46,790
¿Vale? Lo básico. Por eso se llamaba Java básico.

92
00:04:47,370 --> 00:04:58,779
Ahora, las estructuras de control son mecanismos, son elementos, son elementos del lenguaje, del lenguaje de Java, ¿se entiende?

93
00:04:58,779 --> 00:05:03,819
Que lo que permiten es romper ese flujo normal.

94
00:05:04,259 --> 00:05:12,500
En vez de decir, empieza aquí y acaba aquí, pues ahora el flujo de ejecución de los datos, el flujo de ejecución de las instrucciones,

95
00:05:12,500 --> 00:05:14,899
puede que no sea tan lineal

96
00:05:14,899 --> 00:05:16,300
secuencial

97
00:05:16,300 --> 00:05:17,540
1, 2, 3, 4, 5

98
00:05:17,540 --> 00:05:19,699
puede ser que haga saltos

99
00:05:19,699 --> 00:05:21,600
puede ser que vuelva atrás

100
00:05:21,600 --> 00:05:24,019
cuando se rompe

101
00:05:24,019 --> 00:05:26,279
el flujo normal de

102
00:05:26,279 --> 00:05:27,560
el flujo lógico

103
00:05:27,560 --> 00:05:29,759
el flujo secuencial de datos

104
00:05:29,759 --> 00:05:32,120
pues se necesita emplear

105
00:05:32,120 --> 00:05:34,459
una estructura de control

106
00:05:34,459 --> 00:05:36,560
que controla este flujo

107
00:05:36,560 --> 00:05:37,660
me permite decir salta

108
00:05:37,660 --> 00:05:39,019
me permite decir vuelve atrás

109
00:05:39,019 --> 00:05:44,779
Se denomina flujo de ejecución

110
00:05:44,779 --> 00:05:48,519
El orden en el que se ejecutan determinados conjuntos de instrucciones y sentencias

111
00:05:48,519 --> 00:05:50,939
Por ahora el nuestro era secuencial básico

112
00:05:50,939 --> 00:05:55,480
Y el flujo lógico es de arriba a abajo, de izquierda a derecha

113
00:05:55,480 --> 00:05:57,079
¿Estamos de acuerdo hasta aquí?

114
00:05:58,459 --> 00:06:02,800
Entonces tenemos tres tipos de sentencias de control

115
00:06:02,800 --> 00:06:04,839
Tres grandes familias

116
00:06:04,839 --> 00:06:06,899
Dentro de cada una de estas familias

117
00:06:06,899 --> 00:06:12,500
Puedo tener varios mecanismos que normalmente son equivalentes.

118
00:06:12,740 --> 00:06:22,240
Si yo me sé uno de estos tres, de estos mecanismos, puedo con más o menos esfuerzo hacer lo mismo que hacen los demás.

119
00:06:23,740 --> 00:06:30,839
Entonces tengo los condicionales, tengo los iterativos y tengo las llamadas a métodos.

120
00:06:30,839 --> 00:06:38,439
Los condicionales son los que me permiten decir si ejecuto o no un trozo de código

121
00:06:38,439 --> 00:06:44,220
Entonces tendré un bloque de código y en base a algo, a una condición

122
00:06:44,220 --> 00:06:47,120
Hemos visto la lógica booleana, entonces sabemos un true o un false

123
00:06:47,120 --> 00:06:51,139
Ejecuto un trozo de código o no lo ejecuto

124
00:06:51,139 --> 00:06:55,240
O ejecuto un trozo de código, un bloque de código o ejecuto otro distinto

125
00:06:55,240 --> 00:06:58,220
Pero hay una alternativa, es un or

126
00:06:58,220 --> 00:07:01,399
tengo en cierto momento

127
00:07:01,399 --> 00:07:03,420
un bloque, lo voy a ejecutar

128
00:07:03,420 --> 00:07:05,360
no lo sé, dependerá

129
00:07:05,360 --> 00:07:07,120
de las condiciones con el que

130
00:07:07,120 --> 00:07:09,180
el sistema, con el que mi programa

131
00:07:09,180 --> 00:07:10,860
llega a ese bloque

132
00:07:10,860 --> 00:07:13,480
y habrá una condición, si esta condición es verdadera

133
00:07:13,480 --> 00:07:14,980
lo ejecuto, si esta condición es falsa

134
00:07:14,980 --> 00:07:16,620
no lo ejecuto o ejecuto otro

135
00:07:16,620 --> 00:07:19,040
estos son los condicionales

136
00:07:19,040 --> 00:07:21,579
y dentro de los condicionales

137
00:07:21,579 --> 00:07:22,160
hay tres

138
00:07:22,160 --> 00:07:24,779
hay elifas secas

139
00:07:24,779 --> 00:07:27,360
si esta condición es verdadera

140
00:07:27,360 --> 00:07:29,279
ejecuta. Si no, no ejecuta.

141
00:07:29,839 --> 00:07:30,240
Se acabó.

142
00:07:31,480 --> 00:07:33,420
El if-else, que es su primo

143
00:07:33,420 --> 00:07:35,459
muy cercano, que es

144
00:07:35,459 --> 00:07:37,399
si es verdadera, ejecuta

145
00:07:37,399 --> 00:07:39,639
una cosa. Si es falsa, ejecuta

146
00:07:39,639 --> 00:07:39,939
otra.

147
00:07:41,160 --> 00:07:43,420
Es parecido. De hecho, yo puedo

148
00:07:43,420 --> 00:07:45,019
no tener el if-else

149
00:07:45,019 --> 00:07:47,420
y hacer todo con un if. Pongo

150
00:07:47,420 --> 00:07:49,600
if-condición, ejecuta

151
00:07:49,600 --> 00:07:51,600
esto. If-not, misma

152
00:07:51,600 --> 00:07:53,699
condición, pues ejecuta este otro.

153
00:07:54,120 --> 00:07:55,300
Y he hecho un if-else.

154
00:07:55,980 --> 00:07:57,180
No me hace falta el if-else.

155
00:07:57,360 --> 00:07:59,779
Es cómodo tener, ¿vale?

156
00:08:00,000 --> 00:08:03,779
Pero son equivalentes y puedo tener uno y no tener el otro.

157
00:08:04,899 --> 00:08:07,579
Y luego está el switch, el switch case, ¿vale?

158
00:08:07,779 --> 00:08:08,399
Se llama case.

159
00:08:08,959 --> 00:08:18,399
Que sustancialmente sirve cuando mi condición depende de varios valores de una determinada variable.

160
00:08:18,819 --> 00:08:23,959
Imaginaos que yo tengo una variable entera y digo que si esta variable vale 1, hace una cosa.

161
00:08:24,360 --> 00:08:26,439
Si vale 2, hace una cosa distinta.

162
00:08:26,439 --> 00:08:34,419
si vale 3 hace una cosa distinta. Se puede hacer lo mismo con un if, solo que normalmente cuando

163
00:08:34,419 --> 00:08:42,100
yo intento hacer algo que iría bien con un switch case con un if, me sale un if dentro de un if,

164
00:08:42,100 --> 00:08:47,000
dentro de otro if, dentro de otro if, cosa por el estilo. Una cosa que no se puede leer. Entonces,

165
00:08:47,000 --> 00:08:52,200
como vieron que a veces pasaban estas cosas, dijeron ¿por qué no creamos un condicional

166
00:08:52,200 --> 00:08:58,820
alternativo que en estos casos hace el código mucho más limpio pero sustancialmente es lo

167
00:08:58,820 --> 00:09:10,580
mismo es una forma u otra de hacer las cosas pero es son estructuras equivalentes pero con

168
00:09:10,580 --> 00:09:19,919
sintaxis distintas para que vosotros utilicéis la que os hace el código más leíble y esto lo

169
00:09:19,919 --> 00:09:25,019
vamos a ver hoy, condicionales. Luego estarán los iterativos. Los

170
00:09:25,019 --> 00:09:29,879
iterativos son los que me permiten repetir un determinado código más de una

171
00:09:29,879 --> 00:09:35,980
vez. Son los ciclos, los bucles. Y tenemos

172
00:09:35,980 --> 00:09:42,679
dos importantes y medio. Los dos importantes son el while y el for.

173
00:09:42,679 --> 00:09:49,899
Lo veremos, lo repetiré. Pero cuando yo no sé cuántas veces voy a repetir

174
00:09:49,899 --> 00:09:56,019
un ciclo, sé que me va a meter allí, y voy a repetir, pero no sé si tres, cinco o

175
00:09:56,019 --> 00:10:04,899
veintisiete veces, pues este es un while, con su hermano menor, el do while, que es al

176
00:10:04,899 --> 00:10:10,799
menos una vez hazlo. Mientras el while sería no sé cuántas veces, podría ser cero,

177
00:10:10,799 --> 00:10:18,179
podrían ser mil, no lo sé, pero podría ser cero. El do while es este bloque, hazlo una

178
00:10:18,179 --> 00:10:25,500
vez y luego a lo mejor lo repetirás o no y no sé cuántas veces. Lo veremos con más detalles cuando

179
00:10:25,500 --> 00:10:33,480
lo veamos. El FOR en veces se utiliza cuando yo a priori sé cuántas veces voy a hacer este ciclo.

180
00:10:35,179 --> 00:10:44,740
Ejemplos. Si yo te digo dame números hasta que ponga un cero. Dame un número, dame otro, dame otro, dame otro,

181
00:10:44,740 --> 00:10:46,940
dame otro, si pones 0 a cabo

182
00:10:46,940 --> 00:10:48,100
es un while on for

183
00:10:48,100 --> 00:10:52,509
while, tú no sabes

184
00:10:52,509 --> 00:10:54,769
cuántos números te va a dar

185
00:10:54,769 --> 00:10:56,789
el usuario, podría ser que hoy te da

186
00:10:56,789 --> 00:10:58,970
3, 3, 0, te ha dado 2 números

187
00:10:58,970 --> 00:11:01,090
o puede ser que te da 1, 2, 3

188
00:11:01,090 --> 00:11:02,850
4, 5, 6, 7, 8, 9, 10

189
00:11:02,850 --> 00:11:05,009
12, 13, 0, pues a veces te ha dado

190
00:11:05,009 --> 00:11:06,009
13, no sé

191
00:11:06,009 --> 00:11:09,110
a tiempo de compilación cuántas veces

192
00:11:09,110 --> 00:11:10,690
voy a reciclar

193
00:11:10,690 --> 00:11:12,590
si en vez te digo

194
00:11:12,590 --> 00:11:15,009
dame 5 números

195
00:11:15,009 --> 00:11:18,389
cuántas veces tendré que pedir

196
00:11:18,389 --> 00:11:19,330
dame un número

197
00:11:19,330 --> 00:11:21,129
cinco veces

198
00:11:21,129 --> 00:11:22,549
¿cuántas veces lo voy a hacer?

199
00:11:23,250 --> 00:11:25,409
por lo tanto es un for

200
00:11:25,409 --> 00:11:27,049
para que se entienda

201
00:11:27,049 --> 00:11:31,309
¿puedo hacer lo que hace un for con un while?

202
00:11:33,649 --> 00:11:34,690
sí, tranquilamente

203
00:11:34,690 --> 00:11:36,509
¿puedo hacer lo que hace un while con un for?

204
00:11:37,389 --> 00:11:38,389
sí, tranquilamente

205
00:11:38,389 --> 00:11:40,129
son equivalentes

206
00:11:40,129 --> 00:11:42,129
solo que hay casos

207
00:11:42,129 --> 00:11:44,929
en el que en un while te sale una cosa bonita

208
00:11:44,929 --> 00:11:47,049
que con un for es una cosa infernal

209
00:11:47,049 --> 00:11:49,190
y hay otros casos que con un for

210
00:11:49,190 --> 00:11:51,230
te sale una cosa bonita y con un while

211
00:11:51,230 --> 00:11:52,970
es una cosa infernal que no se entiende

212
00:11:52,970 --> 00:11:55,370
porque a un cierto momento Bob hace ese cálculo

213
00:11:55,370 --> 00:11:57,309
de ahí, ¿vale? Entonces son dos

214
00:11:57,309 --> 00:11:59,309
cosas que hacen lo mismo

215
00:11:59,309 --> 00:12:01,389
son equivalentes, se pueden intercambiar

216
00:12:01,389 --> 00:12:02,830
si tú quieres, pero

217
00:12:02,830 --> 00:12:06,519
en determinados casos

218
00:12:06,519 --> 00:12:08,320
es mejor una cosa

219
00:12:08,320 --> 00:12:10,059
y en determinados casos

220
00:12:10,059 --> 00:12:11,299
es mejor otra

221
00:12:11,299 --> 00:12:12,799
¿sí?

222
00:12:12,799 --> 00:12:15,620
y finalmente

223
00:12:15,620 --> 00:12:17,720
acordaos que estamos en el concepto

224
00:12:17,720 --> 00:12:19,720
de sentencias de control, ¿qué hace una sentencia

225
00:12:19,720 --> 00:12:20,139
de control?

226
00:12:24,309 --> 00:12:25,470
romper el orden lógico

227
00:12:25,470 --> 00:12:28,909
romper el orden lógico con el que se ejecutan

228
00:12:28,909 --> 00:12:31,429
las instrucciones, ¿os acordáis hace 3 minutos?

229
00:12:31,750 --> 00:12:32,049
pues eso

230
00:12:32,049 --> 00:12:35,250
pues, estas 3

231
00:12:35,250 --> 00:12:36,509
hacen esto

232
00:12:36,509 --> 00:12:39,269
esto lo rompe porque puede saltar

233
00:12:39,269 --> 00:12:41,049
un trozo, esto lo rompe porque vuelve

234
00:12:41,049 --> 00:12:42,669
a repetir algo que se había hecho antes

235
00:12:42,669 --> 00:12:45,490
y esto lo rompe porque va a ejecutar

236
00:12:45,490 --> 00:12:48,750
Un trozo de código que está en otro lado

237
00:12:48,750 --> 00:12:55,870
Una llamada a método es que yo he llamado con un nombre una serie de instrucciones

238
00:12:55,870 --> 00:12:57,590
He llamado cocodrilo

239
00:12:57,590 --> 00:12:59,529
Entonces tengo mi main

240
00:12:59,529 --> 00:13:02,490
En un determinado momento llamo el método cocodrilo

241
00:13:03,009 --> 00:13:06,590
Que quiere decir, deja de hacer el main secuencialmente

242
00:13:06,590 --> 00:13:10,490
Falta aquel bloque que yo he llamado cocodrilo

243
00:13:11,049 --> 00:13:13,970
Ejecuta el método cocodrilo

244
00:13:13,970 --> 00:13:17,210
o sea, las instrucciones del método cocodrilo

245
00:13:17,210 --> 00:13:19,649
y cuando has acabado el método cocodrilo

246
00:13:19,649 --> 00:13:22,269
vuelves al main y sigues

247
00:13:22,269 --> 00:13:25,809
entonces ya no es secuencial, ha habido un salto raro

248
00:13:25,809 --> 00:13:30,129
por eso rompe el flujo normal

249
00:13:30,129 --> 00:13:32,029
¿hemos visto algún método?

250
00:13:37,070 --> 00:13:40,269
math en concreto no, math es una clase

251
00:13:40,269 --> 00:13:44,289
integer es otra clase

252
00:13:44,289 --> 00:13:47,610
charact

253
00:13:47,610 --> 00:13:49,169
charat es un método

254
00:13:49,169 --> 00:13:51,210
random sí

255
00:13:51,210 --> 00:13:51,750
math no

256
00:13:51,750 --> 00:13:54,909
math es una clase

257
00:13:54,909 --> 00:13:56,990
porque es el método random

258
00:13:56,990 --> 00:13:58,309
de la clase math

259
00:13:58,309 --> 00:14:00,870
como el método charat

260
00:14:00,870 --> 00:14:02,309
lo llama sobre un string

261
00:14:02,309 --> 00:14:04,809
nosotros todavía esto no lo entendemos bien

262
00:14:04,809 --> 00:14:06,330
porque son cosas de

263
00:14:06,330 --> 00:14:08,629
de objetos

264
00:14:08,629 --> 00:14:10,830
entonces no entendemos porque a veces

265
00:14:10,830 --> 00:14:12,850
lo llamo sobre math que es una clase

266
00:14:12,850 --> 00:14:14,970
y a veces lo llamo sobre un string

267
00:14:14,970 --> 00:14:15,889
que es un objeto

268
00:14:15,889 --> 00:14:18,750
ni idea porque no lo he visto

269
00:14:18,750 --> 00:14:21,110
pero println

270
00:14:21,110 --> 00:14:23,830
¿qué es println?

271
00:14:26,700 --> 00:14:27,340
es un método

272
00:14:27,340 --> 00:14:29,059
¿escrito por quién? no lo sé

273
00:14:29,059 --> 00:14:31,580
pero yo lo he metido en mi main

274
00:14:31,580 --> 00:14:33,220
cuando mi main

275
00:14:33,220 --> 00:14:34,559
llega a un println

276
00:14:34,559 --> 00:14:37,399
se para, no sigue el main

277
00:14:37,399 --> 00:14:39,379
se va a un código

278
00:14:39,379 --> 00:14:41,340
que ha escrito alguien más

279
00:14:41,340 --> 00:14:42,259
no sé dónde

280
00:14:42,259 --> 00:14:45,279
ejecuta ese código que hace que me escriba

281
00:14:45,279 --> 00:14:46,240
algo en pantalla

282
00:14:46,240 --> 00:14:49,080
Y luego vuelvo a mi main y sigo adelante.

283
00:14:50,019 --> 00:14:53,779
El next int o el next del escáner.

284
00:14:54,299 --> 00:14:56,200
Pues mi programa va por allí.

285
00:14:56,360 --> 00:15:00,580
Cuando llega al next, se va a un código que no he escrito yo,

286
00:15:00,700 --> 00:15:03,659
que es un método de la clase escáner o del objeto escáner.

287
00:15:04,320 --> 00:15:09,100
Y allí dentro ejecuta una serie de cosas que me permiten bloquear el proceso

288
00:15:09,100 --> 00:15:11,879
y esperar que alguien teclee algo y le dé al intro.

289
00:15:12,200 --> 00:15:13,980
Cosa que yo no tengo ni idea de cómo se hace.

290
00:15:13,980 --> 00:15:16,000
y nadie de vosotros sabe cómo se hace

291
00:15:16,000 --> 00:15:18,000
de verdad, pero llamando a este

292
00:15:18,000 --> 00:15:19,840
método lo hace él solo

293
00:15:19,840 --> 00:15:22,259
cuando ha acabado ese método

294
00:15:22,259 --> 00:15:23,820
vuelve a mi main

295
00:15:23,820 --> 00:15:24,899
y sigue adelante

296
00:15:24,899 --> 00:15:27,460
pues estas son llamadas al método

297
00:15:27,460 --> 00:15:30,039
un método se reconoce

298
00:15:30,039 --> 00:15:31,519
porque es una palabra

299
00:15:31,519 --> 00:15:34,419
en minúscula y luego hay paréntesis

300
00:15:34,419 --> 00:15:38,539
system.auto.println

301
00:15:38,539 --> 00:15:39,299
y paréntesis

302
00:15:39,299 --> 00:15:41,539
nextint

303
00:15:41,539 --> 00:15:43,259
paréntesis, paréntesis

304
00:15:43,259 --> 00:15:45,399
¿sí?

305
00:15:46,779 --> 00:15:48,159
¿qué más sabemos? charat

306
00:15:48,159 --> 00:15:50,600
charat, paréntesis, numerito, paréntesis

307
00:15:50,600 --> 00:15:52,740
punto equals

308
00:15:52,740 --> 00:15:54,299
y luego lo meto entre paréntesis

309
00:15:54,299 --> 00:15:55,679
todo eso son métodos

310
00:15:55,679 --> 00:15:56,840
¿sí?

311
00:15:58,200 --> 00:16:00,240
los métodos son en minúsculas

312
00:16:00,240 --> 00:16:02,759
empiezan por minúsculas como las variables

313
00:16:02,759 --> 00:16:04,879
pero las variables no tienen la paréntesis

314
00:16:04,879 --> 00:16:06,519
los métodos tienen paréntesis

315
00:16:06,519 --> 00:16:08,639
luego, ¿sobre qué se llaman?

316
00:16:08,799 --> 00:16:10,940
si sobre un objeto, si sobre una clase

317
00:16:10,940 --> 00:16:12,519
eso nos cuesta porque

318
00:16:12,519 --> 00:16:14,679
Que todavía no sabemos la diferencia entre objetos y clases.

319
00:16:15,240 --> 00:16:16,960
Veremos que nosotros la llamaremos sobre nada,

320
00:16:17,460 --> 00:16:18,679
porque nuestros métodos serán

321
00:16:18,679 --> 00:16:20,679
static, estáticos.

322
00:16:20,779 --> 00:16:21,500
¿Y qué quiere decir?

323
00:16:21,899 --> 00:16:24,860
Lo veremos en un multiverso paralelo en diciembre.

324
00:16:25,960 --> 00:16:27,039
¿Sí? Por ahora no.

325
00:16:27,980 --> 00:16:28,480
¡Dudas!

326
00:16:29,500 --> 00:16:31,200
Entonces, dentro de la llamada

327
00:16:31,200 --> 00:16:33,159
métodos, puedo llamar un método directamente,

328
00:16:33,440 --> 00:16:35,059
puedo llamar un método sobre un objeto,

329
00:16:35,059 --> 00:16:36,820
puedo llamar un método sobre una clase.

330
00:16:37,039 --> 00:16:39,179
¿Qué diferencia hay? No lo sé.

331
00:16:39,539 --> 00:16:40,620
No me interesa por ahora.

332
00:16:40,620 --> 00:16:52,559
Por ahora nosotros usaremos esta cosa de aquí como mecanismo que se utiliza dentro del paradigma de programación estructurada, ¿vale?

333
00:16:52,820 --> 00:17:02,720
En la programación estructurada no hay objetos sin clases y por lo tanto estos de aquí por ahora los aparcamos hasta que en un futuro, digamos, os acordáis ese transparente, pues ahora lo usamos.

334
00:17:03,259 --> 00:17:09,160
Y en realidad lo estamos usando constantemente, repito, Math.random está haciendo esto, ¿sí?

335
00:17:09,160 --> 00:17:12,500
y scan.nexint

336
00:17:12,500 --> 00:17:13,380
está usando esto.

337
00:17:13,940 --> 00:17:15,359
He creado un objeto scan,

338
00:17:16,299 --> 00:17:17,880
scanner, scan, igual new,

339
00:17:18,160 --> 00:17:19,640
ese new es un nuevo objeto

340
00:17:19,640 --> 00:17:23,039
y luego está llamando scan.nexint.

341
00:17:23,039 --> 00:17:25,039
Entonces, esto lo estamos usando constantemente

342
00:17:25,039 --> 00:17:27,039
porque necesitamos usarlo para hacer

343
00:17:27,039 --> 00:17:28,799
nuestros programas, pero no sabemos

344
00:17:28,799 --> 00:17:29,539
qué es, por ejemplo.

345
00:17:31,789 --> 00:17:35,029
¿Dudas? ¿Preguntas?

346
00:17:37,779 --> 00:17:39,259
¿Quedan claros

347
00:17:39,259 --> 00:17:41,400
qué es una sentencia

348
00:17:41,400 --> 00:17:43,380
de control y una

349
00:17:43,380 --> 00:17:45,220
estructura de control y que hay

350
00:17:45,220 --> 00:17:47,380
tres tipos de estructura de control

351
00:17:47,380 --> 00:17:49,119
y que cada una tiene

352
00:17:49,119 --> 00:17:51,460
distintas implementaciones

353
00:17:51,460 --> 00:17:53,460
de esta estructura de control, que puede

354
00:17:53,460 --> 00:17:55,440
haber más, pero

355
00:17:55,440 --> 00:17:57,559
que son sustancialmente equivalentes

356
00:17:57,559 --> 00:17:59,319
solo que alguna es más cómoda en un

357
00:17:59,319 --> 00:18:00,299
contexto, alguna en otra.

358
00:18:01,220 --> 00:18:02,700
¿Sí? ¿Dudas?

359
00:18:03,940 --> 00:18:07,440
Bueno, pues vamos

360
00:18:07,440 --> 00:18:08,859
a empezar con los condicionales.

361
00:18:08,980 --> 00:18:11,140
Sirven para proporcionar distintos caminos

362
00:18:11,140 --> 00:18:13,279
lógicos de ejecución y después

363
00:18:13,279 --> 00:18:15,259
continuar con el programa. Yo llego

364
00:18:15,259 --> 00:18:17,380
un momento y tengo

365
00:18:17,380 --> 00:18:18,900
un bivio, se dice bivio

366
00:18:18,900 --> 00:18:21,619
¿bivio se dice?

367
00:18:21,980 --> 00:18:22,740
¿no? ¿cómo se dice?

368
00:18:23,559 --> 00:18:25,539
camino y bifurcación

369
00:18:25,539 --> 00:18:27,519
tengo dos

370
00:18:27,519 --> 00:18:29,160
vías, ¿vale? y puede decir

371
00:18:29,160 --> 00:18:31,380
si pasar por la derecha o pasar por

372
00:18:31,380 --> 00:18:32,519
la izquierda, ¿vale?

373
00:18:33,420 --> 00:18:35,779
normalmente, luego estas cosas se reúnen

374
00:18:35,779 --> 00:18:37,319
después, pero si he ido

375
00:18:37,319 --> 00:18:39,619
a la derecha, he encontrado

376
00:18:39,619 --> 00:18:41,420
el lobo y si he ido

377
00:18:41,420 --> 00:18:43,400
a la izquierda, he encontrado

378
00:18:43,400 --> 00:18:45,220
el gufo, y que me han dicho

379
00:18:45,220 --> 00:18:47,500
pues no lo sé, gufo el búho

380
00:18:47,500 --> 00:18:51,240
así aprendéis italiano, al final tenéis un

381
00:18:51,240 --> 00:18:51,960
B2

382
00:18:51,960 --> 00:18:55,039
hoy hemos aprendido vídeo

383
00:18:55,039 --> 00:18:56,940
en gufo, entran en esa

384
00:18:56,940 --> 00:18:59,480
se valora

385
00:18:59,480 --> 00:19:00,900
una condición

386
00:19:00,900 --> 00:19:03,220
y en base al resultado se ejecutarán

387
00:19:03,220 --> 00:19:04,500
unas instrucciones u otra

388
00:19:04,500 --> 00:19:06,599
en realidad se podría decir también

389
00:19:06,599 --> 00:19:09,380
se ejecutarán unas instrucciones

390
00:19:09,380 --> 00:19:11,559
o no, dependiendo del if que tengo

391
00:19:11,559 --> 00:19:13,180
el if más sencillo es

392
00:19:13,180 --> 00:19:15,720
esto lo hace solo si es verdadera

393
00:19:15,720 --> 00:19:17,019
la condición y ya está

394
00:19:17,019 --> 00:19:19,900
mientras el if es un poquito más complejo, el if else es

395
00:19:19,900 --> 00:19:21,799
si es verdadera hace una cosa

396
00:19:21,799 --> 00:19:22,819
si es falsa hace otra

397
00:19:22,819 --> 00:19:25,059
son dos versiones

398
00:19:25,059 --> 00:19:26,339
parecidas

399
00:19:26,339 --> 00:19:29,119
y aquí lo tenemos

400
00:19:29,119 --> 00:19:31,420
¿vale? esto es

401
00:19:31,420 --> 00:19:32,960
un diagrama de flujo

402
00:19:32,960 --> 00:19:35,700
si veis alguna vez un diagrama

403
00:19:35,700 --> 00:19:37,180
de flujo, no sé si lo habéis visto en otra

404
00:19:37,180 --> 00:19:39,539
asignatura o en vuestra vida

405
00:19:39,539 --> 00:19:40,940
o cosa por el estilo

406
00:19:40,940 --> 00:19:44,759
normalmente en los diagramas de supos

407
00:19:44,759 --> 00:19:46,960
el rombo es un condicional

408
00:19:46,960 --> 00:19:48,119
es una pregunta

409
00:19:48,119 --> 00:19:50,059
entonces si yo llego aquí

410
00:19:50,059 --> 00:19:51,880
hay una condición

411
00:19:51,880 --> 00:19:54,099
evalúo esta condición

412
00:19:54,099 --> 00:19:55,420
que es una

413
00:19:55,420 --> 00:19:58,640
una condición de lógica booleana

414
00:19:58,640 --> 00:19:59,660
que a vosotros os encanta

415
00:19:59,660 --> 00:20:02,259
y si es verdadera

416
00:20:02,259 --> 00:20:04,079
ejecuto este bloque

417
00:20:04,079 --> 00:20:06,980
si es falsa me salto el bloque

418
00:20:06,980 --> 00:20:08,220
y luego sigo adelante

419
00:20:08,220 --> 00:20:11,180
entonces, esta

420
00:20:11,180 --> 00:20:13,279
parte de aquí se ejecuta

421
00:20:13,279 --> 00:20:15,140
si y solo si las condiciones que tengo

422
00:20:15,140 --> 00:20:16,980
ya no tengo

423
00:20:16,980 --> 00:20:19,160
un flujo directo

424
00:20:19,160 --> 00:20:21,160
continuo de ejecución

425
00:20:21,160 --> 00:20:23,539
ya no puedo establecer

426
00:20:23,539 --> 00:20:25,799
a tiempo de programación

427
00:20:25,799 --> 00:20:27,960
si este bloque se ejecutará

428
00:20:27,960 --> 00:20:30,119
o no, porque dependerá

429
00:20:30,119 --> 00:20:32,079
a tiempo de ejecución

430
00:20:32,079 --> 00:20:33,700
de si esta condición será

431
00:20:33,700 --> 00:20:34,720
verdadera o falsa

432
00:20:34,720 --> 00:20:37,480
dame un número, y si el número es 3

433
00:20:37,480 --> 00:20:39,500
hace algo, si no, no. Y no puedo

434
00:20:39,500 --> 00:20:41,559
saber si el usuario es bondad 3 o no.

435
00:20:43,220 --> 00:20:43,680
¿Entiendes?

436
00:20:45,779 --> 00:20:47,079
La otra alternativa

437
00:20:47,079 --> 00:20:48,039
que es el if-fails.

438
00:20:48,799 --> 00:20:50,819
Llego a la condición. Si es

439
00:20:50,819 --> 00:20:52,579
verdadero, hay un bloque.

440
00:20:53,000 --> 00:20:54,660
Y luego sigo. Si es

441
00:20:54,660 --> 00:20:56,660
falso, hay un bloque distinto.

442
00:20:56,660 --> 00:20:59,140
Y luego sigo. Son alternativas.

443
00:20:59,579 --> 00:21:00,579
Es un pseudor.

444
00:21:00,940 --> 00:21:01,740
O esto o esto.

445
00:21:03,319 --> 00:21:04,460
Este de aquí es

446
00:21:04,460 --> 00:21:05,640
o esto o nada.

447
00:21:06,420 --> 00:21:08,680
Y este de aquí es o bloque 1 o bloque 2.

448
00:21:08,799 --> 00:21:30,680
son equivalentes no son lo mismo son muy parecidos porque a veces tú dices sí

449
00:21:33,720 --> 00:21:39,539
tienes que hacer un pago entonces tú tienes tu cuenta del banco y lo que tienes que hacer es

450
00:21:39,539 --> 00:21:46,819
quitarse el dinero del banco y cuando llegas aquí dices oye si el pago es mayor que cero

451
00:21:46,819 --> 00:21:54,720
entonces ejecuta pero si el listo me ha dicho cuánto te pago te pago menos 20 euros entonces

452
00:21:54,720 --> 00:22:00,660
no lo hagas porque si no le sumas 20 euros a la cosa porque harás menos menos 20 me explico

453
00:22:02,259 --> 00:22:10,410
en este caso esto a lo mejor es distinto lo quieres hacer así si es si el pago es correcto

454
00:22:10,410 --> 00:22:12,269
hazlo, si no, no. Y ya está.

455
00:22:12,730 --> 00:22:14,069
Entonces, no usa el silly fetch.

456
00:22:14,609 --> 00:22:16,210
Pero magari puedes decir que si

457
00:22:16,210 --> 00:22:18,430
el pago lo hace, porque es correcto,

458
00:22:18,470 --> 00:22:20,089
lo haces, y si no,

459
00:22:22,130 --> 00:22:22,589
le mandas

460
00:22:22,589 --> 00:22:24,230
un mensaje de error. O

461
00:22:24,230 --> 00:22:26,069
llamas a la policía y le dices,

462
00:22:26,170 --> 00:22:28,349
me han intentado timar. Pues entonces

463
00:22:28,349 --> 00:22:30,269
usarías este de la derecha. Son casos

464
00:22:30,269 --> 00:22:32,269
un poquito distintos. En realidad

465
00:22:32,269 --> 00:22:33,950
esto podría ser en un while,

466
00:22:34,230 --> 00:22:36,170
pero lo veremos en un futuro, que es

467
00:22:36,170 --> 00:22:38,589
si no me das un valor correcto,

468
00:22:38,589 --> 00:22:40,890
Te digo no y te lo vuelvo a pedir

469
00:22:40,890 --> 00:22:44,569
Pasita a pasita

470
00:22:44,569 --> 00:22:45,910
Son muy parecidos

471
00:22:45,910 --> 00:22:48,910
De hecho yo puedo hacer todo lo que pueda hacer con el de la izquierda

472
00:22:48,910 --> 00:22:49,950
Lo puedo hacer con la derecha

473
00:22:49,950 --> 00:22:52,490
Y todo lo que pueda hacer con la derecha lo puedo hacer con la izquierda

474
00:22:52,490 --> 00:22:55,190
Simplemente que a veces me sale más bonito

475
00:22:55,190 --> 00:22:56,190
Hacerlo con uno que con otro

476
00:22:56,190 --> 00:23:01,619
Ejemplo de un is

477
00:23:01,619 --> 00:23:02,960
¿Vale?

478
00:23:03,599 --> 00:23:04,039
Entonces

479
00:23:04,039 --> 00:23:07,079
Int x es igual a 5

480
00:23:07,079 --> 00:23:09,660
Si 5 es menor que

481
00:23:09,660 --> 00:23:11,180
de X es menor que 5.

482
00:23:11,900 --> 00:23:13,519
System.out.println

483
00:23:13,519 --> 00:23:14,339
menor que 5.

484
00:23:15,400 --> 00:23:17,119
System.out.println de fin.

485
00:23:17,900 --> 00:23:18,920
¿Qué escribe esto?

486
00:23:23,680 --> 00:23:27,059
Pon aquí. ¿Por qué solo fin?

487
00:23:31,059 --> 00:23:33,019
Porque 5 no es

488
00:23:33,019 --> 00:23:34,920
menor que 5. Falso.

489
00:23:35,680 --> 00:23:36,759
Y por lo tanto,

490
00:23:37,240 --> 00:23:38,519
esta instrucción,

491
00:23:38,799 --> 00:23:41,420
la que pone menor que 5, no se ejecuta.

492
00:23:42,200 --> 00:23:42,359
¿Vale?

493
00:23:42,359 --> 00:23:44,019
fijaos que if

494
00:23:44,019 --> 00:23:46,559
escrito así, que yo lo odio escrito así

495
00:23:46,559 --> 00:23:48,359
solo se aplica

496
00:23:48,359 --> 00:23:49,559
a este

497
00:23:49,559 --> 00:23:52,460
sentencia, esta sentencia

498
00:23:52,460 --> 00:23:54,619
estaría afuera, estaría ya

499
00:23:54,619 --> 00:23:55,720
aquí abajo

500
00:23:55,720 --> 00:23:57,940
¿me entiende?

501
00:23:58,940 --> 00:23:59,960
ahora, a mí

502
00:23:59,960 --> 00:24:01,720
me gusta que

503
00:24:01,720 --> 00:24:03,920
a lo que se aplica el if

504
00:24:03,920 --> 00:24:05,799
se ponga entre una

505
00:24:05,799 --> 00:24:08,460
entre llaves, en un bloco

506
00:24:08,460 --> 00:24:09,759
o sea, if, bla bla bla

507
00:24:09,759 --> 00:24:11,799
ya ve aquí antes del primer

508
00:24:11,799 --> 00:24:13,720
system, bla bla bla

509
00:24:13,720 --> 00:24:15,880
y ya ve aquí al final

510
00:24:15,880 --> 00:24:17,920
y luego sigo, entonces veo

511
00:24:17,920 --> 00:24:19,140
bien donde está el bloque

512
00:24:19,140 --> 00:24:21,819
a que se aplica, pero si no lo

513
00:24:21,819 --> 00:24:23,460
pongo, esta como funciona

514
00:24:23,460 --> 00:24:25,779
este programa aquí me escribiría solo fin

515
00:24:25,779 --> 00:24:46,279
vamos aquí a la pantalla

516
00:24:46,279 --> 00:24:48,480
ahí se ve

517
00:24:48,480 --> 00:24:49,839
¡ah no, no miréis!

518
00:24:50,839 --> 00:24:51,599
soy yo chicos

519
00:24:51,599 --> 00:24:54,700
¿sabéis que en el examen hay

520
00:24:54,700 --> 00:24:55,660
tres ejercicios más?

521
00:24:58,859 --> 00:25:00,339
vale

522
00:25:00,339 --> 00:25:04,480
antes eran 100

523
00:25:04,480 --> 00:25:05,259
ahora son 150

524
00:25:05,259 --> 00:25:05,819
vale

525
00:25:05,819 --> 00:25:08,839
int x es igual a 5

526
00:25:08,839 --> 00:25:10,799
si x es menor que 6

527
00:25:10,799 --> 00:25:11,440
llave

528
00:25:11,440 --> 00:25:12,460
si está en punto

529
00:25:12,460 --> 00:25:14,099
en el resultado

530
00:25:14,099 --> 00:25:15,400
si está en punto

531
00:25:15,400 --> 00:25:15,920
en el

532
00:25:15,920 --> 00:25:17,240
menor que 6

533
00:25:17,240 --> 00:25:17,799
si

534
00:25:17,799 --> 00:25:19,019
que escribe esto

535
00:25:19,019 --> 00:25:24,970
de todo

536
00:25:24,970 --> 00:25:25,190
¿no?

537
00:25:25,769 --> 00:25:26,690
escribe el resultado

538
00:25:26,690 --> 00:25:28,369
se escribe menor que 6

539
00:25:28,369 --> 00:25:29,230
y escribe fin

540
00:25:29,230 --> 00:25:32,150
¿si?

541
00:25:32,809 --> 00:25:33,509
porque el if

542
00:25:33,509 --> 00:25:36,089
Solo se aplica desde aquí hasta aquí

543
00:25:36,089 --> 00:25:36,910
Este es el bloque

544
00:25:36,910 --> 00:25:39,009
Al bloque que viene después

545
00:25:39,009 --> 00:25:41,910
Esto es el bloque que si es verdadero lo ejecute

546
00:25:41,910 --> 00:25:43,069
Si es falso me lo salto

547
00:25:43,069 --> 00:25:46,289
El último, el fin, está fuera de lista

548
00:25:46,289 --> 00:25:48,650
Entonces siempre se aplicará

549
00:25:48,650 --> 00:25:50,589
Hasta que si es verdadero o falso

550
00:25:50,589 --> 00:25:51,190
La condición

551
00:25:51,190 --> 00:25:52,869
¿Se entiende?

552
00:25:53,369 --> 00:25:56,089
Fijaos que esto no lo podía hacer con un condicional

553
00:25:56,089 --> 00:25:59,250
Con un operador externario

554
00:25:59,250 --> 00:26:01,009
Porque aquí dentro del bloque

555
00:26:01,009 --> 00:26:02,950
Si estoy haciendo dos operaciones

556
00:26:02,950 --> 00:26:10,180
como 5 es menor que 6

557
00:26:10,180 --> 00:26:11,500
true, pues entra aquí

558
00:26:11,500 --> 00:26:12,740
y escribe esto, escribe esto

559
00:26:12,740 --> 00:26:17,980
entonces esto no sirve de nada

560
00:26:17,980 --> 00:26:22,160
¿qué pasa si no pongo las paréntesis?

561
00:26:25,900 --> 00:26:31,400
¿qué pasa si no pongo las paréntesis?

562
00:26:31,400 --> 00:26:31,940
¿dónde?

563
00:26:32,339 --> 00:26:36,940
cambia el resultado

564
00:26:36,940 --> 00:26:46,059
si yo no pusiera las paréntesis

565
00:26:46,059 --> 00:26:48,160
escribiría exactamente lo mismo

566
00:26:48,160 --> 00:26:50,799
pero cuidado que si luego cambio esto

567
00:26:50,799 --> 00:26:51,799
y pongo 7

568
00:26:51,799 --> 00:26:52,900
¿qué me pondría?

569
00:26:56,440 --> 00:26:58,619
sin paréntesis y sin esto

570
00:26:58,619 --> 00:27:03,700
si yo quito las paréntesis

571
00:27:03,700 --> 00:27:04,640
está aquí la llave

572
00:27:04,640 --> 00:27:06,500
y pongo 7 aquí

573
00:27:06,500 --> 00:27:08,480
me dice 7 es menor que 6

574
00:27:08,480 --> 00:27:09,079
falso

575
00:27:09,079 --> 00:27:11,079
esta no la ejecuta

576
00:27:11,079 --> 00:27:13,539
resultado, pero si pondría

577
00:27:13,539 --> 00:27:14,779
menor que 6, fin

578
00:27:14,779 --> 00:27:17,700
si no hubiese las paréntesis, las llevo

579
00:27:17,700 --> 00:27:19,559
si no pongo las llaves

580
00:27:19,559 --> 00:27:21,660
solo se aplica al siguiente comando

581
00:27:21,660 --> 00:27:23,920
que es el primer system.out

582
00:27:23,920 --> 00:27:24,940
entonces sería un problema

583
00:27:24,940 --> 00:27:27,900
en vez con las llaves, si pongo 7

584
00:27:27,900 --> 00:27:29,380
me escribiría solo 5

585
00:27:29,380 --> 00:27:33,940
si no está, se aplica

586
00:27:33,940 --> 00:27:35,980
al siguiente comando

587
00:27:35,980 --> 00:27:37,880
¿vale? solo que si

588
00:27:37,880 --> 00:27:41,940
Si el siguiente comando es un bloque, pues entonces se aplicará a todo el bloque.

589
00:27:42,359 --> 00:27:44,779
Si no es un bloque, a la siguiente instrucción.

590
00:27:47,210 --> 00:27:47,569
¿Se entiende?

591
00:27:48,730 --> 00:27:49,329
¿Dudas?

592
00:27:51,839 --> 00:27:56,640
Para quitaros de problemas, esto no lo hagáis nunca.

593
00:27:57,880 --> 00:28:01,180
Hasta si es un comando solo, lo ponéis entre paréntesis.

594
00:28:01,859 --> 00:28:02,500
Entre llaves.

595
00:28:04,000 --> 00:28:04,279
¿De acuerdo?

596
00:28:07,019 --> 00:28:09,000
Ejemplo número dos, no miréis la parte roja.

597
00:28:09,000 --> 00:28:26,480
con cariño señor inspector cariño entonces te paso viajes entender

598
00:28:33,130 --> 00:28:33,670
sí

599
00:28:33,670 --> 00:29:01,309
Entonces, aquí en este caso concreto, ¿cuál imprimiría? ¿El if, o sea, el then o el else?

600
00:29:03,670 --> 00:29:05,930
En este caso diría

601
00:29:05,930 --> 00:29:06,829
¿Esta es verdadera?

602
00:29:07,269 --> 00:29:07,569
No

603
00:29:07,569 --> 00:29:10,470
Entonces ejecuto el bloque else

604
00:29:10,470 --> 00:29:12,990
Si este es verdadero

605
00:29:12,990 --> 00:29:14,690
O sea que aquí pongo cuatro

606
00:29:14,690 --> 00:29:18,049
Entonces elijo el primer bloque

607
00:29:18,049 --> 00:29:20,150
El bloque then normalmente

608
00:29:20,150 --> 00:29:22,410
Y me salto el bloque else

609
00:29:22,410 --> 00:29:23,829
¿Sí?

610
00:29:24,250 --> 00:29:27,130
Ten en cuenta que en lenguajes más viejos

611
00:29:27,130 --> 00:29:28,430
Como cuando yo era joven

612
00:29:28,430 --> 00:29:32,529
El if else se llamaba if then else

613
00:29:32,529 --> 00:29:35,309
Si, entonces y si no

614
00:29:35,309 --> 00:29:36,230
¿Vale?

615
00:29:36,549 --> 00:29:37,950
Entonces había la rama de

616
00:29:37,950 --> 00:29:41,009
La rama entonces, si esto es verdadero

617
00:29:41,009 --> 00:29:42,369
Entonces hace esto

618
00:29:42,369 --> 00:29:44,529
Y si no, hace este otro

619
00:29:44,529 --> 00:29:47,210
¿Vale? Entonces, este de aquí, la primera rama

620
00:29:47,210 --> 00:29:48,609
La rama verdadera, la otra falsa

621
00:29:48,609 --> 00:29:49,289
Llamando a la computadora

622
00:29:49,289 --> 00:29:50,170
Sí

623
00:29:50,170 --> 00:29:52,269
Claro, pero hay un de, después del de

624
00:29:52,269 --> 00:29:57,420
Sino porque la primera

625
00:29:57,420 --> 00:30:02,059
El primero pone el de

626
00:30:02,059 --> 00:30:04,599
Perro, y pasa el perro también

627
00:30:04,599 --> 00:30:06,380
Independientemente de lo que vaya a ir

628
00:30:06,380 --> 00:30:09,240
esto porque yo he hecho un programa

629
00:30:09,240 --> 00:30:10,039
que tiene sentido

630
00:30:10,039 --> 00:30:13,619
entonces, si es mayor que 5

631
00:30:13,619 --> 00:30:15,839
si es menor que 5, te pone que es menor que 5

632
00:30:15,839 --> 00:30:17,299
y si no es menor que 5, es mayor

633
00:30:17,299 --> 00:30:19,339
igual, un programa que tiene sentido

634
00:30:19,339 --> 00:30:21,319
pero nadie te prohíbe decir aquí

635
00:30:21,319 --> 00:30:23,000
cocodrilo es aquí perro

636
00:30:23,000 --> 00:30:25,660
o aquí hacen una suma

637
00:30:25,660 --> 00:30:27,019
y aquí hacen una resta

638
00:30:27,019 --> 00:30:29,680
el número que te ha dado es menor que 5

639
00:30:29,680 --> 00:30:31,839
lo sumarás y si es mayor que 5 lo restas

640
00:30:31,839 --> 00:30:33,700
¿por qué? no lo sé, eso depende

641
00:30:33,700 --> 00:30:35,440
de tu ejercicio, de por qué estás

642
00:30:35,440 --> 00:30:46,099
haciendo eso. ¿Eh? ¿Dulas? ¿Entiendes? Tened en cuenta que si habéis entendido el

643
00:30:46,099 --> 00:30:52,640
terceternario, que no es lo mismo, pero os facilita mucho entender esto. Es la misma

644
00:30:52,640 --> 00:30:59,819
cosa, ¿vale? Pero, sobre todo la parte de logia booleana, pues entonces esto, esto sería

645
00:30:59,819 --> 00:31:10,819
Que bonito, ocultároslo, ocultároslo. Allí, allí lo veis, ¿eh? Ahora que, ahora que en Egipto, lo tenéis para bajar, que lo veis, pero que, mirad.

646
00:31:11,819 --> 00:31:24,809
Este que hay, ¿eh? ¡Ah! Se sigue viendo, se sigue viendo.

647
00:31:27,309 --> 00:31:32,309
Para que razonéis, es lo de siempre, en el momento que sabéis la solución, os hacen un acertijo.

648
00:31:32,309 --> 00:31:42,309
y mientras nos dice la solución, vosotros estáis pensando en él, en cuanto os dice, ah si era así, es verdad, pues ya está, se ha acabado el juego, entonces ¿qué sale aquí?

649
00:32:07,079 --> 00:32:12,319
¿Qué sale aquí?

650
00:32:12,319 --> 00:32:23,519
Entro aquí, digo, es menor que 5, 5, no, por lo tanto esta rama de aquí no, me voy

651
00:32:23,519 --> 00:32:24,519
al else.

652
00:32:24,519 --> 00:32:30,079
Fijaos que no hay un bloque, a mí me gustaría aquí un bloque que llegue hasta aquí, pero

653
00:32:30,079 --> 00:32:32,720
él no lo ha puesto.

654
00:32:32,720 --> 00:32:39,640
Pero este else, entonces, empieza y se aplica solo al siguiente comando, que es todo este if, ¿vale?

655
00:32:40,220 --> 00:32:42,460
Excepto el último fin, ¿eh?

656
00:32:42,900 --> 00:32:50,440
Entonces, y este de aquí es otro if, donde me dice, vale, seguramente no es menor que 5, porque si no, no estaría aquí, ¿vale?

657
00:32:50,440 --> 00:32:56,180
Pero, ¿cómo? ¿Puede ser igual o mayor? Me pregunto, ¿es exactamente igual a 5?

658
00:32:56,539 --> 00:33:00,579
Y si es verdad, ejecuto eso. Y como es verdad, ejecuto este de aquí.

659
00:33:00,579 --> 00:33:09,599
y me salto el elche morado, que es el if, ¿vale?

660
00:33:09,859 --> 00:33:12,660
El primer if es el azul con el elche azul,

661
00:33:13,119 --> 00:33:17,819
el segundo if es dentro del elche azul y pone if-elche.

662
00:33:18,539 --> 00:33:18,700
¿Sí?

663
00:33:21,170 --> 00:33:24,710
Entonces la solución en este caso es igual a 5.

664
00:33:31,519 --> 00:33:31,859
¿Aquí?

665
00:33:35,759 --> 00:33:37,079
¡Qué bonito así!

666
00:33:38,359 --> 00:33:39,559
Como mismo se entiende mejor.

667
00:33:41,910 --> 00:33:43,910
Y yo lo entiendo mucho mejor así.

668
00:33:43,910 --> 00:33:49,910
Pero es un gasto inútil de paréntesis, pero son gratis.

669
00:33:49,910 --> 00:33:52,910
Eso es a lo que se llamaría indentado.

670
00:33:52,910 --> 00:34:02,349
Indentado es cuando escribes lo que está dentro de un bloque un poquito más a la derecha.

671
00:34:02,349 --> 00:34:06,349
Esto sería, a lo mejor lo que quieras decir tú es anidado.

672
00:34:06,349 --> 00:34:07,349
Eso.

673
00:34:07,349 --> 00:34:09,349
Que es un if dentro de un if.

674
00:34:09,349 --> 00:34:13,570
Esto es un if anitado y luego lo he indentado en el sentido que lo he movido así.

675
00:34:13,889 --> 00:34:16,230
Pero esto lo podría escribir en una línea y funciona.

676
00:34:19,170 --> 00:34:21,469
Entonces, mismo que antes, ¿vale?

677
00:34:22,210 --> 00:34:26,010
Si es este de aquí, entonces hace esto.

678
00:34:26,250 --> 00:34:30,809
Si no, entra aquí dentro y aquí te encontrarás otro if.

679
00:34:31,050 --> 00:34:33,190
Miras el if o lo que sea y lo doblas.

680
00:34:34,369 --> 00:34:34,510
¿Sí?

681
00:34:34,630 --> 00:34:35,949
Debería escribir lo mismo que antes.

682
00:34:41,159 --> 00:34:41,340
¿Sí?

683
00:34:48,949 --> 00:34:50,789
¿Y esto?

684
00:35:35,269 --> 00:35:40,010
el problema de este ejercicio

685
00:35:40,010 --> 00:35:40,550
¿cuál es?

686
00:35:46,670 --> 00:35:49,329
esto ya va a ser en falda

687
00:35:49,329 --> 00:35:55,889
pero el problema serio

688
00:35:55,889 --> 00:35:56,829
aquí es

689
00:35:56,829 --> 00:35:58,309
este else

690
00:35:58,309 --> 00:36:00,389
¿de quién es?

691
00:36:03,090 --> 00:36:03,809
¿de quién todo esto?

692
00:36:04,250 --> 00:36:04,949
¿lo podría ser?

693
00:36:05,269 --> 00:36:09,110
Si esto es así, hace este GIF a secas, y si no, hace esto.

694
00:36:10,829 --> 00:36:12,989
Tendría que tener un ELSE primero para eso, ¿no?

695
00:36:12,989 --> 00:36:14,389
Aquí, el ELSE de primera vez.

696
00:36:15,750 --> 00:36:17,730
Pon un coche de aquí, un coche de aquí.

697
00:36:18,329 --> 00:36:18,690
Un llave.

698
00:36:18,909 --> 00:36:19,909
Llave aquí y llave aquí.

699
00:36:20,469 --> 00:36:20,949
¿Está?

700
00:36:22,110 --> 00:36:26,789
Pero si la llave la pones aquí, aquí, aquí, aquí, y luego de aquí a aquí,

701
00:36:27,389 --> 00:36:28,789
pues entonces es otra cosa.

702
00:36:31,369 --> 00:36:32,849
Es lo de siempre con...

703
00:36:32,849 --> 00:36:35,190
¿Os acordáis la precedencia de operadores?

704
00:36:36,329 --> 00:36:36,989
Es lo del mismo.

705
00:36:37,090 --> 00:36:41,210
Si tú sabes cómo funciona Java por dentro, ¿vale?

706
00:36:41,230 --> 00:36:46,809
Y lo sabes bien y te acuerdas todas estas regletas una tras de otra y te las grabas,

707
00:36:47,170 --> 00:36:50,530
entonces si ves así sabes perfectamente que va a salir ahí.

708
00:36:51,989 --> 00:36:52,550
¿Sí?

709
00:36:53,829 --> 00:36:57,989
Si eres como yo, que no me acuerdo mi nombre por la mañana, ¿vale?

710
00:36:58,369 --> 00:37:03,969
Entonces tienes que encontrar otras estrategias, como por ejemplo, poner las paréntesis bien.

711
00:37:03,969 --> 00:37:06,010
si aquí pones las llaves

712
00:37:06,010 --> 00:37:07,929
no tiene, no hace

713
00:37:07,929 --> 00:37:09,710
falta recordarse si Java

714
00:37:09,710 --> 00:37:11,989
este else se lo da al primer if o al segundo if

715
00:37:11,989 --> 00:37:13,949
porque funciona

716
00:37:13,949 --> 00:37:16,030
ya, si yo la paréntesis

717
00:37:16,030 --> 00:37:17,369
la pongo de aquí a aquí

718
00:37:17,369 --> 00:37:19,809
o sea, después del

719
00:37:19,809 --> 00:37:21,869
i mayor que 1 y al final

720
00:37:21,869 --> 00:37:23,750
pues estoy diciendo que este es un if

721
00:37:23,750 --> 00:37:25,750
a secas sin else y si

722
00:37:25,750 --> 00:37:27,769
se ejecuta, entonces se ejecuta todo lo que sale

723
00:37:27,769 --> 00:37:30,250
si en vez de las paréntesis

724
00:37:30,250 --> 00:37:31,070
las pongo

725
00:37:31,070 --> 00:37:33,829
a ver, de aquí

726
00:37:33,829 --> 00:37:42,110
aquí, o mejor de aquí a aquí. Si cambio los paréntesis de otro lado ahora debería trabajar porque no me da la cabeza.

727
00:37:42,110 --> 00:37:48,050
Entonces puedo hacer que este else sea del otro. Si la pongo aquí, aquí al fondo, antes del

728
00:37:48,050 --> 00:37:54,650
segundo if y después del igual a uno, entonces este else es de este if.

729
00:37:56,489 --> 00:38:02,750
Teniendo las llaves correctamente puedo hacer que este else sea de uno o de otro. Por eso os

730
00:38:02,750 --> 00:38:10,849
invito que siempre dice es y condición bloque el se bloque siempre es una

731
00:38:10,849 --> 00:38:16,369
estructura básica se puede hacer sin sí pero lleva antes o después o no lleva

732
00:38:16,369 --> 00:38:21,250
caos en mi modesta

733
00:38:21,250 --> 00:38:32,869
Por pantalla no saldría nada

734
00:38:32,869 --> 00:38:35,429
Ya que la sentencia IF tiene dos formas

735
00:38:35,429 --> 00:38:36,590
IF e IFELS

736
00:38:36,590 --> 00:38:38,530
Y cuando se metan ambas

737
00:38:38,530 --> 00:38:39,929
No se puede saber a cuál

738
00:38:39,929 --> 00:38:43,550
Probablemente

739
00:38:43,550 --> 00:38:45,449
Ni siquiera se da error

740
00:38:45,449 --> 00:38:46,110
Pero

741
00:38:46,110 --> 00:38:48,329
Evitarlo, ¿vale?

742
00:38:49,590 --> 00:38:50,989
Regla clara

743
00:38:50,989 --> 00:38:52,170
y básica

744
00:38:52,170 --> 00:38:54,989
si una cosa que escribís

745
00:38:54,989 --> 00:38:55,949
es ambigua

746
00:38:55,949 --> 00:38:57,989
desambiguadla

747
00:38:57,989 --> 00:39:00,769
si lo que vais a hacer allí puede tener

748
00:39:00,769 --> 00:39:02,530
dos interpretaciones

749
00:39:02,530 --> 00:39:05,250
7 más 5 por 4 menos 2

750
00:39:05,250 --> 00:39:06,889
por 62 dividido 4

751
00:39:06,889 --> 00:39:08,570
¿en qué orden se ejecuta?

752
00:39:08,570 --> 00:39:10,230
pues ponéis paréntesis

753
00:39:10,230 --> 00:39:11,710
y sabéis en qué orden se ejecuta

754
00:39:11,710 --> 00:39:15,030
y ponéis bloques

755
00:39:15,030 --> 00:39:16,949
y sabéis en qué orden se ejecuta

756
00:39:16,949 --> 00:39:18,570
no hagáis código ambiguo

757
00:39:18,570 --> 00:39:31,050
Esto era el if. ¿Os ha gustado? Si os ha gustado el if, os encantará el switch case.

758
00:39:31,050 --> 00:39:37,750
Pues es otra sentencia condicional que permite comparar una determinada variable con varios

759
00:39:37,750 --> 00:39:43,690
valores posibles. Tened en cuenta que el if yo tengo que hacer, si if vale 1, hace esto.

760
00:39:43,690 --> 00:39:47,849
Y si no, si vale 2, y si no vale 2, hace este otro.

761
00:39:48,130 --> 00:39:50,489
Y si no, si vale 3, hace este otro.

762
00:39:50,750 --> 00:39:53,050
Y si no, si vale 4, hace este otro.

763
00:39:53,329 --> 00:39:54,289
Y cosas por el estilo, ¿vale?

764
00:39:54,349 --> 00:39:55,969
Se queda un poquito engordoso.

765
00:39:56,190 --> 00:40:01,289
Entonces, hay una forma de, si es lo que quiero hacer, o sea, una única variable, tengo x.

766
00:40:01,949 --> 00:40:02,969
Y he hecho un menú.

767
00:40:02,969 --> 00:40:08,030
Al principio del mitograma dice, soy una calculadora.

768
00:40:08,409 --> 00:40:10,510
Si quieres sumar, pulsa 1.

769
00:40:10,869 --> 00:40:13,010
Si quieres restar, pulsa 2.

770
00:40:13,010 --> 00:40:15,889
Si quieres multiplicar, pulsa 3, ¿vale?

771
00:40:16,309 --> 00:40:20,610
Y ahora he leído un número, que puede ser 1, 2 o 3, ¿vale?

772
00:40:21,289 --> 00:40:28,110
Y me pongo en un switch case diciendo, si esta variable es 1, entonces pide dos números y suma.

773
00:40:28,610 --> 00:40:32,429
Si esta variable es 2, pues pide dos números y réstalos.

774
00:40:32,750 --> 00:40:36,409
Si esta variable es 3, pide dos números y multiplica.

775
00:40:36,969 --> 00:40:37,769
¿Se entiende?

776
00:40:38,190 --> 00:40:40,230
Para hacer esto, se usa un switch case.

777
00:40:40,230 --> 00:40:42,769
dependiendo del valor de dicha variable

778
00:40:42,769 --> 00:40:44,630
ejecutamos un bloque de código o no

779
00:40:44,630 --> 00:40:45,809
pero hay varios bloques

780
00:40:45,809 --> 00:40:48,789
se puede hacer lo mismo con varios if and

781
00:40:48,789 --> 00:40:50,670
y dados, pero muchas veces el código

782
00:40:50,670 --> 00:40:52,230
es más limpio si se usa el switch case

783
00:40:52,230 --> 00:40:53,389
en este caso

784
00:40:53,389 --> 00:40:56,650
el switch case se usa solo para

785
00:40:56,650 --> 00:40:58,190
este caso, cuando hay una variable

786
00:40:58,190 --> 00:40:59,969
y con muchos valores posibles

787
00:40:59,969 --> 00:41:05,639
si no se utiliza, y esta maravilla

788
00:41:05,639 --> 00:41:06,019
aquí

789
00:41:06,019 --> 00:41:09,019
entonces tengo switch

790
00:41:09,019 --> 00:41:11,500
la variable que voy a mirar

791
00:41:11,500 --> 00:41:13,039
fijaos que aquí no es booleana

792
00:41:13,039 --> 00:41:29,800
Es la variable. Y me dice, en el caso que valga un valor, ¿vale? Este val1 es un... ¿Mi respuesta favorita? Literal. ¿De qué tipo?

793
00:41:29,800 --> 00:41:50,469
¿De qué tipo? Del tipo de variable. Si yo estoy haciendo una comparación entre enteros, pues variable será un int, y val1 será un int, val2 será un int.

794
00:41:50,690 --> 00:41:53,489
si variable es un char

795
00:41:53,489 --> 00:41:56,150
pues val1 será un char

796
00:41:56,150 --> 00:41:57,610
val2 será un char

797
00:41:57,610 --> 00:42:00,260
¿si?

798
00:42:00,539 --> 00:42:01,780
se puede hacer constring

799
00:42:01,780 --> 00:42:07,820
peligro constring

800
00:42:07,820 --> 00:42:11,019
peligro constring

801
00:42:11,019 --> 00:42:11,980
¿vale?

802
00:42:12,360 --> 00:42:14,960
podéis probarlo, peligro constring

803
00:42:14,960 --> 00:42:17,139
acordaos que string es malvado

804
00:42:17,139 --> 00:42:18,139
hasta como objeto

805
00:42:18,139 --> 00:42:21,059
es un objeto que pero se

806
00:42:21,059 --> 00:42:23,159
porta como un tipo primitivo pero no

807
00:42:23,159 --> 00:42:27,119
Springer más valor

808
00:42:27,119 --> 00:42:28,340
No os quiere Springer

809
00:42:28,340 --> 00:42:30,760
Parece amigo

810
00:42:30,760 --> 00:42:32,840
Entonces

811
00:42:32,840 --> 00:42:34,219
Si es el caso 1

812
00:42:34,219 --> 00:42:36,360
Entonces 2 puntos

813
00:42:36,360 --> 00:42:37,820
Haz esta cosa de aquí

814
00:42:37,820 --> 00:42:40,239
Si vale 2

815
00:42:40,239 --> 00:42:41,460
Haz esta cosa de aquí

816
00:42:41,460 --> 00:42:42,519
Si vale n

817
00:42:42,519 --> 00:42:43,360
Haz esta cosa de aquí

818
00:42:43,360 --> 00:42:45,579
Y puedo poner todos los valores que me da la carne

819
00:42:45,579 --> 00:42:47,019
Sería

820
00:42:47,019 --> 00:42:48,679
Ese sentido de aquí

821
00:42:48,679 --> 00:42:53,079
Si la variable vale valor 1

822
00:42:53,079 --> 00:42:56,340
entonces haz las sentencias esta de aquí, ¿vale?

823
00:42:56,559 --> 00:42:58,480
Y luego ya veremos qué pasa.

824
00:42:58,940 --> 00:43:00,440
Si va a elevar el 2, esta de aquí.

825
00:43:00,539 --> 00:43:01,960
Si va a elevar el 10, esta de aquí.

826
00:43:02,440 --> 00:43:04,460
Cuidado con esta palabrita, break.

827
00:43:05,059 --> 00:43:08,019
Break quiere decir interrumpe, rompe aquí.

828
00:43:08,760 --> 00:43:11,300
Esto quiere decir, si llegas a un break,

829
00:43:11,780 --> 00:43:13,480
saltas al final y sigues adelante.

830
00:43:14,159 --> 00:43:15,719
Se ha acabado el switch case.

831
00:43:16,820 --> 00:43:18,500
Si no pongo el break,

832
00:43:19,480 --> 00:43:22,059
ejecuto la primera válida

833
00:43:22,059 --> 00:43:24,639
y todas las sentencias

834
00:43:24,639 --> 00:43:25,719
que haya después

835
00:43:25,719 --> 00:43:27,119
hasta llegar a un break

836
00:43:27,119 --> 00:43:32,460
¿entendéis?

837
00:43:33,719 --> 00:43:34,440
es un poquito

838
00:43:34,440 --> 00:43:36,300
raro

839
00:43:36,300 --> 00:43:38,119
pero si yo me pongamos

840
00:43:38,119 --> 00:43:39,260
que tengo aquí los valores

841
00:43:39,260 --> 00:43:41,800
1, 2, 3, 4, 5, 6, 7, 8, 9, 10

842
00:43:41,800 --> 00:43:44,139
y no tengo los breaks

843
00:43:44,139 --> 00:43:46,519
si el valor que le he dado a x

844
00:43:46,519 --> 00:43:47,880
a la variable es 2

845
00:43:47,880 --> 00:43:50,300
me ejecutará los bloques del 2

846
00:43:50,300 --> 00:43:53,380
del 3, del 4, del 5, del 6, del 7, del 8, del 9, del 10

847
00:43:53,380 --> 00:43:56,239
desde donde entra hasta el final

848
00:43:56,239 --> 00:43:59,059
si le pongo break

849
00:43:59,059 --> 00:44:00,980
si por ejemplo pongo break al 7

850
00:44:00,980 --> 00:44:03,480
pues lo que hace es ejecutar hasta el 7

851
00:44:03,480 --> 00:44:04,719
y encuentra un break y sale

852
00:44:04,719 --> 00:44:07,300
ahora hacemos un ejemplo

853
00:44:07,300 --> 00:44:11,159
existe también

854
00:44:11,159 --> 00:44:12,579
una opción

855
00:44:12,579 --> 00:44:14,199
que es la opción default

856
00:44:14,199 --> 00:44:15,619
que se mete al final

857
00:44:15,619 --> 00:44:18,719
que quiere decir, si esta variable vale val 1 hace una cosa

858
00:44:18,719 --> 00:44:21,099
si vale val 2 hace otra, si vale val 3 hace otra

859
00:44:21,099 --> 00:44:22,559
y si al final

860
00:44:22,559 --> 00:44:24,380
por defecto

861
00:44:24,380 --> 00:44:28,320
Si no vale ninguno de los valores que te he dado antes,

862
00:44:28,659 --> 00:44:29,599
esto es lo que tienes que hacer.

863
00:44:31,280 --> 00:44:32,199
Como un si no.

864
00:44:32,539 --> 00:44:33,539
Si vale esto, entonces.

865
00:44:33,599 --> 00:44:34,360
Si vale esto, entonces.

866
00:44:34,659 --> 00:44:37,960
Y si no, si no has encontrado lo que querías, esto.

867
00:44:38,579 --> 00:44:40,059
Vale la misma cosa del break.

868
00:44:41,179 --> 00:44:43,480
Si no pongo ningún break, se ejecutará esto también.

869
00:44:49,039 --> 00:44:50,300
Ejemplo práctico.

870
00:44:50,300 --> 00:44:53,619
dame una nota

871
00:44:53,619 --> 00:44:55,900
y te la transformo en aprobado

872
00:44:55,900 --> 00:44:57,900
bien, notable, sobresaliente, matriculador

873
00:44:57,900 --> 00:44:58,599
o suspenso.

874
00:44:59,920 --> 00:45:02,139
¿Sí? Entonces, tú me das una nota.

875
00:45:03,500 --> 00:45:03,920
Si es

876
00:45:03,920 --> 00:45:06,179
5, me dice aprobado.

877
00:45:07,039 --> 00:45:07,880
Y sale.

878
00:45:10,000 --> 00:45:11,159
Si es 6,

879
00:45:11,719 --> 00:45:12,460
me dice bien.

880
00:45:13,679 --> 00:45:14,099
Y sale.

881
00:45:15,619 --> 00:45:16,659
Si es 7

882
00:45:16,659 --> 00:45:18,119
y si es 8,

883
00:45:18,480 --> 00:45:19,719
aquí el break no está.

884
00:45:19,719 --> 00:45:21,940
entonces, si yo le he puesto un set

885
00:45:21,940 --> 00:45:23,739
entraría aquí, no hace nada pero

886
00:45:23,739 --> 00:45:26,059
luego ejecuta las de abajo, por lo tanto ejecutaría

887
00:45:26,059 --> 00:45:27,860
también la del 8, déjame acabar

888
00:45:27,860 --> 00:45:30,139
escribiría

889
00:45:30,139 --> 00:45:30,519
notable

890
00:45:30,519 --> 00:45:33,980
y luego pillaría el break y saldría

891
00:45:33,980 --> 00:45:35,940
en este caso 7 y 8

892
00:45:35,940 --> 00:45:36,579
te dan notable

893
00:45:36,579 --> 00:45:39,800
9, sobresaliente

894
00:45:39,800 --> 00:45:41,940
y sale, 10, matrícula honor

895
00:45:41,940 --> 00:45:43,659
sale y en cualquier

896
00:45:43,659 --> 00:45:44,639
otro caso

897
00:45:44,639 --> 00:45:47,760
me escribiría el suspenso que sería del

898
00:45:47,760 --> 00:45:48,559
1 al 5

899
00:45:48,559 --> 00:46:08,940
porque no es un booleano es un valor es un literal 7 y 8 sería un bull y bull no puede

900
00:46:08,940 --> 00:46:14,880
estar dentro de nosotros entonces no me vale como literal para poner ahí esto es en el caso

901
00:46:14,880 --> 00:46:22,559
que sea 5 hace esto, en el caso que sea 6 hace esto, en el caso que sea TRUE o FALSE.

902
00:46:22,559 --> 00:46:29,380
Además 5 and 6 no es nada valga la pena porque el AND como operador booleano va bool y bool,

903
00:46:29,380 --> 00:46:37,960
no int bool, int int. Puedes hacer 5 and 7, no es nada, puedes poner 5 mayor que 7 and

904
00:46:37,960 --> 00:46:42,960
Siete mayor que nueve. Eso sí, porque son bulle-bulle, que haces un E.

905
00:46:42,960 --> 00:46:51,269
¿Sí? ¿Dudas? ¿Parece correcto?

906
00:46:51,269 --> 00:46:59,150
¿Se entiende? No es complejo, pero es la primera vez que lo veis.

907
00:46:59,150 --> 00:47:04,550
Entonces, en este caso de aquí, lo que hay que hacer es siempre gestionar bien dónde

908
00:47:04,550 --> 00:47:06,550
¿Dónde poner el break, dónde no ponerlo?

909
00:47:08,170 --> 00:47:08,349
¿Sí?

910
00:47:08,989 --> 00:47:09,630
¿Y ahí no?

911
00:47:13,230 --> 00:47:13,510
¿A qué?

912
00:47:17,599 --> 00:47:19,039
Pues te daría suspecho.

913
00:47:20,059 --> 00:47:20,840
El problema es tú.

914
00:47:21,500 --> 00:47:22,900
No hay ninguno de estos valores,

915
00:47:23,099 --> 00:47:24,219
entonces te daría suspecho.

916
00:47:24,659 --> 00:47:27,159
Pero es que tú has permitido que alguien

917
00:47:27,159 --> 00:47:28,780
te pusiera el once.

918
00:47:29,440 --> 00:47:31,119
¿Vale? A lo mejor todo esto

919
00:47:31,119 --> 00:47:33,599
lo puedes poner dentro de un if

920
00:47:33,599 --> 00:47:35,179
que si la nota

921
00:47:35,179 --> 00:47:37,119
es mayor que cero y

922
00:47:37,119 --> 00:47:38,559
menor que diez,

923
00:47:38,559 --> 00:47:47,940
o menor o igual que 10, entonces hazme esto, entonces ya se te da 11, y en el else le pones la nota no es válida.

924
00:47:47,940 --> 00:47:58,630
Póngase que estoy comparando 1, 6, 5, porque yo quiero comparar que nota vale 5, no habría que poner nota igual a 5.

925
00:47:58,630 --> 00:48:06,630
No, porque tú estás haciendo un switch case sobre nota, entonces esta suma que si nota, en el caso en que nota valga 5,

926
00:48:06,630 --> 00:48:11,630
En el caso en que nota valga 6, ¿en qué se está haciendo de manera...?

927
00:48:11,630 --> 00:48:15,010
Un igual igual.

928
00:48:15,010 --> 00:48:20,010
La pregunta seria podría ser, ¿es un igual igual o un punto igual?

929
00:48:20,010 --> 00:48:24,010
Y allí habría que ver, por ahora y por primitivo.

930
00:48:24,010 --> 00:48:30,010
La prueba que todos estáis ansiosos de hacer,

931
00:48:30,010 --> 00:48:34,010
si pongo aquí un string y luego aquí pongo strings,

932
00:48:34,010 --> 00:48:39,090
¿me funciona o no?

933
00:48:39,090 --> 00:48:41,230
yo no os voy a decir

934
00:48:41,230 --> 00:48:42,170
si funciona o no

935
00:48:42,170 --> 00:48:44,110
yo os voy a dejar que sea

936
00:48:44,110 --> 00:48:46,670
vuestra curiosidad y vuestra habilidad de programadores

937
00:48:46,670 --> 00:48:48,449
que hagáis un ejemplo

938
00:48:48,449 --> 00:48:49,750
y que lo probéis

939
00:48:49,750 --> 00:48:52,489
y luego os lo pongo en ex

940
00:48:52,489 --> 00:48:58,130
¡Ejercicios!

941
00:48:59,349 --> 00:49:01,010
¡Otro 60 papás de!