1
00:00:00,000 --> 00:00:10,640
No, por Dios, faltaría más. Vale, pues esto de las excepciones había venido a cuento de esto de aquí.

2
00:00:13,320 --> 00:00:23,820
Esta sentencia, como muchísimas otras, pues puede ocurrir que cuando se ponga a ejecutar su tarea, se pone a ejecutarla,

3
00:00:23,820 --> 00:00:25,879
pin, pin, pin, de repente

4
00:00:25,879 --> 00:00:27,899
haga una validación, vea que

5
00:00:27,899 --> 00:00:29,199
algo no

6
00:00:29,199 --> 00:00:31,760
funciona como debe, con lo cual

7
00:00:31,760 --> 00:00:33,240
no tiene sentido que siga

8
00:00:33,240 --> 00:00:35,939
entonces eso mediante código

9
00:00:35,939 --> 00:00:37,799
con sus if, con sus no sé qué, se ve que

10
00:00:37,799 --> 00:00:39,119
ahí no tiene sentido seguir

11
00:00:39,119 --> 00:00:42,079
y entonces en lugar de seguir ese método

12
00:00:42,079 --> 00:00:43,859
hasta el final, lo que

13
00:00:43,859 --> 00:00:45,640
hace es, crea un objeto excepción

14
00:00:45,640 --> 00:00:47,880
y pum, lo lanza

15
00:00:47,880 --> 00:00:49,880
al punto del

16
00:00:49,880 --> 00:00:51,159
código en el que se llamó

17
00:00:51,159 --> 00:00:53,320
en el que fue llamado este método

18
00:00:53,320 --> 00:00:54,880
Ahí lanza ese objeto excepción

19
00:00:54,880 --> 00:00:57,320
¿Ese objeto de qué clase pertenece?

20
00:00:57,820 --> 00:00:59,479
Pues a una clase excepción

21
00:00:59,479 --> 00:01:01,060
Que hay tropecientas mil

22
00:01:01,060 --> 00:01:02,939
Input, mismatch, excepción es una

23
00:01:02,939 --> 00:01:05,000
Render, no excepción, no excepción, la que sea

24
00:01:05,000 --> 00:01:06,659
Construye un objeto

25
00:01:06,659 --> 00:01:09,099
Que guarda esa información y pum

26
00:01:09,099 --> 00:01:11,140
Devuelve

27
00:01:11,140 --> 00:01:12,319
El control

28
00:01:12,319 --> 00:01:14,319
A esta línea de código

29
00:01:14,319 --> 00:01:17,579
Y además de devolver el control a esta línea de código

30
00:01:17,579 --> 00:01:19,340
Entrega un objeto

31
00:01:19,340 --> 00:01:21,140
Excepción con la información dentro

32
00:01:21,140 --> 00:01:22,560
Sobre qué ha pasado, etc.

33
00:01:22,560 --> 00:01:26,560
entonces cuando el control vuelve a esta línea de código

34
00:01:26,560 --> 00:01:28,599
hay dos posibilidades

35
00:01:28,599 --> 00:01:30,359
que este try-catch no exista

36
00:01:30,359 --> 00:01:31,959
que era lo que hemos hecho nosotros hasta ahora

37
00:01:31,959 --> 00:01:33,879
entonces si este try-catch no existe

38
00:01:33,879 --> 00:01:35,959
que es lo que hemos hecho nosotros hasta ahora

39
00:01:35,959 --> 00:01:38,319
la máquina virtual cuando se encuentra

40
00:01:38,319 --> 00:01:39,760
ese objeto de excepción dice vale

41
00:01:39,760 --> 00:01:42,140
te voy a mostrar lo que hay dentro

42
00:01:42,140 --> 00:01:43,340
por consola

43
00:01:43,340 --> 00:01:46,099
para que tú tengas un detalle de lo que ha pasado

44
00:01:46,099 --> 00:01:48,040
y luego voy a parar la ejecución

45
00:01:48,040 --> 00:01:50,420
para siempre, ya jamás parado el programa

46
00:01:50,420 --> 00:01:51,420
y esto ya nunca sigue

47
00:01:51,420 --> 00:01:54,459
bueno, vale, ya sabemos obviamente

48
00:01:54,459 --> 00:01:56,200
que pega tiene eso, en tiempo de desarrollo

49
00:01:56,200 --> 00:01:58,500
de código, cuando estamos haciendo, pues que el programa

50
00:01:58,500 --> 00:02:00,079
pete y pare, muy bien

51
00:02:00,079 --> 00:02:02,060
ha pasado esto, es que he hecho

52
00:02:02,060 --> 00:02:03,959
esto mal, pues

53
00:02:03,959 --> 00:02:05,780
lo arreglo, lo cambio, lo que sea

54
00:02:05,780 --> 00:02:08,379
pero, cuando ya

55
00:02:08,379 --> 00:02:10,439
hemos entregado la aplicación, no puede ser

56
00:02:10,439 --> 00:02:11,560
que el programa se pare

57
00:02:11,560 --> 00:02:13,400
no puede ser que el programa se pare cuando

58
00:02:13,400 --> 00:02:16,080
en este caso

59
00:02:16,080 --> 00:02:18,199
el usuario mete en lugar de un número

60
00:02:18,199 --> 00:02:20,060
mete una cadena, no puede ser

61
00:02:20,060 --> 00:02:21,180
que el programa se pare

62
00:02:21,180 --> 00:02:24,620
entonces, ¿cuál es el plan B?

63
00:02:25,139 --> 00:02:26,259
el plan B es

64
00:02:26,259 --> 00:02:28,199
la sentencia que puede

65
00:02:28,199 --> 00:02:29,520
provocar

66
00:02:29,520 --> 00:02:32,240
esa situación, se mete en este

67
00:02:32,240 --> 00:02:34,280
bloque, tricats, ya está, eso es lo que vimos

68
00:02:34,280 --> 00:02:35,900
ayer, se mete en este bloque tricats

69
00:02:35,900 --> 00:02:38,219
y entonces ahora ya, esta sentencia

70
00:02:38,219 --> 00:02:39,460
trata de ejecutarse

71
00:02:39,460 --> 00:02:41,979
si se ejecuta de principio a fin

72
00:02:41,979 --> 00:02:44,419
fenomenal, se va a la siguiente

73
00:02:44,419 --> 00:02:46,180
si se ejecuta de principio

74
00:02:46,180 --> 00:02:48,300
a fin, fenomenal, ya está

75
00:02:48,300 --> 00:02:50,319
hemos sacado este bloque y ya seguimos

76
00:02:50,319 --> 00:02:52,400
por abajo los catch como si no

77
00:02:52,400 --> 00:02:54,419
existieran, seguiríamos por aquí

78
00:02:54,419 --> 00:02:55,960
los catch como si no existieran

79
00:02:55,960 --> 00:02:57,659
vale, pero

80
00:02:57,659 --> 00:03:00,460
¿qué es lo otro que puede ocurrir?

81
00:03:00,699 --> 00:03:02,060
que esta sentencia

82
00:03:02,060 --> 00:03:04,319
no se ejecute de principio a fin

83
00:03:04,319 --> 00:03:06,659
porque en la mitad por código

84
00:03:06,659 --> 00:03:08,340
por código se detecta que algo

85
00:03:08,340 --> 00:03:10,340
no va bien, el programa

86
00:03:10,340 --> 00:03:11,460
decide pararlo

87
00:03:11,460 --> 00:03:12,919
y

88
00:03:12,919 --> 00:03:16,159
lanzar ese objeto, vale

89
00:03:16,159 --> 00:03:18,740
pues entonces si tenemos un try catch

90
00:03:18,740 --> 00:03:22,000
Ese objeto que ha llegado a este punto

