1
00:00:00,260 --> 00:00:02,140
Venga, ya llegó.

2
00:00:04,960 --> 00:00:06,599
Y eso ha sonado a risa irónica.

3
00:00:09,300 --> 00:00:10,179
¿Ah, sí? ¿Él dice eso?

4
00:00:12,919 --> 00:00:14,560
¿En serio? No tenía ni idea.

5
00:00:14,740 --> 00:00:16,820
Pues nada, tenemos más compenetración de la que parece.

6
00:00:17,620 --> 00:00:21,519
Vale, vale. Bueno, pues esta que sí es vuestra asignatura favorita, redes, no sé.

7
00:00:22,600 --> 00:00:23,379
Ah, mejor.

8
00:00:25,679 --> 00:00:26,600
Esa es la favorita.

9
00:00:27,219 --> 00:00:29,620
Ya, lo que pasa es que os está exigiendo mucho trabajo.

10
00:00:30,000 --> 00:00:31,480
Ese es el único problema que yo le veo.

11
00:00:32,960 --> 00:00:35,039
Pero bueno, esta semana voy a llamar a vuestra profe

12
00:00:35,039 --> 00:00:36,799
y le voy a decir que ya está, que se acabó.

13
00:00:37,219 --> 00:00:38,679
Que venga ya de una vez.

14
00:00:39,420 --> 00:00:40,280
Se acabó tu baja.

15
00:00:40,520 --> 00:00:41,259
Se acabó tu baja.

16
00:00:41,380 --> 00:00:43,320
Lo decido yo, que tengo la titulación médica.

17
00:00:44,340 --> 00:00:44,700
Eso.

18
00:00:45,759 --> 00:00:48,280
Así que nada, yo confío que ya pronto tengáis profe.

19
00:00:48,960 --> 00:00:49,740
Venga, pues a ver.

20
00:00:50,420 --> 00:00:52,420
Estábamos con la sentencia iterativa, ¿vale?

21
00:00:53,039 --> 00:00:56,859
Como rápido repaso para los que el otro día

22
00:00:56,859 --> 00:00:58,520
después de corregir el examen,

23
00:00:58,520 --> 00:01:01,200
Pues estaban ahí un poquito ya

24
00:01:01,200 --> 00:01:02,460
Desconectados o lo que fuera

25
00:01:02,460 --> 00:01:03,799
¿Vale?

26
00:01:04,780 --> 00:01:06,939
A ver, recordad que la sintaxis

27
00:01:06,939 --> 00:01:08,620
De la sentencia iterativa

28
00:01:08,620 --> 00:01:10,420
Es esto

29
00:01:10,420 --> 00:01:12,560
Es esto, ¿verdad?

30
00:01:13,299 --> 00:01:15,340
Donde aquí se pone una condición

31
00:01:15,340 --> 00:01:17,299
Esta es

32
00:01:17,299 --> 00:01:17,959
¿Vale?

33
00:01:19,019 --> 00:01:21,739
Entonces, esta es una sentencia

34
00:01:21,739 --> 00:01:22,920
Una sentencia

35
00:01:22,920 --> 00:01:25,079
Igual que el if

36
00:01:25,079 --> 00:01:27,780
Donde poníamos una condición

37
00:01:27,780 --> 00:01:31,359
Esto también era una sentencia

38
00:01:31,359 --> 00:01:33,519
Esto también era una única sentencia

39
00:01:33,519 --> 00:01:35,099
Y si hay un else

40
00:01:35,099 --> 00:01:37,379
Pues también

41
00:01:37,379 --> 00:01:39,219
Todo esto es una única sentencia

42
00:01:39,219 --> 00:01:40,540
¿Vale? Entonces son sentencias

43
00:01:40,540 --> 00:01:43,040
Complejas porque tienen

44
00:01:43,040 --> 00:01:45,560
Varias líneas de código pero son una sola

45
00:01:45,560 --> 00:01:46,700
Son una sola

46
00:01:46,700 --> 00:01:49,219
¿Vale? Entonces

47
00:01:49,219 --> 00:01:51,140
¿Cómo funciona el while? El while

48
00:01:51,140 --> 00:01:52,719
Permite repetir

49
00:01:52,719 --> 00:01:54,459
Varias veces

50
00:01:54,459 --> 00:01:57,420
Las sentencias que pongamos aquí dentro ¿Verdad?

51
00:01:57,780 --> 00:02:06,159
entonces, la diferencia entre el while y el if, pues ya sabemos cuál es,

52
00:02:06,980 --> 00:02:09,360
aparentemente son muy parecidas, ¿no?

53
00:02:10,439 --> 00:02:16,500
Son muy parecidas porque en ambas se evalúa una condición,

54
00:02:17,139 --> 00:02:20,020
aquí se evalúa una condición, aquí también, son muy parecidas,

55
00:02:20,780 --> 00:02:28,240
si la condición es true, entro dentro, luego hasta ahí son iguales,

56
00:02:28,240 --> 00:02:31,520
Y una vez que ya hemos terminado lo que hay dentro

57
00:02:31,520 --> 00:02:34,000
Ahí es donde viene la diferencia entre el while y el if

58
00:02:34,000 --> 00:02:35,659
Si es el while

59
00:02:35,659 --> 00:02:37,780
Otra vez vuelvo arriba

60
00:02:37,780 --> 00:02:39,319
Y vuelvo a evaluarla

61
00:02:39,319 --> 00:02:41,460
Que sigue cumpliéndose

62
00:02:41,460 --> 00:02:43,400
Hago esto de nuevo

63
00:02:43,400 --> 00:02:45,740
Y otra vez

64
00:02:45,740 --> 00:02:47,419
Vuelvo arriba, esa es la diferencia

65
00:02:47,419 --> 00:02:49,280
Con el if, evaluábamos condición

66
00:02:49,280 --> 00:02:51,340
Que se cumple, entro

67
00:02:51,340 --> 00:02:53,180
Igual que el while, y se acabó

68
00:02:53,180 --> 00:02:55,659
Y sigo por abajo, independientemente

69
00:02:55,659 --> 00:02:57,259
De que condición siga cumpliéndose o no

70
00:02:57,259 --> 00:02:58,719
Ya se acabó

71
00:02:58,719 --> 00:03:01,060
Esto se va a hacer cero veces

72
00:03:01,060 --> 00:03:02,419
O una máximo

73
00:03:02,419 --> 00:03:05,780
En función de si condición es falsa o true

74
00:03:05,780 --> 00:03:07,919
Estas cuantas se van a hacer

75
00:03:07,919 --> 00:03:08,840
Ni idea

76
00:03:08,840 --> 00:03:11,000
Se van a hacer entre cero

77
00:03:11,000 --> 00:03:12,900
Si cuando yo llego por aquí

78
00:03:12,900 --> 00:03:14,560
La condición ya es falsa de partida

79
00:03:14,560 --> 00:03:15,919
En ese caso se harán cero

80
00:03:15,919 --> 00:03:18,139
O un montón

81
00:03:18,139 --> 00:03:20,699
¿De qué depende ese montón?

82
00:03:21,439 --> 00:03:23,340
Pues que cuando vayamos a evaluar

83
00:03:23,340 --> 00:03:25,900
Esta condición se haya convertido en falsa

84
00:03:25,900 --> 00:03:29,060
En cuanto se convierta en falsa, ya no se hace más, ¿vale?

85
00:03:30,259 --> 00:03:34,860
Entonces, para muchos problemas necesitamos hacer esto.

86
00:03:35,259 --> 00:03:38,340
No hay forma de resolverlo si no podemos usar esa sentencia.

87
00:03:38,460 --> 00:03:42,500
No podemos hacer cualquier cosa solamente con asignaciones y sentencias de decisión.

88
00:03:43,219 --> 00:03:43,719
No podemos.

89
00:03:43,719 --> 00:03:47,620
Hay veces que hay que repetir un código varias veces.

90
00:03:48,199 --> 00:03:50,319
En ese caso vamos a tener que usar esta sentencia.

91
00:03:51,360 --> 00:03:51,580
Vale.

92
00:03:52,840 --> 00:03:54,659
Entonces, el funcionamiento está claro, ¿no?

93
00:03:54,659 --> 00:04:01,120
Entonces, como ahí va siempre una condición

94
00:04:01,120 --> 00:04:02,780
Esto lo podríamos poner

95
00:04:02,780 --> 00:04:04,680
Esto lo podríamos poner, ¿no?

96
00:04:04,680 --> 00:04:07,000
Pero esto, feo, malo

97
00:04:07,000 --> 00:04:08,659
Esto no lo queremos, ¿vale?

98
00:04:09,060 --> 00:04:10,199
Esto muy mal

99
00:04:10,199 --> 00:04:11,719
Todo mal esto

100
00:04:11,719 --> 00:04:14,599
Un bucle, porque esto ya sabemos

101
00:04:14,599 --> 00:04:16,060
Lo que va a conducir

102
00:04:16,060 --> 00:04:18,959
Esto va a conducir a un programa

103
00:04:18,959 --> 00:04:23,889
Que nunca jamás va a terminar

104
00:04:23,889 --> 00:04:25,750
Ahí hasta el infinito

105
00:04:25,750 --> 00:04:27,550
¿Vale? Nunca jamás va a terminar

106
00:04:27,550 --> 00:04:28,990
Eso no tiene que ocurrir

107
00:04:28,990 --> 00:04:53,310
Porque yo ahora mismo no tengo más opción que irme al sistema operativo y matar este proceso. No tengo otra alternativa que matar este proceso. Afortunadamente el eclipse me da este botoncito y este botoncito es el kill. Me lo da, pues bueno. Pero nunca jamás debería acabar un programa porque mato el proceso. Siempre tiene que haber una salida.

108
00:04:53,310 --> 00:04:58,769
Entonces, por ejemplo, esto ya sí que te da

109
00:04:58,769 --> 00:05:03,110
Yo aquí pongo una condición

110
00:05:03,110 --> 00:05:08,730
Por ejemplo, mientras n sea diferente de 0

111
00:05:08,730 --> 00:05:13,449
Por ejemplo, esta condición ya es una condición que puede ser true o puede ser false

112
00:05:13,449 --> 00:05:19,930
Lo que pasa es que, aun así, si yo hago esto, por ejemplo

