1
00:00:00,000 --> 00:00:02,240
Venga, a ver, un poco de alegría, por Dios

2
00:00:02,240 --> 00:00:04,879
Vale

3
00:00:04,879 --> 00:00:07,519
Bueno, pues este código parece que nos ha gustado

4
00:00:07,519 --> 00:00:08,599
Vamos a hacerle pruebas

5
00:00:08,599 --> 00:00:12,019
Pero en lugar de 30 vamos a poner

6
00:00:12,019 --> 00:00:13,820
Ah, no, 10 votaciones las que están

7
00:00:13,820 --> 00:00:14,560
Vale, 10

8
00:00:14,560 --> 00:00:17,739
Pues venga, vamos a ejecutarlo

9
00:00:17,739 --> 00:00:21,890
Primero vamos a ejecutarlo

10
00:00:21,890 --> 00:00:23,850
A ver si funciona, no vaya a ser que

11
00:00:23,850 --> 00:00:27,730
Que el código esté mal ya de partida

12
00:00:27,730 --> 00:00:29,510
Venga, tenemos

13
00:00:30,070 --> 00:00:31,390
Tres se van a presentar

14
00:00:31,390 --> 00:00:32,689
tres votantes, nombre

15
00:00:32,689 --> 00:00:35,090
el A, el B

16
00:00:35,090 --> 00:00:37,530
y el C, vale, y ahora empezamos

17
00:00:37,530 --> 00:00:39,390
a votar, pues venga, voto

18
00:00:39,390 --> 00:00:40,950
a este, voto a este

19
00:00:40,950 --> 00:00:42,009
voto a este

20
00:00:42,009 --> 00:00:45,869
voto a este, a este

21
00:00:45,869 --> 00:00:46,990
a este

22
00:00:46,990 --> 00:00:48,869
a este, a este

23
00:00:48,869 --> 00:00:51,390
y a este, y a este, vale

24
00:00:51,390 --> 00:00:53,310
¿veis?

25
00:00:53,929 --> 00:00:55,590
cuando yo he mostrado

26
00:00:55,590 --> 00:00:57,030
mi map

27
00:00:57,030 --> 00:00:59,549
que lo he mostrado directamente así

28
00:00:59,549 --> 00:01:05,099
lógicamente

29
00:01:05,099 --> 00:01:07,079
la máquina virtual de Java ha tenido que llamar

30
00:01:07,079 --> 00:01:08,439
al toString de map

31
00:01:08,439 --> 00:01:10,840
y el toString de map es bonito

32
00:01:10,840 --> 00:01:13,019
el toString de map es bonito

33
00:01:13,019 --> 00:01:15,500
porque nos lo muestra entre llaves, así todo chulo

34
00:01:15,500 --> 00:01:17,000
¿vale? el toString de map

35
00:01:17,000 --> 00:01:19,659
y no solo eso, nos lo ha mostrado

36
00:01:19,659 --> 00:01:21,659
en orden alfabético

37
00:01:21,659 --> 00:01:23,200
de claves

38
00:01:23,200 --> 00:01:26,689
¿vale? ¿por qué nos lo ha mostrado

39
00:01:26,689 --> 00:01:28,209
en orden alfabético de claves?

40
00:01:28,329 --> 00:01:30,469
porque era un trimap, si hubiera sido un

41
00:01:30,469 --> 00:01:32,670
hashMap no tendría por qué haberlo

42
00:01:32,670 --> 00:01:34,829
mostrado en orden alfabético de claves

43
00:01:34,829 --> 00:01:36,189
¿vale?

44
00:01:36,409 --> 00:01:38,969
Bueno, y aquí como no hay mayoría absoluta

45
00:01:38,969 --> 00:01:40,170
Bueno, hay mayoría absoluta, vale

46
00:01:40,170 --> 00:01:42,609
Entonces uno podría decir

47
00:01:42,609 --> 00:01:44,829
Ay, que bien, he pasado las pruebas

48
00:01:44,829 --> 00:01:52,459
Entonces

49
00:01:52,459 --> 00:01:54,340
Hemos hecho

50
00:01:54,340 --> 00:01:55,859
Ups, ya está

51
00:01:55,859 --> 00:01:57,519
Una primera prueba

52
00:01:57,519 --> 00:02:01,260
Y vale, bien, parece que funciona

53
00:02:01,260 --> 00:02:02,840
Hemos metido nombres, los ha mostrado

54
00:02:02,840 --> 00:02:04,840
En orden alfabético porque es un trimap

55
00:02:04,840 --> 00:02:07,099
Vale, funciona

56
00:02:07,099 --> 00:02:09,080
Pero claro, uno pues no puede

57
00:02:09,080 --> 00:02:10,699
Cometer el error de

58
00:02:10,699 --> 00:02:13,960
Darlo por válido a la primera prueba

59
00:02:13,960 --> 00:02:15,319
Para eso hay

60
00:02:15,319 --> 00:02:17,960
Todo un protocolo

61
00:02:17,960 --> 00:02:19,900
De creación de casos

62
00:02:19,900 --> 00:02:22,020
De prueba, pruebas unitarias

63
00:02:22,020 --> 00:02:23,020
Pruebas de

64
00:02:23,020 --> 00:02:25,900
De proyecto

65
00:02:25,900 --> 00:02:27,439
De todo, de las cuales

66
00:02:27,439 --> 00:02:29,199
Algo pues más o menos ya sabéis

67
00:02:29,199 --> 00:02:31,000
De entornos de desarrollo

68
00:02:31,000 --> 00:02:33,580
Entonces por ejemplo

69
00:02:33,580 --> 00:02:35,500
Si yo sigo haciendo pruebas porque no caigo

70
00:02:35,500 --> 00:02:37,520
En el error

71
00:02:37,520 --> 00:02:39,120
De a la primera prueba que me sale bien

72
00:02:39,120 --> 00:02:40,120
Darlo por válido

73
00:02:40,120 --> 00:02:41,979
Pues aquí podríamos

74
00:02:41,979 --> 00:02:44,580
Hacer esta prueba

75
00:02:44,580 --> 00:02:45,740
¿Cuántos se presentan?

76
00:02:46,099 --> 00:02:47,360
Se presentan JJ

77
00:02:47,360 --> 00:02:51,000
Pues este programa lógicamente

78
00:02:51,000 --> 00:02:52,960
No ha pasado la fase de pruebas

79
00:02:52,960 --> 00:02:55,020
Porque cuando yo pongo

80
00:02:55,020 --> 00:02:56,639
Se presentan JJ

81
00:02:56,639 --> 00:02:58,159
Me sale

82
00:02:58,159 --> 00:03:00,319
Una excepción, ¿vale?

83
00:03:00,360 --> 00:03:03,060
Que es lo que digo, que siempre hemos pasado

84
00:03:03,060 --> 00:03:04,139
Un poco así por alto

85
00:03:04,139 --> 00:03:05,719
Porque no

86
00:03:05,719 --> 00:03:09,180
teníamos todavía tiempo para meternos en ello

87
00:03:09,180 --> 00:03:11,300
vale, pues ahora vamos a meternos ya un pelín

88
00:03:11,300 --> 00:03:12,639
vamos a meternos ya un pelín

89
00:03:12,639 --> 00:03:14,580
en el tema de las excepciones

90
00:03:14,580 --> 00:03:20,319
vale, pues vamos a meternos

91
00:03:20,319 --> 00:03:21,740
ya un pelinín en este tema

92
00:03:21,740 --> 00:03:24,199
un pelinín, tampoco que nos vayamos a

93
00:03:24,199 --> 00:03:26,180
volver locos porque tampoco hace

94
00:03:26,180 --> 00:03:26,520
falta

95
00:03:26,520 --> 00:03:30,280
tampoco hace falta volverse locos

96
00:03:30,280 --> 00:03:34,439
bueno, pues

97
00:03:34,439 --> 00:03:38,000
muy rápidamente

98
00:03:38,000 --> 00:03:51,419
No, no, no

99
00:03:51,419 --> 00:03:53,099
Gracias

100
00:03:53,099 --> 00:04:01,490
No os creen

101
00:04:01,490 --> 00:04:02,469
No os creen

102
00:04:02,469 --> 00:04:04,189
¿Quién es?

103
00:04:04,189 --> 00:04:06,789
No, alguien nos creó

104
00:04:06,789 --> 00:04:12,189
¿Qué?

105
00:04:13,310 --> 00:04:18,430
a ver, entonces

106
00:04:18,430 --> 00:04:20,569
¿qué es una excepción?

107
00:04:23,310 --> 00:04:28,300
pues una excepción

108
00:04:28,300 --> 00:04:29,879
en realidad es

109
00:04:29,879 --> 00:04:31,019
un objeto

110
00:04:31,019 --> 00:04:33,040
eso es una excepción

111
00:04:33,040 --> 00:04:34,319
es un objeto

112
00:04:34,319 --> 00:04:38,240
que se crea

113
00:04:38,240 --> 00:04:39,199
que se instancia

114
00:04:39,199 --> 00:04:41,740
que aparece ese objeto, se crea esa instancia

115
00:04:41,740 --> 00:04:43,480
cuando el programa

116
00:04:43,480 --> 00:04:46,079
decide que ha pasado

117
00:04:46,079 --> 00:04:47,399
algo raro que no le gusta

118
00:04:47,399 --> 00:04:49,899
Entonces, todo es código

119
00:04:49,899 --> 00:04:52,600
Una excepción no es que haya pasado algo raro

120
00:04:52,600 --> 00:04:54,019
Que se haya roto la RAM

121
00:04:54,019 --> 00:04:56,980
Que se haya roto el teclado

122
00:04:56,980 --> 00:04:58,939
Y pum, aparezca algo de eso

123
00:04:58,939 --> 00:05:01,439
No, es todo código también

124
00:05:01,439 --> 00:05:02,139
Todo código

125
00:05:02,139 --> 00:05:04,519
Entonces, cuando uno tiene un programa Java

126
00:05:04,519 --> 00:05:08,360
Pues nosotros ya sabemos que nuestros programas Java

127
00:05:08,360 --> 00:05:11,420
Aparte de hacer nuestras propias sentencias

128
00:05:11,420 --> 00:05:15,019
Lógicamente también llaman a métodos que hacen cosas

129
00:05:15,019 --> 00:05:33,600
Por ejemplo, aquí hemos llamado al método nextIn que hace cosas. A veces también llamamos al método systemOut que hace cosas. Nosotros, aparte de nuestras propias sentencias, llamamos a métodos que hacen cosas.

130
00:05:33,600 --> 00:05:57,199
Y estos son métodos que hacen código, que a su vez pueden llamar a métodos que hacen código, ¿vale? Pues puede ocurrir que en alguno de estos puntos se verifique una condición con un if y esa condición lleve a que se genere, aparezca un objeto excepción, ¿vale? Aparezca.

131
00:05:57,199 --> 00:05:59,240
Por ejemplo, en nuestro ejemplo que estamos viendo aquí,

132
00:05:59,779 --> 00:06:02,300
el next in se ha metido a hacer cosas.

133
00:06:03,060 --> 00:06:05,300
Entonces, el next in aquí ha validado,

134
00:06:06,199 --> 00:06:11,259
a ver, si esa cadena de texto que se ha leído por el teclado

135
00:06:11,259 --> 00:06:13,939
se ha puesto aquí a validar por dentro,

136
00:06:14,459 --> 00:06:17,420
si es una sucesión de cifras que componen un entero o no lo es.