91
00:03:22,000 --> 00:03:23,659
Ese objeto que ha llegado a este punto

92
00:03:23,659 --> 00:03:26,259
Empieza a compararse con los cats

93
00:03:26,259 --> 00:03:28,319
Que hay abajo, en nuestro caso hay dos

94
00:03:28,319 --> 00:03:30,699
Dice, a ver, me acaba de llegar aquí una excepción

95
00:03:30,699 --> 00:03:32,979
Esa excepción de qué clase es

96
00:03:32,979 --> 00:03:34,300
Es de la clase

97
00:03:34,300 --> 00:03:35,819
Pepito exception, vale

98
00:03:35,819 --> 00:03:37,020
Voy a ver si hay algún cat

99
00:03:37,020 --> 00:03:39,340
Que capture pepito exception

100
00:03:39,340 --> 00:03:41,719
Pepito exception, no, paso del cat

101
00:03:41,719 --> 00:03:44,599
Pepito exception, no, paso del cat

102
00:03:44,599 --> 00:03:45,379
Con lo cual

103
00:03:45,379 --> 00:03:47,979
No hay ningún cat que capture

104
00:03:47,979 --> 00:03:49,960
la pepito exception que lanzó este

105
00:03:49,960 --> 00:03:52,340
luego este try-catch no vale para nada

106
00:03:52,340 --> 00:03:54,319
se para la aplicación

107
00:03:54,319 --> 00:03:56,500
igualmente, se para igualmente

108
00:03:56,500 --> 00:03:58,120
vale, pero

109
00:03:58,120 --> 00:04:00,199
si el

110
00:04:00,199 --> 00:04:02,099
objeto excepción que nos ha mandado este

111
00:04:02,099 --> 00:04:04,120
no es pepito exception, sino

112
00:04:04,120 --> 00:04:05,580
input mismatch exception

113
00:04:05,580 --> 00:04:07,659
pues él va a catch por, anda mira

114
00:04:07,659 --> 00:04:10,139
coincide, el objeto

115
00:04:10,139 --> 00:04:11,580
que me ha llegado en este punto

116
00:04:11,580 --> 00:04:14,060
coincide con este, pues entonces

117
00:04:14,060 --> 00:04:16,079
me meto aquí en este bloque y hago

118
00:04:16,079 --> 00:04:17,600
lo que haya en ese bloque

119
00:04:17,600 --> 00:04:19,639
hago lo que hay en ese bloque

120
00:04:19,639 --> 00:04:21,120
que es lo que al programador le dé la gana

121
00:04:21,120 --> 00:04:23,680
avisar, volver a pedir

122
00:04:23,680 --> 00:04:24,959
el dato

123
00:04:24,959 --> 00:04:27,879
en ese caso habría que meter el try-catch en un bucle

124
00:04:27,879 --> 00:04:29,519
claro, para que estuviera todo el rato

125
00:04:29,519 --> 00:04:31,399
intentándolo hasta que el dato fuera

126
00:04:31,399 --> 00:04:33,600
correcto, lo que fuera

127
00:04:33,600 --> 00:04:35,860
y una vez que ha acabado el catch

128
00:04:35,860 --> 00:04:37,699
continuamos

129
00:04:37,699 --> 00:04:39,399
con la línea siguiente

130
00:04:39,399 --> 00:04:41,540
al bloque try-catch, como si nada

131
00:04:41,540 --> 00:04:43,560
hubiera pasado, el programa no se para y todo

132
00:04:43,560 --> 00:04:44,779
sigue ahí estupendamente

133
00:04:44,779 --> 00:04:47,220
como si nada hubiera pasado, ahí seguimos

134
00:04:47,220 --> 00:04:49,459
¿vale? y así es como deberían ser

135
00:04:49,459 --> 00:04:51,779
los programas ya en producción

136
00:04:51,779 --> 00:04:53,839
si algo falla

137
00:04:53,839 --> 00:04:55,420
porque el usuario ha metido mal los datos

138
00:04:55,420 --> 00:04:56,180
por lo que sea

139
00:04:56,180 --> 00:04:58,639
el programa te da una alternativa

140
00:04:58,639 --> 00:05:00,379
sobrevive como puede

141
00:05:00,379 --> 00:05:02,339
en este caso ¿cómo ha sobrevivido?

142
00:05:02,819 --> 00:05:04,300
pues poniendo n igual a 10

143
00:05:04,300 --> 00:05:07,199
y sigue

144
00:05:07,199 --> 00:05:08,860
no se para y ya está

145
00:05:08,860 --> 00:05:09,420
¿vale?

146
00:05:10,879 --> 00:05:13,259
si aquí, si la excepción ha salido aquí

147
00:05:13,259 --> 00:05:15,300
por ejemplo en esta

148
00:05:15,300 --> 00:05:16,079
sentencia

149
00:05:16,079 --> 00:05:18,660
aunque haya

150
00:05:18,660 --> 00:05:20,379
sentencias después

151
00:05:20,379 --> 00:05:22,720
estas ya no se llegan a ejecutar

152
00:05:22,720 --> 00:05:24,040
nunca, vale

153
00:05:24,040 --> 00:05:26,360
me explico

154
00:05:26,360 --> 00:05:28,339
next in ha intentado ejecutarse

155
00:05:28,339 --> 00:05:30,100
y en un momento ha visto que algo no funciona

156
00:05:30,100 --> 00:05:32,379
no le gusta y pum, crea el objeto

157
00:05:32,379 --> 00:05:33,920
excepción y devuelve el control

158
00:05:33,920 --> 00:05:36,379
vale, pues ahí ya

159
00:05:36,379 --> 00:05:38,000
empiezan a comprobarse los catch

160
00:05:38,000 --> 00:05:40,019
estas sentencias como si no existiera

161
00:05:40,019 --> 00:05:42,439
nunca se ejecuta, todo lo que haya

162
00:05:42,439 --> 00:05:44,379
por debajo, dentro del bloque

163
00:05:44,379 --> 00:06:09,180
Todo lo que haya por debajo de la sentencia que provoca la excepción se queda sin ejecutar para siempre jamás. Se ejecutará el catch correspondiente y luego ya se sigue por abajo. Y esto que estaba por debajo se ha quedado sin ejecutar porque se interrumpió el flujo del programa, se interrumpió aquí por la excepción.

164
00:06:09,180 --> 00:06:11,100
Se interrumpió aquí el flujo

165
00:06:11,100 --> 00:06:12,480
Se va el catch y seguimos

166
00:06:12,480 --> 00:06:13,339
¿Vale?

167
00:06:13,980 --> 00:06:15,959
Entonces bueno, nosotros ya usamos

168
00:06:15,959 --> 00:06:17,819
El bloque try catch

169
00:06:17,819 --> 00:06:19,740
Como nos dé la gana

170
00:06:19,740 --> 00:06:21,600
¿Vale?

171
00:06:23,759 --> 00:06:24,699
Entonces para

172
00:06:24,699 --> 00:06:27,399
Antes de seguir

173
00:06:27,399 --> 00:06:28,500
Para que no os aburráis

174
00:06:28,500 --> 00:06:30,579
Por ejemplo, pues ahora ya que conocemos el try catch

175
00:06:30,579 --> 00:06:33,019
Vamos a

176
00:06:33,019 --> 00:06:35,459
Usarlo para hacer la validación

177
00:06:35,459 --> 00:06:36,540
De

178
00:06:36,540 --> 00:06:37,839
Esto de aquí

179
00:06:37,839 --> 00:06:40,500
porque yo aquí en realidad no he hecho una validación

180
00:06:40,500 --> 00:06:41,779
cuando he planteado este ejemplo

