1
00:00:00,000 --> 00:00:04,099
Que aunque se vea al revés, lo que importa es hacerse una idea de lo que se ha contado

2
00:00:04,099 --> 00:00:07,419
y volver a oírlo por si algo no ha quedado claro, simplemente.

3
00:00:09,279 --> 00:00:12,140
Bueno, vamos a completar con lo de excepciones.

4
00:00:13,400 --> 00:00:21,039
Lo que contamos el otro día era simplemente que las excepciones son una forma

5
00:00:21,039 --> 00:00:25,300
que tiene el código de avisar de que ha pasado algo raro.

6
00:00:25,300 --> 00:00:27,859
entonces un código

7
00:00:27,859 --> 00:00:29,839
siempre puede avisar

8
00:00:29,839 --> 00:00:31,899
si nosotros lo programamos así, claro

9
00:00:31,899 --> 00:00:34,119
de que han pasado cosas de mil maneras

10
00:00:34,119 --> 00:00:36,439
pues puede avisar

11
00:00:36,439 --> 00:00:38,640
mostrando un mensaje por consola

12
00:00:38,640 --> 00:00:40,840
puede avisar

13
00:00:40,840 --> 00:00:42,619
en el caso de que estemos haciendo un método

14
00:00:42,619 --> 00:00:46,280
puede avisar

15
00:00:46,280 --> 00:00:48,219
mediante el valor de retorno

16
00:00:48,219 --> 00:00:50,979
y lo ponemos aquí

17
00:00:50,979 --> 00:00:52,560
si el valor de retorno es cero

18
00:00:52,560 --> 00:00:53,820
es que ha pasado no sé qué

19
00:00:53,820 --> 00:00:55,979
eso lo estuvimos viendo el otro día

20
00:00:55,979 --> 00:00:57,079
puede avisar de muchas formas

21
00:00:57,079 --> 00:01:00,159
pero cada una de ellas tiene sus

22
00:01:00,159 --> 00:01:01,840
inconvenientes, esta

23
00:01:01,840 --> 00:01:03,759
que este aviso para qué sirve

24
00:01:03,759 --> 00:01:06,319
pues solo porque si hay alguien sentado delante en la consola

25
00:01:06,319 --> 00:01:07,120
lo lea

26
00:01:07,120 --> 00:01:09,879
lo lea y decida parar

27
00:01:09,879 --> 00:01:11,859
en el programa y decida hacer algo

28
00:01:11,859 --> 00:01:12,500
vale

29
00:01:12,500 --> 00:01:16,140
bajo esas circunstancias que son un poco raras

30
00:01:16,140 --> 00:01:18,060
que haya alguien sentado para leerlo y entonces

31
00:01:18,060 --> 00:01:19,200
decidir cómo actúa

32
00:01:19,200 --> 00:01:21,659
y esto de aquí lo mismo, vale

33
00:01:21,659 --> 00:01:23,939
si es que este valor de retorno no tiene ya

34
00:01:23,939 --> 00:01:24,840
un uso concreto

35
00:01:24,840 --> 00:01:27,620
si este valor de retorno tiene un uso concreto

36
00:01:27,620 --> 00:01:29,379
que es devolver el resultado

37
00:01:29,379 --> 00:01:30,760
de este método

38
00:01:30,760 --> 00:01:33,219
pues si tiene ese uso concreto

39
00:01:33,219 --> 00:01:35,540
no podemos usarlo como código

40
00:01:35,540 --> 00:01:37,719
de error o como código de lo que ha pasado

41
00:01:37,719 --> 00:01:39,560
¿vale? no podemos

42
00:01:39,560 --> 00:01:41,500
porque ya tiene un uso concreto que es

43
00:01:41,500 --> 00:01:43,640
devolver la suma, la multiplicación, lo que sea

44
00:01:43,640 --> 00:01:44,299
que sea de aquí

45
00:01:44,299 --> 00:01:47,560
entonces hay un mecanismo para avisar de que algo

46
00:01:47,560 --> 00:01:49,200
raro ha pasado, que es el de excepciones

47
00:01:49,200 --> 00:01:51,120
que

48
00:01:51,120 --> 00:01:54,439
se puede hacer

49
00:01:54,439 --> 00:01:56,680
en cualquier momento del código

50
00:01:56,680 --> 00:01:58,540
escribiendo esto

51
00:01:58,540 --> 00:01:59,840
como vimos el otro día

52
00:01:59,840 --> 00:02:04,670
esto y aquí un objeto excepción

53
00:02:04,670 --> 00:02:07,030
un objeto excepción

54
00:02:07,030 --> 00:02:07,609
el que sea

55
00:02:07,609 --> 00:02:11,800
¿vale?

56
00:02:12,039 --> 00:02:14,400
esta es una sentencia más de código en Java

57
00:02:14,400 --> 00:02:14,960
el throw

58
00:02:14,960 --> 00:02:16,159
entonces

59
00:02:16,159 --> 00:02:19,580
cuando la máquina virtual

60
00:02:19,580 --> 00:02:21,539
se encuentra esta sentencia escrita

61
00:02:21,539 --> 00:02:23,439
lo que hace es

62
00:02:23,439 --> 00:02:25,139
crear un objeto

63
00:02:25,139 --> 00:02:27,120
de este tipo

64
00:02:27,120 --> 00:02:29,599
instanciar un objeto como este

65
00:02:29,599 --> 00:02:31,180
instanciarlo

66
00:02:31,180 --> 00:02:33,500
y si

67
00:02:33,500 --> 00:02:35,520
no hay nada más, si no hay más indicaciones

68
00:02:35,520 --> 00:02:37,159
que esto, no hay nada más puesto en el código

69
00:02:37,159 --> 00:02:38,039
lo que hace es

70
00:02:38,039 --> 00:02:41,259
mostrar un aviso

71
00:02:41,259 --> 00:02:43,120
mediante letras rojas en la consola que estamos

72
00:02:43,120 --> 00:02:45,439
acostumbrados a verlo, un aviso con letras rojas

73
00:02:45,439 --> 00:02:47,099
en la consola que estamos acostumbrados

74
00:02:47,099 --> 00:02:48,219
y además

75
00:02:48,219 --> 00:02:51,560
parar el programa, eso es lo que hace

76
00:02:51,560 --> 00:02:52,759
muestra

77
00:02:52,759 --> 00:02:54,740
una traza roja

78
00:02:54,740 --> 00:02:56,759
con información sobre lo que ha pasado

79
00:02:56,759 --> 00:02:57,500
y para el programa.

80
00:02:58,280 --> 00:02:59,819
Eso es lo que hace la máquina virtual

81
00:02:59,819 --> 00:03:02,139
cuando se encuentra esta sentencia.

82
00:03:03,719 --> 00:03:03,919
¿Vale?

83
00:03:04,580 --> 00:03:06,300
Y eso nos ha pasado un montón de veces.

84
00:03:06,300 --> 00:03:08,280
El ver que salían letras rojas

85
00:03:08,280 --> 00:03:09,539
y que el programa paraba.

86
00:03:09,699 --> 00:03:11,300
Nos ha pasado un montón de veces.

87
00:03:11,439 --> 00:03:11,699
¿Por qué?

88
00:03:12,340 --> 00:03:13,939
Porque hemos llamado a métodos,

89
00:03:14,039 --> 00:03:14,939
hemos hecho cosas

90
00:03:14,939 --> 00:03:17,520
que cuando se ha entrado en ese método

91
00:03:17,520 --> 00:03:19,580
la máquina virtual se ha encontrado esto.

92
00:03:21,020 --> 00:03:21,259
¿Vale?

93
00:03:21,259 --> 00:03:25,740
pues cuando hemos tratado de acceder a objetos que eran nulos

94
00:03:25,740 --> 00:03:28,560
cuando hemos llamado a métodos de leer por teclado

95
00:03:28,560 --> 00:03:30,240
por ejemplo next in

96
00:03:30,240 --> 00:03:34,000
y lo que le hemos pasado era una cadena con caracteres

97
00:03:34,000 --> 00:03:36,800
entonces ese next in ha entrado dentro y ha visto

98
00:03:36,800 --> 00:03:39,580
uy es un carácter, pues ese next in tiene dentro el throw

99
00:03:39,580 --> 00:03:43,199
entonces cuando una excepción aparece

100
00:03:43,199 --> 00:03:44,780
no es que se haya roto algo

101
00:03:44,780 --> 00:03:49,500
es simplemente que se ha ejecutado una línea de código como esta

102
00:03:49,500 --> 00:03:51,639
ya está, se ha ejecutado una línea de código como esa

103
00:03:51,639 --> 00:03:53,879
esa línea de código

104
00:03:53,879 --> 00:03:55,780
lo normal es que vaya lógicamente

105
00:03:55,780 --> 00:03:57,419
dentro de un if, claro

106
00:03:57,419 --> 00:03:59,840
un if

107
00:03:59,840 --> 00:04:01,780
de verificación, ¿qué ha pasado esa cosa

108
00:04:01,780 --> 00:04:03,740
rara? que yo me esperaba

109
00:04:03,740 --> 00:04:05,280
un número y tengo un carácter

110
00:04:05,280 --> 00:04:07,580
que este objeto es nulo

111
00:04:07,580 --> 00:04:09,759
lo que sea, ¿qué ha pasado una cosa

112
00:04:09,759 --> 00:04:10,860
rara? pues throw

113
00:04:10,860 --> 00:04:13,919
lo normal es que esos throw por tanto estén dentro de if

114
00:04:13,919 --> 00:04:15,659
y si ha pasado algo

115
00:04:15,659 --> 00:04:17,399
uno decida que se lance excepción

116
00:04:17,399 --> 00:04:41,060
Entonces, es la mejor manera de avisar de que algo ha pasado, ¿vale? Y repito, la respuesta de la máquina virtual a esta sentencia cuando se la encuentra, si no hay nada más que esto, si no hay nada más, es mostrar la traza roja con información y detener la ejecución, ¿vale? Detenerla y ya está, detenerla.