137
00:06:17,420 --> 00:06:18,480
Se ha puesto a validarlo.

138
00:06:19,000 --> 00:06:20,579
Nosotros no lo vemos, pero lo hace aquí dentro.

139
00:06:21,399 --> 00:06:23,959
Entonces, cuando ha comprobado que no,

140
00:06:23,959 --> 00:06:25,560
Que lo que le hemos metido

141
00:06:25,560 --> 00:06:27,540
No es una sucesión de cifras

142
00:06:27,540 --> 00:06:28,579
Que forman un entero

143
00:06:28,579 --> 00:06:30,300
Cuando ha comprobado eso

144
00:06:30,300 --> 00:06:33,199
Ha creado un objeto

145
00:06:33,199 --> 00:06:35,100
Excepción, lo ha creado

146
00:06:35,100 --> 00:06:39,500
Y lo ha mandado de vuelta

147
00:06:39,500 --> 00:06:41,379
De vuelta

148
00:06:41,379 --> 00:06:42,740
Al punto

149
00:06:42,740 --> 00:06:44,779
En el que se llamó a este método

150
00:06:44,779 --> 00:06:47,639
Es como si lo pasara por parámetro

151
00:06:47,639 --> 00:06:50,060
Como si fuera un paso por parámetro

152
00:06:50,060 --> 00:06:51,579
Es decir

153
00:06:51,579 --> 00:06:52,500
Next in

154
00:06:52,500 --> 00:06:54,399
ha hecho lo que tenga que hacer

155
00:06:54,399 --> 00:06:57,040
ya sabemos que si next in

156
00:06:57,040 --> 00:06:58,579
hubiera terminado con éxito

157
00:06:58,579 --> 00:07:00,480
si hubiera terminado con éxito

158
00:07:00,480 --> 00:07:03,319
ya sabríamos que lo que se habría devuelto

159
00:07:03,319 --> 00:07:05,040
es el valor

160
00:07:05,040 --> 00:07:06,660
entero leído, ya lo sabemos

161
00:07:06,660 --> 00:07:09,279
pero next in no ha acabado con éxito

162
00:07:09,279 --> 00:07:11,000
next in en algún momento

163
00:07:11,000 --> 00:07:13,100
ha hecho un if y ha visto que

164
00:07:13,100 --> 00:07:15,000
esa secuencia leída no es

165
00:07:15,000 --> 00:07:16,779
un número, con lo cual

166
00:07:16,779 --> 00:07:18,740
el next in no ha llegado a terminar

167
00:07:18,740 --> 00:07:21,040
y a devolver el número

168
00:07:21,040 --> 00:07:23,060
entero leído, sino que mucho

169
00:07:23,060 --> 00:07:25,360
antes de eso, ha creado

170
00:07:25,360 --> 00:07:26,759
un objeto excepción

171
00:07:26,759 --> 00:07:28,620
y ese es el que le ha

172
00:07:28,620 --> 00:07:31,139
entregado al punto de llamada.

173
00:07:31,480 --> 00:07:32,620
Ese es el que le ha entregado.

174
00:07:33,660 --> 00:07:35,319
En realidad es como si le estuviera

175
00:07:35,319 --> 00:07:36,779
pasando un parámetro también.

176
00:07:37,279 --> 00:07:38,439
Le pasa un objeto excepción.

177
00:07:39,259 --> 00:07:41,019
Pues ahora mi programa, este que

178
00:07:41,019 --> 00:07:41,600
está aquí,

179
00:07:43,339 --> 00:07:45,300
habiendo llamado al nextIn,

180
00:07:46,079 --> 00:07:46,939
tiene dos opciones,

181
00:07:47,100 --> 00:07:48,600
tiene dos posibilidades, por tanto,

182
00:07:48,600 --> 00:07:51,199
repito que el nextIn haya terminado

183
00:07:51,199 --> 00:07:52,040
correctamente

184
00:07:52,040 --> 00:07:54,819
le haya devuelto el número entero

185
00:07:54,819 --> 00:07:55,759
y mi programa sigue

186
00:07:55,759 --> 00:07:59,379
o que el nextIn no haya terminado correctamente

187
00:07:59,379 --> 00:08:01,120
y la forma de saber que no ha terminado

188
00:08:01,120 --> 00:08:02,980
correctamente es porque le ha llegado

189
00:08:02,980 --> 00:08:03,939
este objeto de excepción

190
00:08:03,939 --> 00:08:07,060
pues aquí que ocurre

191
00:08:07,060 --> 00:08:09,060
pues si estamos en un punto

192
00:08:09,060 --> 00:08:10,779
del programa en el cual

193
00:08:10,779 --> 00:08:12,759
de ese método que hemos llamado

194
00:08:12,759 --> 00:08:14,879
hemos recibido ese objeto de excepción

195
00:08:14,879 --> 00:08:17,220
que indica no he podido terminar correctamente

196
00:08:17,220 --> 00:08:18,339
lo siento no he podido terminar

197
00:08:18,339 --> 00:08:20,759
y te mando un objeto de excepción para avisarte.

198
00:08:21,500 --> 00:08:23,540
Pues si ha ocurrido eso, ¿qué pasa?

199
00:08:23,759 --> 00:08:26,079
Que si yo no hago nada y me quedo tan tranquila

200
00:08:26,079 --> 00:08:29,100
como hemos hecho siempre, no hacer nada al respecto,

201
00:08:29,279 --> 00:08:31,980
si no hacemos nada al respecto, ¿qué es lo que ocurre?

202
00:08:31,980 --> 00:08:37,840
Que el programa automáticamente terminó, se para

203
00:08:37,840 --> 00:08:40,980
y aquí se han acabado las cosas, programa terminado.

204
00:08:41,879 --> 00:08:43,519
Eso es lo que pasa, ¿vale?

205
00:08:44,200 --> 00:08:47,840
Cuando llamamos a un método que en algún momento

206
00:08:47,840 --> 00:08:51,100
verifica que una condición no le gusta

207
00:08:51,100 --> 00:08:52,539
lo que obtiene

208
00:08:52,539 --> 00:08:54,820
y me entrega una excepción

209
00:08:54,820 --> 00:08:57,100
en lugar de completarse y darme el valor

210
00:08:57,100 --> 00:08:58,960
pues el punto

211
00:08:58,960 --> 00:09:00,820
en el que llamé recibe

212
00:09:00,820 --> 00:09:02,480
esa excepción y pum

213
00:09:02,480 --> 00:09:04,840
el programa se paró

214
00:09:04,840 --> 00:09:07,220
ya no hay más programa que ejecutar

215
00:09:07,220 --> 00:09:07,740
¿vale?

216
00:09:09,440 --> 00:09:10,899
repito, no es que de repente

217
00:09:10,899 --> 00:09:12,840
cuando salen esas letras rojas

218
00:09:12,840 --> 00:09:15,019
de aquí, o las letras rojas

219
00:09:15,019 --> 00:09:16,940
que nos han salido, no es

220
00:09:16,940 --> 00:09:18,940
que haya pasado algo extraño

221
00:09:18,940 --> 00:09:21,120
no controlado, no ha pasado nada extraño

222
00:09:21,120 --> 00:09:22,679
forma parte de nuestro programa

223
00:09:22,679 --> 00:09:24,720
el next in

224
00:09:24,720 --> 00:09:27,019
hacía cosas, no le ha gustado

225
00:09:27,019 --> 00:09:28,779
algo, en este caso

226
00:09:28,779 --> 00:09:30,860
no le ha gustado que lo que ha leído del buffer

227
00:09:30,860 --> 00:09:32,740
del teclado era JJ

228
00:09:32,740 --> 00:09:34,519
en lugar de ser un número, no le ha gustado

229
00:09:34,519 --> 00:09:35,820
y te dice, uy, no me gusta

230
00:09:35,820 --> 00:09:40,659
pues construye instancia

231
00:09:40,659 --> 00:09:42,120
ese objeto excepción

232
00:09:42,120 --> 00:09:43,779
y te lo devuelve

233
00:09:43,779 --> 00:09:46,399
en lugar de devolverte el número entero

234
00:09:46,399 --> 00:09:48,080
que hay en ese buffer

235
00:09:48,080 --> 00:09:55,299
Entonces, es todo programa, no es que pase nada raro, no es que aparezca un evento y de repente, porque otra cosa es la programación entra de evento, es otra cosa.

236
00:09:56,700 --> 00:10:07,919
Pero lo que sí que ocurre es que la máquina virtual, en cuanto ve que en este punto, en esta sentencia, la vuelta ha llegado vía objeto excepción,

237
00:10:08,519 --> 00:10:14,940
cuando ve que la vuelta ha llegado vía objeto excepción y no ha llegado vía valor de retorno normal, el valor de retorno del método,

238
00:10:14,940 --> 00:10:16,700
sino que ha llegado vía objeto de excepción

239
00:10:16,700 --> 00:10:18,960
lo que sí que ocurre es que la máquina virtual

240
00:10:18,960 --> 00:10:22,000
te hace un siso en la consola

241
00:10:22,000 --> 00:10:24,000
con los detalles de ese objeto

242
00:10:24,000 --> 00:10:25,559
y luego para

243
00:10:25,559 --> 00:10:26,279
se acabó

244
00:10:26,279 --> 00:10:29,440
entonces todas esas letras rojas que vemos

245
00:10:29,440 --> 00:10:31,080
son los detalles

246
00:10:31,080 --> 00:10:33,100
que hay dentro del objeto

247
00:10:33,100 --> 00:10:35,679
que ha recibido el programa

248
00:10:35,679 --> 00:10:37,620
principal cuando se ha llamado

249
00:10:37,620 --> 00:10:39,019
a ese método que ha hecho cosas raras

250
00:10:39,019 --> 00:10:40,419
eso es lo que vemos

251
00:10:40,419 --> 00:10:43,460
que es lo que hemos visto

252
00:10:43,460 --> 00:10:46,159
aquí

253
00:10:46,159 --> 00:11:02,970
vale

254
00:11:02,970 --> 00:11:11,059
es lo que hemos visto aquí

255
00:11:11,059 --> 00:11:13,639
estos son los detalles

256
00:11:13,639 --> 00:11:14,759
que están dentro

257
00:11:14,759 --> 00:11:16,299
de ese objeto

258
00:11:16,299 --> 00:11:18,460
y los detalles son

259
00:11:18,460 --> 00:11:21,899
oye, la clase a la que pertenece

260
00:11:21,899 --> 00:11:23,200
el objeto excepción

261
00:11:23,200 --> 00:11:24,899
que yo te mando

262
00:11:24,899 --> 00:11:26,460
es esta clase

263
00:11:26,460 --> 00:11:28,759
inputMisMatchException

264
00:11:28,759 --> 00:11:31,279
es que este objeto excepción particular

265
00:11:31,279 --> 00:11:32,799
es muy

266
00:11:32,799 --> 00:11:35,200
sencillito, hay algunos que tienen dentro

267
00:11:35,200 --> 00:11:36,440
más información y más cosas

268
00:11:36,440 --> 00:11:38,460
oye, que me pasó eso

269
00:11:38,460 --> 00:11:41,139
cuando tú llamaste a votaciones

270
00:11:41,139 --> 00:11:43,259
y yo de votaciones me fui a votaciones

271
00:11:43,259 --> 00:11:45,240
y de votaciones me fui a escáner y de escáner

272
00:11:45,240 --> 00:11:47,360
me fui a escáner a esta línea y de escáner me fui a esta