113
00:05:19,930 --> 00:05:40,139
vale

114
00:05:40,139 --> 00:05:42,420
vale, entonces

115
00:05:42,420 --> 00:05:48,459
ahora este bucle, esta condición

116
00:05:48,459 --> 00:05:50,240
en principio no es

117
00:05:50,240 --> 00:05:52,379
true ni false, depende del valor

118
00:05:52,379 --> 00:05:54,279
de n, pero claro

119
00:05:54,279 --> 00:05:56,240
aquí ahora mismo este programa también

120
00:05:56,240 --> 00:05:57,360
sigue siendo

121
00:05:57,360 --> 00:06:00,540
muy feo, yo lo ejecuto

122
00:06:00,540 --> 00:06:01,519
y si a n

123
00:06:01,519 --> 00:06:04,139
le doy un 7, pues

124
00:06:04,139 --> 00:06:05,160
estoy en las mismas

125
00:06:05,160 --> 00:06:07,579
¿no?

126
00:06:07,579 --> 00:06:09,680
no, en las mismas dosis, las un 7 no entran

127
00:06:09,680 --> 00:06:12,920
a no, en el distinto

128
00:06:12,920 --> 00:06:14,040
claro, si

129
00:06:14,040 --> 00:06:16,120
vale

130
00:06:16,120 --> 00:06:20,889
ahí estoy, le doy 7

131
00:06:20,889 --> 00:06:22,870
y estoy en las mismas

132
00:06:22,870 --> 00:06:24,089
claro, obviamente, ¿verdad?

133
00:06:24,970 --> 00:06:26,790
bueno, mato el proceso porque es que no tengo

134
00:06:26,790 --> 00:06:27,870
otra manera de salir

135
00:06:27,870 --> 00:06:30,069
claro, ¿cuál es el problema?

136
00:06:30,810 --> 00:06:32,490
que aquí dentro del bucle

137
00:06:32,490 --> 00:06:34,910
no hay nada que permita

138
00:06:34,910 --> 00:06:36,889
que esta condición pase

139
00:06:36,889 --> 00:06:38,470
de ser true a false, no hay nada

140
00:06:38,470 --> 00:06:40,790
entonces si tenemos un bucle

141
00:06:40,790 --> 00:06:42,490
que lo que hay dentro es absolutamente

142
00:06:42,490 --> 00:06:44,170
independiente de la condición

143
00:06:44,170 --> 00:06:48,089
pues aquí hay algo raro, en este código alguna cosa rara va a haber diseñada

144
00:06:48,089 --> 00:06:51,750
porque si de partida es true, va a ser true siempre

145
00:06:51,750 --> 00:06:54,629
con lo cual nunca va a acabar ese bucle, nunca va a acabar

146
00:06:54,629 --> 00:06:59,990
entonces normalmente los programas, los códigos que hacemos para resolver un problema

147
00:06:59,990 --> 00:07:03,389
son tales que lo que ocurre aquí dentro

148
00:07:03,389 --> 00:07:08,569
va alterando las variables que forman esta condición

149
00:07:08,569 --> 00:07:10,790
de tal forma que alguna vez eso sea falso

150
00:07:10,790 --> 00:07:14,269
Por ejemplo, aquí podríamos estar leyendo este número

151
00:07:14,269 --> 00:07:16,389
Todo el rato

152
00:07:16,389 --> 00:07:24,069
A ver, estoy poniendo ejemplos solamente

153
00:07:24,069 --> 00:07:26,689
De situaciones en las cuales

154
00:07:26,689 --> 00:07:28,509
El bucle terminaría, no terminaría

155
00:07:28,509 --> 00:07:30,250
Vale, si yo esto no lo pongo

156
00:07:30,250 --> 00:07:32,170
No es que

157
00:07:32,170 --> 00:07:34,230
Representen un problema real que estoy resolviendo

158
00:07:34,230 --> 00:07:36,350
Estoy solamente viendo códigos

159
00:07:36,350 --> 00:07:36,870
En los cuales

160
00:07:36,870 --> 00:07:39,850
Para ver cómo funciona la sentencia while

161
00:07:39,850 --> 00:07:41,649
no estamos resolviendo ningún

162
00:07:41,649 --> 00:07:44,569
vale, entonces aquí está claro, ¿no? que si yo de partida

163
00:07:44,569 --> 00:07:46,569
meto un valor diferente de 0

164
00:07:46,569 --> 00:07:47,269
voy a entrar

165
00:07:47,269 --> 00:07:49,610
y este bucle no va a acabar en la vida

166
00:07:49,610 --> 00:07:52,529
a veces uno hace su programa

167
00:07:52,529 --> 00:07:54,709
que sí que está resolviendo un problema, lo que sea

168
00:07:54,709 --> 00:07:56,670
y esas son cosas

169
00:07:56,670 --> 00:07:58,709
que si las identificamos

170
00:07:58,709 --> 00:08:00,370
nos podemos dar cuenta de que

171
00:08:00,370 --> 00:08:01,490
uy, algo raro he hecho yo

172
00:08:01,490 --> 00:08:04,490
algo raro he hecho yo porque es que este bucle es infinito

173
00:08:04,490 --> 00:08:06,410
¿vale? entonces

174
00:08:06,410 --> 00:08:08,550
en este caso, por ejemplo

175
00:08:08,550 --> 00:08:10,449
en este caso

176
00:08:10,449 --> 00:08:12,009
ahora la variable n

177
00:08:12,009 --> 00:08:13,670
en cada iteración

178
00:08:13,670 --> 00:08:16,569
¿vale? cada iteración es

179
00:08:16,569 --> 00:08:18,209
cada una de las pasadas del bucle

180
00:08:18,209 --> 00:08:20,750
en cada iteración el valor de n cambia

181
00:08:20,750 --> 00:08:22,370
el valor de n cambia

182
00:08:22,370 --> 00:08:24,209
con lo cual

183
00:08:24,209 --> 00:08:26,490
n puede ser 0

184
00:08:26,490 --> 00:08:27,189
en algún momento

185
00:08:27,189 --> 00:08:30,149
entonces ahora ya sí, ahora ya este programa

186
00:08:30,149 --> 00:08:31,670
tiene un bucle que termina

187
00:08:31,670 --> 00:08:34,210
yo le meto primero 8

188
00:08:34,210 --> 00:08:36,149
vale, y vuelve a pedir el número

189
00:08:36,149 --> 00:08:37,929
7, me vuelve a pedir el número

190
00:08:37,929 --> 00:08:39,370
3, me vuelve a pedir el número

191
00:08:39,370 --> 00:08:41,730
0, ya está, terminó

192
00:08:41,730 --> 00:08:43,330
¿Vale? Terminó

193
00:08:43,330 --> 00:08:45,909
Entonces este bucle

194
00:08:45,909 --> 00:08:48,250
Ya sí que termina

195
00:08:48,250 --> 00:08:51,200
Termina por código

196
00:08:51,200 --> 00:08:53,399
Que es la idea, tener una salida por código

197
00:08:53,399 --> 00:08:54,340
¿Vale?

198
00:08:55,700 --> 00:08:57,179
¿Alguien no se ha despertado todavía?

199
00:08:57,860 --> 00:08:58,360
Vale

200
00:08:58,360 --> 00:09:05,320
O esto mismo también podría ser

201
00:09:05,320 --> 00:09:05,940
Por ejemplo

202
00:09:05,940 --> 00:09:10,940
Por ejemplo, este programa

203
00:09:10,940 --> 00:09:11,539
¿Qué haría?

204
00:09:13,019 --> 00:09:15,559
un momento

205
00:09:15,559 --> 00:09:22,600
vale, cuando digo que haría

206
00:09:22,600 --> 00:09:24,519
no digo que me leáis las sílabas

207
00:09:24,519 --> 00:09:26,620
pues repite, mientras n sea

208
00:09:26,620 --> 00:09:28,360
diferente de 0, muestra un mensaje

209
00:09:28,360 --> 00:09:30,720
y luego a n le resta 0, le resta 1

210
00:09:30,720 --> 00:09:32,240
no quiero que me leáis

211
00:09:32,240 --> 00:09:34,460
me interpretéis las líneas, lo que quiero es que me digáis

212
00:09:34,460 --> 00:09:36,440
en conjunto cuál es el resultado final

213
00:09:36,440 --> 00:09:40,379
de este programa, este programa en conjunto

214
00:09:40,379 --> 00:09:40,860
¿qué hace?

215
00:09:47,549 --> 00:09:48,710
no, no, no, pero no me

216
00:09:48,710 --> 00:09:51,250
traduzcas Java

217
00:09:51,250 --> 00:09:53,129
no me hagas un traductor de idioma

218
00:09:53,129 --> 00:09:54,250
no me traduzcas Java, dime

219
00:09:54,250 --> 00:09:56,629
este programa te hace esto

220
00:09:56,629 --> 00:10:00,830
vale

221
00:10:00,830 --> 00:10:03,470
eso es más parecido a lo que yo esperaba

222
00:10:03,470 --> 00:10:04,769
te saluda, pero

223
00:10:04,769 --> 00:10:06,570
y ya está, algo más

224
00:10:06,570 --> 00:10:08,389
¿cuántas veces te saluda?

225
00:10:10,389 --> 00:10:10,830
vale

226
00:10:10,830 --> 00:10:13,090
eso sí, este programa te saluda tantas

227
00:10:13,090 --> 00:10:14,789
veces como tú le hayas dicho al principio

228
00:10:14,789 --> 00:10:16,309
es lo que hace, ¿no?

229
00:10:16,809 --> 00:10:18,649
le metes un numerito y

230
00:10:18,649 --> 00:10:21,049
te saluda

231
00:10:21,049 --> 00:10:22,529
y lo decrementa

232
00:10:22,529 --> 00:10:26,570
Con lo cual, ya te ha saludado una vez y ha contado esa vez.

233
00:10:27,669 --> 00:10:30,870
Como no ha llegado a cero, te vuelve a saludar, ¿vale?

234
00:10:32,210 --> 00:10:34,549
¿Vale? Pues este bucle ya sé que terminaría.

235
00:10:36,190 --> 00:10:43,299
Entonces le metemos 7, pues hala, ahí tenemos las 7 veces, ¿vale?