117
00:04:41,060 --> 00:04:42,899
vale, entonces

118
00:04:42,899 --> 00:04:44,959
¿qué vimos el otro día? bueno, pues cuando

119
00:04:44,959 --> 00:04:46,959
pasa esto, cuando

120
00:04:46,959 --> 00:04:48,860
la máquina virtual encuentra

121
00:04:48,860 --> 00:04:51,240
este throw y lanza la excepción

122
00:04:51,240 --> 00:04:53,100
y se para

123
00:04:53,100 --> 00:04:54,899
la máquina virtual, sabemos que

124
00:04:54,899 --> 00:04:56,800
tenemos una manera de alterar este

125
00:04:56,800 --> 00:04:58,899
funcionamiento, de alterarlo

126
00:04:58,899 --> 00:05:00,980
tenemos una manera de alterarlo, y es

127
00:05:00,980 --> 00:05:02,980
oye, en este código

128
00:05:02,980 --> 00:05:05,120
que me puede lanzar

129
00:05:05,120 --> 00:05:06,339
por ejemplo, nosotros tenemos

130
00:05:06,339 --> 00:05:08,680
un objeto scanner

131
00:05:08,680 --> 00:05:10,920
que va a leer

132
00:05:10,920 --> 00:05:14,250
tenemos esta sentencia

133
00:05:14,250 --> 00:05:17,089
¿vale? tenemos esta sentencia de aquí

134
00:05:17,089 --> 00:05:17,610
nextIn

135
00:05:17,610 --> 00:05:19,509
entonces este es un método

136
00:05:19,509 --> 00:05:22,889
este es un método al que la máquina virtual salta

137
00:05:22,889 --> 00:05:25,810
la máquina virtual salta

138
00:05:25,810 --> 00:05:27,329
y se pone a leer

139
00:05:27,329 --> 00:05:29,069
del teclado, a hacer cositas

140
00:05:29,069 --> 00:05:30,930
entonces si detecta

141
00:05:30,930 --> 00:05:33,509
que lo que ha leído son caracteres

142
00:05:33,509 --> 00:05:35,670
si detecta que lo que ha leído son caracteres

143
00:05:35,670 --> 00:05:36,569
pues hace el throw

144
00:05:36,569 --> 00:05:38,230
el throw este

145
00:05:38,230 --> 00:05:41,370
y este throw en particular

146
00:05:41,370 --> 00:05:42,829
que hace el next in dentro

147
00:05:42,829 --> 00:05:45,110
será un throw del tipo

148
00:05:45,110 --> 00:05:47,449
algo así

149
00:05:47,449 --> 00:06:09,709
creo que se llamaba así

150
00:06:09,709 --> 00:06:11,689
la excepción que nos salía cuando intentábamos

151
00:06:11,689 --> 00:06:12,410
leer un número

152
00:06:12,410 --> 00:06:15,069
y resulta que no era número

153
00:06:15,069 --> 00:06:16,889
sino que era carácter

154
00:06:16,889 --> 00:06:21,100
ah, no era number format exceptio

155
00:06:21,100 --> 00:06:23,240
una de las dos, o input type o number format

156
00:06:23,240 --> 00:06:25,139
da igual

157
00:06:25,139 --> 00:06:36,560
vale

158
00:06:47,470 --> 00:06:52,529
Bueno, pues esto de aquí estará dentro del método NextIn, ¿verdad? Estará dentro.

159
00:06:53,009 --> 00:06:58,430
El método NextIn se pone a coger del buffer, del teclado, se pone a verificar cosas,

160
00:06:58,930 --> 00:07:03,269
si verifica que la cadena no son números, hace el throw, ¿vale?

161
00:07:03,629 --> 00:07:06,029
Todo esto estará dentro de ese método NextIn.

162
00:07:06,290 --> 00:07:12,629
Nosotros cuando hemos llamado a NextIn, pues esperábamos que pasara todo lo necesario para leer del teclado,

163
00:07:12,730 --> 00:07:15,550
lo que fuera, bueno, pues todo eso está dentro de NextIn, ¿vale?

164
00:07:15,550 --> 00:07:31,529
Entonces dentro de next in habrá todo el código para leer y dentro de ese código habrá algo de este estilo, habrá algo de este estilo que será, oye, si esta cadena que yo me he encontrado en el buffer del teclado no son números, lanza esta excepción, ¿vale?

165
00:07:31,529 --> 00:07:44,149
Por eso cuando nosotros hemos ejecutado esta sentencia y le hemos pasado una cadena que no eran números, nos hemos encontrado las letras rojas que nos decían number for my exception y se ha detenido la ejecución.

166
00:07:44,149 --> 00:07:46,430
bueno, nos hemos encontrado eso

167
00:07:46,430 --> 00:07:48,209
porque al entrar dentro de NextInt

168
00:07:48,209 --> 00:07:50,769
la máquina virtual ha ejecutado esta sentencia

169
00:07:50,769 --> 00:07:52,910
por eso nos hemos encontrado eso

170
00:07:52,910 --> 00:07:54,769
pues las letritas rojas

171
00:07:54,769 --> 00:07:56,970
y además que la ejecución se para

172
00:07:56,970 --> 00:08:00,449
eso es lo que nos hemos encontrado

173
00:08:00,449 --> 00:08:02,790
vale, bueno, pues también

174
00:08:02,790 --> 00:08:04,189
sabemos que, oye

175
00:08:04,189 --> 00:08:05,990
quiero alterar este funcionamiento

176
00:08:05,990 --> 00:08:08,470
no quiero que aunque

177
00:08:08,470 --> 00:08:10,410
NextInt se encuentre

178
00:08:10,410 --> 00:08:12,629
números, perdón, caracteres

179
00:08:12,629 --> 00:08:14,730
en vez de números, no quiero

180
00:08:14,730 --> 00:08:16,649
que se pare el programa, porque

181
00:08:16,649 --> 00:08:18,870
es muy radical, que por cualquier cosita que pase

182
00:08:18,870 --> 00:08:20,730
se tenga que parar el programa, es muy

183
00:08:20,730 --> 00:08:21,850
radical, uno

184
00:08:21,850 --> 00:08:24,649
en su ejecución de su código, en su

185
00:08:24,649 --> 00:08:26,769
diseño puede decir, oye, si no

186
00:08:26,769 --> 00:08:28,589
es un número, sino que

187
00:08:28,589 --> 00:08:30,250
son caracteres, pues mala suerte

188
00:08:30,250 --> 00:08:32,549
ya sobreviviré de otra manera, pero

189
00:08:32,549 --> 00:08:34,129
no detengas el programa por eso

190
00:08:34,129 --> 00:08:36,789
entonces uno puede alterar este funcionamiento básico

191
00:08:36,789 --> 00:08:38,070
puede alterarlo

192
00:08:38,070 --> 00:08:40,570
¿vale? ¿y cómo lo altera? pues como dijimos

193
00:08:40,570 --> 00:08:42,129
también el otro día y como hemos hecho otras veces

194
00:08:42,129 --> 00:08:45,049
esta sentencia que es la peligrosa

195
00:08:45,049 --> 00:08:46,789
porque es la que cuando saltamos

196
00:08:46,789 --> 00:08:48,129
dentro tiene el throw

197
00:08:48,129 --> 00:08:50,610
tiene el throw si pasa algo raro

198
00:08:50,610 --> 00:08:52,750
y ya sabemos que el throw es el que

199
00:08:52,750 --> 00:08:53,509
provoca esto

200
00:08:53,509 --> 00:08:56,909
pues esta sentencia la capturamos

201
00:08:56,909 --> 00:08:57,690
¿no?

202
00:08:58,529 --> 00:09:20,460
y la capturamos de esta manera

203
00:09:20,460 --> 00:09:22,879
ahora ya simplemente metiendo esta

204
00:09:22,879 --> 00:09:24,740
sentencia en try catch, aquí

205
00:09:24,740 --> 00:09:27,220
la excepción que queremos capturar

206
00:09:27,220 --> 00:09:28,740
y aquí

207
00:09:28,740 --> 00:09:31,019
lo que queramos en el catch

208
00:09:31,019 --> 00:09:33,399
simplemente así alteramos

209
00:09:33,399 --> 00:09:35,399
el funcionamiento, la sentencia se va a ejecutar

210
00:09:35,399 --> 00:09:36,000
igualmente

211
00:09:36,000 --> 00:09:38,539
que no hay problema

212
00:09:38,539 --> 00:09:41,299
se ha ejecutado sin ningún error

213
00:09:41,299 --> 00:09:43,480
y no hemos llegado al throw

214
00:09:43,480 --> 00:09:45,200
porque este

215
00:09:45,200 --> 00:09:46,740
if era falso

216
00:09:46,740 --> 00:09:49,019
pues el programa sigue por aquí tan feliz

217
00:09:49,019 --> 00:09:51,539
que si ha habido un problema

218
00:09:51,539 --> 00:09:53,539
porque al saltar a next in

219
00:09:53,539 --> 00:09:55,340
esto ha sido true

220
00:09:55,340 --> 00:09:57,120
la máquina virtual ha hecho el throw

221
00:09:57,120 --> 00:09:59,220
vale, pues si, la máquina virtual ha hecho el throw

222
00:09:59,220 --> 00:10:01,899
pero ya no saltamos a mostrar líneas rojas

223
00:10:01,899 --> 00:10:03,700
y stop, ha hecho el throw

224
00:10:03,700 --> 00:10:05,720
pero la máquina virtual lo que hace ahora

225
00:10:05,720 --> 00:10:06,580
es saltar al catch

226
00:10:06,580 --> 00:10:09,399
luego la máquina virtual