181
00:06:41,779 --> 00:06:45,259
he hecho un try-catch para que el programa no pare

182
00:06:45,259 --> 00:06:48,800
pero si lo mete mal el usuario

183
00:06:48,800 --> 00:06:51,000
me mete JJ en lugar de un número

184
00:06:51,000 --> 00:06:53,480
lo fijo a N igual a 10

185
00:06:53,480 --> 00:06:56,980
es decir, en realidad no estoy validando

186
00:06:56,980 --> 00:06:59,439
porque no estoy volviéndolo a pedir hasta que me meta

187
00:06:59,439 --> 00:07:01,920
un número en lugar de una cadena

188
00:07:01,920 --> 00:07:05,620
¿vale? entonces, repito, esa validación

189
00:07:05,620 --> 00:07:07,399
se podría hacer sin un try-catch

190
00:07:07,399 --> 00:07:08,639
como dijimos ayer

191
00:07:08,639 --> 00:07:10,980
tú me lees con ScanNextLine

192
00:07:10,980 --> 00:07:13,180
ScanNextLine jamás va a lanzar excepción

193
00:07:13,180 --> 00:07:15,100
nunca, entonces ahora ya

194
00:07:15,100 --> 00:07:16,879
una vez que has cogido la cadena

195
00:07:16,879 --> 00:07:19,139
vas a ver si

196
00:07:19,139 --> 00:07:21,339
carácter por carácter son un dígito

197
00:07:21,339 --> 00:07:23,379
de la tabla ASCII, te puedes hacer la validación

198
00:07:23,379 --> 00:07:25,300
por código, ¿vale? pero yo

199
00:07:25,300 --> 00:07:27,199
no quiero esa validación, quiero que

200
00:07:27,199 --> 00:07:29,379
hagáis una validación usando

201
00:07:29,379 --> 00:07:30,560
NextInt

202
00:07:30,560 --> 00:07:32,800
usando el bloque TryCatch

203
00:07:32,800 --> 00:07:35,379
y combinándolo con un bucle de alguna manera

204
00:07:35,379 --> 00:07:37,300
para asegurarse de que eso se va

205
00:07:37,300 --> 00:07:42,839
va a estar ahí todo el rato, mientras el usuario no meta un número.

206
00:07:43,100 --> 00:07:50,540
Entonces, vamos a, por tanto, sacarlo a un método para que lo hagáis en un método.

207
00:07:50,680 --> 00:07:53,720
Por ejemplo, esto lo podríamos refactorizar a un método.

208
00:07:53,819 --> 00:07:55,420
Vamos a suponer que yo ahora lo que quiero es esto.

209
00:07:57,199 --> 00:08:00,660
n igual, con lo cual esta inicialización ya no la quiero,

210
00:08:02,920 --> 00:08:09,379
n igual leerNúmero, ¿vale?

211
00:08:09,379 --> 00:08:12,879
leer número, me voy a hacer ahora el método leer número auxiliar

212
00:08:12,879 --> 00:08:20,060
aquí abajo, vale, entonces lo que quiero es que este código

213
00:08:20,060 --> 00:08:24,019
que iría en

214
00:08:24,019 --> 00:08:43,120
leer número, me falta

215
00:08:43,120 --> 00:08:57,769
aquí el escáner, esto, aquí ya

216
00:08:57,769 --> 00:09:02,129
no nos pinta nada, era el ejemplo que habíamos puesto

217
00:09:02,129 --> 00:09:05,409
varias excepciones, vale, leer número

218
00:09:05,409 --> 00:09:07,710
return n

219
00:09:07,710 --> 00:09:09,610
vale

220
00:09:09,610 --> 00:09:11,769
y aquí quito n igual a

221
00:09:11,769 --> 00:09:14,169
vale, entonces esta versión

222
00:09:14,169 --> 00:09:16,269
de leer número es una versión

223
00:09:16,269 --> 00:09:17,350
que en realidad no valida

224
00:09:17,350 --> 00:09:19,210
intenta leer el número

225
00:09:19,210 --> 00:09:21,730
que puede hacerlo, fenomenal

226
00:09:21,730 --> 00:09:22,610
me devuelve n

227
00:09:22,610 --> 00:09:26,230
que no ha podido hacerlo porque me ha dado excepción

228
00:09:26,230 --> 00:09:28,570
me devuelve n igual a 10

229
00:09:28,570 --> 00:09:30,029
luego no es una versión

230
00:09:30,029 --> 00:09:31,690
en realidad que se meta en un bucle

231
00:09:31,690 --> 00:09:32,690
y esté validando

232
00:09:32,690 --> 00:09:36,509
Y no termine hasta que no me pueda devolver un número

233
00:09:36,509 --> 00:09:37,769
Vale, pues

234
00:09:37,769 --> 00:09:40,029
Hacedme ahora

235
00:09:40,029 --> 00:09:41,389
Combinando el try-catch

236
00:09:41,389 --> 00:09:42,389
Uy

237
00:09:42,389 --> 00:09:48,149
La versión con validación

238
00:09:48,149 --> 00:09:49,029
De esto

239
00:09:49,029 --> 00:09:51,669
Joder, ¿qué estoy haciendo?

240
00:09:53,190 --> 00:09:53,570
C

241
00:09:53,570 --> 00:09:58,250
Vale

242
00:09:58,250 --> 00:10:01,799
Vamos a llamarla valida

243
00:10:01,799 --> 00:10:03,940
Para que sea más bonita

244
00:10:03,940 --> 00:10:11,440
Pues venga

245
00:10:11,440 --> 00:10:14,919
Completadme ese método

246
00:10:14,919 --> 00:10:16,120
Con try-catch

247
00:10:16,120 --> 00:10:18,100
y next in

248
00:10:18,100 --> 00:10:25,889
no

249
00:10:25,889 --> 00:10:29,450
vale, un bucle que está ahí todo el rato

250
00:10:29,450 --> 00:10:31,230
y hasta que no se

251
00:10:31,230 --> 00:10:33,470
introduzca un número entero, no sale

252
00:10:33,470 --> 00:10:40,940
vale, pues aquí simplemente

253
00:10:40,940 --> 00:10:41,879
tampoco

254
00:10:41,879 --> 00:10:44,840
quedo, no vamos locos

255
00:10:44,840 --> 00:10:46,659
a ver, aquí

256
00:10:46,659 --> 00:10:50,279
hay que hacer un bucle, lógicamente

257
00:10:50,279 --> 00:10:52,200
hay que hacer un bucle porque hay que estar todo el rato

258
00:10:52,200 --> 00:10:53,620
leyendo

259
00:10:53,620 --> 00:10:56,360
mientras no se cumpla la condición

260
00:10:56,360 --> 00:10:57,639
de número válido, ¿no?

261
00:10:57,639 --> 00:11:00,240
entonces a ver si lo hacemos así directamente

262
00:11:00,240 --> 00:11:01,940
mientras

263
00:11:01,940 --> 00:11:02,860
no válido

264
00:11:02,860 --> 00:11:05,840
si vamos tecleando así

265
00:11:05,840 --> 00:11:07,419
luego ya podemos depurar si queremos

266
00:11:07,419 --> 00:11:15,960
¿vale? o sea esto es un bucle

267
00:11:15,960 --> 00:11:17,779
un bucle que va a estar ahí

268
00:11:17,779 --> 00:11:18,980
pum pum pum pum pum pum

269
00:11:18,980 --> 00:11:21,600
mientras se dé esta condición

270
00:11:21,600 --> 00:11:22,399
que es no válido

271
00:11:22,399 --> 00:11:25,580
¿vale? entonces entramos inicialmente

272
00:11:25,580 --> 00:11:27,240
¿y qué es lo que hacemos? pues que lo que hacemos