236
00:10:45,620 --> 00:10:49,879
Hay una manera fea también de salir de los bucles.

237
00:10:49,879 --> 00:10:54,220
Por ejemplo, que es la famosa sentencia break que no nos gusta nada tampoco.

238
00:10:55,799 --> 00:11:05,240
El bucle que yo he hecho de que te saluda siete veces o ocho o las n que metas, sería igual que hacer esto.

239
00:11:06,679 --> 00:11:09,679
Pero por Dios, esto no nos gusta nada.

240
00:11:11,059 --> 00:11:17,120
A ver, la sentencia break es una sentencia que en sí misma tiene un significado.

241
00:11:17,779 --> 00:11:21,139
Ya no solo, hasta ahora la sentencia break la hemos usado solo para esto.

242
00:11:21,139 --> 00:11:25,220
Para el switch case, la hemos usado solamente para esto.

243
00:11:25,799 --> 00:11:28,899
Case 1, bla, bla, bla

244
00:11:28,899 --> 00:11:30,600
Y luego poníamos aquí el break

245
00:11:30,600 --> 00:11:32,000
Y así en cada caso

246
00:11:32,000 --> 00:11:34,240
Y lo que decíamos era

247
00:11:34,240 --> 00:11:36,960
El break lo que hace es

248
00:11:36,960 --> 00:11:37,940
En ese momento

249
00:11:37,940 --> 00:11:40,399
Para la evaluación de cases

250
00:11:40,399 --> 00:11:41,460
Este es de aquí

251
00:11:41,460 --> 00:11:52,909
No, no, no, no se mete en el siguiente caso

252
00:11:52,909 --> 00:11:53,750
¿Vale?

253
00:11:53,889 --> 00:11:56,529
El break lo que hace es una sentencia

254
00:11:56,529 --> 00:11:58,370
Ahora ya podemos ver su significado general

255
00:11:58,370 --> 00:11:59,929
Su significado general es

256
00:11:59,929 --> 00:12:02,169
sale del bloque en el que

257
00:12:02,169 --> 00:12:04,250
está metida, sale del bloque

258
00:12:04,250 --> 00:12:05,909
entonces en el switch

259
00:12:05,909 --> 00:12:07,169
hacía justo lo que queríamos

260
00:12:07,169 --> 00:12:10,350
¿qué es uno? pues ejecuta esto

261
00:12:10,350 --> 00:12:11,269
y ya sale

262
00:12:11,269 --> 00:12:13,450
porque si no poníamos un break

263
00:12:13,450 --> 00:12:15,929
se ponía a ejecutar todo lo que había

264
00:12:15,929 --> 00:12:17,929
a continuación, independientemente de que

265
00:12:17,929 --> 00:12:20,049
la condición, el valor

266
00:12:20,049 --> 00:12:21,690
fuera cierto o no

267
00:12:21,690 --> 00:12:23,429
entonces el switch era así

268
00:12:23,429 --> 00:12:25,909
miraba el valor

269
00:12:25,909 --> 00:12:27,429
de la variable que yo pusiera aquí

270
00:12:27,429 --> 00:12:29,769
poníamos aquí una variable

271
00:12:29,769 --> 00:12:31,590
que era igual a 1

272
00:12:31,590 --> 00:12:33,009
hacía lo que hubiera dentro

273
00:12:33,009 --> 00:12:35,909
y si no había un break, ya seguía

274
00:12:35,909 --> 00:12:37,629
seguía con todas las demás

275
00:12:37,629 --> 00:12:39,750
aunque este número no coincidiera

276
00:12:39,750 --> 00:12:40,649
ya seguía con todas

277
00:12:40,649 --> 00:12:43,590
pero no queríamos eso, queríamos

278
00:12:43,590 --> 00:12:45,789
que si esta variable era igual a este valor

279
00:12:45,789 --> 00:12:47,750
o igual a este, una vez que

280
00:12:47,750 --> 00:12:49,470
ha hecho lo que estaba dentro, ya está

281
00:12:49,470 --> 00:12:51,629
saliera y dejara de evaluar cosas

282
00:12:51,629 --> 00:12:53,669
saliera, pues para eso

283
00:12:53,669 --> 00:12:55,610
poníamos el break, porque el break es

284
00:12:55,610 --> 00:12:57,029
una sentencia que se puede usar

285
00:12:57,029 --> 00:12:59,330
en más contextos que en el switch case

286
00:12:59,330 --> 00:13:00,769
El break significa

287
00:13:00,769 --> 00:13:04,009
Sal del bloque en el que estás

288
00:13:04,009 --> 00:13:05,909
Abandona automáticamente el bloque

289
00:13:05,909 --> 00:13:06,549
En el que estás

290
00:13:06,549 --> 00:13:09,009
Entonces también la podemos usar en un while

291
00:13:09,009 --> 00:13:11,309
Entonces

292
00:13:11,309 --> 00:13:13,730
Este bucle es un while true

293
00:13:13,730 --> 00:13:15,009
Pero si termina

294
00:13:15,009 --> 00:13:18,110
Porque si n ha llegado a 0

295
00:13:18,110 --> 00:13:19,870
Break, y break que significa

296
00:13:19,870 --> 00:13:21,710
Sal de este bloque

297
00:13:21,710 --> 00:13:22,909
Abandona, rompe

298
00:13:22,909 --> 00:13:25,809
Si hay algo por aquí debajo, si hay más sentencias

299
00:13:25,809 --> 00:13:26,549
O lo que sea

300
00:13:26,549 --> 00:13:28,830
Ni llega a ellas

301
00:13:28,830 --> 00:13:36,200
¿Y si el if lo pones como un bloque?

302
00:13:36,379 --> 00:13:37,139
Ah, esto no llega

303
00:13:37,139 --> 00:13:39,080
Bueno, da igual

304
00:13:39,080 --> 00:13:41,980
Ah, vale

305
00:13:41,980 --> 00:13:43,879
Ya sé lo que dices

306
00:13:43,879 --> 00:13:45,980
Si sale de aquí y se va a este

307
00:13:45,980 --> 00:13:47,620
No, sale del

308
00:13:47,620 --> 00:13:50,419
Yo creo que sale del bucle enterito

309
00:13:50,419 --> 00:13:51,500
Déjame comprobarlo

310
00:13:51,500 --> 00:13:56,039
Porque normalmente se hacen para romper bucles

311
00:13:56,039 --> 00:13:57,220
Espérate que quite esto

312
00:13:57,220 --> 00:14:01,210
Vale, a ver

313
00:14:01,210 --> 00:14:02,830
En este caso está claro, ¿no?

314
00:14:03,149 --> 00:14:04,370
En este caso está claro

315
00:14:04,370 --> 00:14:06,090
Para lo que sirve el break

316
00:14:06,090 --> 00:14:07,990
Pero, repito, no se usa.

317
00:14:08,210 --> 00:14:11,850
Es una sentencia que está puesta ahí.

318
00:14:11,850 --> 00:14:13,870
Para que uno tenga el recurso, en un momento dado,

319
00:14:13,950 --> 00:14:15,870
tiene que romper un bucle por las buenas,

320
00:14:16,149 --> 00:14:17,490
pero jamás se programa así.

321
00:14:18,210 --> 00:14:21,850
Tú, si quieres, ¿cómo indicas que el bucle finaliza?

322
00:14:21,929 --> 00:14:22,629
Con la condición.

323
00:14:23,289 --> 00:14:25,590
Porque si lo haces así, el que está mirando este código,

324
00:14:25,850 --> 00:14:27,350
le complicas muchísimo la vida.

325
00:14:27,470 --> 00:14:28,990
Dice un bucle infinito.

326
00:14:29,169 --> 00:14:30,669
Ostras, me voy a tener que meter dentro

327
00:14:30,669 --> 00:14:33,690
para ver qué hace que esto acabe.

328
00:14:33,690 --> 00:14:36,850
y a lo mejor aquí dentro hay una llamada a un método

329
00:14:36,850 --> 00:14:38,629
y muchas cosas y le complicas mucho la vida

330
00:14:38,629 --> 00:14:40,769
entonces los códigos tienen que ser legibles

331
00:14:40,769 --> 00:14:42,809
y cuando uno eche un vistazo entender que ocurre

332
00:14:42,809 --> 00:14:45,090
y yo con un while true aquí no entiendo nada

333
00:14:45,090 --> 00:14:46,750
pero si yo pongo un while

334
00:14:46,750 --> 00:14:49,090
n diferente de 0 pues ya automáticamente

335
00:14:49,090 --> 00:14:50,690
veo, ah, se repite n veces

336
00:14:50,690 --> 00:14:52,590
vale, entonces

337
00:14:52,590 --> 00:14:54,710
el break no es

338
00:14:54,710 --> 00:14:56,690
una sentencia aconsejable de usar

339
00:14:56,690 --> 00:14:58,610
más que nada porque no hace ninguna falta

340
00:14:58,610 --> 00:15:00,750
no es necesaria en absoluto

341
00:15:00,750 --> 00:15:02,929
no hace falta, siempre puedes salir de un bucle

342
00:15:02,929 --> 00:15:04,769
Poniendo la condición correcta

343
00:15:04,769 --> 00:15:05,649
Y es como debes hacerlo

344
00:15:05,649 --> 00:15:08,909
Pero bueno, está ahí por herencia del pasado

345
00:15:08,909 --> 00:15:10,570
Por si en algún momento dado tiene que usarla

346
00:15:10,570 --> 00:15:12,990
Y en el switch case, ahí sí que es imprescindible

347
00:15:12,990 --> 00:15:13,950
Ahí sí que es imprescindible

348
00:15:13,950 --> 00:15:17,169
Es el único caso en el que hay que usarla

349
00:15:17,169 --> 00:15:17,450
¿Vale?

350
00:15:18,769 --> 00:15:20,870
Venga, pues entonces, aquí está clarísimo

351
00:15:20,870 --> 00:15:23,409
Que saldríamos del bucle en cuanto llegamos a 0

352
00:15:23,409 --> 00:15:24,809
Con lo cual esto nos saludaría

353
00:15:24,809 --> 00:15:26,789
7 veces

354
00:15:26,789 --> 00:15:28,470
¿Vale?

355
00:15:29,809 --> 00:15:30,929
Nos hace las 7

356
00:15:30,929 --> 00:15:32,049
¿Vale?