227
00:10:09,399 --> 00:10:11,379
a resultas de ejecutar un throw

228
00:10:11,379 --> 00:10:13,600
tiene dos caminos, que la excepción

229
00:10:13,600 --> 00:10:15,919
no esté capturada, no haya un try catch

230
00:10:15,919 --> 00:10:17,679
letras rojas

231
00:10:17,679 --> 00:10:18,820
y parada de ejecución

232
00:10:18,820 --> 00:10:21,620
que la sentencia si esté

233
00:10:21,620 --> 00:10:23,820
capturada, la excepción si esté capturada

234
00:10:23,820 --> 00:10:25,460
pues entonces va al otro camino

235
00:10:25,460 --> 00:10:27,840
que es ejecutar lo que hay en el catch

236
00:10:27,840 --> 00:10:29,539
lo que uno haya escrito, lo que le dé la gana

237
00:10:29,539 --> 00:10:30,740
como si es nada, en blanco

238
00:10:30,740 --> 00:10:32,480
ejecuta eso

239
00:10:32,480 --> 00:10:35,940
y luego continúa el programa sin pararlo

240
00:10:35,940 --> 00:10:37,200
continúa el programa sin pararlo

241
00:10:37,200 --> 00:10:39,740
son las dos posibilidades

242
00:10:39,740 --> 00:10:41,779
que tiene la máquina virtual cuando se encuentra

243
00:10:41,779 --> 00:10:42,139
un flow

244
00:10:42,139 --> 00:10:45,279
y va a depender de si está capturada

245
00:10:45,279 --> 00:10:47,559
o no está capturada esta excepción

246
00:10:47,559 --> 00:10:48,279
¿vale?

247
00:10:50,019 --> 00:10:51,779
porque podría estar capturada la otra

248
00:10:51,779 --> 00:10:53,740
imaginaos que yo aquí

249
00:10:53,740 --> 00:10:55,879
tengo este mismo

250
00:10:55,879 --> 00:10:56,580
try-catch

251
00:10:56,580 --> 00:10:58,820
pero en lugar de

252
00:10:58,820 --> 00:11:00,379
tener ahí number for my exception

253
00:11:00,379 --> 00:11:03,139
tengo por ejemplo null pointer exception

254
00:11:03,139 --> 00:11:06,559
tengo esta, tengo un try catch

255
00:11:06,559 --> 00:11:07,600
que pone null pointer exception

256
00:11:07,600 --> 00:11:10,519
vale, pues entonces, la máquina virtual

257
00:11:10,519 --> 00:11:12,059
entra al next thing

258
00:11:12,059 --> 00:11:13,799
se encuentra

259
00:11:13,799 --> 00:11:16,440
la cadena del buffer que estoy leyendo

260
00:11:16,440 --> 00:11:18,139
no son números, throw

261
00:11:18,139 --> 00:11:19,899
pero la que lanza es esta

262
00:11:19,899 --> 00:11:21,879
esta está capturada, no

263
00:11:21,879 --> 00:11:24,299
la que está capturada es esta otra

264
00:11:24,299 --> 00:11:25,919
y no es la que hemos lanzado

265
00:11:25,919 --> 00:11:28,440
es esta, con lo cual

266
00:11:28,440 --> 00:11:30,559
a resultas de este throw nos iríamos

267
00:11:30,559 --> 00:11:32,539
a este camino, nos iríamos a letras rojas

268
00:11:32,539 --> 00:11:34,480
y esto, porque a mí me has dado

269
00:11:34,480 --> 00:11:36,100
indicaciones solo para esta

270
00:11:36,100 --> 00:11:38,879
me has dado indicaciones para esta, para esta no me has dado

271
00:11:38,879 --> 00:11:40,659
con lo cual

272
00:11:40,659 --> 00:11:42,220
aunque esto esté en un try-catch

273
00:11:42,220 --> 00:11:45,000
como la que está capturada no es la que se ha lanzado

274
00:11:45,000 --> 00:11:46,240
pues

275
00:11:46,240 --> 00:11:48,559
procederíamos a letras rojas y esto

276
00:11:48,559 --> 00:11:50,940
sin embargo

277
00:11:50,940 --> 00:11:52,419
imaginaos que aquí lo que ha ocurrido

278
00:11:52,419 --> 00:11:53,860
que scan yo no lo he instanciado

279
00:11:53,860 --> 00:11:55,200
y scan es null

280
00:11:55,200 --> 00:11:57,700
porque no lo he instanciado

281
00:11:57,700 --> 00:11:58,360
si me he olvidado

282
00:11:58,360 --> 00:11:59,399
hacer el new scanner

283
00:11:59,399 --> 00:12:00,480
vale

284
00:12:00,480 --> 00:12:00,940
pues entonces

285
00:12:00,940 --> 00:12:02,220
este try catch entramos

286
00:12:02,220 --> 00:12:03,080
y la excepción

287
00:12:03,080 --> 00:12:03,980
que saldría aquí

288
00:12:03,980 --> 00:12:05,120
si sería

289
00:12:05,120 --> 00:12:06,100
null pointer exception

290
00:12:06,100 --> 00:12:07,440
porque scan es null

291
00:12:07,440 --> 00:12:08,259
null

292
00:12:08,259 --> 00:12:09,620
intenta llamar a algo

293
00:12:09,620 --> 00:12:10,700
y ya le sale

294
00:12:10,700 --> 00:12:11,700
el null pointer exception

295
00:12:11,700 --> 00:12:12,600
entonces

296
00:12:12,600 --> 00:12:14,340
esta si estaría capturada

297
00:12:14,340 --> 00:12:16,059
con lo cual

298
00:12:16,059 --> 00:12:18,240
la de null pointer exception

299
00:12:18,240 --> 00:12:19,940
no detendría el programa

300
00:12:19,940 --> 00:12:20,960
aunque scan fuera null

301
00:12:20,960 --> 00:12:21,639
no lo detendría

302
00:12:21,639 --> 00:12:23,580
se iría

303
00:12:23,580 --> 00:12:24,679
a lo que hay aquí

304
00:12:24,679 --> 00:12:25,720
Y luego continuaríamos.

305
00:12:27,580 --> 00:12:27,980
¿Vale?

306
00:12:29,620 --> 00:12:30,799
Bueno, pues lo importante,

307
00:12:31,240 --> 00:12:32,720
sobre todo lo que aportamos ahora,

308
00:12:32,840 --> 00:12:34,700
porque más o menos cómo funcionaba el try-catch,

309
00:12:35,059 --> 00:12:36,379
más o menos podíamos tenerlo

310
00:12:36,379 --> 00:12:37,759
de alguna vez que lo hemos tenido que usar,

311
00:12:38,480 --> 00:12:40,480
es por qué aparecen las excepciones.

312
00:12:40,700 --> 00:12:42,200
Son una sentencia más de código

313
00:12:42,200 --> 00:12:43,980
que aparecen a resultas

314
00:12:43,980 --> 00:12:45,500
de que la máquina virtual ejecuta un throw.

315
00:12:47,200 --> 00:12:49,360
¿Y qué implica la ejecución de un throw?

316
00:12:49,820 --> 00:12:51,879
Pues implica o esto o esto.

317
00:12:52,299 --> 00:12:53,519
Depende de si hay captura

318
00:12:53,519 --> 00:12:55,879
o no hay captura, ya está

319
00:12:55,879 --> 00:12:57,500
¿vale?

320
00:12:59,299 --> 00:13:00,379
entonces también dijimos

321
00:13:00,379 --> 00:13:02,519
el otro día, oye y objetos excepción

322
00:13:02,519 --> 00:13:03,919
¿cuántos tipos distintos hay?

323
00:13:04,279 --> 00:13:05,320
pues tropecientos mil

324
00:13:05,320 --> 00:13:07,659
conocemos muchos

325
00:13:07,659 --> 00:13:10,519
null pointer exception, string line desbound exception

326
00:13:10,519 --> 00:13:12,720
number formal exception

327
00:13:12,720 --> 00:13:14,860
divide by zero exception

328
00:13:14,860 --> 00:13:16,500
conocemos muchos ya porque nos han

329
00:13:16,500 --> 00:13:18,620
aparecido, pero hay muchísimos

330
00:13:18,620 --> 00:13:20,399
más, cada uno

331
00:13:20,399 --> 00:13:22,480
de ellos asociado a una

332
00:13:22,480 --> 00:13:24,580
causa de error específica

333
00:13:24,580 --> 00:13:26,000
¿vale?

334
00:13:26,879 --> 00:13:27,899
entonces el throw

335
00:13:27,899 --> 00:13:29,879
instancia el objeto

336
00:13:29,879 --> 00:13:32,639
asociado que él cree

337
00:13:32,639 --> 00:13:34,220
que está asociado a esa causa de error

338
00:13:34,220 --> 00:13:36,840
ya hicimos el otro día un ejemplo

339
00:13:36,840 --> 00:13:37,460
en el cual

340
00:13:37,460 --> 00:13:39,679
lanzábamos nosotros

341
00:13:39,679 --> 00:13:41,779
nuestra propia excepción

342
00:13:41,779 --> 00:13:44,200
lanzábamos nosotros un null pointer exception

343
00:13:44,200 --> 00:13:45,879
asociado a otra cosa

344
00:13:45,879 --> 00:13:48,000
entonces bueno, no pegaba mucho pero podíamos lanzarlo

345
00:13:48,000 --> 00:13:50,759
¿vale?

346
00:13:50,759 --> 00:13:53,840
vale, entonces

347
00:13:53,840 --> 00:13:56,220
ahora que estamos aquí

348
00:13:56,220 --> 00:13:58,200
antes de ver ya el ejemplo y todo eso

349
00:13:58,200 --> 00:14:00,220
vamos a terminar un poco con los try-catch

350
00:14:00,220 --> 00:14:05,149
entonces esta es la