273
00:11:27,240 --> 00:11:28,059
es leer el numerito

274
00:11:28,059 --> 00:11:31,460
n igual a scan

275
00:11:31,460 --> 00:11:33,139
punto next int

276
00:11:33,139 --> 00:11:36,039
vale, aquí como podemos

277
00:11:36,039 --> 00:11:37,679
validar que sea no válido

278
00:11:37,679 --> 00:11:39,879
pues en el catch es la única opción

279
00:11:39,879 --> 00:11:41,100
porque si no es válido

280
00:11:41,100 --> 00:11:43,899
next in nos avisa lanzándonos una excepción

281
00:11:43,899 --> 00:11:45,919
es como nos avisa next in de que no es

282
00:11:45,919 --> 00:11:46,299
válido

283
00:11:46,299 --> 00:11:49,440
entonces la forma

284
00:11:49,440 --> 00:11:51,519
de que nosotros tenemos de saber

285
00:11:51,519 --> 00:11:53,960
que no ha sido válido es

286
00:11:53,960 --> 00:11:55,279
porque

287
00:11:55,279 --> 00:11:57,580
estamos entrando en la excepción

288
00:11:57,580 --> 00:11:59,139
entonces

289
00:11:59,139 --> 00:12:01,799
no nos queda más remedio

290
00:12:01,799 --> 00:12:10,940
que capturar esto lógicamente entonces tenemos que capturar esto intenta hacer

291
00:12:10,940 --> 00:12:21,730
esto si no consigues hacerlo porque te sale input miss match exception si no te

292
00:12:21,730 --> 00:12:37,379
sale pues avisa número no válido y no válido seguirá siendo true vale

293
00:12:37,379 --> 00:12:39,620
entonces cuando lo cambiamos a false

294
00:12:39,620 --> 00:12:40,899
para que el bucle salga

295
00:12:40,899 --> 00:12:43,259
después de haberlo leído

296
00:12:43,259 --> 00:12:45,620
si hemos conseguido terminarla

297
00:12:45,620 --> 00:12:47,500
si lo hemos leído de principio a fin

298
00:12:47,500 --> 00:12:48,639
y llegamos a este punto

299
00:12:48,639 --> 00:12:51,580
si llegamos a este punto es porque no nos vamos al catch

300
00:12:51,580 --> 00:12:54,080
no válido

301
00:12:54,080 --> 00:12:54,940
igual a false

302
00:12:54,940 --> 00:12:56,419
y ya está

303
00:12:56,419 --> 00:12:58,899
y ahora cuando hayamos salido ya del while

304
00:12:58,899 --> 00:13:01,240
tenemos la seguridad de que n

305
00:13:01,240 --> 00:13:03,100
es un número válido

306
00:13:03,100 --> 00:13:04,899
porque si no nunca habríamos salido de

307
00:13:04,899 --> 00:13:06,919
vale pues ya está

308
00:13:06,919 --> 00:13:08,259
Por ejemplo

309
00:13:08,259 --> 00:13:10,960
Otra cosa es que luego lo hagáis con un do while

310
00:13:10,960 --> 00:13:13,019
O lo hagáis con

311
00:13:13,019 --> 00:13:14,700
La condición de otra manera

312
00:13:14,700 --> 00:13:16,940
Pero vamos, que la idea es eso

313
00:13:16,940 --> 00:13:19,240
Un bucle que está intentando todo el rato

314
00:13:19,240 --> 00:13:20,659
Intentando todo el rato

315
00:13:20,659 --> 00:13:25,700
Espera que lo llame

316
00:13:25,700 --> 00:13:27,600
Desde aquí

317
00:13:27,600 --> 00:13:29,940
Válido

318
00:13:29,940 --> 00:13:30,600
¿Dónde está?

319
00:13:30,779 --> 00:13:33,419
Voy a llamar a ese método

320
00:13:33,419 --> 00:13:38,149
Se llamaba

321
00:13:38,149 --> 00:13:39,070
Ah, valida número

322
00:13:39,070 --> 00:13:42,610
Vamos a ver dónde está

323
00:13:42,610 --> 00:13:50,419
¿Dónde tengo la llamada valida número?

324
00:13:54,179 --> 00:14:03,240
Ah, está aquí

325
00:14:03,240 --> 00:14:04,679
En candidaturas, estará, ¿no?

326
00:14:04,899 --> 00:14:05,840
Vale, está aquí, sí

327
00:14:05,840 --> 00:14:07,720
Valida

328
00:14:07,720 --> 00:14:13,120
Vale, pues lo llamo aquí en candidaturas

329
00:14:13,120 --> 00:14:14,840
Para leerme un número válido

330
00:14:14,840 --> 00:14:15,519
Valida número

331
00:14:15,519 --> 00:14:16,919
Vamos a...

332
00:14:16,919 --> 00:14:19,259
Y aquí tengo un error en algún sitio

333
00:14:19,259 --> 00:14:25,370
Abajo del todo está, ¿no?

334
00:14:25,529 --> 00:14:26,750
Ah, que tengo dos retunen

335
00:14:26,750 --> 00:14:28,149
Vale

336
00:14:28,149 --> 00:14:31,169
vale, vamos a ver si esto funciona

337
00:14:31,169 --> 00:14:31,970
correctamente

338
00:14:31,970 --> 00:14:41,450
¿cuántos se presentan? entonces si yo aquí

339
00:14:41,450 --> 00:14:43,169
metiera esto

340
00:14:43,169 --> 00:14:47,889
vale, que maravilla

341
00:14:47,889 --> 00:14:49,789
vale, pues vamos a

342
00:14:49,789 --> 00:14:57,480
arreglarlo

343
00:14:57,480 --> 00:15:12,080
no, no, no

344
00:15:12,080 --> 00:15:14,340
el número lo hemos

345
00:15:14,340 --> 00:15:15,840
leído correctamente

346
00:15:15,840 --> 00:15:18,779
Ah, vale, vale, el número lo hemos leído

347
00:15:18,779 --> 00:15:20,740
No, no, no, el número lo hemos leído

348
00:15:20,740 --> 00:15:21,899
Y ahora

349
00:15:21,899 --> 00:15:24,200
No válido se pone a falso

350
00:15:24,200 --> 00:15:26,679
Y ahora como no es válido

351
00:15:26,679 --> 00:15:33,029
Lo ha leído correctamente

352
00:15:33,029 --> 00:15:33,750
Y

353
00:15:33,750 --> 00:15:39,889
Sí, pero no entiendo por qué

354
00:15:39,889 --> 00:15:41,009
No, con el

355
00:15:41,009 --> 00:15:44,779
Yo lo que he intentado ha sido ponerte en el

356
00:15:44,779 --> 00:15:47,000
Que volviese a asignar el n a 0

357
00:15:47,000 --> 00:15:47,860
O a 0

358
00:15:47,860 --> 00:15:50,919
Porque si no se te quedaba con el número que le estaba dando

359
00:15:50,919 --> 00:15:52,600
y buscar trabajo

360
00:15:52,600 --> 00:15:54,960
pero como a ver

361
00:15:54,960 --> 00:15:57,620
si lo que se trata de entender

362
00:15:57,620 --> 00:15:59,039
porque hace eso, no lo entiendo

363
00:15:59,039 --> 00:16:00,399
vamos a ver

364
00:16:00,399 --> 00:16:02,799
no entiendo porque lo hace

365
00:16:02,799 --> 00:16:07,250
vale, pues nada, ya he puesto esto

366
00:16:07,250 --> 00:16:09,330
entonces, esta cláusula se puede añadir

367
00:16:09,330 --> 00:16:11,309
opcionalmente, en el contexto