273
00:11:47,360 --> 00:11:48,220
y de escáner me fui a esta

274
00:11:48,220 --> 00:11:50,779
fue aquí, en la línea

275
00:11:50,779 --> 00:11:53,500
947 de la clase escáner

276
00:11:53,500 --> 00:11:54,379
fue en esta línea

277
00:11:54,379 --> 00:11:56,700
donde me encontré yo

278
00:11:56,700 --> 00:11:59,139
haciendo mi código que no me gustaba

279
00:11:59,139 --> 00:12:01,379
lo que estaba viendo ahí, que no me gustaba

280
00:12:01,379 --> 00:12:02,220
pues fue aquí

281
00:12:02,220 --> 00:12:05,159
donde yo decidí crear mi objeto

282
00:12:05,159 --> 00:12:07,539
de la clase InputMismatchException

283
00:12:07,539 --> 00:12:09,019
y te lo envié.

284
00:12:09,740 --> 00:12:11,100
Es lo que nos está contando.

285
00:12:12,080 --> 00:12:12,320
Entonces,

286
00:12:13,340 --> 00:12:15,480
una vez que la máquina virtual ya ha sacado

287
00:12:15,480 --> 00:12:17,299
la información de dentro de ese objeto,

288
00:12:18,399 --> 00:12:19,919
paz, para el programa.

289
00:12:21,120 --> 00:12:21,519
Y ya está.

290
00:12:21,600 --> 00:12:22,740
Y por eso no ha seguido.

291
00:12:25,220 --> 00:12:25,460
¿Vale?

292
00:12:26,600 --> 00:12:28,720
Bueno, pues hasta ahí está claro lo que es una excepción.

293
00:12:28,720 --> 00:12:30,500
Una excepción es un objeto

294
00:12:30,500 --> 00:12:32,500
que se crea con información dentro

295
00:12:32,500 --> 00:12:35,000
que detalla que algo raro ha pasado

296
00:12:35,000 --> 00:12:36,419
y es un objeto

297
00:12:36,419 --> 00:12:37,779
que como todos los objetos de Java

298
00:12:37,779 --> 00:12:38,940
pertenece a una clase

299
00:12:38,940 --> 00:12:42,179
clases de posibles excepciones

300
00:12:42,179 --> 00:12:44,480
hay 3.598 millones

301
00:12:44,480 --> 00:12:46,759
esta es una de ellas

302
00:12:46,759 --> 00:12:48,799
¿vale?

303
00:12:49,120 --> 00:12:49,740
esta es una

304
00:12:49,740 --> 00:12:51,440
JavaUtilInputMidMatchExcept

305
00:12:51,440 --> 00:12:52,620
¿vale?

306
00:12:52,720 --> 00:12:54,580
entonces ¿cuál es el problema de las excepciones?

307
00:12:55,120 --> 00:12:57,639
que cuando le llegan a un punto

308
00:12:57,639 --> 00:12:59,340
que en este caso aquí han llegado aquí

309
00:12:59,340 --> 00:13:00,600
el next in

310
00:13:00,600 --> 00:13:03,340
se ha ido a un sitio

311
00:13:03,340 --> 00:13:06,700
no ha podido completarlo

312
00:13:06,700 --> 00:13:08,539
si hubiera podido completarlo, genial

313
00:13:08,539 --> 00:13:11,659
nos habría devuerto el entero para guardarlo aquí

314
00:13:11,659 --> 00:13:13,320
no ha podido completarlo

315
00:13:13,320 --> 00:13:15,840
con lo cual nos ha mandado el objeto excepción

316
00:13:15,840 --> 00:13:17,779
la máquina virtual en este punto

317
00:13:17,779 --> 00:13:19,460
lo ha mostrado por consola

318
00:13:19,460 --> 00:13:20,940
y ahora ya sí que sí

319
00:13:20,940 --> 00:13:23,100
lo grave es que

320
00:13:23,100 --> 00:13:26,639
lo grave es

321
00:13:26,639 --> 00:13:28,600
que aquí el programa

322
00:13:28,600 --> 00:13:30,240
se acabó

323
00:13:30,240 --> 00:13:48,960
Esto. No hay forma de continuar. Bueno, pues eso es un rollo realmente. ¿Por qué? Porque es imposible controlar todos los errores. Es imposible todos los posibles fallos.

324
00:13:48,960 --> 00:13:51,279
entonces entregar una aplicación

325
00:13:51,279 --> 00:13:53,600
que en algún momento

326
00:13:53,600 --> 00:13:55,519
pues puede de repente

327
00:13:55,519 --> 00:13:56,460
pasarle esto

328
00:13:56,460 --> 00:13:59,480
que está el usuario que de repente

329
00:13:59,480 --> 00:14:00,779
ve ahí un chorizo extraño

330
00:14:00,779 --> 00:14:03,100
y se le ha parado la aplicación

331
00:14:03,100 --> 00:14:04,580
pues hombre no es la idea

332
00:14:04,580 --> 00:14:07,419
entonces tenemos que entregar

333
00:14:07,419 --> 00:14:09,460
aplicaciones no con la garantía

334
00:14:09,460 --> 00:14:11,419
de que nunca jamás van a petar porque eso es

335
00:14:11,419 --> 00:14:13,620
imposible seguro que hay cosas que no contemplamos

336
00:14:13,620 --> 00:14:15,320
pero al menos tenemos

337
00:14:15,320 --> 00:14:17,399
que intentar entregarlas

338
00:14:17,399 --> 00:14:19,399
con caminos alternativos

339
00:14:19,399 --> 00:14:20,679
en el caso de que peten

340
00:14:20,679 --> 00:14:23,220
para que no se paren y puedan seguir

341
00:14:23,220 --> 00:14:24,159
para que no se paren

342
00:14:24,159 --> 00:14:27,399
esta, desde luego no le hemos implementado

343
00:14:27,399 --> 00:14:28,559
ningún camino alternativo

344
00:14:28,559 --> 00:14:31,399
esta es muy mona, te lo prometo

345
00:14:31,399 --> 00:14:35,639
esta no le hemos implementado ningún camino alternativo

346
00:14:35,639 --> 00:14:37,500
¿vale? entonces en cuanto

347
00:14:37,500 --> 00:14:39,200
se ha encontrado el error de que el usuario

348
00:14:39,200 --> 00:14:41,360
ha puesto JJ, pues ha petado

349
00:14:41,360 --> 00:14:42,399
pues muy mal hecho

350
00:14:42,399 --> 00:14:45,299
bueno, pues ¿qué podemos hacer?

351
00:14:45,759 --> 00:14:47,259
lo que podemos es decir, oye

352
00:14:47,259 --> 00:14:51,179
Esta excepción, esta sentencia

353
00:14:51,179 --> 00:14:56,500
Si el usuario es un poco malintencionado

354
00:14:56,500 --> 00:14:59,879
Y el usuario se empeña en meter aquí

355
00:14:59,879 --> 00:15:07,809
Aunque yo le diga, dame número entero positivo

356
00:15:07,809 --> 00:15:16,750
Aunque yo me empeñe en decirle al usuario

357
00:15:16,750 --> 00:15:18,490
Dame número entero positivo

358
00:15:18,490 --> 00:15:23,110
Si el usuario se empeña en meterme aquí JJ

359
00:15:23,110 --> 00:15:27,269
bueno, voy a dar un camino alternativo

360
00:15:27,269 --> 00:15:29,950
para que no se pare la aplicación ahí

361
00:15:29,950 --> 00:15:31,190
porque tal y como lo tenemos

362
00:15:31,190 --> 00:15:33,470
si el usuario mete aquí hola, ¿qué tal?

363
00:15:33,710 --> 00:15:34,610
pum, se va a parar

364
00:15:34,610 --> 00:15:38,929
no tenemos por qué resignarnos a que eso te va a ocurrir

365
00:15:38,929 --> 00:15:41,750
¿cómo podemos darle un camino alternativo?

366
00:15:43,149 --> 00:15:45,789
bueno, podemos hacerlo pasando de las excepciones

367
00:15:45,789 --> 00:15:46,830
en realidad también

368
00:15:46,830 --> 00:15:49,230
por ejemplo, aquí ¿qué podríamos hacer

369
00:15:49,230 --> 00:15:50,629
para que no se parara la aplicación?

370
00:15:51,649 --> 00:15:52,789
olvidándose de las excepciones

371
00:15:52,789 --> 00:15:53,769
que eso os ocurriría

372
00:15:53,769 --> 00:15:56,549
y como lo validaríais

373
00:15:56,549 --> 00:16:00,639
pero como

374
00:16:00,639 --> 00:16:03,120
por lo pronto el next scene habría que quitarlo

375
00:16:03,120 --> 00:16:04,600
habría que poner un next line para

376
00:16:04,600 --> 00:16:06,220
que leyera lo que fuera

377
00:16:06,220 --> 00:16:08,240
y ahora ya esta cadena

378
00:16:08,240 --> 00:16:10,960
pasarla a una función que hagamos

379
00:16:10,960 --> 00:16:13,220
para ver si realmente es una sucesión

380
00:16:13,220 --> 00:16:13,940
de dígitos

381
00:16:13,940 --> 00:16:17,080
si lo es entonces ya

382
00:16:17,080 --> 00:16:19,039
permito que el programa sigue

383
00:16:19,039 --> 00:16:20,519
si no bucle otra vez

384
00:16:20,519 --> 00:16:23,120
es un rollo esa validación

385
00:16:23,120 --> 00:16:24,940
en realidad ¿no? porque tenemos

386
00:16:24,940 --> 00:16:26,720
nosotros que leerlo con

387
00:16:26,720 --> 00:16:28,840
next line, eso, hacer el

388
00:16:28,840 --> 00:16:30,759
código para ver si es una sucesión

389
00:16:30,759 --> 00:16:32,840
de dígitos, si lo

390
00:16:32,840 --> 00:16:34,679
es, sigo, si no

391
00:16:34,679 --> 00:16:36,539
bucle para arriba, vale

392
00:16:36,539 --> 00:16:38,600
bueno, podríamos hacerlo así

393
00:16:38,600 --> 00:16:40,659
sin excepciones, pero bueno

394
00:16:40,659 --> 00:16:42,460
hay una forma más cómoda

395
00:16:42,460 --> 00:16:44,480
que es, hombre, el next in

396
00:16:44,480 --> 00:16:46,720
el next in está para algo

397
00:16:46,720 --> 00:16:48,620
el next in está para leer un número

398
00:16:48,620 --> 00:16:50,580
entero, porque voy a

399
00:16:50,580 --> 00:16:52,039
coger yo aquí un next line

400
00:16:52,039 --> 00:16:54,480
luego obligarme a la validación

401
00:16:54,480 --> 00:16:55,700
No, dejo aquí mi next in

402
00:16:55,700 --> 00:16:58,059
Y lo que hago es hacer una cosa que es

403
00:16:58,059 --> 00:17:01,000
Voy a capturar la excepción

404
00:17:01,000 --> 00:17:03,779
Es decir, aquí

405
00:17:03,779 --> 00:17:06,019
Yo veo, porque soy muy listo

406
00:17:06,019 --> 00:17:07,119
Y sé de qué va esto

407
00:17:07,119 --> 00:17:10,059
Veo que puede haber una excepción

408
00:17:10,059 --> 00:17:11,200
Puede haberla

409
00:17:11,200 --> 00:17:13,099
Pues voy a decir, oye