351
00:14:05,149 --> 00:14:07,809
la estructura básica de un try-catch

352
00:14:07,809 --> 00:14:09,789
es esta que ya hemos visto

353
00:14:09,789 --> 00:14:12,210
la que hemos mencionado

354
00:14:12,210 --> 00:14:16,659
pues dentro del try-catch

355
00:14:16,659 --> 00:14:18,059
se ponen la

356
00:14:18,059 --> 00:14:19,759
o las sentencias que uno quiera

357
00:14:19,759 --> 00:14:22,179
se puede poner aquí muchas sentencias

358
00:14:22,179 --> 00:14:26,399
da igual, cállate

359
00:14:26,399 --> 00:14:29,850
¿vale?

360
00:14:29,850 --> 00:14:33,049
y aquí se pone un tipo de excepción

361
00:14:33,049 --> 00:14:34,169
un tipo de excepción

362
00:14:34,169 --> 00:14:36,169
imaginaos que pongo esta

363
00:14:36,169 --> 00:14:41,850
un tipo de excepción y aquí un nombre de variable

364
00:14:41,850 --> 00:14:43,570
esto es como si fuera

365
00:14:43,570 --> 00:14:45,570
la lista de parámetros

366
00:14:45,570 --> 00:14:46,769
que recibe un método

367
00:14:46,769 --> 00:14:49,169
la lista de parámetros que recibe un método

368
00:14:49,169 --> 00:14:49,789
¿vale?

369
00:14:52,009 --> 00:14:52,570
Andrés

370
00:14:52,570 --> 00:14:55,110
¿vale?

371
00:14:55,149 --> 00:14:57,070
esta es la estructura del try-catch básica

372
00:14:57,070 --> 00:14:59,009
entonces, ¿esto qué significa?

373
00:15:02,460 --> 00:15:04,240
la sentencia o las sentencias

374
00:15:04,240 --> 00:15:05,580
se intentan ejecutar

375
00:15:05,580 --> 00:15:07,100
si una de ellas

376
00:15:07,100 --> 00:15:10,600
tiene como consecuencia

377
00:15:10,600 --> 00:15:12,460
una excepción de este tipo

378
00:15:12,460 --> 00:15:13,940
de este tipo

379
00:15:13,940 --> 00:15:15,399
de este tipo

380
00:15:15,399 --> 00:15:17,779
pues entonces saltamos al catch

381
00:15:17,779 --> 00:15:20,399
y esto es como si fuera un método en realidad

382
00:15:20,399 --> 00:15:22,179
y a este método

383
00:15:22,179 --> 00:15:24,000
se le pasa como parámetro

384
00:15:24,000 --> 00:15:26,379
un objeto excepción de este tipo

385
00:15:26,379 --> 00:15:28,299
entonces el objeto excepción

386
00:15:28,299 --> 00:15:30,539
lo instancia la máquina virtual

387
00:15:30,539 --> 00:15:32,360
o sea el propio throw de hecho lo tenía

388
00:15:32,360 --> 00:15:34,220
el throw decía

389
00:15:34,220 --> 00:15:37,259
throw new la excepción que sea

390
00:15:37,259 --> 00:15:44,279
¿veis? el propio throw

391
00:15:44,279 --> 00:15:45,639
ya instancia

392
00:15:45,639 --> 00:15:47,120
un objeto excepción

393
00:15:47,120 --> 00:15:49,919
y ese objeto excepción es el que recibe

394
00:15:49,919 --> 00:15:51,980
el catch como parámetro, lo recibe aquí

395
00:15:51,980 --> 00:15:53,500
¿vale?

396
00:15:53,700 --> 00:15:55,940
el catch recibe como parámetro un objeto

397
00:15:55,940 --> 00:15:58,340
excepción que es el que se ha instanciado

398
00:15:58,340 --> 00:16:00,259
como consecuencia de hacer el throw

399
00:16:00,259 --> 00:16:02,080
entonces yo aquí le puedo llamar

400
00:16:02,080 --> 00:16:03,580
le podéis llamar como os dé la gana

401
00:16:03,580 --> 00:16:05,080
a este objeto excepción

402
00:16:05,080 --> 00:16:07,320
esto vedlo como si fuera

403
00:16:07,320 --> 00:16:09,039
la cabecera de un método

404
00:16:09,039 --> 00:16:12,299
este es el objeto parámetro

405
00:16:12,299 --> 00:16:12,980
que recibe

406
00:16:12,980 --> 00:16:14,919
este método

407
00:16:14,919 --> 00:16:18,179
y el objeto parámetro que recibe es el objeto

408
00:16:18,179 --> 00:16:20,559
excepción que se ha instanciado

409
00:16:20,559 --> 00:16:21,480
cuando se hizo el throw

410
00:16:21,480 --> 00:16:23,799
entonces

411
00:16:23,799 --> 00:16:25,460
recopilamos

412
00:16:25,460 --> 00:16:28,259
esto, hemos saltado al código

413
00:16:28,259 --> 00:16:28,840
de nextIn

414
00:16:28,840 --> 00:16:31,059
ha hecho un throw

415
00:16:31,059 --> 00:16:33,159
bueno, la que sea

416
00:16:33,159 --> 00:16:34,200
ha hecho un throw

417
00:16:34,200 --> 00:16:36,700
la máquina virtual al ver el throw

418
00:16:36,700 --> 00:16:40,940
ha generado este objeto, lo ha instanciado

419
00:16:40,940 --> 00:16:43,559
y ahora se pone a mirar

420
00:16:43,559 --> 00:16:48,399
¿la sentencia que ha generado este throw

421
00:16:48,399 --> 00:16:50,740
está dentro de un try-catch?

422
00:16:51,259 --> 00:16:54,200
no, letra roja, sí, stop

423
00:16:54,200 --> 00:16:58,980
sí, vale, ¿ese catch se corresponde

424
00:16:58,980 --> 00:17:01,039
con la excepción que yo he instanciado?

425
00:17:01,720 --> 00:17:04,839
no se corresponde, letra roja, sí, stop

426
00:17:04,839 --> 00:17:07,460
si se corresponde, pues ahora ya

427
00:17:07,460 --> 00:17:09,039
entramos en el catch

428
00:17:09,039 --> 00:17:10,920
pasándole como parámetro

429
00:17:10,920 --> 00:17:13,539
este objeto que acabamos de instanciar

430
00:17:13,539 --> 00:17:14,599
¿vale?

431
00:17:15,519 --> 00:17:17,059
ya está, ese es el funcionamiento

432
00:17:17,059 --> 00:17:19,299
y ahora con este objeto que acabamos de instanciar

433
00:17:19,299 --> 00:17:21,779
uno puede hacer aquí lo que le dé la gana

434
00:17:21,779 --> 00:17:23,839
lo que normalmente

435
00:17:23,839 --> 00:17:25,160
queremos hacer con este objeto

436
00:17:25,160 --> 00:17:27,200
es simplemente sacar

437
00:17:27,200 --> 00:17:29,240
información sobre la excepción, nada más

438
00:17:29,240 --> 00:17:30,980
entonces este objeto x

439
00:17:30,980 --> 00:17:33,140
o e, como lo queráis haber llamado

440
00:17:33,140 --> 00:17:34,420
es un objeto excepción

441
00:17:34,420 --> 00:17:36,440
que tiene dentro información

442
00:17:36,440 --> 00:17:37,779
varia sobre la excepción

443
00:17:37,779 --> 00:17:40,319
y podemos sacarla mediante sus métodos

444
00:17:40,319 --> 00:17:42,279
si nosotros hacemos aquí a ver que métodos tiene

445
00:17:42,279 --> 00:17:44,460
pues tienen métodos relacionados con

446
00:17:44,460 --> 00:17:46,440
pues dame el objeto que generó el método

447
00:17:46,440 --> 00:17:48,359
que llamó la excepción, información varia

448
00:17:48,359 --> 00:17:50,240
entre ellas el método

449
00:17:50,240 --> 00:17:52,579
más importante, más usado

450
00:17:52,579 --> 00:18:01,440
es este, este método

451
00:18:01,440 --> 00:18:03,660
es un método

452
00:18:03,660 --> 00:18:05,000
de los objetos exception

453
00:18:05,000 --> 00:18:07,359
de las clases excepción que lo único

454
00:18:07,359 --> 00:18:09,359
que hace es hacer unos system

455
00:18:09,359 --> 00:18:11,339
OutprintDLN con un montón

456
00:18:11,339 --> 00:18:12,740
de información sobre la excepción.

457
00:18:13,299 --> 00:18:15,000
En qué línea se produjo de código,

458
00:18:15,200 --> 00:18:17,359
quién le había llamado, es decir,

459
00:18:17,680 --> 00:18:19,359
esto muestra

460
00:18:19,359 --> 00:18:21,400
y además las muestra en colorcito

461
00:18:21,400 --> 00:18:23,480
rojo. Esto muestra

462
00:18:23,480 --> 00:18:25,680
los mismos

463
00:18:25,680 --> 00:18:27,299
mensajes que vemos nosotros

464
00:18:27,299 --> 00:18:29,619
cuando la excepción no es capturada.

465
00:18:30,220 --> 00:18:31,640
Los mismos, coinciden, son los mismos.

466
00:18:32,700 --> 00:18:33,380
Entonces, si la excepción

467
00:18:33,380 --> 00:18:35,480
no es capturada, ya hemos visto que la máquina virtual

468
00:18:35,480 --> 00:18:36,599
muestra unos mensajes

469
00:18:36,599 --> 00:18:39,339
y además para, pues los mensajes

470
00:18:39,339 --> 00:18:41,420
que muestra, los saca

471
00:18:41,420 --> 00:18:43,460
de aquí también, los genera

472
00:18:43,460 --> 00:18:45,299
también la máquina virtual con este método