368
00:16:11,309 --> 00:16:13,090
de lo que estamos haciendo nosotros ahora no pinta mucho

369
00:16:13,090 --> 00:16:15,269
pinta sobre todo cuando has abierto recursos

370
00:16:15,269 --> 00:16:17,269
de ficheros, de sockets

371
00:16:17,269 --> 00:16:19,629
de lo que sea, y tienes que asegurarte

372
00:16:19,629 --> 00:16:21,429
de que tanto si vas por el try

373
00:16:21,429 --> 00:16:22,370
como si ibas por el catch

374
00:16:22,370 --> 00:16:23,450
los recursos quedan cerrados

375
00:16:23,450 --> 00:16:24,730
entonces el finally

376
00:16:24,730 --> 00:16:26,450
¿qué es?

377
00:16:27,370 --> 00:16:28,389
abre un bloque

378
00:16:28,389 --> 00:16:29,950
y lo que hay en este bloque

379
00:16:29,950 --> 00:16:31,289
se ejecuta

380
00:16:31,289 --> 00:16:33,610
tanto si finalizas el try

381
00:16:33,610 --> 00:16:34,789
como si finalizas el catch

382
00:16:34,789 --> 00:16:35,950
¿vale?

383
00:16:36,250 --> 00:16:37,970
si el try es exitoso

384
00:16:37,970 --> 00:16:39,009
y completas todo

385
00:16:39,009 --> 00:16:40,370
se va a finally

386
00:16:40,370 --> 00:16:41,870
hace lo que ponga en finally

387
00:16:41,870 --> 00:16:42,470
y sigue

388
00:16:42,470 --> 00:16:44,549
si el try no es exitoso

389
00:16:44,549 --> 00:16:45,750
porque aparece una excepción

390
00:16:45,750 --> 00:16:46,370
va a catch

391
00:16:46,370 --> 00:16:47,830
completa el catch

392
00:16:47,830 --> 00:16:48,769
y luego a finally

393
00:16:48,769 --> 00:16:49,309
ya está

394
00:16:49,309 --> 00:16:50,370
el finally es un bloque

395
00:16:50,370 --> 00:16:51,230
que se ejecuta

396
00:16:51,230 --> 00:16:54,210
tanto si vas por la rama try como si vas por esta

397
00:16:54,210 --> 00:16:56,029
entonces si hay algo

398
00:16:56,029 --> 00:16:57,509
que queremos hacer en ambos casos

399
00:16:57,509 --> 00:17:00,070
que normalmente es cerrar recursos

400
00:17:00,070 --> 00:17:01,250
que hayamos abierto

401
00:17:01,250 --> 00:17:03,070
para intentar hacer algo

402
00:17:03,070 --> 00:17:05,789
pero como no estamos dando recursos de ningún tipo

403
00:17:05,789 --> 00:17:07,369
ni bases de datos, ni fichero, ni nada

404
00:17:07,369 --> 00:17:09,349
pues la finally en este contexto nuestro

405
00:17:09,349 --> 00:17:10,670
pinta poco

406
00:17:10,670 --> 00:17:13,029
porque si hay algo que queremos hacer

407
00:17:13,029 --> 00:17:15,470
tanto por esta rama

408
00:17:15,470 --> 00:17:17,369
como por esta, pues lo vamos a poner después

409
00:17:17,369 --> 00:17:18,329
y ya está

410
00:17:18,329 --> 00:17:21,130
vale, no necesitamos que sea una cosa

411
00:17:21,130 --> 00:17:21,769
ahí acotada

412
00:17:21,769 --> 00:17:24,309
pero bueno, ahí está el final

413
00:17:24,309 --> 00:17:31,049
bueno, es otro bloque que puedes tú

414
00:17:31,049 --> 00:17:32,730
hacer aquí, asociado al try-catch

415
00:17:32,730 --> 00:17:34,369
y es simplemente un código

416
00:17:34,369 --> 00:17:36,170
que se va a ejecutar

417
00:17:36,170 --> 00:17:39,210
sí o sí, si haya hecho el try

418
00:17:39,210 --> 00:17:40,710
o se haya hecho el catch

419
00:17:40,710 --> 00:17:42,289
se va a hacer sí o sí, entonces

420
00:17:42,289 --> 00:17:45,029
pega en un contexto muy concreto

421
00:17:45,029 --> 00:17:47,150
en el contexto de que lo que tú haces en el try

422
00:17:47,150 --> 00:17:49,130
es acceder a un

423
00:17:49,130 --> 00:17:50,849
fichero, acceder a una base de datos

424
00:17:50,849 --> 00:17:53,009
entonces para hacer eso tienes que abrir un

425
00:17:53,009 --> 00:17:55,269
recurso antes, entonces ese recurso

426
00:17:55,269 --> 00:17:57,130
tú lo quieres dejar, lo tienes

427
00:17:57,130 --> 00:17:59,009
que cerrar luego, lo quieres dejar cerrado

428
00:17:59,009 --> 00:18:00,990
entonces ese cierre de

429
00:18:00,990 --> 00:18:03,130
recursos, se lo voy a poner ahí, lo voy a poner

430
00:18:03,130 --> 00:18:03,990
porque quede

431
00:18:03,990 --> 00:18:05,750
normalmente

432
00:18:05,750 --> 00:18:11,460
para cerrar recursos

433
00:18:11,460 --> 00:18:15,380
de cosas que se hayan abierto

434
00:18:15,380 --> 00:18:17,240
aquí, en el

435
00:18:17,240 --> 00:18:19,380
try-catch, te aseguras de que lo dejas

436
00:18:19,380 --> 00:18:20,079
Ahí cerradito

437
00:18:20,079 --> 00:18:22,960
¿Vale? Pero vamos

438
00:18:22,960 --> 00:18:25,500
Que con el try con recursos

439
00:18:25,500 --> 00:18:26,920
Que es otra variante del try

440
00:18:26,920 --> 00:18:29,539
Que eso tiene más interés verlo con bases de datos

441
00:18:29,539 --> 00:18:31,220
Ni siquiera hace falta

442
00:18:31,220 --> 00:18:33,019
Al final, ni siquiera haría falta

443
00:18:33,019 --> 00:18:35,059
Pero bueno, que sepáis para lo que vale

444
00:18:35,059 --> 00:18:36,740
Por si la veis por ahí

445
00:18:36,740 --> 00:18:38,180
¿Vale? Ya está

446
00:18:38,180 --> 00:18:42,640
Bueno, pues entonces, la otra cosa

447
00:18:42,640 --> 00:18:44,599
Que tenéis que saber de excepciones

448
00:18:44,599 --> 00:18:45,420
La otra cosa

449
00:18:45,420 --> 00:18:48,200
¿Vale? Pues que ha sido una excepción

450
00:18:48,200 --> 00:18:50,099
Una excepción ha sido

451
00:18:50,099 --> 00:18:52,279
una forma de avisarnos de algo

452
00:18:52,279 --> 00:18:53,980
eso ha sido una excepción

453
00:18:53,980 --> 00:18:55,980
el next in

454
00:18:55,980 --> 00:18:57,559
este de aquí

455
00:18:57,559 --> 00:18:59,400
nos ha avisado

456
00:18:59,400 --> 00:19:01,539
¿vale? el next in

457
00:19:01,539 --> 00:19:04,220
nos ha avisado de que algo raro

458
00:19:04,220 --> 00:19:05,799
ha pasado, eso es una excepción

459
00:19:05,799 --> 00:19:07,539
un aviso de que algo raro ha pasado

460
00:19:07,539 --> 00:19:09,599
y luego tú ese aviso

461
00:19:09,599 --> 00:19:11,660
decides qué hacer con él