357
00:15:32,929 --> 00:15:42,409
Y ahora, esto, que bueno, yo no lo he visto nunca, pero vamos a ver por curiosidad cómo funcionaría.

358
00:15:42,509 --> 00:15:47,610
Si te saldría de este, con lo cual estaríamos en las mismas y seguiría siendo un bucle infinito,

359
00:15:48,230 --> 00:15:53,370
o break significa sal del bucle más en el que estás, sal del bucle más interno en el que estás, que sería este.

360
00:15:57,049 --> 00:16:07,139
Yo tengo una teoría, pero vamos a ponerle 4 para que sale del bucle en el que estás, efectivamente.

361
00:16:07,139 --> 00:16:10,100
No, no, no, está bien

362
00:16:10,100 --> 00:16:12,059
Porque hay pequeños detalles

363
00:16:12,059 --> 00:16:14,259
Que son curiosidades

364
00:16:14,259 --> 00:16:15,039
Que tienen sentido

365
00:16:15,039 --> 00:16:18,220
Entonces el break es la sentencia de

366
00:16:18,220 --> 00:16:19,799
Romper bucles

367
00:16:19,799 --> 00:16:21,500
Pero no las usemos

368
00:16:21,500 --> 00:16:23,679
No es necesario

369
00:16:23,679 --> 00:16:25,500
Y el código va a quedar muy feo

370
00:16:25,500 --> 00:16:27,860
Entonces nunca haríamos un código así

371
00:16:27,860 --> 00:16:29,559
Nunca haríamos un código así

372
00:16:29,559 --> 00:16:31,179
Este código lo cambiaríamos

373
00:16:31,179 --> 00:16:33,299
Y lo pondríamos así

374
00:16:33,299 --> 00:16:34,059
¿Vale?

375
00:16:34,059 --> 00:16:36,840
Así ya sí que estaría

376
00:16:36,840 --> 00:16:37,879
Un código mucho más bonito

377
00:16:37,879 --> 00:16:39,759
¿Vale?

378
00:16:42,120 --> 00:16:43,179
Entonces ya

379
00:16:43,179 --> 00:16:45,820
De nuevo con un while

380
00:16:45,820 --> 00:16:47,820
Se abre un bloque otra vez

381
00:16:47,820 --> 00:16:48,820
Como con un if

382
00:16:48,820 --> 00:16:51,820
No es obligatoria

383
00:16:51,820 --> 00:16:52,519
Las llaves

384
00:16:52,519 --> 00:16:55,279
Si solo se hace una sentencia

385
00:16:55,279 --> 00:16:57,139
¿Vale? Por ejemplo

386
00:16:57,139 --> 00:16:58,700
Si yo

387
00:16:58,700 --> 00:17:00,179
Este

388
00:17:00,179 --> 00:17:02,440
Este bucle

389
00:17:02,440 --> 00:17:04,380
Fuera así

390
00:17:04,380 --> 00:17:06,579
Sería infinito en este caso

391
00:17:06,579 --> 00:17:07,579
Claro, vamos, no

392
00:17:07,579 --> 00:17:09,720
Me gustaría si este bucle

393
00:17:09,720 --> 00:17:11,299
Bueno, a ver, puedo hacer esto

394
00:17:11,299 --> 00:17:14,000
Hola, concatenarlo con n

395
00:17:14,000 --> 00:17:16,119
Y a n decrementarlo

396
00:17:16,119 --> 00:17:17,119
Este ya no sería infinito

397
00:17:17,119 --> 00:17:20,980
Hola, muestro el valor de n

398
00:17:20,980 --> 00:17:22,279
Y lo decremento

399
00:17:22,279 --> 00:17:25,299
Pues este bucle

400
00:17:25,299 --> 00:17:27,160
Como solo tiene una sentencia dentro

401
00:17:27,160 --> 00:17:28,059
Solo tiene una

402
00:17:28,059 --> 00:17:29,839
La llave es opcional

403
00:17:29,839 --> 00:17:32,059
¿Vale? La llave es opcional

404
00:17:32,059 --> 00:17:34,400
entonces las sentencias que vengan a continuación

405
00:17:34,400 --> 00:17:36,160
ya la máquina virtual sabe que están

406
00:17:36,160 --> 00:17:37,339
fuera del while, no hay duda

407
00:17:37,339 --> 00:17:39,640
aunque las tabulara, me da lo mismo

408
00:17:39,640 --> 00:17:42,220
porque las tabulaciones son solo para dejar el código

409
00:17:42,220 --> 00:17:44,039
claro, a la máquina virtual las tabulaciones

410
00:17:44,039 --> 00:17:45,140
los espacios le dan igual

411
00:17:45,140 --> 00:17:48,279
entonces si no hay llaves, por muchas sentencias

412
00:17:48,279 --> 00:17:50,079
que haya aquí, el bucle

413
00:17:50,079 --> 00:17:52,200
while solo tiene dentro esta

414
00:17:52,200 --> 00:17:54,000
lo que pasa es que

415
00:17:54,000 --> 00:17:56,440
para evitar efectivamente confusiones

416
00:17:56,440 --> 00:17:57,579
y para no meter la pata

417
00:17:57,579 --> 00:17:59,859
siempre es buena idea abrir un

418
00:17:59,859 --> 00:18:01,299
bloque de llaves

419
00:18:01,299 --> 00:18:04,039
siempre es buena idea abrirlo y así queda clarísimo

420
00:18:04,039 --> 00:18:04,619
que hay dentro

421
00:18:04,619 --> 00:18:08,119
pero recordad que desde el momento

422
00:18:08,119 --> 00:18:09,319
en que abrís un bloque

423
00:18:09,319 --> 00:18:11,819
como hacemos con un if

424
00:18:11,819 --> 00:18:14,099
automáticamente se abre aquí

425
00:18:14,099 --> 00:18:16,240
como si fuera un ámbito nuevo de variables

426
00:18:16,240 --> 00:18:18,099
recordad que entonces

427
00:18:18,099 --> 00:18:20,200
cualquier cosa que declaréis aquí

428
00:18:20,200 --> 00:18:22,359
cualquier cosa que declaréis aquí

429
00:18:22,359 --> 00:18:24,480
solo se puede usar

430
00:18:24,480 --> 00:18:26,200
aquí dentro y solo es visible

431
00:18:26,200 --> 00:18:27,839
aquí dentro para hacer lo que uno quiera

432
00:18:27,839 --> 00:18:29,079
solo es visible ahí dentro

433
00:18:29,079 --> 00:18:31,339
En cuanto el bloque termina

434
00:18:31,339 --> 00:18:33,119
En cuanto el bloque termina

435
00:18:33,119 --> 00:18:35,539
Esa variable m se ha ido a la basura

436
00:18:35,539 --> 00:18:36,559
Y ha desaparecido

437
00:18:36,559 --> 00:18:39,200
Y con ella su valor, fuera, a la basura

438
00:18:39,200 --> 00:18:41,420
Entonces yo aquí si quisiera

439
00:18:41,420 --> 00:18:42,839
Mostrar el valor que tiene m

440
00:18:42,839 --> 00:18:45,079
Me dirían, pero ¿quién es m?

441
00:18:45,079 --> 00:18:46,660
No tengo ni idea de quién es m

442
00:18:46,660 --> 00:18:49,339
Porque m la declaraste dentro de este bloque

443
00:18:49,339 --> 00:18:51,180
Luego se usó aquí dentro

444
00:18:51,180 --> 00:18:52,759
Para todo lo que hiciera falta, se usó

445
00:18:52,759 --> 00:18:54,619
Y cuando el bloque terminó

446
00:18:54,619 --> 00:18:57,180
Y hemos venido a este punto, m a la basura

447
00:18:57,180 --> 00:19:02,910
bueno, con un retune

448
00:19:02,910 --> 00:19:03,890
sales del main, no

449
00:19:03,890 --> 00:19:06,950
la única, es que tienes la opción

450
00:19:06,950 --> 00:19:08,529
natural, que es declararla fuera

451
00:19:08,529 --> 00:19:10,549
¿vale?

452
00:19:10,809 --> 00:19:12,430
la declaras fuera y solucionado

453
00:19:12,430 --> 00:19:16,279
¿vale? entonces, tú en

454
00:19:16,279 --> 00:19:18,500
si vas a usar una variable en un sitio

455
00:19:18,500 --> 00:19:20,240
tienes que asegurarte que esa variable está

456
00:19:20,240 --> 00:19:22,460
declarada en el bloque al que pertenezca

457
00:19:22,460 --> 00:19:24,339
esa sentencia, entonces, esta sentencia

458
00:19:24,339 --> 00:19:25,480
¿qué bloque pertenece?

459
00:19:25,920 --> 00:19:28,420
a este grandote de main, es en el que está

460
00:19:28,420 --> 00:19:30,240
a este grandote, pertenece a esa

461
00:19:30,240 --> 00:19:32,279
Pues entonces tiene que estar declarada ahí

462
00:19:32,279 --> 00:19:34,700
¿Vale? Si solamente la usáramos

463
00:19:34,700 --> 00:19:35,299
Aquí dentro

464
00:19:35,299 --> 00:19:38,019
Y esta sentencia

465
00:19:38,019 --> 00:19:40,740
Esta M solamente sirviera

466
00:19:40,740 --> 00:19:41,920
Para ser usada aquí dentro

467
00:19:41,920 --> 00:19:44,000
Solo, le doy un valor y la muestro aquí

468
00:19:44,000 --> 00:19:46,400
Solo, pues entonces la declaro ahí

469
00:19:46,400 --> 00:19:48,880
Porque como solo la voy a usar

470
00:19:48,880 --> 00:19:49,920
Aquí dentro, la declaro ahí

471
00:19:49,920 --> 00:19:52,920
¿Y qué ventaja tiene declararla ahí

472
00:19:52,920 --> 00:19:53,500
En vez de fuera?

473
00:19:54,500 --> 00:19:56,200
Que el resto del código ya no

474
00:19:56,200 --> 00:19:57,220
Ya no molesta

475
00:19:57,220 --> 00:20:00,079
Porque ya no está esa variable M ahí

476
00:20:00,079 --> 00:20:01,000
ya ha desaparecido

477
00:20:01,000 --> 00:20:04,039
entonces esta variable m solo va a existir