473
00:18:45,299 --> 00:18:47,519
¿vale? pero bueno, eso es lo de menos

474
00:18:47,519 --> 00:18:51,759
entonces, este objeto

475
00:18:51,759 --> 00:18:53,440
repito, lo podemos usar aquí dentro

476
00:18:53,440 --> 00:18:55,599
para ver cosas

477
00:18:55,599 --> 00:18:56,819
de la excepción si queremos

478
00:18:56,819 --> 00:18:59,660
o podemos pasar de él y limitarnos a

479
00:18:59,660 --> 00:19:01,660
poner aquí, pues ha habido un error

480
00:19:01,660 --> 00:19:04,039
lo que yo quiera, o un retun

481
00:19:04,039 --> 00:19:05,640
para que el método salga

482
00:19:05,640 --> 00:19:07,519
lo que a mí me dé la gana, puedo poner

483
00:19:07,519 --> 00:19:12,569
entonces cuando estoy todavía

484
00:19:12,569 --> 00:19:14,490
en fase de desarrollo de pruebas

485
00:19:14,490 --> 00:19:16,490
de mi código, no lo he entregado

486
00:19:16,490 --> 00:19:18,430
al cliente, estoy todavía haciendo

487
00:19:18,430 --> 00:19:20,450
pruebas, siempre tendremos

488
00:19:20,450 --> 00:19:22,009
esto puesto, siempre

489
00:19:22,009 --> 00:19:24,490
porque lo que yo quiero es

490
00:19:24,490 --> 00:19:25,410
si hay un error

491
00:19:25,410 --> 00:19:28,430
ver toda la explicación, quiero verla

492
00:19:28,430 --> 00:19:32,369
entonces cuando estamos en esa fase en la que yo

493
00:19:32,369 --> 00:19:33,970
como programador estoy haciendo pruebas

494
00:19:33,970 --> 00:19:36,450
yo si ha habido un problema y me he ido

495
00:19:36,450 --> 00:19:38,490
al catch, quiero ver todos los detalles de lo que

496
00:19:38,490 --> 00:19:40,690
ha pasado, pues entonces llamo a esto

497
00:19:40,690 --> 00:19:41,769
pondré esto dentro

498
00:19:41,769 --> 00:19:44,690
pero claro, cuando ya

499
00:19:44,690 --> 00:19:46,549
he entregado el software y ya se lo he

500
00:19:46,549 --> 00:19:48,509
dado al cliente, esto

501
00:19:48,509 --> 00:19:50,829
lo comentaremos y lo quitaremos

502
00:19:50,829 --> 00:19:52,750
porque

503
00:19:52,750 --> 00:19:54,289
en el caso de que haya una excepción

504
00:19:54,289 --> 00:19:56,410
yo ya en el tiempo de explotación

505
00:19:56,410 --> 00:19:58,589
de la aplicación, no quiero que le salgan

506
00:19:58,589 --> 00:20:00,569
letras rojas que no va a entender

507
00:20:00,569 --> 00:20:02,349
al que la está ejecutando

508
00:20:02,349 --> 00:20:04,529
lo más que puedo querer es

509
00:20:04,529 --> 00:20:06,450
que le salga un mensajito de disculpe

510
00:20:06,450 --> 00:20:08,369
ha habido un error, contáctenos el sitio técnico

511
00:20:08,369 --> 00:20:10,349
a lo mejor si puedo querer que le aparezca eso

512
00:20:10,349 --> 00:20:12,410
pues pondría aquí un mensaje

513
00:20:12,410 --> 00:20:14,309
con eso, o una escritura

514
00:20:14,309 --> 00:20:15,329
en el archivo de logs

515
00:20:15,329 --> 00:20:20,259
lo habitual, vale, entonces

516
00:20:20,259 --> 00:20:22,319
en tiempo de desarrollo

517
00:20:22,319 --> 00:20:23,619
esto

518
00:20:23,619 --> 00:20:26,160
es fundamental que esté, porque me va a ayudar

519
00:20:26,160 --> 00:20:28,099
si mi aplicación está dando errores

520
00:20:28,099 --> 00:20:29,759
me va a ayudar a explicarme

521
00:20:29,759 --> 00:20:32,200
a entenderlo, cuando ya entrego

522
00:20:32,200 --> 00:20:34,400
la aplicación, todo esto lo voy comentando, lo quito

523
00:20:34,400 --> 00:20:36,140
porque en ese caso

524
00:20:36,140 --> 00:20:38,480
cuando hay error, la información

525
00:20:38,480 --> 00:20:40,460
es al cliente, no es al desarrollador

526
00:20:40,460 --> 00:20:42,539
y la información para el cliente

527
00:20:42,539 --> 00:20:44,339
para el usuario del software no es

528
00:20:44,339 --> 00:20:46,740
main, la línea, no sé qué

529
00:20:46,740 --> 00:20:49,240
no es esa, la información para el cliente

530
00:20:49,240 --> 00:20:50,660
para el usuario de la aplicación es

531
00:20:50,660 --> 00:20:53,059
ha habido un error, no se pudo ejecutar

532
00:20:53,059 --> 00:20:54,920
o la que uno decida

533
00:20:54,920 --> 00:20:55,720
¿vale?

534
00:20:58,880 --> 00:21:00,019
bueno, por eso por un lado

535
00:21:00,019 --> 00:21:02,980
vale, luego los cats admiten

536
00:21:02,980 --> 00:21:03,960
diferentes

537
00:21:03,960 --> 00:21:06,599
variantes

538
00:21:06,599 --> 00:21:08,359
para dejar a lo mejor más completo

539
00:21:08,359 --> 00:21:10,559
más bonito, variantes que se han ido incorporando

540
00:21:10,559 --> 00:21:12,400
según las versiones, por ejemplo

541
00:21:12,400 --> 00:21:14,440
está el try, el multicatch

542
00:21:14,440 --> 00:21:17,519
si yo quiero capturar

543
00:21:17,519 --> 00:21:19,059
varias excepciones, por ejemplo

544
00:21:19,059 --> 00:21:21,599
uno podría decir, el scan next in

545
00:21:21,599 --> 00:21:23,640
me puede generar la number

546
00:21:23,640 --> 00:21:25,640
formal exception, que ya lo sabemos, vale

547
00:21:25,640 --> 00:21:27,859
pues yo capturaría la number formal exception

548
00:21:27,859 --> 00:21:42,160
y aquí pongo

549
00:21:42,160 --> 00:21:44,380
pues lo que quiera yo, que se ejecute

550
00:21:44,380 --> 00:21:45,960
cuando se da la number formal exception

551
00:21:45,960 --> 00:21:48,259
pero puede decir, ya, pero aquí también

552
00:21:48,259 --> 00:21:50,279
en estas sentencias, también puede

553
00:21:50,279 --> 00:21:52,500
ser que ocurra otra, puede ser que ocurra

554
00:21:52,500 --> 00:21:53,880
por ejemplo la null pointer exception

555
00:21:53,880 --> 00:21:56,220
vale, pues entonces ponemos

556
00:21:56,220 --> 00:21:58,319
otro catch, este es el

557
00:21:58,319 --> 00:22:00,119
multicatch, asociado a un mismo

558
00:22:00,119 --> 00:22:02,160
try, podemos poner un montón de catch

559
00:22:02,160 --> 00:22:04,059
distintos, cada una de ellas con

560
00:22:04,059 --> 00:22:05,000
diferentes excepciones

561
00:22:05,000 --> 00:22:18,029
y así podríamos poner tropecientos

562
00:22:18,029 --> 00:22:19,769
catch, si es que el código

563
00:22:19,769 --> 00:22:21,849
que yo tengo aquí, puede que

564
00:22:21,849 --> 00:22:23,769
genere muchos diferentes tipos de

565
00:22:23,769 --> 00:22:25,589
excepciones y yo quiero capturarlas todas

566
00:22:25,589 --> 00:22:28,130
pues podría hacer un multicatch

567
00:22:28,130 --> 00:22:31,630
y ahora ya pues esto funciona

568
00:22:31,630 --> 00:22:33,170
esto se intenta ejecutar

569
00:22:33,170 --> 00:22:35,430
que no hay ningún problema, fenomenal

570
00:22:35,430 --> 00:22:37,670
saltamos por aquí y pasamos de los

571
00:22:37,670 --> 00:22:38,890
cats y seguimos

572
00:22:38,890 --> 00:22:40,970
que sale esta excepción

573
00:22:40,970 --> 00:22:43,849
se salta el cats, se ejecuta esto

574
00:22:43,849 --> 00:22:45,210
y continuamos

575
00:22:45,210 --> 00:22:47,670
el programa no se para, el resto de los cats

576
00:22:47,670 --> 00:22:49,730
se ignoran, que la excepción

577
00:22:49,730 --> 00:22:50,529
que salta es esta

578
00:22:50,529 --> 00:22:53,109
pues entonces se ejecuta este cats

579
00:22:53,109 --> 00:22:54,609
y ya seguimos por el final

580
00:22:54,609 --> 00:22:56,990
entonces si sale una excepción

581
00:22:56,990 --> 00:22:59,450
la máquina virtual va a ir catch por catch

582
00:22:59,450 --> 00:23:01,589
desde arriba hasta que encuentre

583
00:23:01,589 --> 00:23:03,490
el primero en el cual se

584
00:23:03,490 --> 00:23:05,269
corresponde la excepción generada con esta

585
00:23:05,269 --> 00:23:06,829
en cuanto lo encuentra

586
00:23:06,829 --> 00:23:09,410
entra adentro, hace lo que tenga que hacer

587
00:23:09,410 --> 00:23:10,950
y ya está, y sale

588
00:23:10,950 --> 00:23:13,450
entonces es el multicatch

589
00:23:13,450 --> 00:23:15,569
y así yo puedo tratar de forma diferente

590
00:23:15,569 --> 00:23:17,710
diferentes excepciones