462
00:19:11,660 --> 00:19:14,039
lo ignoras, con lo cual

463
00:19:14,039 --> 00:19:16,039
el programa se va a parar como eso llegue

464
00:19:16,039 --> 00:19:18,299
o lo capturas con el try catch

465
00:19:18,299 --> 00:19:19,940
¿vale? pero es un aviso

466
00:19:19,940 --> 00:19:22,440
Eso es lo que es una excepción, un aviso de que algo raro ha pasado

467
00:19:22,440 --> 00:19:24,380
Vale, pues igual que ya

468
00:19:24,380 --> 00:19:26,160
Hay tropecientos mil

469
00:19:26,160 --> 00:19:28,359
Posibles avisos programados en Java

470
00:19:28,359 --> 00:19:30,440
Si uno se pone a abrir aquí

471
00:19:30,440 --> 00:19:32,279
De la JRE

472
00:19:32,279 --> 00:19:34,119
Que tiene todas las clases

473
00:19:34,119 --> 00:19:35,000
Que nosotros usamos

474
00:19:35,000 --> 00:19:38,319
Pues aquí, vale, si se pone aquí a abrir

475
00:19:38,319 --> 00:19:40,180
Pues es que aquí se va a encontrar

476
00:19:40,180 --> 00:19:42,599
Con un montón de clases excepción por todas partes

477
00:19:42,599 --> 00:19:44,339
Vale

478
00:19:44,339 --> 00:19:46,539
Vamos a preguntarle

479
00:19:46,539 --> 00:19:48,359
A nuestro amigo, a ver si nos dice

480
00:19:48,359 --> 00:19:50,559
¿Cuántas clases excepción hay en la JRE?

481
00:19:51,380 --> 00:19:53,140
Sí, sí, o cuál quieres tú

482
00:19:53,140 --> 00:19:54,299
Si yo le pregunto a quien quieras

483
00:19:54,299 --> 00:19:56,960
¿Pero por qué os cae mejor este?

484
00:19:57,400 --> 00:19:59,019
Si este es el que manipuló a uno

485
00:19:59,019 --> 00:20:00,180
Y le hizo tirarse por la ventana

486
00:20:00,180 --> 00:20:03,799
¿Por qué os cae también este?

487
00:20:04,519 --> 00:20:04,960
Vale

488
00:20:04,960 --> 00:20:08,359
¿Pero cuál es el enlace de Gemini, el verdadero?

489
00:20:08,500 --> 00:20:09,259
Este, ¿no? Vale

490
00:20:09,259 --> 00:20:11,740
Vale

491
00:20:11,740 --> 00:20:17,190
Clases excepción

492
00:20:17,190 --> 00:20:18,849
Hay

493
00:20:18,849 --> 00:20:20,609
aproximadamente

494
00:20:20,609 --> 00:20:23,089
en la

495
00:20:23,089 --> 00:20:25,069
JDK

496
00:20:25,069 --> 00:20:26,970
estándar, es decir

497
00:20:26,970 --> 00:20:29,069
en las clases que usamos nosotros

498
00:20:29,069 --> 00:20:30,470
para programar

499
00:20:30,470 --> 00:20:32,670
Scanner, System.out, todas esas

500
00:20:32,670 --> 00:20:35,109
pues ¿cuántas de ellas son clases

501
00:20:35,109 --> 00:20:36,950
de excepción? Aproximadamente

502
00:20:36,950 --> 00:20:38,950
¿si tarda mucho?

503
00:20:42,660 --> 00:20:44,160
Ah bueno, que pocas

504
00:20:44,160 --> 00:20:45,819
yo creía que había más

505
00:20:45,819 --> 00:20:48,819
entre 400 y 600

506
00:20:48,819 --> 00:20:51,799
En versiones de JDK 21-25

507
00:20:51,799 --> 00:20:52,980
Porque claro, se han ido sacando

508
00:20:52,980 --> 00:20:54,339
Porque ya pesaba demasiado

509
00:20:54,339 --> 00:20:55,799
¿Vale?

510
00:21:00,009 --> 00:21:02,750
Vale, pues no hay tantas

511
00:21:02,750 --> 00:21:03,990
Yo creía que había más

512
00:21:03,990 --> 00:21:06,829
Vale, no, no queremos esto

513
00:21:06,829 --> 00:21:10,920
¿Y clases en total?

514
00:21:13,970 --> 00:21:16,769
¿De cuántas clases disponemos en la JDK para usarlas?

515
00:21:16,789 --> 00:21:17,730
Porque estamos usando cuatro

516
00:21:17,730 --> 00:21:20,960
Bueno, ahora más

517
00:21:20,960 --> 00:21:22,819
Ahora como usamos ArrayList, LinkedList

518
00:21:22,819 --> 00:21:24,019
Todo eso son clases, claro

519
00:21:24,019 --> 00:21:26,779
Es mucho más impresionante

520
00:21:26,779 --> 00:21:27,720
Es que no me pareció alto

521
00:21:27,720 --> 00:21:29,180
¿Ves? Es que intuye mal

522
00:21:29,180 --> 00:21:31,519
He dicho de hecho que me parecía muy bajo

523
00:21:31,519 --> 00:21:33,480
Bueno, no son tantas

524
00:21:33,480 --> 00:21:35,160
De 4.500 a 5.000

525
00:21:35,160 --> 00:21:39,180
A ver, sin incluir implementaciones

526
00:21:39,180 --> 00:21:40,700
Ni clases internas

527
00:21:40,700 --> 00:21:42,519
Que eso ya lo veremos con interfaces gráficas

528
00:21:42,519 --> 00:21:44,980
Si incluimos implementaciones

529
00:21:44,980 --> 00:21:47,079
De interfaces

530
00:21:47,079 --> 00:21:49,619
Y clases internas

531
00:21:49,619 --> 00:21:50,259
20.000

532
00:21:50,259 --> 00:21:56,049
Pues 20.000 cosas tenemos aquí

533
00:21:56,049 --> 00:21:57,829
Para usar

534
00:21:57,829 --> 00:22:00,630
Y eso sin ningún framework

535
00:22:00,630 --> 00:22:02,529
Cualquier aplicación mínima

536
00:22:02,529 --> 00:22:04,049
Necesita un framework

537
00:22:04,049 --> 00:22:05,670
Un framework es a su vez

538
00:22:05,670 --> 00:22:07,150
Un montón de hard con cosas

539
00:22:07,150 --> 00:22:09,289
Para JavaFX

540
00:22:09,289 --> 00:22:12,130
Para Spring, para todo

541
00:22:12,130 --> 00:22:14,329
Un framework son otras cuantas miles

542
00:22:14,329 --> 00:22:15,109
De clases

543
00:22:15,109 --> 00:22:16,529
Más las que haga uno

544
00:22:16,529 --> 00:22:18,710
Conclusión, una aplicación Java

545
00:22:18,710 --> 00:22:21,390
En realidad estará usando

546
00:22:21,390 --> 00:22:23,630
Cientos de clases

547
00:22:23,630 --> 00:22:24,730
Normalmente

548
00:22:24,730 --> 00:22:27,069
pero claro, solo se distribuyen

549
00:22:27,069 --> 00:22:28,829
las que has hecho tú, porque las otras

550
00:22:28,829 --> 00:22:30,029
las lleva la máquina virtual

551
00:22:30,029 --> 00:22:32,170
se distribuyen las que has hecho tú

552
00:22:32,170 --> 00:22:34,170
y los frameworks de los que tires

553
00:22:34,170 --> 00:22:36,869
ni siquiera, porque ahora

554
00:22:36,869 --> 00:22:38,829
con Mabel, que lo haremos

555
00:22:38,829 --> 00:22:41,029
en JavaFX también, para que lo veáis