478
00:20:04,039 --> 00:20:06,039
durante el tiempo que tarda en ejecutarse

479
00:20:06,039 --> 00:20:08,279
el tiempo que tarda en ejecutarse

480
00:20:08,279 --> 00:20:09,220
esa variable existe

481
00:20:09,220 --> 00:20:11,700
eso ha terminado de ejecutarse

482
00:20:11,700 --> 00:20:12,859
la variable se va a la basura

483
00:20:12,859 --> 00:20:14,500
memoria que me ahorro

484
00:20:14,500 --> 00:20:16,680
y confusiones

485
00:20:16,680 --> 00:20:18,960
porque si aquí sigue habiendo una variable m

486
00:20:18,960 --> 00:20:21,039
yo estoy en 30.000 líneas más abajo

487
00:20:21,039 --> 00:20:22,160
intento declarar otra m

488
00:20:22,160 --> 00:20:23,420
me dice no puedo declarar m

489
00:20:23,420 --> 00:20:25,059
pero si yo no tengo ninguna m

490
00:20:25,059 --> 00:20:27,940
si la tienes porque la has declarado más arriba

491
00:20:27,940 --> 00:20:29,779
entonces es buena práctica

492
00:20:29,779 --> 00:20:31,119
Declarar las variables

493
00:20:31,119 --> 00:20:34,319
En el bloque más interno en el que se usan

494
00:20:34,319 --> 00:20:35,839
Es buena práctica

495
00:20:35,839 --> 00:20:38,220
Y así fuera de ese bloque no existen

496
00:20:38,220 --> 00:20:38,920
No molestan

497
00:20:38,920 --> 00:20:40,980
Y puede ser la misma

498
00:20:40,980 --> 00:20:45,200
A ver, puedes declarar

499
00:20:45,200 --> 00:20:48,920
Te refieres a esto

500
00:20:48,920 --> 00:20:51,339
Te pones interno

501
00:20:51,339 --> 00:20:53,319
Pero si la has clasificado fuera, usa esa

502
00:20:53,319 --> 00:20:54,640
Porque luego te borrará

503
00:20:54,640 --> 00:20:56,799
No, no, no

504
00:20:56,799 --> 00:20:58,420
Entonces lo que lo estropeas es aquí

505
00:20:58,420 --> 00:21:00,839
La estropeas ahí

506
00:21:00,839 --> 00:21:03,059
te dice, oye, que la variable está duplicada

507
00:21:03,059 --> 00:21:04,579
entonces

508
00:21:04,579 --> 00:21:07,059
el problema es que aquí, si lo dejas así

509
00:21:07,059 --> 00:21:09,259
aquí dentro, abre una ambigüedad

510
00:21:09,259 --> 00:21:10,440
que es cuando yo digo M

511
00:21:10,440 --> 00:21:12,240
a cuál me estoy refiriendo

512
00:21:12,240 --> 00:21:15,259
a la que yo he declarado aquí dentro

513
00:21:15,259 --> 00:21:16,700
y que sustituye a la otra

514
00:21:16,700 --> 00:21:18,839
o me estoy refiriendo a esta

515
00:21:18,839 --> 00:21:20,519
entonces para evitar esa ambigüedad

516
00:21:20,519 --> 00:21:22,000
directamente no te deja

517
00:21:22,000 --> 00:21:29,380
¿vale? pero aquí sí

518
00:21:29,380 --> 00:21:35,200
¿vale? porque Java, no olvidemos

519
00:21:35,200 --> 00:21:35,579
aunque

520
00:21:35,579 --> 00:21:38,660
Java es un lenguaje extraño

521
00:21:38,660 --> 00:21:41,059
porque no es ni compilado ni interpretado

522
00:21:41,059 --> 00:21:42,279
es una mezcla de las dos cosas

523
00:21:42,279 --> 00:21:44,819
entonces los lenguajes interpretados

524
00:21:44,819 --> 00:21:45,700
¿qué significan?

525
00:21:46,019 --> 00:21:47,640
que se van interpretando línea por línea

526
00:21:47,640 --> 00:21:50,180
con lo cual podemos entender

527
00:21:50,180 --> 00:21:52,359
que cada línea es independiente de las demás

528
00:21:52,359 --> 00:21:54,059
y que van de abajo

529
00:21:54,059 --> 00:21:55,660
perdón, de arriba a abajo

530
00:21:55,660 --> 00:21:57,559
entonces primero se hace esta

531
00:21:57,559 --> 00:21:59,380
luego se hace esta otra

532
00:21:59,380 --> 00:22:01,859
entonces cuando se hace esta

533
00:22:01,859 --> 00:22:04,200
lo que hay abajo todavía no se ha mirado

534
00:22:04,200 --> 00:22:05,420
con lo cual no molesta

535
00:22:05,420 --> 00:22:08,220
esos son los programas interpretados

536
00:22:08,220 --> 00:22:28,960
En los compilados se mira todo en su conjunto, entonces lo que se compila todo, entonces lo que hay arriba sí se puede ver afectado por lo que hay abajo, de ahí vienen los errores de compilación, ¿verdad? Los errores de compilación es que, oye, aquí has hecho una cosa y no me casa con lo de abajo, entonces no te dejo que compiles ni ejecutes.

537
00:22:28,960 --> 00:22:31,160
entonces los compilados se mira en bloque

538
00:22:31,160 --> 00:22:32,920
a ver si todo casa y todo está bien

539
00:22:32,920 --> 00:22:35,099
y luego ya una vez compilados se ejecuta

540
00:22:35,099 --> 00:22:37,480
y los interpretados puros

541
00:22:37,480 --> 00:22:39,099
se va a línea por

542
00:22:39,099 --> 00:22:41,019
ni se compila ni nada, se va

543
00:22:41,019 --> 00:22:43,019
línea por línea, cuando yo hago una línea

544
00:22:43,019 --> 00:22:44,859
lo que hay abajo ni lo he mirado todavía

545
00:22:44,859 --> 00:22:46,759
me da exactamente igual, yo voy línea por línea

546
00:22:46,759 --> 00:22:49,079
lo que puede ocurrir cuando ejecuto una línea es que esa línea

547
00:22:49,079 --> 00:22:51,220
esté mal, esté mal escrita lo que sea

548
00:22:51,220 --> 00:22:53,200
pero cuando yo ejecuto una línea

549
00:22:53,200 --> 00:22:54,220
lo de abajo ni se mira

550
00:22:54,220 --> 00:22:57,359
esos serían los interpretados puros, entonces Java es una mezcla

551
00:22:57,359 --> 00:22:59,319
de los dos, recordad que primero se hace

552
00:22:59,319 --> 00:23:01,019
una especie de pre-compilación

553
00:23:01,019 --> 00:23:03,319
y en ese sentido algunas cosas

554
00:23:03,319 --> 00:23:05,339
que hay abajo sí que pueden afectar a lo que hay

555
00:23:05,339 --> 00:23:07,359
arriba y te dice, oye, esto no me está

556
00:23:07,359 --> 00:23:08,220
casando, arréglalo

557
00:23:08,220 --> 00:23:11,779
pero es una pre-compilación

558
00:23:11,779 --> 00:23:13,500
solo, luego se hace un código

559
00:23:13,500 --> 00:23:15,440
intermedio que ya la máquina virtual de Java

560
00:23:15,440 --> 00:23:16,420
va interpretando

561
00:23:16,420 --> 00:23:19,460
vale, pues ese medio

562
00:23:19,460 --> 00:23:21,319
carácter de interpretado que

563
00:23:21,319 --> 00:23:23,240
tiene, ese medio carácter a veces

564
00:23:23,240 --> 00:23:23,819
da la cara

565
00:23:23,819 --> 00:23:27,019
que es muy malo, lo de ser

566
00:23:27,019 --> 00:23:28,920
interpretado es malo

567
00:23:28,920 --> 00:23:31,039
¿cuál es la ventaja que tiene? que es independiente

568
00:23:31,039 --> 00:23:32,920
de la plataforma, porque yo tengo el

569
00:23:32,920 --> 00:23:34,980
intérprete que me hace la traducción a cada

570
00:23:34,980 --> 00:23:36,480
equipo, ¿vale?

571
00:23:37,099 --> 00:23:38,960
entonces si tú tienes un

572
00:23:38,960 --> 00:23:41,259
traductor en cada país

573
00:23:41,259 --> 00:23:42,940
tú puedes hablar un único idioma

574
00:23:42,940 --> 00:23:44,579
y al país que vayas

575
00:23:44,579 --> 00:23:46,920
ese traductor, ese intérprete

576
00:23:46,920 --> 00:23:48,980
te lo va a traducir al chino, al

577
00:23:48,980 --> 00:23:50,799
japonés, al que sea, tú puedes

578
00:23:50,799 --> 00:23:52,880
hablar el único idioma, y ese es el

579
00:23:52,880 --> 00:23:53,720
lenguaje interpretado

580
00:23:53,720 --> 00:23:55,859
¿vale? pues entonces

581
00:23:55,859 --> 00:23:58,559
esa es la ventaja de los interpretados

582
00:23:58,559 --> 00:24:00,559
que las pautas

583
00:24:00,559 --> 00:24:02,599
de programación son únicas y universales

584
00:24:02,599 --> 00:24:04,559
y ya cada equipo se preocupa

585
00:24:04,559 --> 00:24:06,160
de interpretar, por eso Java

586
00:24:06,160 --> 00:24:08,160
intenta ser una mezcla de ambos

587
00:24:08,160 --> 00:24:09,519
esa es la única ventaja que tiene

588
00:24:09,519 --> 00:24:12,519
pero el problema es que no hay

589
00:24:12,519 --> 00:24:12,980
esa

590
00:24:12,980 --> 00:24:16,339
especie de verificación de si todo

591
00:24:16,339 --> 00:24:17,680
casa entre sí, que no la hay

592
00:24:17,680 --> 00:24:20,180
eso es malo también, entonces por eso

593
00:24:20,180 --> 00:24:22,079
Java es una mezcla de los dos, bueno pues

594
00:24:22,079 --> 00:24:23,819
lo que estaba diciendo es que su

595
00:24:23,819 --> 00:24:26,000
carácter, su pseudo carácter