591
00:23:17,710 --> 00:23:27,089
No, a ver, el throw

592
00:23:27,089 --> 00:23:29,490
genera una excepción

593
00:23:29,490 --> 00:23:31,369
o sea, si hay un método que tú

594
00:23:31,369 --> 00:23:32,789
generas varias, pues dependerá

595
00:23:32,789 --> 00:23:35,410
que no hay números en la cadena

596
00:23:35,410 --> 00:23:36,269
throw new exception

597
00:23:36,269 --> 00:23:39,349
que el scan es nulo

598
00:23:39,349 --> 00:23:41,470
pues throw new number formal exception

599
00:23:41,470 --> 00:23:43,769
throw null pointer exception

600
00:23:43,769 --> 00:23:45,490
o sea, el throw, cada throw

601
00:23:45,490 --> 00:23:47,509
te lanza una única excepción

602
00:23:47,509 --> 00:23:50,369
te lanza la que corresponda

603
00:23:50,369 --> 00:23:51,609
a eso que tú has verificado

604
00:23:51,609 --> 00:23:54,089
pero un solo método, pues puede tener

605
00:23:54,089 --> 00:23:56,109
diferentes throw, si pasa

606
00:23:56,109 --> 00:23:58,069
esto, throw esta, ahora sigues

607
00:23:58,069 --> 00:23:59,769
haciendo cosas, que pase esto, throw

608
00:23:59,769 --> 00:24:02,210
esa otra cosa, o sea el throw

609
00:24:02,210 --> 00:24:04,130
te lanza un objeto de excepción

610
00:24:04,130 --> 00:24:06,089
pero claro, un mismo método en función

611
00:24:06,089 --> 00:24:08,069
de lo que ha pasado, pues puede ejecutar un throw

612
00:24:08,069 --> 00:24:09,430
o puede ejecutar otro, el que sea

613
00:24:09,430 --> 00:24:11,829
en cada momento dado

614
00:24:11,829 --> 00:24:13,970
este next in puede haber

615
00:24:13,970 --> 00:24:16,069
ocurrido que te genere la number

616
00:24:16,069 --> 00:24:17,910
formar exceptio, porque el throw

617
00:24:17,910 --> 00:24:19,529
que se ha lanzado es este

618
00:24:19,529 --> 00:24:21,789
porque la condición que fue true es esta

619
00:24:21,789 --> 00:24:24,089
pero en otro momento dado, esta misma

620
00:24:24,089 --> 00:24:26,170
sentencia puede que te lance otro throw

621
00:24:26,170 --> 00:24:27,990
porque no entró por este if

622
00:24:27,990 --> 00:24:29,970
sino que entró por otro, y tenía otro throw

623
00:24:29,970 --> 00:24:31,869
a eso me refiero

624
00:24:31,869 --> 00:24:33,730
que a todos casi tienen

625
00:24:33,730 --> 00:24:34,690
tanto, pero tienen

626
00:24:34,690 --> 00:24:40,069
sí, pero

627
00:24:40,069 --> 00:24:42,470
piensa que aquí no tienes por qué tener solo una sentencia

628
00:24:42,470 --> 00:24:43,309
puedes tener muchas

629
00:24:43,309 --> 00:24:45,269
puedes tener muchas

630
00:24:45,269 --> 00:24:46,569
lo que tú puedes es

631
00:24:46,569 --> 00:24:50,390
¿Cuál ha sido? ¿Cuál de ellos posibles ha sido?

632
00:24:50,769 --> 00:24:52,509
Entonces, claro, tú aquí

633
00:24:52,509 --> 00:24:54,130
los cats que pongas

634
00:24:54,130 --> 00:24:56,250
en este código de una o más

635
00:24:56,250 --> 00:24:58,390
sentencias, se supone que en algún sitio

636
00:24:58,390 --> 00:25:00,130
habrá un throw al menos

637
00:25:00,130 --> 00:25:01,529
correspondiente a esto

638
00:25:01,529 --> 00:25:04,069
si es tu pregunta, de hecho es que si no lo hay

639
00:25:04,069 --> 00:25:06,670
el compilador te va a decir

640
00:25:06,670 --> 00:25:07,230
uy

641
00:25:07,230 --> 00:25:10,210
esta excepción no es posible

642
00:25:10,210 --> 00:25:11,990
que se lance, o sea, como

643
00:25:11,990 --> 00:25:14,069
en la máquina virtual, el compilador

644
00:25:14,069 --> 00:25:15,210
tiene acceso al código

645
00:25:15,210 --> 00:25:17,250
si tú pones aquí una sentencia

646
00:25:17,250 --> 00:25:20,390
que ese throw no lo tiene en ningún sitio

647
00:25:20,390 --> 00:25:21,809
te va a decir

648
00:25:21,809 --> 00:25:24,329
esta excepción es imposible

649
00:25:24,329 --> 00:25:26,130
que la puedas lanzar, es imposible

650
00:25:26,130 --> 00:25:28,349
¿vale? entonces en alguna

651
00:25:28,349 --> 00:25:29,930
de las ramas del next in

652
00:25:29,930 --> 00:25:32,210
tendrá que haber un throw

653
00:25:32,210 --> 00:25:34,369
correspondiente a esta y a esta

654
00:25:34,369 --> 00:25:35,930
y a esta, todas las que tú pongas ahí

655
00:25:35,930 --> 00:25:38,549
¿vale? pero cada throw te lanza una sola

656
00:25:38,549 --> 00:25:40,589
otra cosa es que dentro de este código

657
00:25:40,589 --> 00:25:42,029
que puede ser de una o muchas

658
00:25:42,029 --> 00:25:44,470
pues hay un montón de throws en diferentes sitios

659
00:25:44,470 --> 00:25:45,650
en función de los if

660
00:25:45,650 --> 00:25:47,269
en función de los if

661
00:25:47,269 --> 00:25:47,609
¿vale?

662
00:25:49,250 --> 00:25:50,690
pues sería el multicatch

663
00:25:50,690 --> 00:25:52,569
que se puede poner también

664
00:25:52,569 --> 00:25:54,170
desde cierta versión

665
00:25:54,170 --> 00:25:55,430
pues como or

666
00:25:55,430 --> 00:25:55,869
pero bueno

667
00:25:55,869 --> 00:25:56,769
eso cuando hagamos un ejemplo

668
00:25:56,769 --> 00:25:57,369
lo podemos ver

669
00:25:57,369 --> 00:25:58,250
pues numbers for exception

670
00:25:58,250 --> 00:26:00,150
o null pointer exception

671
00:26:00,150 --> 00:26:00,690
o

672
00:26:00,690 --> 00:26:01,950
y así se pone un único catch

673
00:26:01,950 --> 00:26:02,490
tan largo

674
00:26:02,490 --> 00:26:03,410
también se puede poner

675
00:26:03,410 --> 00:26:05,549
y ya por último

676
00:26:05,549 --> 00:26:06,890
porque debe estar a

677
00:26:06,890 --> 00:26:07,289
a no

678
00:26:07,289 --> 00:26:08,089
son las 11 todavía

679
00:26:08,089 --> 00:26:10,509
vale

680
00:26:10,509 --> 00:26:11,509
para cerrar un poco

681
00:26:11,509 --> 00:26:12,049
esto de

682
00:26:12,049 --> 00:26:14,009
la sintaxis del try catch

683
00:26:14,009 --> 00:26:16,609
el try-catch puede finalizar

684
00:26:16,609 --> 00:26:17,589
opcionalmente

685
00:26:17,589 --> 00:26:20,109
si uno quiere, no es obligatorio

686
00:26:20,109 --> 00:26:22,430
con una cláusula

687
00:26:22,430 --> 00:26:23,730
que se llama la final

688
00:26:23,730 --> 00:26:28,109
después de los try-catch

689
00:26:28,109 --> 00:26:30,369
si uno quiere puede poner el

690
00:26:30,369 --> 00:26:32,549
final y ya ves

691
00:26:32,549 --> 00:26:34,490
otra vez que es

692
00:26:34,490 --> 00:26:36,089
una especie de epilo

693
00:26:36,089 --> 00:26:38,349
lo que tú quieres que se haga

694
00:26:38,349 --> 00:26:40,470
tanto si

695
00:26:40,470 --> 00:26:41,930
ejecutó el try

696
00:26:41,930 --> 00:26:43,990
porque no hubo excepciones, como si

697
00:26:44,009 --> 00:26:45,450
ejecutó cualquiera de los catch.

698
00:26:46,190 --> 00:26:48,130
Es una especie de epílogo, que sería,

699
00:26:48,710 --> 00:26:51,990
intenta hacer esto, que funciona, fenomenal,

700
00:26:52,430 --> 00:26:54,829
que no funciona, ejecuta el catch que toque.

701
00:26:55,390 --> 00:26:57,710
Y ahora, en cualquiera de esas opciones,

702
00:26:57,710 --> 00:27:01,109
para terminar, ejecuta el final.

703
00:27:03,109 --> 00:27:04,470
Entonces es, por ejemplo,

704
00:27:05,170 --> 00:27:08,289
cuando se abre un recurso, un fichero,

705
00:27:08,450 --> 00:27:11,910
se abre una tubería, se abre un hilo, cualquier cosa,

706
00:27:11,910 --> 00:27:14,170
que son recursos que luego hay que cerrar

707
00:27:14,170 --> 00:27:16,309
esos recursos hay que cerrarlos siempre

708
00:27:16,309 --> 00:27:18,509
haya funcionado la lectura

709
00:27:18,509 --> 00:27:20,069
sobre ellos o no haya funcionado

710
00:27:20,069 --> 00:27:21,829
entonces a la estructura típica

711
00:27:21,829 --> 00:27:24,670
pues en el finally poner sentencias de cierre

712
00:27:24,670 --> 00:27:26,609
de recursos, porque esos recursos