556
00:22:41,029 --> 00:22:43,309
tu aplicación se sincroniza

557
00:22:43,309 --> 00:22:44,950
con el repositorio, no tienes que

558
00:22:44,950 --> 00:22:46,329
cargar con lo hard todo el rato

559
00:22:46,329 --> 00:22:48,950
porque si no, las aplicaciones

560
00:22:49,470 --> 00:22:50,450
pesarían un montón

561
00:22:50,450 --> 00:22:52,569
cualquier aplicación pesaría mucho

562
00:22:52,569 --> 00:22:55,109
Tus propias clases si las tiene que tener

563
00:22:55,109 --> 00:22:57,410
Pero los hard de los frameworks

564
00:22:57,410 --> 00:22:58,390
Que tú quieres usar

565
00:22:58,390 --> 00:23:01,029
Si los quieres meter ya eso iría engordando

566
00:23:01,029 --> 00:23:02,529
Entonces está en un repositorio

567
00:23:02,529 --> 00:23:04,750
Y tú pones el enlace a ese repositorio

568
00:23:04,750 --> 00:23:07,029
Y cuando la aplicación arranca

569
00:23:07,029 --> 00:23:08,569
Las descarga

570
00:23:08,569 --> 00:23:10,849
Y las tiene local, eso sí que sí

571
00:23:10,849 --> 00:23:13,009
Las tiene que tener en almacenamiento local

572
00:23:13,009 --> 00:23:14,730
Cuando se, pero bueno

573
00:23:14,730 --> 00:23:15,829
Eso ya lo veremos, vale

574
00:23:15,829 --> 00:23:18,210
Bueno, muy bonito, ¿no?

575
00:23:18,210 --> 00:23:20,569
Entonces, esto venía a cuento de que

576
00:23:20,569 --> 00:23:21,910
Las excepciones son

577
00:23:21,910 --> 00:23:23,869
avisos, ¿vale?

578
00:23:26,150 --> 00:23:27,630
Avisos ya establecidos.

579
00:23:27,950 --> 00:23:29,609
Hay los que nos ha dicho este,

580
00:23:30,009 --> 00:23:32,069
entre 300 y 500 o algo así nos ha dicho.

581
00:23:32,890 --> 00:23:34,930
Pero aún así puede ser que nosotros

582
00:23:34,930 --> 00:23:36,390
queramos avisar de cosas

583
00:23:36,390 --> 00:23:38,609
que ahí no están contempladas.

584
00:23:39,730 --> 00:23:42,309
Por ejemplo, para no engorronar esta,

585
00:23:42,789 --> 00:23:43,829
¿o la engorronamos?

586
00:23:47,619 --> 00:23:49,019
Venga, vamos a engorronarla

587
00:23:49,019 --> 00:23:50,420
y así ya la dejamos completa.

588
00:23:51,019 --> 00:23:52,500
Esta aplicación de los votos.

589
00:23:52,500 --> 00:23:55,180
Nosotros aquí hemos validado

590
00:23:55,180 --> 00:23:57,259
Venga, vamos a

591
00:23:57,259 --> 00:23:58,640
En lugar de engorronarla vamos a hacer

592
00:23:58,640 --> 00:24:00,079
Votaciones B

593
00:24:00,079 --> 00:24:02,599
Me hago aquí un copia y pega

594
00:24:02,599 --> 00:24:07,079
Votaciones

595
00:24:07,079 --> 00:24:07,960
Versión 2

596
00:24:07,960 --> 00:24:23,000
Votaciones 2

597
00:24:23,000 --> 00:24:23,660
Venga

598
00:24:23,660 --> 00:24:25,240
Para no poner

599
00:24:25,240 --> 00:24:30,920
Ala, pues estas votaciones 2

600
00:24:30,920 --> 00:24:39,339
Venga, vamos a situarnos

601
00:24:39,339 --> 00:24:41,819
A ver, por ejemplo, este programa

602
00:24:41,819 --> 00:24:42,859
Nuestro que hacía

603
00:24:42,859 --> 00:24:48,500
Pues establecía las candidaturas con este método

604
00:24:48,500 --> 00:24:52,339
Para eso, para establecer las candidaturas

605
00:24:52,339 --> 00:24:54,940
Pedía primero cuántos se iban a presentar

606
00:24:54,940 --> 00:24:57,039
Haciendo un método que lo validaba

607
00:24:57,039 --> 00:24:59,680
Y luego ya me hacía los candidatos

608
00:24:59,680 --> 00:25:02,700
Todo eso lo hacía el método candidaturas

609
00:25:02,700 --> 00:25:06,259
Vale, y luego ahora ya empezaba nuestro recuento

610
00:25:06,259 --> 00:25:08,660
Que se iba guardando en un map

611
00:25:08,660 --> 00:25:11,400
Y ahora, ¿qué hacía esto?

612
00:25:11,400 --> 00:25:13,039
Pues

613
00:25:13,039 --> 00:25:17,960
Empezaban los votos

614
00:25:17,960 --> 00:25:18,680
Con este for

615
00:25:18,680 --> 00:25:20,059
En este caso eran 10 votos

616
00:25:20,059 --> 00:25:21,079
Empezaban los votos

617
00:25:21,079 --> 00:25:22,940
Lo primero que hacía

618
00:25:22,940 --> 00:25:25,099
Pedir un voto

619
00:25:25,099 --> 00:25:27,039
Para eso

620
00:25:27,039 --> 00:25:29,880
Hacía esta variable y era un do while

621
00:25:29,880 --> 00:25:31,539
Mientras el voto no esté

622
00:25:31,539 --> 00:25:33,420
En los candidatos

623
00:25:33,420 --> 00:25:36,019
Venga vamos a sacar esto a un método

624
00:25:36,019 --> 00:25:37,960
Vamos a refactorizar esto

625
00:25:37,960 --> 00:25:38,920
Vamos a sacarlo a un método

626
00:25:38,920 --> 00:25:41,700
Y que ese método sea pedir voto

627
00:25:41,700 --> 00:25:43,400
Y devolverlo como valor de retorno

628
00:25:43,400 --> 00:25:44,500
¿Vale?

629
00:25:45,539 --> 00:25:46,099
Validando

630
00:25:46,099 --> 00:25:49,140
Que esté en este array

631
00:25:49,140 --> 00:25:51,539
Con lo cual va a haber que pasárselo a ese método

632
00:25:51,539 --> 00:25:53,440
¿Vale?

633
00:25:53,480 --> 00:25:55,920
Entonces vamos a refactorizar el código

634
00:25:55,920 --> 00:25:57,980
¿Sabéis lo que es refactorizar

635
00:25:57,980 --> 00:25:58,960
Dentro de nuestro desarrollo?

636
00:25:59,579 --> 00:26:00,319
Sí, ¿no?

637
00:26:01,119 --> 00:26:04,019
La aplicación, yo no voy a cambiar su funcionamiento

638
00:26:04,019 --> 00:26:05,339
En ningún momento, va a funcionar igual

639
00:26:05,339 --> 00:26:08,000
Voy a cambiar solo el diseño del código

640
00:26:08,000 --> 00:26:08,579
Ya está

641
00:26:08,579 --> 00:26:10,180
Pues vamos a cambiarlo

642
00:26:10,180 --> 00:26:11,000
Sacando esto

643
00:26:11,000 --> 00:26:13,480
¿Lo habéis refactorizado con los diferentes entornos?

644
00:26:13,759 --> 00:26:13,960
No

645
00:26:13,960 --> 00:26:16,519
Bueno, pues

646
00:26:16,519 --> 00:26:19,519
Todos los entornos

647
00:26:19,519 --> 00:26:21,579
Tienen la posibilidad de hacer un refactor automático