596
00:24:26,000 --> 00:24:27,980
su pequeña parte que tiene interpretado

597
00:24:27,980 --> 00:24:29,720
a veces sale

598
00:24:29,720 --> 00:24:31,859
y aflora, y este es uno de los ejemplos en los que

599
00:24:31,859 --> 00:24:33,720
aflora, fijaos la diferencia

600
00:24:33,720 --> 00:24:35,500
entre yo haber declarado M

601
00:24:35,500 --> 00:24:36,980
aquí arriba

602
00:24:36,980 --> 00:24:39,500
que esta

603
00:24:39,500 --> 00:24:40,759
se ha fastidiado

604
00:24:40,759 --> 00:24:43,359
y haber declarado M

605
00:24:43,359 --> 00:24:44,619
aquí abajo

606
00:24:44,619 --> 00:24:47,819
que esta no se fastidia

607
00:24:47,819 --> 00:24:49,059
¿vale?

608
00:24:49,660 --> 00:24:51,619
entonces, yo aquí he declarado mi variable

609
00:24:51,619 --> 00:24:53,099
mi variable M

610
00:24:53,099 --> 00:24:55,420
Hace lo que tenga que hacer

611
00:24:55,420 --> 00:24:57,700
Asigna su valor, se muestra y desaparece

612
00:24:57,700 --> 00:24:58,460
Y se va a la basura

613
00:24:58,460 --> 00:25:00,920
Y ahora después aquí al rato

614
00:25:00,920 --> 00:25:02,319
Vuelvo a declarar otra M

615
00:25:02,319 --> 00:25:04,059
Y esta M

616
00:25:04,059 --> 00:25:08,319
Es válida

617
00:25:08,319 --> 00:25:11,440
Para cualquier momento

618
00:25:11,440 --> 00:25:13,019
A partir de aquí, y es una M nueva

619
00:25:13,019 --> 00:25:15,720
Es una M nueva que yo puedo usar tranquilamente

620
00:25:15,720 --> 00:25:16,420
A partir de aquí

621
00:25:16,420 --> 00:25:19,079
Pero antes no

622
00:25:19,079 --> 00:25:21,180
Recordad que no podemos usar una variable

623
00:25:21,180 --> 00:25:22,619
Antes de que sea declarada

624
00:25:22,619 --> 00:25:28,619
A ver, es que los lenguajes puramente compilados

625
00:25:28,619 --> 00:25:30,880
Normalmente tienen unas reglas

626
00:25:30,880 --> 00:25:31,740
C por ejemplo

627
00:25:31,740 --> 00:25:34,279
Te obligaba a declararlas todas al principio

628
00:25:34,279 --> 00:25:38,339
Para facilitar la tarea de los compiladores

629
00:25:38,339 --> 00:25:39,200
Y todo eso

630
00:25:39,200 --> 00:25:42,140
Vale, aquí por ejemplo

631
00:25:42,140 --> 00:25:43,940
La variable m está declarada

632
00:25:43,940 --> 00:25:45,579
Y está declarada en el bloque gordote

633
00:25:45,579 --> 00:25:46,380
Que es en este

634
00:25:46,380 --> 00:25:48,880
Pero eso no significa que la pueda yo usar aquí

635
00:25:48,880 --> 00:25:52,910
No puedo usarla aquí

636
00:25:52,910 --> 00:25:55,569
Porque la estoy usando antes de estar declarada

637
00:25:55,569 --> 00:25:57,069
¿Vale?

638
00:26:01,150 --> 00:26:02,170
Bueno, pues todo esto

639
00:26:02,170 --> 00:26:04,549
En respuesta, aunque no lo parezca, a tu pregunta

640
00:26:04,549 --> 00:26:06,349
¿Puedo declarar otra M fuera?

641
00:26:06,950 --> 00:26:08,670
Puedes, pero si está después

642
00:26:08,670 --> 00:26:10,869
Del bloque, si está después del bloque

643
00:26:10,869 --> 00:26:11,990
Y será una M nueva

644
00:26:11,990 --> 00:26:14,869
Que no tiene nada que ver con esta porque está ya desaparecido

645
00:26:14,869 --> 00:26:15,710
Y se ha ido a la basura

646
00:26:15,710 --> 00:26:18,569
¿Vale? Pero antes no porque entonces

647
00:26:18,569 --> 00:26:19,990
Aquí habría una ambigüedad

648
00:26:19,990 --> 00:26:22,410
Y la ambigüedad sería esta M

649
00:26:22,410 --> 00:26:25,069
¿Cuál es? ¿Esta cajita o la cajita de arriba?

650
00:26:25,069 --> 00:26:26,910
habría una ambigüedad, vale

651
00:26:26,910 --> 00:26:29,230
vale

652
00:26:29,230 --> 00:26:33,500
ah, vale

653
00:26:33,500 --> 00:26:34,619
lo que estábamos diciendo era

654
00:26:34,619 --> 00:26:37,299
que while las llaves son

655
00:26:37,299 --> 00:26:39,220
opcionales, pero recomendables

656
00:26:39,220 --> 00:26:40,480
para que quede claro el código

657
00:26:40,480 --> 00:26:43,039
y si

658
00:26:43,039 --> 00:26:44,420
abrís llaves

659
00:26:44,420 --> 00:26:47,220
recordad que en ese momento lo que abrís es

660
00:26:47,220 --> 00:26:49,039
un espacio, un ámbito nuevo

661
00:26:49,039 --> 00:26:51,119
un ámbito más pequeñito, lo que se declare

662
00:26:51,119 --> 00:26:52,960
ahí, fuera desaparecido

663
00:26:52,960 --> 00:26:54,500
venía a cuento de todo esto, ¿no?

664
00:26:55,299 --> 00:26:56,900
vale, ¿y qué más cosas de...

665
00:26:56,900 --> 00:27:02,039
Entonces, esta es la única sintaxis que en realidad que hace falta para hacer bucles.

666
00:27:02,119 --> 00:27:02,839
No hace falta más.

667
00:27:03,279 --> 00:27:04,740
Lo que pasa es que igual que ocurría con el if,

668
00:27:05,480 --> 00:27:07,940
hay otras formas de escribir bucles, ¿vale?

669
00:27:08,740 --> 00:27:12,180
Que para algunos ejercicios pegan más y los dejan más bonitos.

670
00:27:12,599 --> 00:27:14,380
Pero solamente porque los dejan más bonitos.

671
00:27:14,799 --> 00:27:17,339
Es como el switch case que deja más bonito un programa

672
00:27:17,339 --> 00:27:20,740
si tú quieres ver, hacer algo en función de si n es un valor u otro.

673
00:27:20,920 --> 00:27:24,619
Se queda más bonito con switch case que con if, else if, else if.

674
00:27:24,619 --> 00:27:27,680
pero se puede hacer todo con el if, el se

675
00:27:27,680 --> 00:27:29,900
pues aquí igual, se puede hacer todo con el while

676
00:27:29,900 --> 00:27:31,259
pero hay veces que queda más bonito

677
00:27:31,259 --> 00:27:33,460
con otras dos variantes más

678
00:27:33,460 --> 00:27:35,799
tres, que las incorporaremos

679
00:27:35,799 --> 00:27:36,539
en breve, vale

680
00:27:36,539 --> 00:27:39,700
y el otro día también, ya hablando

681
00:27:39,700 --> 00:27:41,539
de bucles ya, dijimos que ahora ya

682
00:27:41,539 --> 00:27:43,660
hay cosas que podemos hacer ya con los bucles

683
00:27:43,660 --> 00:27:44,720
que antes no podíamos hacer

684
00:27:44,720 --> 00:27:47,420
como por ejemplo contar, vale

685
00:27:47,420 --> 00:27:49,579
entonces ahora ya hay patrones de

686
00:27:49,579 --> 00:27:51,460
algoritmia, patrones de algoritmia

687
00:27:51,460 --> 00:27:53,000
que ya tenemos que ir incorporando

688
00:27:53,000 --> 00:27:54,599
porque ya con los bucles se complica

689
00:27:54,599 --> 00:27:56,900
con las decisiones, los patrones de algoritmo

690
00:27:56,900 --> 00:27:58,920
eran muy claros, yo me he dado cuenta

691
00:27:58,920 --> 00:28:00,880
en un programa que tiene

692
00:28:00,880 --> 00:28:02,799
dos posibilidades, un if

693
00:28:02,799 --> 00:28:04,819
ya está, un if, no tengo que pensar más

694
00:28:04,819 --> 00:28:06,500
de que depende una a la otra

695
00:28:06,500 --> 00:28:08,319
de esto, pues eso para la condición

696
00:28:08,319 --> 00:28:10,740
me he dado cuenta en un programa que tiene hasta

697
00:28:10,740 --> 00:28:12,920
tres posibilidades, pues un if con un

698
00:28:12,920 --> 00:28:14,920
elseanidado o un if

699
00:28:14,920 --> 00:28:16,940
elseif, o si depende del valor de una

700
00:28:16,940 --> 00:28:18,839
variable, un switch case, y no teníamos

701
00:28:18,839 --> 00:28:19,880
en realidad que

702
00:28:19,880 --> 00:28:22,799
pensar más, lo teníamos

703
00:28:22,799 --> 00:28:23,539
Relativamente claro

704
00:28:23,539 --> 00:28:26,420
Luego ya lo complicado podía ser

705
00:28:26,420 --> 00:28:28,420
Traducir yo las condiciones

706
00:28:28,420 --> 00:28:30,500
A Java, traducirla a una condición

707
00:28:30,500 --> 00:28:32,019
Que está en lenguaje natural, traducirla a Java

708
00:28:32,019 --> 00:28:34,680
Eso podía ser más complicado, pero no teníamos más que pensar

709
00:28:34,680 --> 00:28:36,119
Vale, ahora con el bucle

710
00:28:36,119 --> 00:28:38,819
Hay como más patrones mentales en la cabeza

711
00:28:38,819 --> 00:28:40,680
Se abren más cosas

712
00:28:40,680 --> 00:28:41,539
Más posibilidades

713
00:28:41,539 --> 00:28:43,420
Bueno, pues una de las cosas que se abren

714
00:28:43,420 --> 00:28:46,220
En un programa yo puedo necesitar contar

715
00:28:46,220 --> 00:28:47,299
Contar cosas