713
00:27:26,609 --> 00:27:28,269
a los que has querido acceder

714
00:27:28,269 --> 00:27:29,289
los vas a cerrar

715
00:27:29,289 --> 00:27:32,170
bien si los has usado con éxito

716
00:27:32,170 --> 00:27:34,609
o aunque no los hayas usado con éxito porque han cascado

717
00:27:34,609 --> 00:27:36,450
en cualquier caso los quieres cerrar

718
00:27:36,450 --> 00:27:38,329
pues las sentencias de cerrado

719
00:27:38,329 --> 00:27:40,710
se podrían poner aquí, es el ejemplo más habitual

720
00:27:40,710 --> 00:27:42,289
en el cual un finally viene bien

721
00:27:42,289 --> 00:27:44,390
pero no es obligatorio ponerlo

722
00:27:44,390 --> 00:27:46,829
uno podría poner esos cerrados tanto aquí como aquí

723
00:27:46,829 --> 00:27:48,490
los tendría que duplicar en todas partes

724
00:27:48,490 --> 00:27:51,029
pues para evitar duplicarlos en todas partes

725
00:27:51,029 --> 00:27:52,950
te haces un finally y lo pones solo aquí

726
00:27:52,950 --> 00:27:54,569
¿vale?

727
00:27:55,329 --> 00:27:56,950
entonces uno usa esta cláusula

728
00:27:56,950 --> 00:27:58,369
final si quiere y si no, no

729
00:27:58,369 --> 00:28:03,700
vale, ya por último, antes de irnos

730
00:28:03,700 --> 00:28:05,180
aquí como en

731
00:28:05,180 --> 00:28:06,059
cualquier

732
00:28:06,059 --> 00:28:09,000
conjunto de clases

733
00:28:09,000 --> 00:28:10,700
que ya están hechas en Java

734
00:28:10,700 --> 00:28:13,500
existe una estructura

735
00:28:13,500 --> 00:28:14,759
jerárquica por detrás

736
00:28:14,759 --> 00:28:16,880
en las colecciones ya la hemos visto

737
00:28:16,880 --> 00:28:19,019
clases de colección hay un montón

738
00:28:19,019 --> 00:28:21,619
los tricet, los linked list

739
00:28:21,619 --> 00:28:23,680
los hash map

740
00:28:23,680 --> 00:28:25,319
hay un montón

741
00:28:25,319 --> 00:28:27,640
y todas están en una jerarquía

742
00:28:27,640 --> 00:28:29,319
de clases, las de colecciones

743
00:28:29,319 --> 00:28:30,980
heredan todas de iterable

744
00:28:30,980 --> 00:28:33,279
de colección, luego las de list

745
00:28:33,279 --> 00:28:34,259
hay una jerarquía

746
00:28:34,259 --> 00:28:37,019
perdón

747
00:28:37,019 --> 00:28:42,420
No te entiendo

748
00:28:42,420 --> 00:28:44,940
A ver, todas heredan de object en cualquier caso

749
00:28:44,940 --> 00:28:46,579
Entonces

750
00:28:46,579 --> 00:28:48,140
Las clases excepción

751
00:28:48,140 --> 00:28:50,480
IOSception, FileNotFoundException

752
00:28:50,480 --> 00:28:53,200
NumberFormatException, son clases excepción que ya están hechas

753
00:28:53,200 --> 00:28:54,680
Y todas

754
00:28:54,680 --> 00:28:56,339
Heredan de

755
00:28:56,339 --> 00:28:58,700
De object por supuesto, porque todas heredan de object

756
00:28:58,700 --> 00:29:00,619
Pero luego de object a su vez

757
00:29:00,619 --> 00:29:02,259
Hay una que se llama

758
00:29:02,259 --> 00:29:03,700
Probable, que es una

759
00:29:03,700 --> 00:29:05,539
Clase abstracta, una interfaz

760
00:29:05,539 --> 00:29:07,880
throwable, que significa

761
00:29:07,880 --> 00:29:09,980
pues lanzable, porque las excepciones

762
00:29:09,980 --> 00:29:10,920
son lanzables

763
00:29:10,920 --> 00:29:13,960
bueno, pues de throwable hereda ya

764
00:29:13,960 --> 00:29:16,700
exception

765
00:29:16,700 --> 00:29:19,940
y error

766
00:29:19,940 --> 00:29:22,980
que luego mencionamos que es error

767
00:29:22,980 --> 00:29:23,880
pero es muy parecido

768
00:29:23,880 --> 00:29:27,059
exception es la superclase de todas

769
00:29:27,059 --> 00:29:29,279
las excepciones, es la superclase de todas

770
00:29:29,279 --> 00:29:30,579
es como

771
00:29:30,579 --> 00:29:33,119
collection, que es la superclase de todas

772
00:29:33,119 --> 00:29:35,140
las colecciones, pues exception

773
00:29:35,140 --> 00:29:36,420
es la superclase de todas

774
00:29:36,420 --> 00:29:38,200
exception a su vez

775
00:29:38,200 --> 00:29:40,619
tiene una heredera

776
00:29:40,619 --> 00:29:41,839
que es runtime exception

777
00:29:41,839 --> 00:29:46,329
y otra

778
00:29:46,329 --> 00:29:49,609
que, ah no, perdón, bueno, tenemos que ver

779
00:29:49,609 --> 00:29:51,549
el cuadro, ¿vale? porque exactamente

780
00:29:51,549 --> 00:29:53,589
yo creo que runtime exception hereda

781
00:29:53,589 --> 00:29:54,869
de throwable directamente

782
00:29:54,869 --> 00:29:57,430
pero vamos, lo que quiero decir

783
00:29:57,430 --> 00:29:58,750
¿vale?

784
00:29:59,690 --> 00:30:01,670
lo que quiero decir es que todas las excepciones

785
00:30:01,670 --> 00:30:02,950
que ya están hechas

786
00:30:02,950 --> 00:30:05,410
están en una jerarquía de clases

787
00:30:05,410 --> 00:30:07,109
y en última instancia

788
00:30:07,109 --> 00:30:08,450
heredan todas

789
00:30:08,450 --> 00:30:10,089
de throwable

790
00:30:10,089 --> 00:30:11,569
en última instancia eran todas de throwable

791
00:30:11,569 --> 00:30:13,549
y luego algunas heredan de exception

792
00:30:13,549 --> 00:30:15,910
otras heredan de runtime exception

793
00:30:15,910 --> 00:30:17,089
que ahora veremos la diferencia

794
00:30:17,089 --> 00:30:19,970
¿vale? entonces

795
00:30:19,970 --> 00:30:21,710
¿qué quiero decir?

796
00:30:22,190 --> 00:30:23,829
que este tricats tiene en cuenta

797
00:30:23,829 --> 00:30:25,089
esa estructura jerárquica

798
00:30:25,089 --> 00:30:27,630
y por ejemplo

799
00:30:27,630 --> 00:30:29,250
imaginaos que yo aquí pongo

800
00:30:29,250 --> 00:30:31,390
esto

801
00:30:31,390 --> 00:30:35,259
exception, que es una clase más

802
00:30:35,259 --> 00:30:37,700
es una clase más de la jerarquía

803
00:30:37,700 --> 00:30:39,400
aunque sea una superclase

804
00:30:39,400 --> 00:30:40,980
abstracta, es una clase más

805
00:30:40,980 --> 00:30:43,779
pues como ya conocemos cómo funciona la herencia

806
00:30:43,779 --> 00:30:45,240
si yo pongo aquí

807
00:30:45,240 --> 00:30:47,519
exception, aquí se lanza

808
00:30:47,519 --> 00:30:48,160
la excepción

809
00:30:48,160 --> 00:30:51,279
imaginemos, number format exception

810
00:30:51,279 --> 00:30:53,299
la máquina virtual

811
00:30:53,299 --> 00:30:55,599
iría uno por una, diría number format exception

812
00:30:55,599 --> 00:30:57,240
es esta

813
00:30:57,240 --> 00:30:59,579
pues sí, porque como ya

814
00:30:59,579 --> 00:31:01,559
sabéis, un objeto

815
00:31:01,559 --> 00:31:03,319
pertenece tanto a su clase

816
00:31:03,319 --> 00:31:05,779
como a cualquiera de las superclases

817
00:31:05,779 --> 00:31:07,299
que están por encima de su clase

818
00:31:07,299 --> 00:31:09,440
con lo cual un number

819
00:31:09,440 --> 00:31:11,339
formal exception es number

820
00:31:11,339 --> 00:31:13,480
formal exception pero también es exception

821
00:31:13,480 --> 00:31:15,599
porque es super clase

822
00:31:15,599 --> 00:31:17,400
de ella y todas las clases de exception

823
00:31:17,400 --> 00:31:18,980
heredan de esta en última instancia

824
00:31:18,980 --> 00:31:25,380
entonces este try-catch

825
00:31:25,380 --> 00:31:27,539
los catch a partir de aquí

826
00:31:27,539 --> 00:31:29,420
ya estarían de más

827
00:31:29,420 --> 00:31:31,319
porque sea cual sea la excepción

828
00:31:31,319 --> 00:31:33,079
que se genere, todas van a caer en este

829
00:31:33,079 --> 00:31:35,380
me da igual que sea null

830
00:31:35,380 --> 00:31:37,400
pointer exception, que sea todas porque como son herederas

831
00:31:37,400 --> 00:31:39,180
de estas, de hecho si

832
00:31:39,180 --> 00:31:41,099
escribimos esto, luego

833
00:31:41,099 --> 00:31:43,119
lo escribimos, el compilador me dirá, oye, nunca

834
00:31:43,119 --> 00:31:45,099
vas a llegar a este catch, claro

835
00:31:45,099 --> 00:31:47,140
que nunca vas a llegar, porque es que, aunque