410
00:17:13,099 --> 00:17:15,599
En caso de que haya excepción

411
00:17:15,599 --> 00:17:16,920
Haz esta otra cosa

412
00:17:16,920 --> 00:17:18,640
Y ahí el programa no se para

413
00:17:18,640 --> 00:17:21,380
¿Vale? Eso es lo que se llama

414
00:17:21,380 --> 00:17:22,619
Capturar la excepción

415
00:17:22,619 --> 00:17:25,759
Vale, ¿cómo se captura una excepción?

416
00:17:25,960 --> 00:17:27,619
Pues el famoso bloque try-catch

417
00:17:27,619 --> 00:17:31,720
Entonces, esto es una posible excepción sin capturar

418
00:17:31,720 --> 00:17:34,460
Posible excepción sin capturar está así

419
00:17:34,460 --> 00:17:36,920
Que ya sabemos el efecto que tiene

420
00:17:36,920 --> 00:17:40,039
Si esa excepción llega, programa parado

421
00:17:40,039 --> 00:17:43,759
Vale, pues ahora vamos a capturar la excepción

422
00:17:43,759 --> 00:17:46,019
Variante excepción capturada

423
00:17:46,019 --> 00:17:55,980
¿Cómo capturamos una excepción?

424
00:17:56,839 --> 00:17:59,240
Bueno, pues el bloque básico, ya sabéis cuál es

425
00:17:59,240 --> 00:18:00,619
try

426
00:18:00,619 --> 00:18:05,079
entre llaves

427
00:18:05,079 --> 00:18:07,920
pongo la o las

428
00:18:07,920 --> 00:18:09,940
sentencias, pueden ser una

429
00:18:09,940 --> 00:18:11,980
pueden ser muchas, la o las sentencias

430
00:18:11,980 --> 00:18:14,019
que pueden

431
00:18:14,019 --> 00:18:15,420
generar esa excepción

432
00:18:15,420 --> 00:18:16,900
que pueden generarla

433
00:18:16,900 --> 00:18:19,160
y ahora aquí catch

434
00:18:19,160 --> 00:18:21,779
y aquí pongo

435
00:18:21,779 --> 00:18:24,200
la clase de excepción

436
00:18:24,200 --> 00:18:25,880
que podría generar

437
00:18:25,880 --> 00:18:27,519
esta sentencia, en este caso

438
00:18:27,519 --> 00:18:28,920
es esta

439
00:18:28,920 --> 00:18:31,819
input mismatch

440
00:18:31,819 --> 00:18:33,240
exception, vale

441
00:18:33,240 --> 00:18:40,140
este error es cuando

442
00:18:40,140 --> 00:18:42,019
se espera un tipo de dato

443
00:18:42,019 --> 00:18:43,460
y en un escáner

444
00:18:43,460 --> 00:18:45,940
y es otro, pero vamos, que eso es lo de menos

445
00:18:45,940 --> 00:18:52,839
vale, pues entonces este sería un bloque

446
00:18:52,839 --> 00:18:54,900
básico, que haría

447
00:18:54,900 --> 00:18:56,859
oye tú, intenta hacer

448
00:18:56,859 --> 00:18:57,599
esta excepción

449
00:18:57,599 --> 00:19:01,140
que todo, perdón, esta sentencia

450
00:19:01,140 --> 00:19:02,720
que todo funciona

451
00:19:02,720 --> 00:19:05,059
sin ningún problema, genial

452
00:19:05,059 --> 00:19:06,779
el programa

453
00:19:06,779 --> 00:19:08,720
Continúa por aquí, y todo estupendo

454
00:19:08,720 --> 00:19:09,960
Como si nada hubiera pasado

455
00:19:09,960 --> 00:19:12,259
Vale

456
00:19:12,259 --> 00:19:14,640
¿Qué ocurre si esto

457
00:19:14,640 --> 00:19:15,779
Saca excepción?

458
00:19:16,640 --> 00:19:18,079
Si esto saca excepción

459
00:19:18,079 --> 00:19:20,619
Entonces se hace lo que haya en el catch

460
00:19:20,619 --> 00:19:22,839
Y el programa

461
00:19:22,839 --> 00:19:24,880
Continúa igualmente, o sea, no se para

462
00:19:24,880 --> 00:19:26,680
En ningún caso, vale

463
00:19:26,680 --> 00:19:30,720
Esa es la gracia

464
00:19:30,720 --> 00:19:31,940
De capturar la excepción

465
00:19:31,940 --> 00:19:34,420
Esa es la gracia

466
00:19:34,420 --> 00:19:36,839
de capturarla, que el programa

467
00:19:36,839 --> 00:19:38,720
no para en ningún

468
00:19:38,720 --> 00:19:40,859
caso, salga excepción o no salga

469
00:19:40,859 --> 00:19:50,710
a ver, la excepción

470
00:19:50,710 --> 00:19:52,609
sale, porque es que la excepción

471
00:19:52,609 --> 00:19:54,369
si next int tú le pasas un

472
00:19:54,369 --> 00:19:56,269
jj, la excepción

473
00:19:56,269 --> 00:19:57,630
el objeto se instancia

474
00:19:57,630 --> 00:20:00,430
vale, pero ahora ya el comportamiento

475
00:20:00,430 --> 00:20:02,190
no va a ser el comportamiento por defecto

476
00:20:02,190 --> 00:20:04,410
que es, la máquina virtual te hace

477
00:20:04,410 --> 00:20:05,849
un siso con los datos

478
00:20:05,849 --> 00:20:06,950
y luego lo para

479
00:20:06,950 --> 00:20:10,269
ahora ya, si la excepción sale

480
00:20:10,269 --> 00:20:12,230
lo que se va a hacer es lo que

481
00:20:12,230 --> 00:20:14,329
haya aquí dentro, si no hay nada no se hace nada

482
00:20:14,329 --> 00:20:19,200
esto es lo que se

483
00:20:19,200 --> 00:20:20,680
ejecuta

484
00:20:20,680 --> 00:20:25,180
si salta excepción

485
00:20:25,180 --> 00:20:29,250
ahora mismo con mi catch

486
00:20:29,250 --> 00:20:31,369
no se haría nada y el programa

487
00:20:31,369 --> 00:20:33,190
seguiría, vale

488
00:20:33,190 --> 00:20:37,259
ese es el try catch

489
00:20:37,259 --> 00:20:39,480
básico, vale, el try catch

490
00:20:39,480 --> 00:20:42,490
básico, aquí

491
00:20:42,490 --> 00:20:44,650
lo que pasa es que al hacer un try catch nos hemos

492
00:20:44,650 --> 00:20:46,410
encontrado un primer problema, un try catch

493
00:20:46,410 --> 00:20:47,170
abre un bloque

494
00:20:47,170 --> 00:20:49,910
¿vale? un try catch abre un bloque

495
00:20:49,910 --> 00:20:52,250
entonces al abrir un bloque

496
00:20:52,250 --> 00:20:54,450
cuidado de nuevo con el ámbito de las variables

497
00:20:54,450 --> 00:20:56,410
al abrir un bloque

498
00:20:56,410 --> 00:20:58,589
si yo dejo la n

499
00:20:58,589 --> 00:20:59,710
declarada aquí dentro

500
00:20:59,710 --> 00:21:02,089
ya no va a ser accesible desde aquí

501
00:21:02,089 --> 00:21:04,329
entonces cuidado cuando

502
00:21:04,329 --> 00:21:05,549
abrimos los bloques

503
00:21:05,549 --> 00:21:08,210
porque entonces ahora esto tendría que estar

504
00:21:08,210 --> 00:21:09,890
declarado aquí

505
00:21:09,890 --> 00:21:12,289
y aquí

506
00:21:12,289 --> 00:21:14,130
simplemente dado su valor

507
00:21:14,130 --> 00:21:16,289
¿vale?

508
00:21:16,410 --> 00:21:17,829
Ya, ya, pero ¿por qué?

509
00:21:19,309 --> 00:21:19,789
Claro.

510
00:21:20,970 --> 00:21:22,630
Claro, pero ahora es por otra cosa.

511
00:21:23,349 --> 00:21:24,470
¿Por qué cosa es ahora?

512
00:21:25,750 --> 00:21:27,329
Claro, porque el try-catch

513
00:21:27,329 --> 00:21:28,750
en realidad es como,

514
00:21:29,130 --> 00:21:30,170
en cuanto a flujo,

515
00:21:30,650 --> 00:21:31,809
es como si fuera un if.

516
00:21:32,589 --> 00:21:34,390
Que es, oye tú,

517
00:21:34,950 --> 00:21:36,029
intenta hacer esto.

518
00:21:36,589 --> 00:21:38,930
Si tienes éxito, magnífico,

519
00:21:39,150 --> 00:21:40,410
n se quedará con ese valor.

520
00:21:40,990 --> 00:21:42,710
Pero si no tienes éxito,

521
00:21:43,549 --> 00:21:44,589
te vas al catch,

522
00:21:44,589 --> 00:21:45,769
que sería como el else.

523
00:21:46,410 --> 00:22:04,710
Con lo cual, el compilador que te verifica que todos los flujos estén cubiertos, que ninguna variable se quede abandonada sin inicializar cuando tú la usas después, el compilador te dice, uy, perdón, aquí hay un flujo, aquí hay un camino en el cual la n podría no estar inicializada.

524
00:22:04,710 --> 00:22:06,849
que es lo que hace el compilador, explorar todos los caminos

525
00:22:06,849 --> 00:22:08,869
sean posibles, no lo sean

526
00:22:08,869 --> 00:22:10,730
tengan sentido o no, el compilador

527
00:22:10,730 --> 00:22:12,089
se hace ahí su grafo de caminos

528
00:22:12,089 --> 00:22:14,630
y si en algún camino

529
00:22:14,630 --> 00:22:16,730
alguna variable usada

530
00:22:16,730 --> 00:22:18,049
está sin inicializar, la lía

531
00:22:18,049 --> 00:22:20,750
bueno, pues con este try-catch acabamos de abrir

532
00:22:20,750 --> 00:22:22,829
un camino en el cual n se quedaría

533
00:22:22,829 --> 00:22:24,670
sin inicializar, que es el

534
00:22:24,670 --> 00:22:26,569
camino n declarada

535
00:22:26,569 --> 00:22:28,650
esto no se llega a

536
00:22:28,650 --> 00:22:30,630
completar, porque ha saltado la

537
00:22:30,630 --> 00:22:32,470
excepción en la mitad, no se llega a

538
00:22:32,470 --> 00:22:34,630
completar, luego vamos por

539
00:22:34,630 --> 00:22:36,509
aquí y aquí a la n

540
00:22:36,509 --> 00:22:38,589
no se le hace nada, aquí a la n

541
00:22:38,589 --> 00:22:40,569
no se le hace nada, con lo cual

542
00:22:40,569 --> 00:22:42,190
me dice aquí, cuidado que

543
00:22:42,190 --> 00:22:44,430
he detectado un camino en el cual n

544
00:22:44,430 --> 00:22:45,970
podría no estar inicializada

545
00:22:45,970 --> 00:22:47,329
¿vale?

546
00:22:48,950 --> 00:22:50,630
vale, entonces bueno, ahora ya

547
00:22:50,630 --> 00:22:52,589
entramos en el juego de que queremos hacer

548
00:22:52,589 --> 00:22:54,950
que no queremos, depende de los requisitos de mi aplicación