716
00:28:47,299 --> 00:28:50,460
Como subparte, como pequeña parte

717
00:28:50,460 --> 00:28:51,240
De algo más grande

718
00:28:51,240 --> 00:28:52,880
como pequeña parte de algo más grande

719
00:28:52,880 --> 00:28:55,420
¿vale? pues eso ya es

720
00:28:55,420 --> 00:28:57,359
un patrón que ya incorporamos el otro

721
00:28:57,359 --> 00:28:59,480
día en esos ejemplos, por ejemplo

722
00:28:59,480 --> 00:29:00,380
aquí podríamos

723
00:29:00,380 --> 00:29:03,359
incorporar, este

724
00:29:03,359 --> 00:29:04,680
n ya es un contador, ¿no?

725
00:29:05,319 --> 00:29:07,400
ya es un contador, ya está funcionando como un contador

726
00:29:07,400 --> 00:29:08,619
lo que pasa es que

727
00:29:08,619 --> 00:29:10,640
me está descontando

728
00:29:10,640 --> 00:29:13,420
en lugar de ir hacia arriba, ¿vale?

729
00:29:14,539 --> 00:29:15,119
me está

730
00:29:15,119 --> 00:29:17,700
descontando cuantos

731
00:29:17,700 --> 00:29:18,759
olas

732
00:29:18,759 --> 00:29:20,759
Cuento, pero en general

733
00:29:20,759 --> 00:29:22,460
Cuando uno quiere contar lo que sea

734
00:29:22,460 --> 00:29:23,180
Por ejemplo

735
00:29:23,180 --> 00:29:25,900
Lo que hicimos el otro día, pues

736
00:29:25,900 --> 00:29:30,119
Contar pares

737
00:29:30,119 --> 00:29:32,259
Entre uno

738
00:29:32,259 --> 00:29:33,099
Y

739
00:29:33,099 --> 00:29:35,940
Bueno, contar pares

740
00:29:35,940 --> 00:29:37,720
Ya sabemos que es una tontería

741
00:29:37,720 --> 00:29:39,920
Entre uno y un

742
00:29:39,920 --> 00:29:41,880
Porque serán la mitad de lo que nos han dado

743
00:29:41,880 --> 00:29:44,759
Pero bueno, entre uno y un número solicitado por teclado

744
00:29:44,759 --> 00:29:50,140
Vale, vamos a suponer

745
00:29:50,140 --> 00:29:51,680
Que nos piden este ejercicio

746
00:29:51,680 --> 00:29:54,240
¿Cuántos números pares habrá entre uno

747
00:29:54,240 --> 00:29:56,400
Y un número que me dan por teclado

748
00:29:56,400 --> 00:29:58,720
Vale, habrá la mitad, es una tontería

749
00:29:58,720 --> 00:29:59,720
Vale, pero vamos a contarlos

750
00:29:59,720 --> 00:30:01,500
¿Eh?

751
00:30:04,960 --> 00:30:06,559
Sí, pero bueno, podrías hacer la diferencia

752
00:30:06,559 --> 00:30:07,700
Y hacer la mitad igualmente

753
00:30:07,700 --> 00:30:10,599
Pero bueno, venga, vamos a poner

754
00:30:10,599 --> 00:30:12,700
Contar múltiplos de 3

755
00:30:12,700 --> 00:30:14,180
Que así parece que

756
00:30:14,180 --> 00:30:16,039
Bueno, da igual, dejamos así, da lo mismo

757
00:30:16,039 --> 00:30:16,599
Vale

758
00:30:16,599 --> 00:30:18,240
Vale

759
00:30:18,240 --> 00:30:21,680
Pues venga, pedimos el numerito por teclado

760
00:30:21,680 --> 00:30:29,069
ala, el número ya está pedido

761
00:30:29,069 --> 00:30:31,329
y ahora

762
00:30:31,329 --> 00:30:33,630
la parte de datos de entrada

763
00:30:33,630 --> 00:30:35,549
la tenemos, hay que pedir un único número

764
00:30:35,549 --> 00:30:37,650
ya lo tengo pedido, y ahora pensamos

765
00:30:37,650 --> 00:30:38,650
¿qué tengo que hacer aquí?

766
00:30:39,369 --> 00:30:42,130
tengo que contar cosas, tengo que contarlas

767
00:30:42,130 --> 00:30:44,170
un while voy a necesitar

768
00:30:44,170 --> 00:30:44,789
sí o sí

769
00:30:44,789 --> 00:30:46,769
voy a necesitar un while

770
00:30:46,769 --> 00:30:49,509
para ir

771
00:30:49,509 --> 00:30:51,210
incrementando esa cuenta

772
00:30:51,210 --> 00:30:52,789
que empieza desde cero

773
00:30:52,789 --> 00:30:57,660
tengo que contar cosas, entonces si tengo que

774
00:30:57,660 --> 00:30:59,500
contar cuántas veces ocurre

775
00:30:59,500 --> 00:31:01,619
algo, cuando yo identifico que tengo que

776
00:31:01,619 --> 00:31:03,359
contar cuántas veces ocurre algo

777
00:31:03,359 --> 00:31:05,359
esto va a estar en mi programa

778
00:31:05,359 --> 00:31:07,480
va a estar esto sí o sí, tengo que contar

779
00:31:07,480 --> 00:31:08,839
cuántas veces ocurre algo

780
00:31:08,839 --> 00:31:11,380
vale, pues entonces

781
00:31:11,380 --> 00:31:13,599
ahora ya nos vamos a la siguiente

782
00:31:13,599 --> 00:31:15,319
parte que es, bueno, venga

783
00:31:15,319 --> 00:31:17,200
pues que tengo que contar

784
00:31:17,200 --> 00:31:18,440
como lo plasmo aquí

785
00:31:18,440 --> 00:31:20,660
pues tienes que contar

786
00:31:20,660 --> 00:31:23,480
los números pares

787
00:31:23,480 --> 00:31:25,519
que hay entre uno y el que te han dado, con lo cual

788
00:31:25,519 --> 00:31:27,200
eso se traduce a decir, tengo que

789
00:31:27,200 --> 00:31:29,400
contar cada número que sea par

790
00:31:29,400 --> 00:31:31,140
es decir, yo voy contando

791
00:31:31,140 --> 00:31:32,339
tengo que contar números

792
00:31:32,339 --> 00:31:35,539
es como si contara alumnos, ¿cuántos alumnos son rubios?

793
00:31:35,619 --> 00:31:37,099
voy pasando alumno por alumno

794
00:31:37,099 --> 00:31:38,839
este, este, este, me paro en el que es rubio

795
00:31:38,839 --> 00:31:40,339
este, este, este, me paro en el que es rubio

796
00:31:40,339 --> 00:31:43,119
pues aquí no contamos alumnos

797
00:31:43,119 --> 00:31:45,039
que cumplen una condición, sino que contamos

798
00:31:45,039 --> 00:31:46,460
números que cumplen una condición

799
00:31:46,460 --> 00:31:49,099
luego hago un barrido sobre

800
00:31:49,099 --> 00:31:50,640
números, ¿vale?

801
00:31:50,880 --> 00:31:52,759
entonces lo primero que tengo que identificar es

802
00:31:52,759 --> 00:31:55,400
mi barrido para ver quién cumple la condición

803
00:31:55,400 --> 00:31:56,940
sobre qué concepto es

804
00:31:56,940 --> 00:31:57,799
¿Sobre qué cosa es?

805
00:31:58,000 --> 00:31:59,359
En este caso, sobre números.

806
00:31:59,880 --> 00:32:03,539
Yo tengo que ir sobre el 1, luego sobre el 2, luego sobre el 3, luego sobre el 4.

807
00:32:04,359 --> 00:32:12,559
Vale, pues entonces, alguna variable tendré que tener para que guarde esos elementos por los que yo voy barriendo.

808
00:32:13,119 --> 00:32:21,960
Si yo tuviera que contar cuántos alumnos tienen gafas, pues tendría que tener una variable para el alumno.

809
00:32:22,599 --> 00:32:25,839
Y ahora ya, en esa variable irían entrando los alumnos.

810
00:32:25,839 --> 00:32:27,680
venga tú, entra, entra, entra, a ti te cuento

811
00:32:27,680 --> 00:32:28,839
a ti no, a ti te cuento, a ti no

812
00:32:28,839 --> 00:32:31,680
en este caso no son sobre alumnos

813
00:32:31,680 --> 00:32:33,220
sobre lo que cuento, sino sobre números

814
00:32:33,220 --> 00:32:35,019
pues tendré que tener una variable

815
00:32:35,019 --> 00:32:36,859
en la que voy metiendo los números

816
00:32:36,859 --> 00:32:38,920
por los que voy pasando

817
00:32:38,920 --> 00:32:41,859
vale, pues entonces

818
00:32:41,859 --> 00:32:43,599
aquí me voy a declarar una variable

819
00:32:43,599 --> 00:32:47,039
como son números enteros

820
00:32:47,039 --> 00:32:49,200
pues por ejemplo, num

821
00:32:49,200 --> 00:32:52,079
y ahora, esta variable

822
00:32:52,079 --> 00:32:54,099
tiene que ir recibiendo

823
00:32:54,099 --> 00:32:55,500
tiene que ir recibiendo

824
00:32:55,500 --> 00:32:58,980
Todos los elementos sobre los que yo estoy haciendo el barrido

825
00:32:58,980 --> 00:33:00,279
¿Vale?

826
00:33:00,319 --> 00:33:01,519
Como si tuviera mi variable

827
00:33:01,519 --> 00:33:04,640
Para contar alumnos, pues primero recibe a Andrea

828
00:33:04,640 --> 00:33:05,559
Luego así, luego no sé qué

829
00:33:05,559 --> 00:33:07,180
¿Vale? Para irlos contando

830
00:33:07,180 --> 00:33:09,259
Pues este tiene que ir recibiendo esta variable

831
00:33:09,259 --> 00:33:10,980
Todos los elementos sobre los que voy barriendo

832
00:33:10,980 --> 00:33:13,039
¿Vale? Y ahora pienso

833
00:33:13,039 --> 00:33:15,259
Pues, ¿por cuáles tengo que

834
00:33:15,259 --> 00:33:17,440
Barrer? ¿Cuáles son? Pues entre uno