648
00:26:21,579 --> 00:26:23,200
Pero es casi más lioso usar eso

649
00:26:23,200 --> 00:26:24,759
Que copiarlo tú y llevarlo a otro método

650
00:26:24,759 --> 00:26:27,579
Es casi, pero aquí podríamos hacer un refactor

651
00:26:27,579 --> 00:26:29,160
Y hay un extract método

652
00:26:29,160 --> 00:26:30,880
Que te dice, sácalo a un método

653
00:26:30,880 --> 00:26:32,539
Vamos a probarlo, a ver

654
00:26:32,539 --> 00:26:34,680
Entonces vamos a sacar esto

655
00:26:34,680 --> 00:26:36,059
Esto de aquí

656
00:26:36,059 --> 00:26:38,380
Vamos a refactorizarlo y sacarlo

657
00:26:38,380 --> 00:26:39,920
A un método, StratMethod

658
00:26:39,920 --> 00:26:41,680
Vale

659
00:26:41,680 --> 00:26:43,640
¿Cómo vamos a llamar al método?

660
00:26:43,960 --> 00:26:44,539
GetBoto

661
00:26:44,539 --> 00:26:47,279
Vamos a intentar

662
00:26:47,279 --> 00:26:48,819
A ver si nos lo hace bien

663
00:26:48,819 --> 00:26:51,619
GetBoto, el escáner no se lo quiero pasar

664
00:26:51,619 --> 00:26:53,740
Este no, este fuera

665
00:26:53,740 --> 00:26:56,440
¿Esto lo puedo borrar? No quiero pasarle este

666
00:26:56,440 --> 00:26:58,579
Eh...

667
00:26:58,579 --> 00:26:59,880
Sí, a ver, no

668
00:26:59,880 --> 00:27:02,359
Editar, declarar, no, lo quiero borrar

669
00:27:02,359 --> 00:27:04,339
No quiero pasarle este

670
00:27:04,339 --> 00:27:05,420
Porque lo va a usar él

671
00:27:05,420 --> 00:27:07,279
Entonces, ¿no puedo yo aquí

672
00:27:07,279 --> 00:27:09,539
Este quitarlo? No puedo, ¿verdad?

673
00:27:11,920 --> 00:27:12,160
¿Eh?

674
00:27:15,279 --> 00:27:17,380
Pero no lo tenía, es que no lo he cogido

675
00:27:17,380 --> 00:27:19,500
No, claro, a ver

676
00:27:19,500 --> 00:27:21,359
Él lo que te dice es lo que necesita

677
00:27:21,359 --> 00:27:23,000
Pero yo el escáner no quiero

678
00:27:23,000 --> 00:27:24,660
Quiero crearlo dentro otra vez

679
00:27:24,660 --> 00:27:26,619
Entonces él te dice, vaya a eso, pero bueno

680
00:27:26,619 --> 00:27:29,259
Voy a hacerlo y luego lo borro y se acabó

681
00:27:29,259 --> 00:27:31,119
Entonces, refactor, rename

682
00:27:31,119 --> 00:27:33,279
Pero tiene que haber, no, rename no

683
00:27:33,279 --> 00:27:35,059
Extraer método, tiene que haber alguna manera

684
00:27:35,059 --> 00:27:37,200
De poder quitarle parámetros, es decir, no, este no lo quiero

685
00:27:37,200 --> 00:27:39,920
Pero bueno, no lo sé

686
00:27:39,920 --> 00:27:42,640
Vale, y ahora le paso candidato

687
00:27:42,640 --> 00:27:43,779
Si me va a devolver un este

688
00:27:43,779 --> 00:27:45,900
Venga, que le ca...

689
00:27:45,900 --> 00:27:47,500
Ah, sí, el método va a ser

690
00:27:47,500 --> 00:27:49,799
GetVoto

691
00:27:49,799 --> 00:27:51,940
Vale, pues venga

692
00:27:51,940 --> 00:27:54,039
Nos gusta este, pues no nos llama

693
00:27:54,039 --> 00:27:55,900
Remedio porque no me deja quitar el escáner

694
00:27:55,900 --> 00:27:59,539
Claro, no me deja quitar el escá...

695
00:27:59,539 --> 00:28:01,319
A ver, ah, bueno, pero puedo hacer

696
00:28:01,319 --> 00:28:02,880
Una cosa, le pongo aquí el... Ah, no, es que

697
00:28:02,880 --> 00:28:05,259
Ponérselo para que no tire de aquí

698
00:28:05,259 --> 00:28:06,920
NewScanner

699
00:28:06,920 --> 00:28:09,740
bueno, ya se lo quito a mano y se acabó

700
00:28:09,740 --> 00:28:11,380
refactor

701
00:28:11,380 --> 00:28:14,019
extraeme eso a un método

702
00:28:14,019 --> 00:28:15,880
venga

703
00:28:15,880 --> 00:28:17,859
getBoto

704
00:28:17,859 --> 00:28:21,859
ese es el nombre del método

705
00:28:21,859 --> 00:28:25,039
entonces, efectivamente

706
00:28:25,039 --> 00:28:27,339
me llama a getBoto, pasándole mi scan

707
00:28:27,339 --> 00:28:29,240
no, yo de este scan paso me hago uno local

708
00:28:29,240 --> 00:28:31,740
para él, porque si no tenemos un poco de problemilla

709
00:28:31,740 --> 00:28:35,559
con los cierres, los buffers

710
00:28:35,559 --> 00:28:36,960
etcétera

711
00:28:36,960 --> 00:28:39,500
Y getBoto mío está aquí debajo.

712
00:28:39,859 --> 00:28:46,680
Le quito el escáner y se lo pongo aquí, local.

713
00:28:47,380 --> 00:28:48,500
Que eso da menos problemas.

714
00:29:04,980 --> 00:29:06,339
A ver, y se lo pago como parámetro.

715
00:29:06,779 --> 00:29:09,000
Este va a tirar del otro.

716
00:29:09,380 --> 00:29:11,380
Entonces comparten buffer, comparten todo.

717
00:29:11,380 --> 00:29:14,480
Y yo he visto, a ver, con consola la verdad es que no trabajo mucho.

718
00:29:14,619 --> 00:29:19,000
Pero es más complicado gestionar el tema de los buffers.

719
00:29:19,339 --> 00:29:21,880
Limpiar el buffer de uno que te ha dejado es mucho mejor.

720
00:29:22,299 --> 00:29:24,299
Que todos trabajen con uno suyo local.

721
00:29:24,299 --> 00:29:26,799
y ya está, entonces en lugar de trabajar

722
00:29:26,799 --> 00:29:29,000
con el que me pasa el otro, que tiene toda su mierda

723
00:29:29,000 --> 00:29:31,160
de arriba, pues me hago uno local

724
00:29:31,160 --> 00:29:33,259
que luego va a desaparecer en cuanto este método termine

725
00:29:33,259 --> 00:29:34,440
vale

726
00:29:34,440 --> 00:29:37,099
vale, pues ya está

727
00:29:37,099 --> 00:29:38,500
getVoto

728
00:29:38,500 --> 00:29:43,279
no he cambiado el código, simplemente

729
00:29:43,279 --> 00:29:44,960
me devuelve el voto

730
00:29:44,960 --> 00:29:46,799
validándolo así y me lo devuelve

731
00:29:46,799 --> 00:29:49,119
y aquí llamo a getVoto y se acabó

732
00:29:49,119 --> 00:29:50,859
no he cambiado el código, lo refactorizo

733
00:29:50,859 --> 00:29:53,119
vale, pero vamos a parar aquí un momentito

734
00:29:53,119 --> 00:29:53,559
y luego se