549
00:22:54,950 --> 00:22:56,950
¿vale? vamos a imaginarnos

550
00:22:56,950 --> 00:22:58,450
que me dicen por

551
00:22:58,450 --> 00:23:00,490
defecto, si tú no te das número

552
00:23:00,490 --> 00:23:02,369
de candidatos, por defecto 5

553
00:23:02,369 --> 00:23:04,369
candidatos, por ejemplo

554
00:23:04,369 --> 00:23:07,029
Aquí ya entramos en todas las posibilidades

555
00:23:07,029 --> 00:23:09,609
Que podríamos hacer con estas reglas del juego

556
00:23:09,609 --> 00:23:11,630
Vale, pues por ejemplo

557
00:23:11,630 --> 00:23:12,990
Por ejemplo

558
00:23:12,990 --> 00:23:14,730
Si yo lo dejo así

559
00:23:14,730 --> 00:23:17,289
N por defecto

560
00:23:17,289 --> 00:23:19,009
Tendría 5 candidatos

561
00:23:19,009 --> 00:23:20,809
Yo la leo

562
00:23:20,809 --> 00:23:23,349
Si la lectura es correcta

563
00:23:23,349 --> 00:23:24,869
Pues ya está

564
00:23:24,869 --> 00:23:26,190
Serán los candidatos que me hayan dado

565
00:23:26,190 --> 00:23:28,410
Y si no es correcta

566
00:23:28,410 --> 00:23:30,049
Va a hacer esto de aquí

567
00:23:30,049 --> 00:23:31,190
Que es nada

568
00:23:31,190 --> 00:23:33,089
Y luego va a seguir

569
00:23:33,089 --> 00:23:35,430
Con lo cual este programa no va a parar nunca

570
00:23:35,430 --> 00:23:37,829
Por mucho que yo meta JJHH

571
00:23:37,829 --> 00:23:39,910
Va a seguir, luego es mucho más robusto

572
00:23:39,910 --> 00:23:41,589
Es mucho más robusto

573
00:23:41,589 --> 00:23:44,029
Aquí por ejemplo, para que el usuario supiera

574
00:23:44,029 --> 00:23:45,089
Podríamos avisarle

575
00:23:45,089 --> 00:23:48,210
Se establecen

576
00:23:48,210 --> 00:23:50,109
Los candidatos

577
00:23:50,109 --> 00:23:53,230
A 5

578
00:23:53,230 --> 00:23:55,890
Por defecto, por ejemplo

579
00:23:55,890 --> 00:23:58,529
Vale, pues esto es mucho más robusto

580
00:23:58,529 --> 00:23:59,230
Esto no se va a parar

581
00:23:59,230 --> 00:24:01,369
Que tú no me das un número válido

582
00:24:01,369 --> 00:24:03,670
No pasa nada

583
00:24:03,670 --> 00:24:05,369
Yo lo dejo en 5

584
00:24:05,369 --> 00:24:07,430
O en el que sea

585
00:24:07,430 --> 00:24:13,559
Vale, ya ejecutamos este programa

586
00:24:13,559 --> 00:24:17,200
¿Cuántos se presentan?

587
00:24:17,400 --> 00:24:18,160
Bla, bla, bla

588
00:24:18,160 --> 00:24:20,400
Vale, no me ha gustado

589
00:24:20,400 --> 00:24:21,859
Pero yo no me paro ahí

590
00:24:21,859 --> 00:24:23,539
No me ha gustado lo que me has dicho

591
00:24:23,539 --> 00:24:25,279
Pero yo sigo

592
00:24:25,279 --> 00:24:27,240
¿Veis?

593
00:24:30,450 --> 00:24:32,390
La excepción se ha generado igualmente

594
00:24:32,390 --> 00:24:33,450
Se ha instanciado el objeto

595
00:24:33,450 --> 00:24:36,089
Pero esas letras rojas no me han aparecido

596
00:24:36,089 --> 00:24:46,650
¿Vale? ¿Hasta aquí está claro?

597
00:24:48,150 --> 00:24:48,970
Entonces ese es el bloque

598
00:24:48,970 --> 00:24:51,130
try-catch básico, luego tiene

599
00:24:51,130 --> 00:24:53,470
pequeñas variantes que podemos incorporar

600
00:24:53,470 --> 00:24:55,170
¿vale? pero lo que importa es que el bloque

601
00:24:55,170 --> 00:24:56,309
try-catch básico

602
00:24:56,309 --> 00:24:59,130
lo que permite es que el

603
00:24:59,130 --> 00:25:01,109
programa no se detenga aunque

604
00:25:01,109 --> 00:25:07,940
salga una excepción, porque el

605
00:25:07,940 --> 00:25:09,019
bloque try-catch es así

606
00:25:09,019 --> 00:25:11,859
el catch es el que recibe

607
00:25:11,859 --> 00:25:13,940
la excepción, recordáis

608
00:25:13,940 --> 00:25:15,480
que he dicho antes que cuando este

609
00:25:15,480 --> 00:25:18,440
se ejecuta erróneamente

610
00:25:18,440 --> 00:25:20,160
genera el objeto

611
00:25:20,160 --> 00:25:22,059
y lo entrega al programa

612
00:25:22,059 --> 00:25:25,079
Pues ese va a parar ahí

613
00:25:25,079 --> 00:25:28,380
¿El tipo de objeto de excepción tiene que ser igual a la excepción que es?

614
00:25:28,880 --> 00:25:31,200
Igual o de una subclase

615
00:25:31,200 --> 00:25:32,400
¿Vale?

616
00:25:33,200 --> 00:25:34,380
Entonces si tú lo sabes

617
00:25:34,380 --> 00:25:36,900
Si tú lo sabes lo pones tal cual

618
00:25:36,900 --> 00:25:40,519
Si tú quieres capturar cualquier excepción que se genere

619
00:25:40,519 --> 00:25:42,160
Pero que no te sabes los nombres

620
00:25:42,160 --> 00:25:44,099
Puedes hacer esto

621
00:25:44,099 --> 00:25:48,079
Porque excepción es la superclase de todas

622
00:25:48,079 --> 00:25:51,380
Es la superclase de todas

623
00:25:51,380 --> 00:25:54,759
Pero esto tendría un pequeño inconveniente

624
00:25:54,759 --> 00:25:56,259
Ahora lo incorporamos

625
00:25:56,259 --> 00:25:56,480
¿Vale?

626
00:26:04,730 --> 00:26:05,390
A ver

627
00:26:05,390 --> 00:26:06,730
¿Por qué se me ha vuelto a poner rojo?

628
00:26:07,390 --> 00:26:08,089
¿Mis match?

629
00:26:09,970 --> 00:26:11,569
No, no, es porque en el AH

630
00:26:11,569 --> 00:26:12,289
No lo había puesto

631
00:26:12,289 --> 00:26:13,210
Vale

632
00:26:13,210 --> 00:26:15,950
Vale

633
00:26:15,950 --> 00:26:20,799
Bueno, hasta aquí está claro

634
00:26:20,799 --> 00:26:22,900
¿Vale?

635
00:26:24,079 --> 00:26:25,259
Aquí lo único es que

636
00:26:25,259 --> 00:26:27,039
Aquí vais a ver que en los cats

637
00:26:27,039 --> 00:26:29,380
siempre se pone una cosa por defecto

638
00:26:29,380 --> 00:26:31,799
porque cuando yo estoy haciendo un código

639
00:26:31,799 --> 00:26:33,799
estoy en la fase de creación de mi código

640
00:26:33,799 --> 00:26:34,960
lo estoy haciendo todavía

641
00:26:34,960 --> 00:26:37,940
yo necesito toda la información posible

642
00:26:37,940 --> 00:26:39,720
de por qué me pasan las cosas

643
00:26:39,720 --> 00:26:41,960
entonces yo estoy probando este código

644
00:26:41,960 --> 00:26:44,180
y en la prueba

645
00:26:44,180 --> 00:26:48,500
he visto que algo raro ha pasado

646
00:26:48,500 --> 00:26:50,019
porque se han establecido a 5

647
00:26:50,019 --> 00:26:52,240
pero no sé exactamente

648
00:26:52,240 --> 00:26:53,940
cuál ha sido el fallo, no lo sé

649
00:26:53,940 --> 00:26:55,740
entonces en los cats

650
00:26:55,740 --> 00:26:57,200
se suele poner

651
00:26:57,200 --> 00:26:59,500
se suele poner esto normalmente

652
00:26:59,500 --> 00:27:03,269
esta sentencia de aquí

653
00:27:03,269 --> 00:27:04,309
¿vale?

654
00:27:15,529 --> 00:27:17,150
esta sentencia de aquí

655
00:27:17,150 --> 00:27:19,130
¿qué es lo que hace?

656
00:27:19,589 --> 00:27:21,710
pues precisamente hacer un system out

657
00:27:21,710 --> 00:27:23,750
con las famosas letritas rojas

658
00:27:23,750 --> 00:27:25,170
es lo que hace

659
00:27:25,170 --> 00:27:26,890
entonces viene muy bien

660
00:27:26,890 --> 00:27:29,769
porque cuando tú estás probando tu código

661
00:27:29,769 --> 00:27:32,210
vas a ver todos los detalles

662
00:27:32,210 --> 00:27:33,950
de por qué te ha fallado, vas a verlo

663
00:27:33,950 --> 00:27:35,930
entonces en tiempo

664
00:27:35,930 --> 00:27:37,710
de escritura de código, estamos

665
00:27:37,710 --> 00:27:39,789
analizando la aplicación, esto

666
00:27:39,789 --> 00:27:42,289
conviene mantenerlo en todas las excepciones.

667
00:27:42,589 --> 00:27:42,990
En todas.

668
00:27:43,670 --> 00:27:45,730
Porque te permite sacar por consola

669
00:27:45,730 --> 00:27:47,509
la información de qué ha pasado.

670
00:27:48,170 --> 00:27:48,730
De qué ha pasado.

671
00:27:50,009 --> 00:27:51,769
Si yo no lo tengo, que es como

672
00:27:51,769 --> 00:27:53,730
teníamos antes, la excepción

673
00:27:53,730 --> 00:27:55,930
ha saltado, pero

674
00:27:55,930 --> 00:27:57,630
yo no he visto nada ahí, no he visto detalles

675
00:27:57,630 --> 00:28:00,009
de esa excepción. Si ponemos esto,

676
00:28:00,569 --> 00:28:01,750
¿qué es lo que hace esta

677
00:28:01,750 --> 00:28:04,069
sentencia? Pues el objeto excepción

678
00:28:04,069 --> 00:28:06,130
que es este, el objeto excepción

679
00:28:06,130 --> 00:28:07,690
que me ha llegado del next in

680
00:28:07,690 --> 00:28:09,829
el objeto excepción que me ha llegado

681
00:28:09,829 --> 00:28:11,549
pues llama

682
00:28:11,549 --> 00:28:13,910
a esto y que es lo que hace el print

683
00:28:13,910 --> 00:28:16,049
de stack 3, muestra su contenido

684
00:28:16,049 --> 00:28:16,690
interno

685
00:28:16,690 --> 00:28:19,869
esto es lo que hace el print de stack 3, mostrar

686
00:28:19,869 --> 00:28:21,490
el contenido interno de este objeto

687
00:28:21,490 --> 00:28:26,119
entonces si

688
00:28:26,119 --> 00:28:31,460
¿se inicializa eso con el error?

689
00:28:31,660 --> 00:28:32,180
¿con el tipo de error?