835
00:33:17,440 --> 00:33:18,960
Y el que te han dado

836
00:33:18,960 --> 00:33:21,420
¿Vale? Pues venga, voy a empezar con el primero

837
00:33:21,420 --> 00:33:22,200
Ups

838
00:33:22,200 --> 00:33:24,859
Pues entonces la inicializo a uno

839
00:33:24,859 --> 00:33:26,440
vale

840
00:33:26,440 --> 00:33:28,720
y ahora yo ya

841
00:33:28,720 --> 00:33:30,619
lo siguiente que me queda es

842
00:33:30,619 --> 00:33:32,660
este cumple la condición

843
00:33:32,660 --> 00:33:34,299
de ser par

844
00:33:34,299 --> 00:33:38,880
pues lo cuento

845
00:33:38,880 --> 00:33:41,299
y me voy al siguiente

846
00:33:41,299 --> 00:33:42,759
para seguir haciendo el barrido

847
00:33:42,759 --> 00:33:44,420
vale, me voy al siguiente

848
00:33:44,420 --> 00:33:46,240
vale

849
00:33:46,240 --> 00:33:50,099
entonces ya he avanzado muchísimo

850
00:33:50,099 --> 00:33:51,859
primero he identificado

851
00:33:51,859 --> 00:33:52,619
que tengo que contar

852
00:33:52,619 --> 00:33:55,720
con lo cual tengo ahí mi estructura de contador

853
00:33:55,720 --> 00:33:57,279
empieza valiendo 0

854
00:33:57,279 --> 00:33:59,220
y se irá incrementando, ahora

855
00:33:59,220 --> 00:34:01,259
tengo que pensar, ¿qué tipo

856
00:34:01,259 --> 00:34:03,380
de elemento es sobre el que yo estoy

857
00:34:03,380 --> 00:34:05,220
navegando para contar? ¿qué tipo de

858
00:34:05,220 --> 00:34:06,319
elemento? son números

859
00:34:06,319 --> 00:34:09,199
pues una variable tendrá que

860
00:34:09,199 --> 00:34:11,079
tener esos elementos

861
00:34:11,079 --> 00:34:13,179
secuencialmente, primero uno, luego otro

862
00:34:13,179 --> 00:34:15,300
luego otro que voy contando, pues es esta

863
00:34:15,300 --> 00:34:17,519
vale, ahora

864
00:34:17,519 --> 00:34:21,159
¿de dónde se nutre esa variable

865
00:34:21,159 --> 00:34:23,199
para ir recibiendo todo con lo que yo voy

866
00:34:23,199 --> 00:34:25,179
contando? pues entre uno y el que

867
00:34:25,179 --> 00:34:27,019
me han dado? Bueno, pues

868
00:34:27,019 --> 00:34:27,940
empiezo por 1

869
00:34:27,940 --> 00:34:30,360
y voy incrementándolo.

870
00:34:31,099 --> 00:34:31,539
¿Vale?

871
00:34:32,800 --> 00:34:35,380
Y ahora ya sí que hago la cuenta. ¿La cuenta cuál va a ser?

872
00:34:35,599 --> 00:34:37,059
Esto. Y ya sólo

873
00:34:37,059 --> 00:34:39,199
me falta cuándo termino de contar.

874
00:34:39,679 --> 00:34:40,639
¿Cuál sería la condición?

875
00:34:40,820 --> 00:34:42,679
Cuando el 1 haya llegado al número que te han dado.

876
00:34:43,059 --> 00:34:45,139
Claro, me han dicho, cuenta solamente

877
00:34:45,139 --> 00:34:46,539
entre los extremos 1

878
00:34:46,539 --> 00:34:47,760
y el que te han dado.

879
00:34:48,760 --> 00:34:50,480
Pues entonces la condición será, mientras

880
00:34:50,480 --> 00:34:51,960
este numerito,

881
00:34:52,739 --> 00:34:54,480
que es sobre el que yo estoy

882
00:34:54,480 --> 00:34:56,820
haciendo el barrido, sea menor o igual

883
00:34:56,820 --> 00:34:57,539
que el que me han dado

884
00:34:57,539 --> 00:35:06,739
vale, bueno, esto

885
00:35:06,739 --> 00:35:08,860
pues claro, uno

886
00:35:08,860 --> 00:35:10,920
en un momento dado, pues lo

887
00:35:10,920 --> 00:35:12,699
lo puede ver claro

888
00:35:12,699 --> 00:35:14,079
lo puede hacer del tirón y ya está

889
00:35:14,079 --> 00:35:16,480
no hay por qué desglosarlo en pasos

890
00:35:16,480 --> 00:35:18,780
pero de alguna manera el proceso mental

891
00:35:18,780 --> 00:35:20,320
al que responde

892
00:35:20,320 --> 00:35:21,579
es a este que os digo

893
00:35:21,579 --> 00:35:24,559
entonces ese proceso mental no lo perdéis de vista

894
00:35:24,559 --> 00:35:26,440
porque es necesario en muchos contextos

895
00:35:26,440 --> 00:35:28,360
más complicados, entonces cuando hay

896
00:35:28,360 --> 00:35:30,360
una cuenta, hay un contador

897
00:35:30,360 --> 00:35:32,360
eso está claro, un contador que se va incrementando

898
00:35:32,360 --> 00:35:32,840
en un bucle

899
00:35:32,840 --> 00:35:35,320
y hay una variable

900
00:35:35,320 --> 00:35:37,780
que es la que va recibiendo

901
00:35:37,780 --> 00:35:40,280
todo lo que yo me voy fijando

902
00:35:40,280 --> 00:35:40,900
para contar

903
00:35:40,900 --> 00:35:43,300
que se corresponderá al tipo de dato

904
00:35:43,300 --> 00:35:46,219
de los elementos

905
00:35:46,219 --> 00:35:47,039
que yo estoy contando

906
00:35:47,039 --> 00:35:50,039
entonces una vez que ya lo tengo

907
00:35:50,039 --> 00:35:51,800
pues ya habrá una condición

908
00:35:51,800 --> 00:35:54,239
que indica si toca contarlo o no toca contarlo

909
00:35:54,239 --> 00:35:54,860
una condición

910
00:35:54,860 --> 00:35:57,219
y luego ya tendré que centrarme

911
00:35:57,219 --> 00:35:59,940
primero en que esa variable

912
00:35:59,940 --> 00:36:02,000
vaya cambiando, que esa variable

913
00:36:02,000 --> 00:36:03,980
vaya pasando al siguiente, vaya pasando al siguiente

914
00:36:03,980 --> 00:36:05,880
y luego ya en la

915
00:36:05,880 --> 00:36:07,820
condición en la que paro de contar, no puedo

916
00:36:07,820 --> 00:36:09,599
estar contando hasta el infinito, en algún momento

917
00:36:09,599 --> 00:36:11,400
yo cuento los alumnos

918
00:36:11,400 --> 00:36:13,739
que tienen gafas de aquí, no del

919
00:36:13,739 --> 00:36:15,300
universo entero

920
00:36:15,300 --> 00:36:19,380
¿vale?

921
00:36:21,920 --> 00:36:23,440
¿vale? pues entonces

922
00:36:23,440 --> 00:36:26,760
en el aula

923
00:36:26,760 --> 00:36:28,619
virtual

924
00:36:28,619 --> 00:36:32,300
Hay un montón de ejercicios de esto

925
00:36:32,300 --> 00:36:34,840
Desde muy facilitos hasta más complicados

926
00:36:34,840 --> 00:36:35,579
Vamos a empezar

927
00:36:35,579 --> 00:36:39,000
O vais a empezar ahora con los facilitos del principio

928
00:36:39,000 --> 00:36:40,320
Que alguno creo que es este

929
00:36:40,320 --> 00:36:41,820
O bueno, no es exactamente este

930
00:36:41,820 --> 00:36:42,820
Pero es muy parecido

931
00:36:42,820 --> 00:36:46,780
Yo tenía un teléfono

932
00:36:46,780 --> 00:36:51,679
¿Yo no tenía un teléfono en algún lado?

933
00:36:53,380 --> 00:36:54,019
Uh, sí

934
00:36:54,019 --> 00:36:56,820
Y lo sigo teniendo

935
00:36:56,820 --> 00:36:59,969
Bueno

936
00:36:59,969 --> 00:37:10,239
si no me conecto

937
00:37:10,239 --> 00:37:12,519
a la 55 de John y ya está

938
00:37:12,519 --> 00:37:15,739
ah, no sé

939
00:37:15,739 --> 00:37:17,500
quién es la 55 de John

940
00:37:17,500 --> 00:37:18,599
será él, ¿no?

941
00:37:19,300 --> 00:37:21,400
en un momento me dice la password y listo

942
00:37:21,400 --> 00:37:22,139
o sea, la hackeo

943
00:37:22,139 --> 00:37:25,800
casi, casi

944
00:37:25,800 --> 00:37:35,070
¿y por qué pones

945
00:37:35,070 --> 00:37:37,530
más más?

946
00:37:38,730 --> 00:37:40,030
porque esta variable

947
00:37:40,030 --> 00:37:42,090
los números que yo estoy contando

948
00:37:42,090 --> 00:37:43,550
parten desde el 1

949
00:37:43,550 --> 00:37:45,510
pero tiene que pasar por todos

950
00:37:45,510 --> 00:37:47,429
el 1, y luego el 2, y luego el 3, y luego el 4

951
00:37:47,429 --> 00:37:49,269
yo tengo que hacer esa comprobación con todos

952
00:37:49,269 --> 00:37:50,809
desde el 1 hasta n

953
00:37:50,809 --> 00:37:52,829
entonces para pasar por todos

954
00:37:52,829 --> 00:37:54,269
los tengo que ir incrementando

955
00:37:54,269 --> 00:37:59,730
a ver

956
00:38:30,349 --> 00:38:54,869
¿Qué pasa? ¿Tienes frío?

957
00:39:00,349 --> 00:39:01,349
Gracias.

958
00:39:30,349 --> 00:39:33,250
Venga, pues este listado de aquí.

959
00:39:43,809 --> 00:39:47,670
Bueno, vamos a aprovechar y parar aquí en este momento.

960
00:39:49,070 --> 00:39:50,650
Y luego ya reenganchamos.