836
00:31:47,140 --> 00:31:49,140
sea null point de excepción la que te

837
00:31:49,140 --> 00:31:51,200
genere, esa ya va a

838
00:31:51,200 --> 00:31:53,160
casar aquí, ya va a casar aquí, porque

839
00:31:53,160 --> 00:31:55,099
aquí van a casar todas las que den de

840
00:31:55,099 --> 00:31:55,680
excepción, todas.

841
00:31:57,920 --> 00:31:59,079
Entonces, esto, cuando

842
00:31:59,079 --> 00:32:01,059
uno quiere capturar, quiere hacer un

843
00:32:01,059 --> 00:32:03,259
código súper mega potente

844
00:32:03,259 --> 00:32:04,400
que no se pare nunca,

845
00:32:05,160 --> 00:32:06,519
se hace un try-catch de excepción

846
00:32:06,519 --> 00:32:08,920
y sea cual sea la excepción que se genere,

847
00:32:08,920 --> 00:32:11,680
cualquiera, incluso la que él ni sabía

848
00:32:11,680 --> 00:32:13,480
que existía y que se puede generar

849
00:32:13,480 --> 00:32:15,720
porque no podemos, hay métodos

850
00:32:15,720 --> 00:32:17,819
que hombre, meternos en ellos

851
00:32:17,819 --> 00:32:19,660
para ver todas las posibilidades que pueda generar

852
00:32:19,660 --> 00:32:21,680
es muy complejo, entonces nosotros podemos

853
00:32:21,680 --> 00:32:23,440
de este, pues yo

854
00:32:23,440 --> 00:32:25,779
puedo recordar que me puede generar

855
00:32:25,779 --> 00:32:26,759
la number former exception

856
00:32:26,759 --> 00:32:29,119
pero a lo mejor también hay otra que me pueda generar

857
00:32:29,119 --> 00:32:31,660
que yo la desconozco, que me la genera

858
00:32:31,660 --> 00:32:33,660
cuando pasa algo muy raro, cuando llueve

859
00:32:33,660 --> 00:32:35,559
pues cuando llueve me la genera, no puedo

860
00:32:35,559 --> 00:32:37,500
saberlas todas, entonces

861
00:32:37,500 --> 00:32:38,920
si me hago un catch exception

862
00:32:38,920 --> 00:32:41,500
en ese sentido es el código más robusto

863
00:32:41,500 --> 00:32:43,380
del mundo, porque pase

864
00:32:43,380 --> 00:32:45,500
lo que pase, vayamos al

865
00:32:45,500 --> 00:32:47,619
throw que vayamos, sea el throw

866
00:32:47,619 --> 00:32:49,460
porque llueve exception, sea el throw

867
00:32:49,460 --> 00:32:51,440
porque no me apetece exception, sea el throw

868
00:32:51,440 --> 00:32:53,099
que sea, da igual

869
00:32:53,099 --> 00:32:55,200
va a caer en este catch, va a caer

870
00:32:55,200 --> 00:32:57,359
luego el programa nunca

871
00:32:57,359 --> 00:32:59,160
se va a parar jamás, porque va a estar

872
00:32:59,160 --> 00:33:01,599
capturada cualquier excepción, porque cualquiera

873
00:33:01,599 --> 00:33:03,079
es heredera de exception, cualquiera

874
00:33:03,079 --> 00:33:05,599
entonces, esta sería

875
00:33:05,599 --> 00:33:07,400
la forma más cómoda

876
00:33:07,400 --> 00:33:09,819
de hacer un programa que no se va a parar nunca.

877
00:33:10,059 --> 00:33:10,960
Nunca se va a detener.

878
00:33:11,539 --> 00:33:13,460
Nunca se va a dejar al usuario ahí parado.

879
00:33:14,420 --> 00:33:16,200
En ese sentido, muy robusto.

880
00:33:16,839 --> 00:33:20,000
Pero, hombre, muy poco amigable.

881
00:33:20,779 --> 00:33:23,279
Porque yo aquí en el cache no puedo dar ninguna explicación

882
00:33:23,279 --> 00:33:25,000
porque no tengo ni idea de qué ha pasado.

883
00:33:25,420 --> 00:33:27,359
Si yo voy separando excepción por excepción,

884
00:33:27,519 --> 00:33:28,519
puedo decirle al usuario,

885
00:33:29,420 --> 00:33:31,480
lo siento, pero has metido una cadena mala aquí.

886
00:33:31,599 --> 00:33:34,299
Lo siento, pero no has instanciado el objeto escáner o lo que sea.

887
00:33:34,420 --> 00:33:35,519
Lo siento, pero no sé qué.

888
00:33:35,519 --> 00:33:37,500
puedo distinguir en cada catch

889
00:33:37,500 --> 00:33:39,519
lo que ha pasado y darle explicaciones

890
00:33:39,519 --> 00:33:41,200
pero

891
00:33:41,200 --> 00:33:43,319
si yo lo capturo todo en un único catch

892
00:33:43,319 --> 00:33:44,660
el programa no se va a parar

893
00:33:44,660 --> 00:33:47,319
pero no tengo manera de programar aquí

894
00:33:47,319 --> 00:33:49,519
decirle oye lo que ha pasado, porque yo aquí

895
00:33:49,519 --> 00:33:51,319
no sé qué habrá pasado

896
00:33:51,319 --> 00:33:53,259
sé que voy a saltar cuando se haga una excepción

897
00:33:53,259 --> 00:33:55,500
pero a saber cuál habrá saltado

898
00:33:55,500 --> 00:33:56,019
no tengo ni idea

899
00:33:56,019 --> 00:33:59,079
entonces es un programa que no se para nunca

900
00:33:59,079 --> 00:34:00,660
pero

901
00:34:00,660 --> 00:34:03,119
poco útil

902
00:34:03,119 --> 00:34:04,900
en ese sentido

903
00:34:04,900 --> 00:34:05,960
poco útil porque

904
00:34:05,960 --> 00:34:08,500
puede seguir, va a seguir

905
00:34:08,500 --> 00:34:11,219
pero puede seguir funcionando mal

906
00:34:11,219 --> 00:34:12,400
porque yo no sé qué ha pasado

907
00:34:12,400 --> 00:34:15,219
no sé qué ha pasado para que fuéramos al catch

908
00:34:15,219 --> 00:34:17,139
y por tanto no he podido arreglarlo de forma

909
00:34:17,139 --> 00:34:19,380
personalizada, no he podido arreglarlo de forma personalizada

910
00:34:19,380 --> 00:34:22,559
¿vale?

911
00:34:23,480 --> 00:34:24,739
pero bueno, lo que nos importa

912
00:34:24,739 --> 00:34:27,179
ahora mismo de todo esto que estoy diciendo es

913
00:34:27,179 --> 00:34:29,280
que las clases que ya están hechas en

914
00:34:29,280 --> 00:34:31,019
Javel y las que nos aprovechamos nosotros

915
00:34:31,019 --> 00:34:33,300
todas están diseñadas

916
00:34:33,300 --> 00:34:35,360
en una estructura de superclases

917
00:34:35,360 --> 00:34:37,579
y subclases, porque eso facilita

918
00:34:37,579 --> 00:34:39,300
su uso, y lo estamos

919
00:34:39,300 --> 00:34:41,380
viendo continuamente, lo hemos visto en las colecciones

920
00:34:41,380 --> 00:34:42,840
y aquí también lo vemos

921
00:34:42,840 --> 00:34:45,159
si yo quiero capturar un montón de clases de golpe

922
00:34:45,159 --> 00:34:47,260
pues pongo la superclase y ya está

923
00:34:47,260 --> 00:34:49,079
¿vale? gracias

924
00:34:49,079 --> 00:34:50,940
a esa ventaja de la herencia

925
00:34:50,940 --> 00:34:53,460
que si hay una estructura de superclase

926
00:34:53,460 --> 00:34:55,400
y subclase, todos los

927
00:34:55,400 --> 00:34:57,599
objetos de las subclases caen

928
00:34:57,599 --> 00:34:59,380
en las referencias suyas

929
00:34:59,380 --> 00:35:01,260
propias, pero también encajan

930
00:35:01,260 --> 00:35:02,920
en las de las superclases

931
00:35:02,920 --> 00:35:04,480
y esa tontería

932
00:35:04,480 --> 00:35:06,280
que un objeto encaje

933
00:35:06,280 --> 00:35:08,460
en su clase y encaje

934
00:35:08,460 --> 00:35:10,440
en cualquiera de sus superclases

935
00:35:10,440 --> 00:35:11,860
esa tontería

936
00:35:11,860 --> 00:35:14,659
es lo que permite que la aprobación de todos los objetos

937
00:35:14,659 --> 00:35:15,360
sea potente

938
00:35:15,360 --> 00:35:18,800
porque es mucho más fácil el desarrollo de código

939
00:35:18,800 --> 00:35:20,960
solamente ese detalle

940
00:35:20,960 --> 00:35:21,880
esa es en realidad

941
00:35:21,880 --> 00:35:24,460
el invento de la aprobación de todos los objetos

942
00:35:24,460 --> 00:35:26,659
la herencia, es el verdadero invento

943
00:35:27,800 --> 00:35:28,659
¿vale? y como a través

944
00:35:28,659 --> 00:35:30,400
de esa herencia podemos reutilizar

945
00:35:30,400 --> 00:35:33,280
y podemos hacer códigos mucho más sencillos

946
00:35:33,280 --> 00:35:35,880
bueno, pues en cuanto a try-catch

947
00:35:35,880 --> 00:35:37,460
lo podemos dejar aquí y nada más

948
00:35:37,460 --> 00:35:41,260
y ya a la vuelta del recreo

949
00:35:41,260 --> 00:35:43,059
pues ya vemos cómo hacer nuestras propias excepciones

950
00:35:43,059 --> 00:35:43,980
y damos algún ejemplo