690
00:28:33,440 --> 00:28:34,500
¿se inicializa el qué?

691
00:28:34,500 --> 00:28:35,740
el input mismas

692
00:28:35,740 --> 00:28:41,579
Pero no he inicializado el qué

693
00:28:41,579 --> 00:28:45,900
Pero es que este es el parámetro

694
00:28:45,900 --> 00:28:48,240
Es una declaración del parámetro que recibe el catch

695
00:28:48,240 --> 00:28:50,460
Es como una declaración del parámetro de un método

696
00:28:50,460 --> 00:28:51,000
Vale

697
00:28:51,000 --> 00:28:54,619
Entonces esto lo que significa es

698
00:28:54,619 --> 00:28:55,740
Oye tú al catch

699
00:28:55,740 --> 00:28:57,700
Tú vas a recibir

700
00:28:57,700 --> 00:29:00,039
El objeto excepción

701
00:29:00,039 --> 00:29:02,019
Que es de esta clase

702
00:29:02,019 --> 00:29:04,440
Que es el que te habrá mandado este

703
00:29:04,440 --> 00:29:07,140
vale, es como una declaración de parámetros

704
00:29:07,140 --> 00:29:08,319
de un método, vale

705
00:29:08,319 --> 00:29:11,039
entonces si ejecutamos ahora este código con el

706
00:29:11,039 --> 00:29:12,220
print extract trace

707
00:29:12,220 --> 00:29:14,400
pues ahora ya

708
00:29:14,400 --> 00:29:18,380
veis, me sale esto

709
00:29:18,380 --> 00:29:19,900
este es el print extract trace

710
00:29:19,900 --> 00:29:22,680
el programa no para, el programa sigue, se establecen

711
00:29:22,680 --> 00:29:23,759
a 5, dime nombre

712
00:29:23,759 --> 00:29:26,440
pero me está mostrando

713
00:29:26,440 --> 00:29:27,759
datos sobre la excepción

714
00:29:27,759 --> 00:29:30,740
pues en qué momento del código fue

715
00:29:30,740 --> 00:29:32,440
qué excepción fue

716
00:29:32,440 --> 00:29:33,759
etcétera

717
00:29:33,759 --> 00:29:35,799
luego esta sentencia

718
00:29:35,799 --> 00:29:37,359
conviene ponerla dentro de los

719
00:29:37,359 --> 00:29:39,160
catch de cualquier try catch

720
00:29:39,160 --> 00:29:41,339
porque me va a dar información

721
00:29:41,339 --> 00:29:44,859
por consola, no es que

722
00:29:44,859 --> 00:29:45,799
pase, pero bueno

723
00:29:45,799 --> 00:29:52,609
te va a facilitar el desarrollo del código

724
00:29:52,609 --> 00:29:54,670
lógicamente, vas a saber cuando fallen las cosas

725
00:29:54,670 --> 00:29:56,549
una cosa es que tengas una excepción

726
00:29:56,549 --> 00:29:58,630
y otra cosa es que en un código normal

727
00:29:58,630 --> 00:30:00,789
lo normal es que tú tengas

728
00:30:00,789 --> 00:30:02,950
27.000

729
00:30:02,950 --> 00:30:04,490
excepciones distintas

730
00:30:05,049 --> 00:30:06,150
entonces si no

731
00:30:06,150 --> 00:30:08,569
vas dando los detalles de cada una

732
00:30:08,569 --> 00:30:10,509
pues depurar ese código es una

733
00:30:10,509 --> 00:30:11,210
barbaridad

734
00:30:11,210 --> 00:30:14,349
luego lógicamente

735
00:30:14,349 --> 00:30:16,750
cuando ya este código está estupendo

736
00:30:16,750 --> 00:30:18,589
perfecto, yo ya he pasado todas las fases

737
00:30:18,589 --> 00:30:20,029
de prueba, me encanta como está

738
00:30:20,029 --> 00:30:22,849
que bonito, y ya lo entrego

739
00:30:22,849 --> 00:30:24,829
para que se suba a producción

740
00:30:24,829 --> 00:30:26,130
y ya

741
00:30:26,130 --> 00:30:28,049
lo empiece a usar la gente

742
00:30:28,049 --> 00:30:30,549
entonces esto lo quito, lógicamente

743
00:30:30,549 --> 00:30:32,369
porque si no lo quito

744
00:30:32,369 --> 00:30:34,470
cada vez que el usuario meta mal el dato

745
00:30:34,470 --> 00:30:36,509
Le sale esto

746
00:30:36,509 --> 00:30:37,490
Que es muy feo

747
00:30:37,490 --> 00:30:38,490
¿Vale?

748
00:30:39,630 --> 00:30:42,230
Nosotros queremos que el usuario vea solamente esto

749
00:30:42,230 --> 00:30:44,049
Se establecen a 5, dime nombre

750
00:30:44,049 --> 00:30:45,109
No queremos que vea esto

751
00:30:45,109 --> 00:30:47,289
¿Vale? Esto no lo queremos

752
00:30:47,289 --> 00:30:50,230
Esta información nos viene muy bien a nosotros

753
00:30:50,230 --> 00:30:52,650
Mientras estamos desarrollando y probando el código

754
00:30:52,650 --> 00:30:54,710
Una vez que lo mandamos

755
00:30:54,710 --> 00:30:56,089
Ya a producción para que

756
00:30:56,089 --> 00:30:58,490
Los usuarios disfruten de él

757
00:30:58,490 --> 00:31:00,509
Pues quitamos esas cosas

758
00:31:00,509 --> 00:31:02,309
Claro, estas cosas las quitamos

759
00:31:02,309 --> 00:31:03,309
¿Vale?

760
00:31:04,470 --> 00:31:09,970
Las sustituiríamos por enviar a un fichero de log.

761
00:31:10,589 --> 00:31:13,049
Pero bueno, eso ya lo dejamos para el año que viene.

762
00:31:13,769 --> 00:31:13,930
¿Vale?

763
00:31:16,349 --> 00:31:17,970
Vale, pues este es el try catch.

764
00:31:19,950 --> 00:31:25,329
Entonces, en relación a la pregunta que hacía Nacho.

765
00:31:25,329 --> 00:31:33,910
A ver, lo normal es que tú pongas aquí la excepción que te va a generar.

766
00:31:34,470 --> 00:31:38,470
pero claro, las excepciones que hay muchísimas

767
00:31:38,470 --> 00:31:40,990
son todas herederas de exception

768
00:31:40,990 --> 00:31:44,109
hay tropecientas mil posibles excepciones

769
00:31:44,109 --> 00:31:47,029
y heredan todas de la superclase de exception

770
00:31:47,029 --> 00:31:49,089
entonces como ya sabéis

771
00:31:49,089 --> 00:31:54,250
una variable cae en su clase

772
00:31:54,250 --> 00:31:55,730
y en todas las superclases

773
00:31:55,730 --> 00:31:58,410
entonces yo podría también ponerlo así

774
00:31:58,410 --> 00:32:01,009
y ya está, y no pasa nada

775
00:32:01,009 --> 00:32:03,829
podría dejar aquí exception

776
00:32:03,829 --> 00:32:08,309
Podría dejar exception y vale

777
00:32:08,309 --> 00:32:09,349
Y ya está

778
00:32:09,349 --> 00:32:12,670
Porque tengo la seguridad de que el objeto

779
00:32:12,670 --> 00:32:13,650
Que va a lanzar este

780
00:32:13,650 --> 00:32:16,869
El objeto que va a lanzar es exception

781
00:32:16,869 --> 00:32:17,769
¿Vale?

782
00:32:18,869 --> 00:32:20,569
Claro, lo que no puedo es poner una excepción

783
00:32:20,569 --> 00:32:22,609
Que este código no va a poder lanzar nunca

784
00:32:22,609 --> 00:32:23,869
Por ejemplo

785
00:32:23,869 --> 00:32:26,309
Array index out of bound

786
00:32:26,309 --> 00:32:27,390
Era una excepción que es

787
00:32:27,390 --> 00:32:29,890
Array index

788
00:32:29,890 --> 00:32:33,819
Out of bound

789
00:32:33,819 --> 00:32:35,480
Exception

790
00:32:35,480 --> 00:32:40,849
Ah bueno, es que esta es

791
00:32:40,849 --> 00:32:42,710
Pero por ejemplo

792
00:32:42,710 --> 00:32:43,849
No, la voy a poner

793
00:32:43,849 --> 00:33:00,380
Por ejemplo, esta es otra excepción

794
00:33:00,380 --> 00:33:02,480
Otra excepción que está por ahí contemplada

795
00:33:02,480 --> 00:33:03,119
Y o exception

796
00:33:03,119 --> 00:33:05,819
Esta excepción es una excepción que sale

797
00:33:05,819 --> 00:33:07,940
Cuando uno trata de leer de un fichero

798
00:33:07,940 --> 00:33:09,000
Y no puede

799
00:33:09,000 --> 00:33:11,400
Entonces yo aquí no puedo plantar

800
00:33:11,400 --> 00:33:12,740
Captúramela y o exception

801
00:33:12,740 --> 00:33:15,220
Me va a decir, perdona

802
00:33:15,220 --> 00:33:18,019
Es que este bloque

803
00:33:18,019 --> 00:33:20,700
Nunca te va a dar esta

804
00:33:20,700 --> 00:33:21,619
Nunca te va a dar

805
00:33:21,619 --> 00:33:22,839
entonces no me captures esa

806
00:33:22,839 --> 00:33:25,680
¿vale? no me captures esa porque esa excepción

807
00:33:25,680 --> 00:33:27,480
nunca te la va a provocar ese bloque

808
00:33:27,480 --> 00:33:29,539
pero si yo pongo

809
00:33:29,539 --> 00:33:31,359
exception aquí no hay ningún problema

810
00:33:31,359 --> 00:33:33,980
porque exception es la super clase

811
00:33:33,980 --> 00:33:35,819
y por tanto input type mismatch

812
00:33:35,819 --> 00:33:36,380
exception

813
00:33:36,380 --> 00:33:39,819
hereda de esta, entonces esto encaja perfectamente

814
00:33:39,819 --> 00:33:42,440
¿vale?

815
00:33:48,279 --> 00:33:50,460
claro, cuando tú hayas hecho pruebas

816
00:33:50,460 --> 00:33:52,500
pues habrás visto cuál es

817
00:33:52,500 --> 00:33:53,259
¿vale?

818
00:33:53,259 --> 00:33:55,660
entonces cuál es el problema de poner

819
00:33:55,660 --> 00:33:57,900
exception, tiene un pequeño

820
00:33:57,900 --> 00:33:59,240
problema y es

821
00:33:59,240 --> 00:34:01,920
que este bloque puede tener un montón de

822
00:34:01,920 --> 00:34:03,579
cosas, yo puedo haber capturado

823
00:34:03,579 --> 00:34:05,660
un bloque de golpe para no ir tricat

824
00:34:05,660 --> 00:34:07,900
tricat por línea, entonces a lo mejor

825
00:34:07,900 --> 00:34:09,760
este bloque me genera

826
00:34:09,760 --> 00:34:11,039
un montón de cosas, por ejemplo

827
00:34:11,039 --> 00:34:13,840
yo que sé, para poner aquí algo

828
00:34:13,840 --> 00:34:15,800
luego lo, vamos a imaginarnos que

829
00:34:15,800 --> 00:34:16,920
tenemos aquí un

830
00:34:16,920 --> 00:34:18,699
un array

831
00:34:18,699 --> 00:34:36,539
por poner algo, y ahora yo me voy a hacer aquí

832
00:34:36,539 --> 00:34:40,460
Pues n de 0

833
00:34:40,460 --> 00:34:43,019
Perdón, números

834
00:34:43,019 --> 00:34:46,280
Números de 0

835
00:34:46,280 --> 00:34:48,460
Igual a 0

836
00:34:48,460 --> 00:34:49,480
A n

837
00:34:49,480 --> 00:34:53,820
Vale, a ver, por ejemplo

838
00:34:53,820 --> 00:34:56,079
Imaginaos capturar excepciones

839
00:34:56,079 --> 00:34:57,539
De que yo me salga un array

840
00:34:57,539 --> 00:34:58,840
Eso ya es demasiado

841
00:34:58,840 --> 00:35:01,260
Normalmente 1

842
00:35:01,260 --> 00:35:03,699
Es lo suficientemente cuidadoso

843
00:35:03,699 --> 00:35:05,940
Cuando hace su código, asegurarse de que sus for

844
00:35:05,940 --> 00:35:07,199
Y sus cosas no se salen del array

845
00:35:07,199 --> 00:35:10,880
Pero bueno, por poner aquí el ejemplo

846
00:35:10,880 --> 00:35:12,659
Aquí yo tengo dos sentencias

847
00:35:12,659 --> 00:35:16,239
Aquí en principio habría dos posibles excepciones

848
00:35:16,239 --> 00:35:21,739
Esta porque el tipo no case

849
00:35:21,739 --> 00:35:24,559
Y esta porque yo me salga del array

850
00:35:24,559 --> 00:35:26,260
Que de hecho me saldría

851
00:35:26,260 --> 00:35:28,960
Si la hago aquí

852
00:35:28,960 --> 00:35:31,159
Voy a poner la que estaba

853
00:35:31,159 --> 00:35:32,300
Esta de aquí

854
00:35:32,300 --> 00:35:40,760
Se llama así, ¿no?

855
00:35:40,760 --> 00:35:42,880
Input type

856
00:35:42,880 --> 00:35:45,480
O input mismatch

857
00:35:45,480 --> 00:35:46,699
Exception

858
00:35:46,699 --> 00:35:48,460
La he puesto bien, ¿no?

859
00:35:50,260 --> 00:35:50,820
Vale

860
00:35:50,820 --> 00:35:57,909
Vale, porque la había quitado del

861
00:35:57,909 --> 00:35:59,269
Vale

862
00:35:59,269 --> 00:36:02,150
Bueno, pues por ejemplo, yo ejecuto este código

863
00:36:02,150 --> 00:36:03,909
Ejecuto este código

864
00:36:03,909 --> 00:36:07,690
¿Cuánto se presenta? Le voy a poner el número

865
00:36:07,690 --> 00:36:08,630
Bueno, vale, 6

866
00:36:08,630 --> 00:36:11,150
Pues también

867
00:36:11,150 --> 00:36:13,889
En este caso, ¿qué excepción me ha salido de aquí?

868
00:36:14,570 --> 00:36:15,489
Esta no me ha salido

869
00:36:15,489 --> 00:36:17,070
Porque esta lo he hecho bien, he puesto 6

870
00:36:17,070 --> 00:36:18,650
Pero sin embargo aquí

871
00:36:18,650 --> 00:36:20,449
Aquí sí que me ha salido excepción

872
00:36:20,449 --> 00:36:22,989
Pero el catch no la ha capturado

873
00:36:22,989 --> 00:36:24,710
No la ha capturado

874
00:36:24,710 --> 00:36:27,409
Porque el catch sólo captura

875
00:36:27,409 --> 00:36:29,389
La excepción que yo le ponga aquí

876
00:36:29,389 --> 00:36:30,730
Sólo captura esta

877
00:36:30,730 --> 00:36:32,630
Entonces el programa ha parado

878
00:36:32,630 --> 00:36:33,969
Este programa mío terminó

879
00:36:33,969 --> 00:36:36,909
Porque aquí hay dos posibles excepciones

880
00:36:36,909 --> 00:36:38,369
Pero sólo está capturada la primera

881
00:36:38,369 --> 00:36:39,809
¿Vale?

882
00:36:41,610 --> 00:36:42,250
Entonces

883
00:36:42,250 --> 00:36:45,170
¿Qué pasa si yo

884
00:36:45,170 --> 00:36:48,579
Cambio y pongo esta

885
00:36:48,579 --> 00:36:54,139
ahora ya este catch

886
00:36:54,139 --> 00:36:55,860
me vale para las dos

887
00:36:55,860 --> 00:36:58,059
porque las dos

888
00:36:58,059 --> 00:37:00,239
la rain desbound exception

889
00:37:00,239 --> 00:37:02,659
esta de aquí, la rain desoutbound exception

890
00:37:02,659 --> 00:37:03,739
esta

891
00:37:03,739 --> 00:37:06,179
y la

892
00:37:06,179 --> 00:37:08,239
input miss match exception, las dos

893
00:37:08,239 --> 00:37:10,199
heredan de exception, con lo cual

894
00:37:10,199 --> 00:37:11,900
ahora este catch me vale para las dos

895
00:37:11,900 --> 00:37:13,500
entonces si yo pongo exception

896
00:37:13,500 --> 00:37:15,639
me da igual que la cague por aquí

897
00:37:15,639 --> 00:37:18,280
que la cague por aquí, se va a hacer

898
00:37:18,280 --> 00:37:18,659
esto

899
00:37:18,659 --> 00:37:20,679
Y voy a seguir

900
00:37:20,679 --> 00:37:22,300
Con el programa sin parar

901
00:37:22,300 --> 00:37:23,199
¿Vale?

902
00:37:24,159 --> 00:37:25,619
Es decir, yo ahora meto

903
00:37:25,619 --> 00:37:27,300
76

904
00:37:27,300 --> 00:37:30,380
Efectivamente

905
00:37:30,380 --> 00:37:31,780
Aquí la he cagado

906
00:37:31,780 --> 00:37:33,500
Aquí la he cagado

907
00:37:33,500 --> 00:37:35,039
Pero el programa no ha parado

908
00:37:35,039 --> 00:37:37,320
Me ha hecho el catch, lo ha capturado

909
00:37:37,320 --> 00:37:39,440
Y ha seguido, dime nombre patatín

910
00:37:39,440 --> 00:37:42,280
Luego en principio no podría pensar

911
00:37:42,280 --> 00:37:44,099
Ah vale, pues mira, pongo aquí exception

912
00:37:44,099 --> 00:37:46,539
Y genial, pase lo que pase

913
00:37:46,539 --> 00:37:48,000
En el código que hay aquí dentro

914
00:37:48,000 --> 00:37:49,659
pase lo que pase

915
00:37:49,659 --> 00:37:51,940
voy a ir al catch

916
00:37:51,940 --> 00:37:52,880
y el programa va a seguir

917
00:37:52,880 --> 00:37:56,099
pero aquí es donde viene el pequeño problema

918
00:37:56,099 --> 00:37:58,079
que es feo, claro, es que yo no

919
00:37:58,079 --> 00:37:59,920
quiero tratar todas las excepciones

920
00:37:59,920 --> 00:38:01,800
por igual, si pasa esto

921
00:38:01,800 --> 00:38:02,760
quiero hacer una cosa

922
00:38:02,760 --> 00:38:05,559
¿vale? pero es que fijaos lo que ha pasado

923
00:38:05,559 --> 00:38:07,940
aquí me ha metido el número estupendamente

924
00:38:07,940 --> 00:38:09,639
¿vale? imaginaos que este

925
00:38:09,639 --> 00:38:12,119
catch fuera, se establecen

926
00:38:12,119 --> 00:38:13,500
los candidatos por defecto

927
00:38:13,500 --> 00:38:14,699
y yo pongo aquí

928
00:38:14,699 --> 00:38:21,170
n igual a 10 que son los candidatos por defecto

929
00:38:21,170 --> 00:38:23,289
por ejemplo, con lo cual ya no me hace falta

930
00:38:23,289 --> 00:38:24,090
inicializarla

931
00:38:24,090 --> 00:38:26,429
porque en cualquiera de los caminos

932
00:38:26,429 --> 00:38:29,150
ahora ya el compilador ya le parece que tiene

933
00:38:29,150 --> 00:38:31,389
valor, imaginaos que mi código es este

934
00:38:31,389 --> 00:38:33,130
si salta

935
00:38:33,130 --> 00:38:34,849
excepción se establecen por defecto

936
00:38:34,849 --> 00:38:35,489
n igual a 10

937
00:38:35,489 --> 00:38:38,809
vale, que he ganado poniendo excepción

938
00:38:38,809 --> 00:38:40,650
una cosa buena he ganado

939
00:38:40,650 --> 00:38:42,590
y es que si esta

940
00:38:42,590 --> 00:38:45,269
funciona bien, pero esta casca

941
00:38:45,269 --> 00:38:46,769
el programa no para

942
00:38:46,769 --> 00:38:49,050
se va al catch y no para

943
00:38:49,050 --> 00:38:50,929
luego en ese sentido es robusto

944
00:38:50,929 --> 00:38:52,630
vale, pero jolín

945
00:38:52,630 --> 00:38:53,489
¿a costa de qué?

946
00:38:54,170 --> 00:38:56,769
de haber ignorado completamente el n

947
00:38:56,769 --> 00:38:58,269
del usuario

948
00:38:58,269 --> 00:39:00,590
porque la excepción me ha salido aquí

949
00:39:00,590 --> 00:39:02,389
y yo lo he puesto aquí a 10

950
00:39:02,389 --> 00:39:04,670
entonces esto tampoco está muy bonito

951
00:39:04,670 --> 00:39:06,789
¿entendéis por qué

952
00:39:06,789 --> 00:39:09,030
la solución de meter todas las excepciones

953
00:39:09,030 --> 00:39:09,889
en el mismo saco

954
00:39:09,889 --> 00:39:12,829
tampoco es buena? porque no las quiero tratar todas por igual

955
00:39:12,829 --> 00:39:14,670
si la que me sale es esta

956
00:39:14,670 --> 00:39:16,909
quiero hacer una cosa que es n igual a 10

957
00:39:16,909 --> 00:39:18,730
pero si la que me sale es esta

958
00:39:18,730 --> 00:39:20,250
entonces quiero hacer otra distinta

959
00:39:20,250 --> 00:39:22,849
no quiero hacer el n igual a 10, la que me sale es esta

960
00:39:22,849 --> 00:39:24,190
entonces

961
00:39:24,190 --> 00:39:26,550
no las meto todas dentro del mismo paraguas

962
00:39:26,550 --> 00:39:28,730
exception, ¿qué es lo que puedo hacer en este

963
00:39:28,730 --> 00:39:30,530
caso? me hago tantos

964
00:39:30,530 --> 00:39:32,210
cats como excepciones tenga

965
00:39:32,210 --> 00:39:34,530
que ese es el try multi

966
00:39:34,530 --> 00:39:36,670
cats, entonces

967
00:39:36,670 --> 00:39:38,489
yo aquí me haría

968
00:39:38,489 --> 00:39:40,510
primero mi cats para la

969
00:39:40,510 --> 00:39:42,369
mismas exception

970
00:39:42,369 --> 00:39:50,199
esta, que

971
00:39:50,199 --> 00:39:53,469
Vale

972
00:39:53,469 --> 00:39:56,190
Entonces, si la que me sale

973
00:39:56,190 --> 00:39:57,989
Es esta, genial

974
00:39:57,989 --> 00:39:58,889
Entra aquí

975
00:39:58,889 --> 00:40:01,230
Y me hace el n igual a 10

976
00:40:01,230 --> 00:40:03,989
Pero, ¿qué pasa si la que me sale es esta?

977
00:40:04,489 --> 00:40:06,190
Si la que me sale es esta, también quiero

978
00:40:06,190 --> 00:40:08,190
Capturarla, no quiero que se pare

979
00:40:08,190 --> 00:40:09,909
Pues otro catch

980
00:40:09,909 --> 00:40:11,869
¿Qué excepción era esta?

981
00:40:12,650 --> 00:40:13,989
Esa era la de

982
00:40:13,989 --> 00:40:16,030
La he quitado, array index out of bound

983
00:40:16,030 --> 00:40:16,429
¿No?

984
00:40:17,429 --> 00:40:18,070
Array

985
00:40:18,070 --> 00:40:21,670
Index out of

986
00:40:21,670 --> 00:40:24,719
bounce

987
00:40:24,719 --> 00:40:26,940
excepción

988
00:40:26,940 --> 00:40:37,110
y por ejemplo ponemos

989
00:40:37,110 --> 00:40:38,250
no he podido

990
00:40:38,250 --> 00:40:40,349
rellenar el array

991
00:40:40,349 --> 00:40:45,119
ahora ya, bien, ahora ya esto está mejor

992
00:40:45,119 --> 00:40:47,239
vale, las estoy tratando

993
00:40:47,239 --> 00:40:48,300
por separado

994
00:40:48,300 --> 00:40:53,539
vale, las estoy tratando

995
00:40:53,539 --> 00:40:54,219
por separado

996
00:40:54,219 --> 00:40:57,760
si este código me falla por la de arriba

997
00:40:57,760 --> 00:40:59,300
me pone n igual a 10

998
00:40:59,300 --> 00:41:01,980
si este código

999
00:41:01,980 --> 00:41:03,619
me falla por la de abajo

1000
00:41:03,619 --> 00:41:04,500
no por esta

1001
00:41:04,500 --> 00:41:06,800
no me pone n igual a 10

1002
00:41:06,800 --> 00:41:09,139
luego el n será el que se haya recibido

1003
00:41:09,139 --> 00:41:09,440
aquí

1004
00:41:09,440 --> 00:41:12,920
y me hace lo que sea, en este caso

1005
00:41:12,920 --> 00:41:14,239
pues no he podido rellenar el array

1006
00:41:14,239 --> 00:41:16,980
¿vale? ya está

1007
00:41:16,980 --> 00:41:21,150
entonces la idea es

1008
00:41:21,150 --> 00:41:23,190
tratar a las excepciones por separado

1009
00:41:23,190 --> 00:41:25,670
¿vale?

1010
00:41:27,579 --> 00:41:29,440
entonces es un rollo porque hay que

1011
00:41:29,440 --> 00:41:32,079
saber de alguna manera que excepciones

1012
00:41:32,079 --> 00:41:33,940
generan nuestros códigos

1013
00:41:33,940 --> 00:41:35,679
pero no se capturan tampoco

1014
00:41:35,679 --> 00:41:37,980
lo que pasa es que

1015
00:41:37,980 --> 00:41:39,280
hay dos tipos de excepciones

1016
00:41:39,280 --> 00:41:41,179
Que eso bueno

1017
00:41:41,179 --> 00:41:42,400
Ya lo tenemos que ver el próximo día

1018
00:41:42,400 --> 00:41:47,389
Y las que no son obligatorias

1019
00:41:47,389 --> 00:41:48,849
De capturar como estas

1020
00:41:48,849 --> 00:41:49,929
Pues bueno

1021
00:41:49,929 --> 00:41:52,469
No se suelen capturar tanto

1022
00:41:52,469 --> 00:41:56,159
Capturar esta excepción repito

1023
00:41:56,159 --> 00:41:58,099
Por ejemplo es absurdo

1024
00:41:58,099 --> 00:42:00,039
Se supone que partimos

1025
00:42:00,039 --> 00:42:01,320
De que uno cuando está programando

1026
00:42:01,320 --> 00:42:02,780
Sabe hacer sus for y sus cosas

1027
00:42:02,780 --> 00:42:03,860
Para no salirse del array

1028
00:42:03,860 --> 00:42:05,920
Y sabe que hay un parámetro length

1029
00:42:05,920 --> 00:42:08,780
Con el que validar si te has salido del length o no

1030
00:42:08,780 --> 00:42:12,460
Entonces capturar esa excepción

1031
00:42:12,460 --> 00:42:13,119
es un poco raro

1032
00:42:13,119 --> 00:42:21,000
para muchas cosas

1033
00:42:21,000 --> 00:42:22,059
son

1034
00:42:22,059 --> 00:42:23,159
sobre todo

1035
00:42:23,159 --> 00:42:24,340
para

1036
00:42:24,340 --> 00:42:25,760
hacer el programa

1037
00:42:25,760 --> 00:42:26,320
robusto

1038
00:42:26,320 --> 00:42:26,800
en el sentido

1039
00:42:26,800 --> 00:42:28,139
de que no va a parar

1040
00:42:28,139 --> 00:42:30,059
porque pase algo raro

1041
00:42:30,059 --> 00:42:31,159
porque tú le estás dando

1042
00:42:31,159 --> 00:42:32,019
una vía alternativa

1043
00:42:32,019 --> 00:42:33,019
¿vale?

1044
00:42:33,699 --> 00:42:34,519
eso es lo fundamental

1045
00:42:34,519 --> 00:42:35,739
tú le das una vía alternativa

1046
00:42:35,739 --> 00:42:36,860
y en esa vía alternativa

1047
00:42:36,860 --> 00:42:37,380
en el catch

1048
00:42:37,380 --> 00:42:38,860
se lo vuelves a pedir

1049
00:42:38,860 --> 00:42:39,800
lo que tú quieras

1050
00:42:39,800 --> 00:42:40,559
¿vale?

1051
00:42:40,739 --> 00:42:41,280
eso por un lado

1052
00:42:41,280 --> 00:42:41,980
y luego por otro lado

1053
00:42:41,980 --> 00:42:43,139
intercambiarse información

1054
00:42:43,139 --> 00:42:43,960
entre clases

1055
00:42:43,960 --> 00:42:45,079
¿vale?

1056
00:42:45,159 --> 00:42:45,320
que

1057
00:42:45,320 --> 00:42:46,980
es que no

1058
00:42:46,980 --> 00:42:50,440
Vamos, que tenemos que continuar viendo

1059
00:42:50,440 --> 00:42:51,639
Lo que nos faltan cosas aquí

1060
00:42:51,639 --> 00:42:54,380
Lo que hemos visto hasta ahora es

1061
00:42:54,380 --> 00:42:55,920
La primera de las prestaciones

1062
00:42:55,920 --> 00:42:57,900
Que es evitar que el programa pare

1063
00:42:57,900 --> 00:42:59,659
Porque tú le das una vía alternativa

1064
00:42:59,659 --> 00:43:01,719
Y en esa vía ya lo que tú quieras

1065
00:43:01,719 --> 00:43:04,840
Meterte en el bucle para que te lo vuelva a pedir

1066
00:43:04,840 --> 00:43:05,679
Lo que tú quieras

1067
00:43:05,679 --> 00:43:07,519
Fijaros un valor por defecto, lo que sea

1068
00:43:07,519 --> 00:43:08,860
Tú ya juegas con eso como quieras

1069
00:43:08,860 --> 00:43:12,300
Aquí como veis, el compilador

1070
00:43:12,300 --> 00:43:13,099
Que es un pesado

1071
00:43:13,099 --> 00:43:15,840
El compilador solamente se hace

1072
00:43:15,840 --> 00:43:17,199
su grafo de caminos

1073
00:43:17,199 --> 00:43:19,440
y es que el compilador es

1074
00:43:19,440 --> 00:43:20,739
muy tonto porque

1075
00:43:20,739 --> 00:43:24,019
su grafo de caminos, aunque tú le pongas un if

1076
00:43:24,019 --> 00:43:26,059
con una condición que va a ser falso siempre

1077
00:43:26,059 --> 00:43:27,639
porque tú lo sabes, lo estás haciendo

1078
00:43:27,639 --> 00:43:28,719
va a ser falso siempre

1079
00:43:28,719 --> 00:43:32,159
el grafo de caminos considera que entras en ese if

1080
00:43:32,159 --> 00:43:34,000
pues aquí igual

1081
00:43:34,000 --> 00:43:35,619
al añadir yo este catch

1082
00:43:35,619 --> 00:43:38,519
el compilador

1083
00:43:38,519 --> 00:43:39,900
automáticamente ve

1084
00:43:39,900 --> 00:43:42,019
que se ha abierto otro camino

1085
00:43:42,019 --> 00:43:43,840
nuevo, tenemos este camino

1086
00:43:43,840 --> 00:43:45,199
este y este

1087
00:43:45,199 --> 00:43:47,940
su grafo de camino se ha ampliado con este

1088
00:43:47,940 --> 00:43:50,039
y en este n no tiene nada

1089
00:43:50,039 --> 00:43:52,059
con lo cual

1090
00:43:52,059 --> 00:43:53,860
el compilador aquí se nos ha vuelto a quejar

1091
00:43:53,860 --> 00:43:54,500
por este n

1092
00:43:54,500 --> 00:43:57,579
porque repito, el compilador no mira

1093
00:43:57,579 --> 00:43:59,199
significados

1094
00:43:59,199 --> 00:44:01,679
mira posibles caminos

1095
00:44:01,679 --> 00:44:03,559
aunque no sean

1096
00:44:03,559 --> 00:44:05,579
alcanzables, o sea, el camino de llegar aquí

1097
00:44:05,579 --> 00:44:07,460
sin tener n un valor

1098
00:44:07,460 --> 00:44:08,960
no es posible

1099
00:44:08,960 --> 00:44:12,019
porque llegamos aquí, se ha saltado esta excepción

1100
00:44:12,019 --> 00:44:13,860
y para haber saltado

1101
00:44:13,860 --> 00:44:14,679
esta excepción

1102
00:44:14,679 --> 00:44:17,280
esto tenemos que haberlo completado entero

1103
00:44:17,280 --> 00:44:19,059
con lo cual n tendría algo

1104
00:44:19,059 --> 00:44:21,360
entonces nosotros sabemos que

1105
00:44:21,360 --> 00:44:23,500
n siempre va a tener un valor para el compilador

1106
00:44:23,500 --> 00:44:25,500
¿no? pues entonces pues yo que sé

1107
00:44:25,500 --> 00:44:27,340
ponemos aquí

1108
00:44:27,340 --> 00:44:28,659
lo que sea, esto ya

1109
00:44:28,659 --> 00:44:31,320
lo que decidamos

1110
00:44:31,320 --> 00:44:33,519
en función de requisitos de la aplicación

1111
00:44:33,519 --> 00:44:38,719
¿vale? ¿hasta aquí está claro?

1112
00:44:39,940 --> 00:44:40,420
vale

1113
00:44:40,420 --> 00:44:42,679
bueno, pues mañana entonces seguimos

1114
00:44:42,679 --> 00:44:44,780
con esto de excepciones, que nos queda un poquito todavía