1
00:00:00,240 --> 00:00:05,759
Venga, pues vamos a seguir con lo siguiente que vamos a ver

2
00:00:05,759 --> 00:00:08,439
Venga, relax

3
00:00:08,439 --> 00:00:23,699
Bueno, pues a ver, ¿qué es esto de las excepciones?

4
00:00:25,199 --> 00:00:29,079
Vale, bueno, hasta ahora ya no suenan

5
00:00:29,079 --> 00:00:32,659
No suenan porque a veces no las hemos encontrado

6
00:00:32,659 --> 00:00:38,259
Entonces, para nosotros, ahora mismo, hasta ahora, ¿qué es una excepción?

7
00:00:39,359 --> 00:00:45,380
Una excepción es algo que ha aparecido de repente, no sabemos ni de dónde ha salido,

8
00:00:46,600 --> 00:00:52,159
se supone que resulta de una sentencia que no ha funcionado correctamente y ha parado el programa.

9
00:00:53,000 --> 00:00:55,439
Esa es nuestra experiencia hasta ahora con las excepciones.

10
00:00:56,399 --> 00:01:00,560
Por ejemplo, pues nos la hemos encontrado en una situación como esta.

11
00:01:00,560 --> 00:01:08,250
Por ejemplo, imaginaos que tenemos esto, un programa que tiene esto escrito

12
00:01:08,250 --> 00:01:11,049
y ahora por ejemplo

13
00:01:11,049 --> 00:01:12,989
imaginaos que tenemos esto aquí

14
00:01:12,989 --> 00:01:20,000
bueno, pues imaginaos que tenemos

15
00:01:20,000 --> 00:01:21,680
un código

16
00:01:21,680 --> 00:01:24,180
con dos líneas de código que

17
00:01:24,180 --> 00:01:25,480
tienen esto

18
00:01:25,480 --> 00:01:27,900
entonces nosotros ya sabemos que pasa

19
00:01:27,900 --> 00:01:30,920
cuando la máquina virtual se ponga a ejecutar

20
00:01:30,920 --> 00:01:32,840
esto, cuando ya estamos en tiempo de ejecución

21
00:01:32,840 --> 00:01:34,400
hace esta línea

22
00:01:34,400 --> 00:01:36,640
y cuando va a hacer esta ya hemos visto

23
00:01:36,640 --> 00:01:38,299
lo que pasa, ya hemos visto lo que pasa

24
00:01:38,299 --> 00:01:39,760
que de repente

25
00:01:39,760 --> 00:01:42,739
han salido una línea roja

26
00:01:42,739 --> 00:01:44,340
ahí, en la consola

27
00:01:44,340 --> 00:01:45,859
han salido una línea roja

28
00:01:45,859 --> 00:01:48,159
donde ha aparecido

29
00:01:48,159 --> 00:01:50,799
escrito algo como esto

30
00:01:50,799 --> 00:01:56,129
¿vale?

31
00:01:56,469 --> 00:01:58,250
ha aparecido escrito algo como eso

32
00:01:58,250 --> 00:01:59,629
y además

33
00:01:59,629 --> 00:02:02,989
el programa se ha detenido

34
00:02:02,989 --> 00:02:04,810
todas las sentencias

35
00:02:04,810 --> 00:02:06,150
que hubiera a partir de aquí

36
00:02:06,150 --> 00:02:08,509
ya no se han ejecutado

37
00:02:08,509 --> 00:02:10,689
porque el programa se ha parado

38
00:02:10,689 --> 00:02:11,949
¿vale?

39
00:02:11,949 --> 00:02:14,430
esta es nuestra experiencia hasta ahora

40
00:02:14,430 --> 00:02:17,090
en tiempo de ejecución

41
00:02:17,090 --> 00:02:17,930
con las excepciones

42
00:02:17,930 --> 00:02:20,789
nos ha pasado también, pues a lo mejor

43
00:02:20,789 --> 00:02:22,490
imaginaos que tenemos un código así

44
00:02:22,490 --> 00:02:28,520
y de repente

45
00:02:28,520 --> 00:02:30,400
tenemos a lo mejor esta línea

46
00:02:30,400 --> 00:02:34,379
tenemos un código con estas líneas

47
00:02:34,379 --> 00:02:36,099
bueno, pues la máquina virtual

48
00:02:36,099 --> 00:02:38,240
ha hecho esta sentencia, muy bien

49
00:02:38,240 --> 00:02:40,500
ahora se ha puesto a hacer esta, que implica

50
00:02:40,500 --> 00:02:42,740
una división, ¿y qué nos ha pasado?

51
00:02:43,479 --> 00:02:44,360
pues que de nuevo

52
00:02:44,360 --> 00:02:46,340
han aparecido, una letra roja por ahí

53
00:02:46,340 --> 00:02:48,719
donde ponía

54
00:02:48,719 --> 00:02:49,439
algo como esto

55
00:02:49,439 --> 00:02:59,000
y el programa además se ha parado

56
00:02:59,000 --> 00:03:00,939
y todo lo que hubiera a continuación

57
00:03:00,939 --> 00:03:03,180
ha dejado de ocurrir, esto es más o menos

58
00:03:03,180 --> 00:03:04,979
lo que nos hemos encontrado

59
00:03:04,979 --> 00:03:06,719
nosotros hasta ahora relacionado

60
00:03:06,719 --> 00:03:08,680
con el término excepción

61
00:03:08,680 --> 00:03:09,960
relacionado con el término excepción

62
00:03:09,960 --> 00:03:12,400
bueno, pues la idea es que ahora entendamos

63
00:03:12,400 --> 00:03:15,300
qué es una excepción y cómo usarlas

64
00:03:15,300 --> 00:03:16,500
cómo utilizarlas

65
00:03:16,500 --> 00:03:18,539
dentro de nuestros desarrollos

66
00:03:18,539 --> 00:03:20,099
porque son una herramienta más

67
00:03:20,099 --> 00:03:23,039
para hacer nuestros desarrollos, son una herramienta más

68
00:03:23,039 --> 00:03:24,900
no son sólo algo que aparece

69
00:03:24,900 --> 00:03:26,699
cuando hemos hecho algo mal

70
00:03:26,699 --> 00:03:29,020
y que tenemos entonces que irnos

71
00:03:29,020 --> 00:03:30,960
al código a cambiarlo para que no aparezca

72
00:03:30,960 --> 00:03:32,520
no son sólo eso

73
00:03:32,520 --> 00:03:35,219
hasta ahora sí han sido sólo eso para nosotros

74
00:03:35,219 --> 00:03:37,000
algo que cuando ya estábamos

75
00:03:37,000 --> 00:03:38,080
en tiempo de ejecución

76
00:03:38,080 --> 00:03:40,740
aparecía y decíamos

77
00:03:40,740 --> 00:03:42,740
uy, he hecho algo mal en el código

78
00:03:42,740 --> 00:03:45,340
pues voy a entrar a cambiarlo

79
00:03:45,340 --> 00:03:46,599
porque he hecho algo mal

80
00:03:46,599 --> 00:03:49,039
hasta ahora es lo único que ha sido para todas las excepciones

81
00:03:49,039 --> 00:03:51,780
pero repito, son más que eso, son una herramienta

82
00:03:51,780 --> 00:03:53,240
más grande que podemos usar

83
00:03:53,240 --> 00:03:55,099
dentro de nuestros desarrollos

84
00:03:55,099 --> 00:03:57,620
para comunicar

85
00:03:57,620 --> 00:03:58,180
cosas

86
00:03:58,180 --> 00:04:01,340
que eso es justo lo que nos está pasando aquí

87
00:04:01,340 --> 00:04:03,500
lo que nos está haciendo

88
00:04:03,500 --> 00:04:05,659
Java aquí

89
00:04:05,659 --> 00:04:06,919
es comunicarnos cosas

90
00:04:06,919 --> 00:04:09,159
nos está comunicando, cállate

91
00:04:09,159 --> 00:04:11,419
nos está comunicando, ojo

92
00:04:11,419 --> 00:04:12,620
que estás dividiendo por cero

93
00:04:12,620 --> 00:04:15,159
ojo que estás accediendo

94
00:04:15,159 --> 00:04:17,120
a un objeto que es null

95
00:04:17,120 --> 00:04:20,120
nos está comunicando cosas, nos está dando información.

96
00:04:20,899 --> 00:04:22,980
Pues nosotros también podemos usar las excepciones

97
00:04:22,980 --> 00:04:26,579
y hacer nuestras propias excepciones para comunicar cosas.

98
00:04:27,160 --> 00:04:29,079
Cuando hacemos nosotros métodos,

99
00:04:29,879 --> 00:04:33,079
podemos usar excepciones nuestras que creamos

100
00:04:33,079 --> 00:04:35,240
y que nos inventamos para comunicar cosas.

101
00:04:35,879 --> 00:04:36,639
Y para eso sirve.

102
00:04:37,079 --> 00:04:39,959
Las excepciones son un mecanismo que tiene el software

103
00:04:39,959 --> 00:04:42,120
para comunicar cosas que están pasando.

104
00:04:42,899 --> 00:04:44,060
Eso es lo que es una excepción.

105
00:04:45,120 --> 00:04:46,100
En realidad es eso.

106
00:04:46,100 --> 00:04:51,189
es un mecanismo

107
00:04:51,189 --> 00:04:53,069
un mecanismo, una herramienta más

108
00:04:53,069 --> 00:04:55,129
de código, un mecanismo

109
00:04:55,129 --> 00:05:01,939
para comunicar

110
00:05:01,939 --> 00:05:03,800
cosas que están pasando

111
00:05:03,800 --> 00:05:05,879
durante la ejecución de un código

112
00:05:05,879 --> 00:05:27,139
eso es en general las excepciones

113
00:05:27,139 --> 00:05:29,300
un mecanismo que tenemos que aprender a utilizar

114
00:05:29,300 --> 00:05:30,980
para comunicar cosas

115
00:05:30,980 --> 00:05:33,220
que pasan durante la ejecución de un código

116
00:05:33,220 --> 00:05:35,139
vale, lo que pasa

117
00:05:35,139 --> 00:05:36,839
es que las excepciones en particular

118
00:05:36,839 --> 00:05:38,779
las cosas que comunican

119
00:05:38,779 --> 00:05:41,259
son cosas que están pasando

120
00:05:41,259 --> 00:05:43,139
mal, son cosas malas

121
00:05:43,139 --> 00:05:45,319
para eso sirven, son una herramienta

122
00:05:45,319 --> 00:05:47,220
para comunicar cosas malas que están

123
00:05:47,220 --> 00:05:48,819
pasando, cosas que no deberían

124
00:05:48,819 --> 00:05:51,240
¿vale? entonces estas

125
00:05:51,240 --> 00:05:53,220
cosas que comunican las excepciones

126
00:05:53,220 --> 00:05:55,720
pues están especializadas

127
00:05:55,720 --> 00:05:57,139
sirven para comunicar

128
00:05:57,139 --> 00:05:59,519
cosas que no deberían pasar

129
00:05:59,519 --> 00:06:01,660
nos informan

130
00:06:01,660 --> 00:06:03,199
oye, está pasando esto y no debería

131
00:06:03,199 --> 00:06:10,550
¿vale? porque tenemos

132
00:06:10,550 --> 00:06:12,470
otras herramientas para comunicar

133
00:06:12,470 --> 00:06:13,829
cosas que no pasa nada

134
00:06:13,829 --> 00:06:15,029
¿por qué pasa?

135
00:06:15,029 --> 00:06:16,949
de hecho

136
00:06:16,949 --> 00:06:19,949
es exactamente

137
00:06:19,949 --> 00:06:21,730
lo mismo que he planteado antes

138
00:06:21,730 --> 00:06:23,250
cuando explicaba el método replace

139
00:06:23,250 --> 00:06:24,889
he dicho el replace

140
00:06:24,889 --> 00:06:26,910
te devuelve un valor de retorno

141
00:06:26,910 --> 00:06:28,730
ese valor de retorno

142
00:06:28,730 --> 00:06:31,050
te sirve para verificar

143
00:06:31,050 --> 00:06:33,649
si encontró el código o si no lo encontró

144
00:06:33,649 --> 00:06:36,129
entonces mediante ese valor de retorno

145
00:06:36,129 --> 00:06:37,769
también nos están informando

146
00:06:37,769 --> 00:06:38,250
de cosas

147
00:06:38,250 --> 00:06:41,649
pero eso que nos informan no tiene nada que ver con que

148
00:06:41,649 --> 00:06:43,670
haya ocurrido algo que no tenga que ocurrir

149
00:06:43,670 --> 00:07:02,170
No, el replace dice que existe, sustituyo, que no existe, no sustituyo, pero es un funcionamiento completamente normal, eso no significa que haya ocurrido algo fuera de control, entonces yo no lo comunico con una excepción, lo comunico con un valor de retorno, ¿vale?

150
00:07:02,170 --> 00:07:04,810
bueno, pues las excepciones son una forma

151
00:07:04,810 --> 00:07:06,050
de comunicar cosas

152
00:07:06,050 --> 00:07:09,550
que no deberían ocurrir

153
00:07:09,550 --> 00:07:10,910
nos alertan de cosas

154
00:07:10,910 --> 00:07:11,970
que no deberían ocurrir

155
00:07:11,970 --> 00:07:14,970
por eso, las excepciones

156
00:07:14,970 --> 00:07:16,990
cuando aparecen, y ahora veremos

157
00:07:16,990 --> 00:07:18,670
cómo aparecen, no es que aparezcan de la nada

158
00:07:18,670 --> 00:07:20,370
no es que el ordenador se las saque de la manga

159
00:07:20,370 --> 00:07:22,629
ahora veremos cómo aparecen

160
00:07:22,629 --> 00:07:25,089
pues las excepciones cuando aparecen

161
00:07:25,089 --> 00:07:27,110
además

162
00:07:27,110 --> 00:07:28,170
además

163
00:07:28,170 --> 00:07:30,550
paran la ejecución del código

164
00:07:30,550 --> 00:07:32,009
detienen la máquina virtual

165
00:07:32,009 --> 00:07:51,430
Entonces, esa es otra de sus particularidades. Cuando la excepción aparece, la máquina virtual detiene la ejecución del código, porque asume que eso que ha ocurrido no debería. Entonces, es importante, cuando la excepción aparece, además se detiene la ejecución del código, ¿vale?

166
00:07:51,430 --> 00:07:55,810
entonces además

167
00:07:55,810 --> 00:07:57,990
después de aparecer la excepción

168
00:07:57,990 --> 00:07:59,310
la máquina virtual

169
00:07:59,310 --> 00:08:01,189
que es

170
00:08:01,189 --> 00:08:03,629
la que está interpretando las sentencias

171
00:08:03,629 --> 00:08:05,750
la que está ejecutando las sentencias

172
00:08:05,750 --> 00:08:07,910
ya sabéis que es la máquina virtual que va sentencia

173
00:08:07,910 --> 00:08:09,930
por sentencia ejecutando

174
00:08:09,930 --> 00:08:11,990
pues como resultado de ejecutar

175
00:08:11,990 --> 00:08:13,889
una, si como resultado de ejecutar

176
00:08:13,889 --> 00:08:15,529
una aparece esto

177
00:08:15,529 --> 00:08:17,829
pues la máquina

178
00:08:17,829 --> 00:08:18,790
virtual para

179
00:08:18,790 --> 00:08:21,449
la máquina virtual para el código,

180
00:08:22,389 --> 00:08:23,129
para la ejecución.

181
00:08:25,490 --> 00:08:26,970
Y repito, precisamente por eso,

182
00:08:27,110 --> 00:08:29,389
porque lo que nos comunican las excepciones

183
00:08:29,389 --> 00:08:30,910
se supone que es algo que no debería ocurrir.

184
00:08:31,470 --> 00:08:33,230
Por eso la máquina virtual para la ejecución.

185
00:08:35,070 --> 00:08:39,230
Aún así, ya sabemos que tenemos una manera

186
00:08:39,230 --> 00:08:42,549
de evitar que la máquina virtual

187
00:08:42,549 --> 00:08:44,029
pare la ejecución,

188
00:08:44,169 --> 00:08:45,649
aunque haya salido una de estas.

189
00:08:46,309 --> 00:08:48,070
Porque eso también lo hemos usado.

190
00:08:48,070 --> 00:08:50,990
¿vale? es la otra cosa

191
00:08:50,990 --> 00:08:52,769
con la que también hemos

192
00:08:52,769 --> 00:08:54,450
trabajado relacionada con excepciones

193
00:08:54,450 --> 00:08:56,710
¿vale? es decir

194
00:08:56,710 --> 00:08:57,950
relacionada con excepciones

195
00:08:57,950 --> 00:09:01,149
ya estamos familiarizados con que aparezcan

196
00:09:01,149 --> 00:09:02,809
cuando hacemos algo raro

197
00:09:02,809 --> 00:09:04,629
como esto

198
00:09:04,629 --> 00:09:06,610
como esto, ya estamos familiarizados

199
00:09:06,610 --> 00:09:08,710
con que aparezcan y también ya

200
00:09:08,710 --> 00:09:09,970
hemos visto alguna vez

201
00:09:09,970 --> 00:09:12,710
que podemos evitar que el código se pare

202
00:09:12,710 --> 00:09:14,590
aunque aparezca

203
00:09:14,590 --> 00:09:16,029
entonces si nosotros no hacemos nada

204
00:09:16,029 --> 00:09:18,230
y ponemos las sentencias tal cual

205
00:09:18,230 --> 00:09:20,210
ya hemos verificado

206
00:09:20,210 --> 00:09:21,409
porque nos ha pasado muchas veces

207
00:09:21,409 --> 00:09:22,929
que el código se va a detener

208
00:09:22,929 --> 00:09:25,009
eso es como funciona por defecto

209
00:09:25,009 --> 00:09:28,210
pero si queremos evitar que la máquina virtual

210
00:09:28,210 --> 00:09:29,250
pare la ejecución

211
00:09:29,250 --> 00:09:33,940
ya sabemos que tenemos un truco

212
00:09:33,940 --> 00:09:36,600
una herramienta de código para evitarlo

213
00:09:36,600 --> 00:09:38,539
¿qué truco hemos usado

214
00:09:38,539 --> 00:09:39,399
a veces para eso?

215
00:09:39,940 --> 00:09:40,419
¿qué os suena?

216
00:09:41,000 --> 00:09:43,559
para evitar que la máquina virtual pare la ejecución

217
00:09:43,559 --> 00:09:44,279
cuando hay una excepción

218
00:09:44,279 --> 00:09:44,740
¿os suena?

219
00:09:47,399 --> 00:09:48,159
try cut

220
00:09:48,159 --> 00:09:50,580
es decir

221
00:09:50,580 --> 00:09:57,590
es decir, este código

222
00:09:57,590 --> 00:10:01,269
este código tal cual está

223
00:10:01,269 --> 00:10:03,370
con estas dos sentencias

224
00:10:03,370 --> 00:10:05,149
aquí no hay tutía

225
00:10:05,149 --> 00:10:07,830
cuando la máquina virtual se ponga a ejecutar

226
00:10:07,830 --> 00:10:09,669
este código, va a salir

227
00:10:09,669 --> 00:10:11,350
el null pointer exception

228
00:10:11,350 --> 00:10:14,850
va a salir

229
00:10:14,850 --> 00:10:17,389
y no solo va a salir el null pointer exception

230
00:10:17,389 --> 00:10:19,769
sino que la ejecución

231
00:10:19,769 --> 00:10:20,350
se va a parar

232
00:10:20,350 --> 00:10:22,570
y se acabó

233
00:10:22,570 --> 00:10:25,470
lo que viniera después no se va a ejecutar

234
00:10:25,470 --> 00:10:26,929
porque se ha parado, está claro

235
00:10:26,929 --> 00:10:29,529
con ese código así no hay alternativa

236
00:10:29,529 --> 00:10:30,590
esto es lo que va a pasar

237
00:10:30,590 --> 00:10:33,549
null pointer exception y la ejecución detenida

238
00:10:33,549 --> 00:10:34,129
vale

239
00:10:34,129 --> 00:10:37,669
que queremos impedir que la ejecución

240
00:10:37,669 --> 00:10:38,330
se detenga

241
00:10:38,330 --> 00:10:40,870
aunque haya salido la excepción

242
00:10:40,870 --> 00:10:43,370
porque va a salir, eso sí que no puedo evitarlo con este código

243
00:10:43,370 --> 00:10:45,830
si aquí tengo null y aquí a un objeto null

244
00:10:45,830 --> 00:10:47,190
accedo a sus propiedades

245
00:10:47,190 --> 00:10:48,230
no va a salir null pointer exception

246
00:10:48,230 --> 00:10:51,509
bueno, pues si quiero evitar que se detenga la ejecución

247
00:10:51,509 --> 00:10:54,149
aunque la excepción me salga, si quiere evitarlo

248
00:10:54,149 --> 00:10:55,570
¿qué podemos hacer?

249
00:10:56,129 --> 00:10:57,529
pues la sentencia

250
00:10:57,529 --> 00:11:00,649
que creemos que va a provocar

251
00:11:00,649 --> 00:11:02,470
ese problema, la que creemos

252
00:11:02,470 --> 00:11:04,570
que puede provocarlo, la peligrosa

253
00:11:04,570 --> 00:11:06,450
la metemos en un bloque

254
00:11:06,450 --> 00:11:08,450
así, la metemos

255
00:11:08,450 --> 00:11:10,730
entre llaves, en un bloque con un tray delante

256
00:11:10,730 --> 00:11:12,409
y entonces le decimos

257
00:11:12,409 --> 00:11:14,350
oye, inténtala

258
00:11:14,350 --> 00:11:15,950
inténtala

259
00:11:15,950 --> 00:11:17,570
que te sale

260
00:11:17,570 --> 00:11:20,149
magnífico, la haces

261
00:11:20,149 --> 00:11:22,590
y sigues con el código que venga debajo.

262
00:11:23,970 --> 00:11:26,909
Que no te sale, porque te sale una excepción.

263
00:11:27,730 --> 00:11:29,110
Pues entonces te metes aquí.

264
00:11:29,769 --> 00:11:33,769
Es como si fuera un if-else, pero adaptado a excepciones.

265
00:11:34,629 --> 00:11:36,570
Entonces, el try-catch tiene este formato.

266
00:11:37,429 --> 00:11:40,389
Try, entre llaves, la o las sentencias,

267
00:11:40,529 --> 00:11:42,389
aquí puede haber muchas, no tiene por qué haber una.

268
00:11:42,970 --> 00:11:45,710
Entre llaves, el código que nos preocupa.

269
00:11:45,710 --> 00:11:48,370
El código que creemos que puede que dé excepción

270
00:11:48,370 --> 00:11:50,029
y por tanto pararse el programa.

271
00:11:50,149 --> 00:11:52,350
hay el código que nos preocupa

272
00:11:52,350 --> 00:11:53,070
y ahora catch

273
00:11:53,070 --> 00:11:54,929
y aquí tenemos que escribir

274
00:11:54,929 --> 00:11:57,809
la excepción que creemos que va a salir

275
00:11:57,809 --> 00:11:59,169
¿vale?

276
00:12:00,389 --> 00:12:01,850
esto con pequeños matices

277
00:12:01,850 --> 00:12:04,409
que ya incorporaremos cuando tengamos más

278
00:12:04,409 --> 00:12:05,889
entonces yo aquí creo que

279
00:12:05,889 --> 00:12:07,889
puede que salga null pointer exception

280
00:12:07,889 --> 00:12:11,000
por ejemplo

281
00:12:11,000 --> 00:12:18,580
bueno, pues entonces tenemos que poner el catch

282
00:12:18,580 --> 00:12:20,259
y entre paréntesis

283
00:12:20,259 --> 00:12:22,539
como si pusiéramos la declaración

284
00:12:22,539 --> 00:12:23,799
de un objeto

285
00:12:23,799 --> 00:12:25,240
de un objeto

286
00:12:25,240 --> 00:12:28,480
que pertenece a una clase

287
00:12:28,480 --> 00:12:29,879
excepción con ese nombre

288
00:12:29,879 --> 00:12:35,399
ahora nos meteremos más

289
00:12:35,399 --> 00:12:36,720
nos meteremos más en

290
00:12:36,720 --> 00:12:38,860
estos nombres

291
00:12:38,860 --> 00:12:41,019
estos nombres de clase, nos meteremos más

292
00:12:41,019 --> 00:12:43,220
ahora mismo lo que estoy simplemente poniendo es

293
00:12:43,220 --> 00:12:44,220
cómo se hace un try-catch

294
00:12:44,220 --> 00:12:54,059
bueno, pues un try-catch

295
00:12:54,059 --> 00:12:56,000
básico se hace así

296
00:12:56,000 --> 00:12:58,240
ya lo hemos usado en algún momento

297
00:12:58,240 --> 00:12:59,799
cuando hacíamos la clase teclado

298
00:12:59,799 --> 00:13:00,559
para evitar

299
00:13:00,559 --> 00:13:03,360
tener que poner el throws, etc.

300
00:13:03,360 --> 00:13:09,519
Lo usamos porque lo habíamos necesitado, pero todavía no teníamos muy claro por qué lo usábamos.

301
00:13:10,360 --> 00:13:12,019
Bueno, pues ¿para qué lo usamos?

302
00:13:12,539 --> 00:13:19,399
Para evitar que un código, en caso de generar excepción de algún tipo, pare la ejecución.

303
00:13:20,019 --> 00:13:23,559
Si plantamos un try-catch, estas sentencias se ejecutan.

304
00:13:24,139 --> 00:13:29,519
Y en caso de que salga la excepción que está en el catch, si sale la que está en el catch,

305
00:13:29,519 --> 00:13:32,340
entonces la máquina virtual lo que hace es

306
00:13:32,340 --> 00:13:33,679
se va aquí

307
00:13:33,679 --> 00:13:35,480
y ejecuta lo que yo ponga ahí

308
00:13:35,480 --> 00:13:38,000
lo que me dé la gana, como si pongo ahí mis líneas

309
00:13:38,000 --> 00:13:39,840
hombre, no es la idea, porque si

310
00:13:39,840 --> 00:13:41,620
yo he venido aquí al catch

311
00:13:41,620 --> 00:13:44,259
es porque algo ha ido mal, si algo ha ido mal

312
00:13:44,259 --> 00:13:46,019
lo más que querré hacer será

313
00:13:46,019 --> 00:13:47,360
avisar y ya está

314
00:13:47,360 --> 00:13:49,919
¿vale? pero ahí uno puede poner lo que quiera

315
00:13:49,919 --> 00:13:50,879
es un bloque más de código

316
00:13:50,879 --> 00:13:54,200
bueno, pues solamente incorporando el try catch

317
00:13:54,200 --> 00:13:56,539
ya, la excepción sale igualmente

318
00:13:56,539 --> 00:13:57,759
eso no lo hemos cambiado

319
00:13:57,759 --> 00:13:59,639
porque si yo hago n.nombre

320
00:13:59,639 --> 00:14:01,259
es que va a salir la excepción, pero

321
00:14:01,259 --> 00:14:02,740
la máquina virtual ya no para el programa

322
00:14:02,740 --> 00:14:05,019
y esto continúa por aquí tan tranquilo

323
00:14:05,019 --> 00:14:07,700
¿vale? continúa por ahí y ya está

324
00:14:07,700 --> 00:14:09,159
y además

325
00:14:09,159 --> 00:14:11,320
se ejecuta lo que haya aquí dentro

326
00:14:11,320 --> 00:14:13,340
que normalmente pues será

327
00:14:13,340 --> 00:14:14,019
un aviso

328
00:14:14,019 --> 00:14:17,639
una escritura

329
00:14:17,639 --> 00:14:19,580
de archivo de logs para indicar

330
00:14:19,580 --> 00:14:21,419
ha habido error de no sé qué, lo que sea

331
00:14:21,419 --> 00:14:25,580
bueno, pues en resumen

332
00:14:25,580 --> 00:14:28,019
una excepción es algo que se

333
00:14:28,019 --> 00:14:30,000
genera, ahora veremos

334
00:14:30,000 --> 00:14:32,100
como consecuencia de

335
00:14:32,100 --> 00:14:34,039
la ejecución de una sentencia

336
00:14:34,039 --> 00:14:35,519
de código que ha salido mal.

337
00:14:36,379 --> 00:14:37,080
Que ha salido mal.

338
00:14:37,919 --> 00:14:39,240
Entonces, como una sentencia de código

339
00:14:39,240 --> 00:14:42,059
ha salido mal, pues la excepción

340
00:14:42,059 --> 00:14:42,480
aparece.

341
00:14:43,600 --> 00:14:45,340
Que está capturada

342
00:14:45,340 --> 00:14:47,860
o lo que es lo mismo, que está dentro de un

343
00:14:47,860 --> 00:14:49,700
try-catch, porque

344
00:14:49,700 --> 00:14:51,779
estar dentro de un try-catch significa estar

345
00:14:51,779 --> 00:14:53,759
capturada. Que está

346
00:14:53,759 --> 00:14:56,000
capturada, que está dentro de un bloque try-catch,

347
00:14:56,580 --> 00:14:57,500
no pasa nada.

348
00:14:58,299 --> 00:14:59,820
La máquina virtual salta

349
00:14:59,820 --> 00:15:01,039
automáticamente al catch

350
00:15:01,039 --> 00:15:03,779
hace lo que tenga que hacer y continúa

351
00:15:03,779 --> 00:15:05,279
el programa y no se para

352
00:15:05,279 --> 00:15:07,759
entonces, eso hace que

353
00:15:07,759 --> 00:15:09,379
sí, uy, gracias

354
00:15:09,379 --> 00:15:13,820
eso hace

355
00:15:13,820 --> 00:15:16,000
que el programa sea más robusto

356
00:15:16,000 --> 00:15:17,980
porque no se para por cualquier tontería

357
00:15:17,980 --> 00:15:19,200
pero claro, cuidado

358
00:15:19,200 --> 00:15:21,980
porque ha habido un problema, entonces el resto

359
00:15:21,980 --> 00:15:23,379
del programa tiene que estar

360
00:15:23,379 --> 00:15:24,759
hecho de tal manera

361
00:15:24,759 --> 00:15:27,299
que no arrastre estas complicaciones

362
00:15:27,299 --> 00:15:30,039
claro, pero eso ya es tema del programador

363
00:15:30,039 --> 00:15:30,799
de lo que esté haciendo

364
00:15:30,799 --> 00:15:33,299
bueno, pues entonces

365
00:15:33,299 --> 00:15:36,519
eso es una excepción, una forma de avisar

366
00:15:36,519 --> 00:15:37,500
de que algo ha ido mal

367
00:15:37,500 --> 00:15:40,440
y ahora ya la pregunta siguiente

368
00:15:40,440 --> 00:15:41,700
sería, pero ¿de dónde sale?

369
00:15:42,159 --> 00:15:42,899
¿cómo es que aparece?

370
00:15:43,460 --> 00:15:46,100
yo sé que si tecleo esta línea

371
00:15:46,100 --> 00:15:48,820
y la ejecuto, me salen palabras rojas

372
00:15:48,820 --> 00:15:50,419
pero no sabemos más

373
00:15:50,419 --> 00:15:52,259
no sabemos qué es lo que ha pasado ahí debajo

374
00:15:52,259 --> 00:15:54,000
si ha salido un enano escribiendo

375
00:15:54,000 --> 00:15:55,559
en el redal roja, qué es lo que ha salido ahí

376
00:15:55,559 --> 00:15:57,419
no tenemos ni idea de cuál es el origen de eso,

377
00:15:57,740 --> 00:15:58,700
que se ha desencadenado.

378
00:15:59,600 --> 00:16:03,480
Bueno, eso es lo que tenemos que entender ahora.

379
00:16:05,950 --> 00:16:09,370
Bueno, pues entonces, silencio.

380
00:16:11,889 --> 00:16:15,429
Bueno, algunas excepciones ya nos suenan,

381
00:16:16,450 --> 00:16:17,929
porque nos las hemos encontrado a veces.

382
00:16:19,250 --> 00:16:20,970
Null pointer exception ya nos suena.

383
00:16:21,269 --> 00:16:24,809
Sabemos que nos aparece cuando un objeto que es null,

384
00:16:24,809 --> 00:16:26,370
un objeto que es null,

385
00:16:26,370 --> 00:16:28,549
tratamos de acceder

386
00:16:28,549 --> 00:16:30,789
o a propiedades o a métodos con el punto

387
00:16:30,789 --> 00:16:32,789
como tratemos de acceder

388
00:16:32,789 --> 00:16:35,190
al contenido o al comportamiento

389
00:16:35,190 --> 00:16:36,870
con métodos de un objeto que es null

390
00:16:36,870 --> 00:16:38,029
ya sabemos que esta nos sale

391
00:16:38,029 --> 00:16:40,269
nos han salido más

392
00:16:40,269 --> 00:16:42,669
nos han salido la divide by 0

393
00:16:42,669 --> 00:16:45,049
esa excepción que he escrito antes

394
00:16:45,049 --> 00:16:46,950
que nos ha salido cuando hemos tratado

395
00:16:46,950 --> 00:16:48,149
de hacer una división por 0

396
00:16:48,149 --> 00:16:50,110
pero nos han salido más

397
00:16:50,110 --> 00:16:51,990
nos ha salido

398
00:16:51,990 --> 00:17:04,559
esta también nos ha salido

399
00:17:04,559 --> 00:17:06,680
esta excepción nos salía

400
00:17:06,680 --> 00:17:08,920
cuando recorríamos un array

401
00:17:08,920 --> 00:17:11,240
cuando tratábamos de acceder a una posición

402
00:17:11,240 --> 00:17:13,240
que el array no tenía

403
00:17:13,240 --> 00:17:15,180
el array tenía tres posiciones

404
00:17:15,180 --> 00:17:16,279
y debíamos acceder a las siete

405
00:17:16,279 --> 00:17:18,859
pues nos salía array index bound exception

406
00:17:18,859 --> 00:17:21,220
también nos ha salido la string

407
00:17:21,220 --> 00:17:22,660
index out of bound exception

408
00:17:22,660 --> 00:17:25,059
cuando tratábamos de acceder a posiciones

409
00:17:25,059 --> 00:17:27,119
de un string en las que no había tampoco

410
00:17:27,119 --> 00:17:28,839
caracteres

411
00:17:28,839 --> 00:17:29,539
bueno pues

412
00:17:29,539 --> 00:17:32,400
nombrecitos de estos ya nos suenan

413
00:17:32,400 --> 00:17:34,740
ya no suenan nombres de esos

414
00:17:34,740 --> 00:17:36,759
bueno, pues esos nombres de dónde salen

415
00:17:36,759 --> 00:17:38,759
estos nombres en realidad

416
00:17:38,759 --> 00:17:41,140
son nombres de clases de Java

417
00:17:41,140 --> 00:17:42,200
que ya están hechas

418
00:17:42,200 --> 00:17:50,400
es decir

419
00:17:50,400 --> 00:17:52,240
cada posible cosa rara

420
00:17:52,240 --> 00:17:54,420
que puede ocurrir, cada posible cosa rara

421
00:17:54,420 --> 00:17:55,880
dividir por cero

422
00:17:55,880 --> 00:17:57,500
salirte de un array

423
00:17:57,500 --> 00:17:59,220
acceder a un objeto nulo

424
00:17:59,220 --> 00:18:02,180
acceder de forma concurrente a un recurso

425
00:18:02,180 --> 00:18:04,799
que también nos ha salido el concurrent modification exception

426
00:18:04,799 --> 00:18:06,819
nos salió con el for each y las colecciones

427
00:18:06,819 --> 00:18:08,619
pues cada cosa rara

428
00:18:08,619 --> 00:18:10,500
que puede ocurrir

429
00:18:10,500 --> 00:18:12,880
tiene una clase declarada

430
00:18:12,880 --> 00:18:14,940
asociada, tiene una clase

431
00:18:14,940 --> 00:18:15,640
declarada

432
00:18:15,640 --> 00:18:18,299
conclusión, tenemos

433
00:18:18,299 --> 00:18:21,039
en la máquina virtual de Java, en la librería que tiene dentro

434
00:18:21,039 --> 00:18:23,220
tropecientan mil clases de estas

435
00:18:23,220 --> 00:18:24,680
tropecientan mil

436
00:18:24,680 --> 00:18:26,900
una por cada cosa rara

437
00:18:26,900 --> 00:18:29,259
que puede ocurrir, tropecientan mil

438
00:18:29,259 --> 00:18:30,900
si las

439
00:18:31,440 --> 00:18:39,410
miramos por aquí

440
00:18:39,410 --> 00:18:40,589
a ver

441
00:18:40,589 --> 00:19:38,690
bueno, a ver

442
00:19:38,690 --> 00:19:42,160
vale, pues

443
00:19:42,160 --> 00:19:45,119
la máquina virtual de Java

444
00:19:45,119 --> 00:19:47,019
ya sabéis que incorpora

445
00:19:47,019 --> 00:19:49,119
un montón de paquetes

446
00:19:49,119 --> 00:19:50,359
tropecientos mil

447
00:19:50,359 --> 00:19:55,630
tropecientos, estos son sólo los de

448
00:19:55,630 --> 00:19:57,390
el JAR Java base

449
00:19:57,390 --> 00:19:59,490
de ahí, pero aparte del JAR Java base

450
00:19:59,490 --> 00:20:00,730
pues está este JAR

451
00:20:00,730 --> 00:20:03,569
está este, o sea, hay tropecientos

452
00:20:03,569 --> 00:20:04,529
donde

453
00:20:04,529 --> 00:20:06,809
cada jar tiene un montón

454
00:20:06,809 --> 00:20:07,869
de paquetes

455
00:20:07,869 --> 00:20:10,950
y cada paquete, si uno se pone

456
00:20:10,950 --> 00:20:12,910
a cotillear, se va a encontrar en cada

457
00:20:12,910 --> 00:20:14,150
uno de ellos distribuido

458
00:20:14,150 --> 00:20:16,750
clases que acaban con la palabra

459
00:20:16,750 --> 00:20:18,849
excepción. Bueno, pues

460
00:20:18,849 --> 00:20:20,769
las clases que representan cosas

461
00:20:20,769 --> 00:20:21,890
raras que pueden ocurrir

462
00:20:21,890 --> 00:20:24,170
por convenio, para

463
00:20:24,170 --> 00:20:26,750
enterarnos todos y entendernos todos, tienen

464
00:20:26,750 --> 00:20:27,730
el nombrecito que tengan

465
00:20:27,730 --> 00:20:29,589
y acaban en excepción.

466
00:20:30,890 --> 00:20:32,529
Entonces, esto en particular será

467
00:20:32,529 --> 00:20:34,329
excepción de tipo NTLM

468
00:20:34,329 --> 00:20:36,390
que vete a saber a qué se refieren las siglas estas

469
00:20:36,390 --> 00:20:38,569
algo de seguridad de NTLM, yo que sé

470
00:20:38,569 --> 00:20:42,289
aquí que lo entendemos mejor

471
00:20:42,289 --> 00:20:43,650
pues por ejemplo

472
00:20:43,650 --> 00:20:46,789
en este paquete están las clases relacionadas

473
00:20:46,789 --> 00:20:48,289
con entrada y salida archivos

474
00:20:48,289 --> 00:20:50,349
pues aquí nos encontramos muchas

475
00:20:50,349 --> 00:20:51,450
que acaban en excepción

476
00:20:51,450 --> 00:20:54,009
pues por ejemplo

477
00:20:54,009 --> 00:20:55,750
esta

478
00:20:55,750 --> 00:20:57,210
esto es

479
00:20:57,210 --> 00:21:00,430
excepción de que has llegado

480
00:21:00,430 --> 00:21:02,509
a fin de archivo, una cosa rara que te ha ocurrido

481
00:21:02,509 --> 00:21:04,150
has llegado a fin de archivo, estás tratando de leer.

482
00:21:04,849 --> 00:21:06,150
No puedo, has llegado al final.

483
00:21:06,710 --> 00:21:08,690
Esta es una clase excepción programada

484
00:21:08,690 --> 00:21:09,549
para esa situación.

485
00:21:10,569 --> 00:21:12,410
Aquí abajo, pues tenemos otra.

486
00:21:13,150 --> 00:21:14,930
Esta es una excepción programada

487
00:21:14,930 --> 00:21:16,970
para la situación, el fichero no existe.

488
00:21:17,549 --> 00:21:19,150
Al que tratas de acceder no existe.

489
00:21:20,549 --> 00:21:21,329
Quiero decir,

490
00:21:22,509 --> 00:21:23,589
hay tropecientas

491
00:21:23,589 --> 00:21:25,089
clases excepción ya hechas,

492
00:21:25,210 --> 00:21:27,190
tropecientas hechas, que están

493
00:21:27,190 --> 00:21:29,170
asociadas a cosas raras que pueden ocurrir.

494
00:21:29,809 --> 00:21:31,589
¿Vale? Ya nos hemos encontrado,

495
00:21:31,589 --> 00:21:33,410
repito, el array inDesbound,

496
00:21:33,529 --> 00:21:34,609
el pointer exception, etc.

497
00:21:35,470 --> 00:21:37,549
Bueno, pues esas clases

498
00:21:37,549 --> 00:21:41,750
de esas clases se instancian objetos

499
00:21:41,750 --> 00:21:43,069
de esas clases

500
00:21:43,069 --> 00:21:45,910
y esos objetos son los que aparecen

501
00:21:45,910 --> 00:21:47,789
cuando ha ocurrido

502
00:21:47,789 --> 00:21:48,849
alguna de esas cosas raras.

503
00:21:49,730 --> 00:21:50,849
Así es como funciona esto.

504
00:21:52,069 --> 00:21:53,589
Por ejemplo, a ver

505
00:21:53,589 --> 00:22:10,329
ahí he cerrado esto, mierda.

506
00:22:31,079 --> 00:22:32,180
Vale, pues a ver

507
00:22:32,180 --> 00:22:35,680
vamos por ejemplo

508
00:22:35,680 --> 00:22:37,700
a abrir la clase string

509
00:22:37,700 --> 00:22:39,400
que la clase string

510
00:22:39,400 --> 00:22:40,819
alguno de los métodos que tiene

511
00:22:40,819 --> 00:22:43,140
alguno de los métodos tendrá contemplado

512
00:22:43,140 --> 00:22:45,599
que si hace algo raro avise con alguna excepción

513
00:22:45,599 --> 00:22:47,220
pues vamos a mirar

514
00:22:47,220 --> 00:22:48,400
cómo está avisando

515
00:22:48,400 --> 00:22:51,299
cómo es eso de que se cree

516
00:22:51,299 --> 00:22:53,220
el objeto, este que digo, que se crea

517
00:22:53,220 --> 00:22:54,200
cuando pasa eso raro

518
00:22:54,200 --> 00:22:57,140
aquí seguro que tengo una clase

519
00:22:57,140 --> 00:22:58,440
string por algún lado

520
00:22:58,440 --> 00:23:04,640
sí, no sé, lo que quiero es entrar en una clase de la máquina

521
00:23:04,640 --> 00:23:06,519
Y entrar desde aquí, porque si entro desde el otro lado

522
00:23:06,519 --> 00:23:07,759
Tarda mucho en abrirlo

523
00:23:07,759 --> 00:23:10,279
Aquí, quiero entrar

524
00:23:10,279 --> 00:23:12,500
Implementación de la clase string

525
00:23:12,500 --> 00:23:13,559
Vale

526
00:23:13,559 --> 00:23:15,940
Entonces

527
00:23:15,940 --> 00:23:21,440
A ver si encuentro rápido

528
00:23:21,440 --> 00:23:26,880
Un throw

529
00:23:26,880 --> 00:23:27,579
Por ahí

530
00:23:27,579 --> 00:23:36,769
Espera, vamos a buscar aquí

531
00:23:36,769 --> 00:23:37,710
Control F

532
00:23:37,710 --> 00:23:52,920
Vale, este método

533
00:23:52,920 --> 00:23:54,539
Lanza

534
00:23:54,539 --> 00:24:06,019
vale, pues por ejemplo

535
00:24:06,019 --> 00:24:10,220
a ver, la clase string

536
00:24:10,220 --> 00:24:12,700
tiene aquí un método

537
00:24:12,700 --> 00:24:14,240
bueno, es que perdí antes el constructor

538
00:24:14,240 --> 00:24:17,579
vamos a coger otro método cualquiera

539
00:24:17,579 --> 00:24:18,700
que se entenderá mejor

540
00:24:18,700 --> 00:24:35,940
throws este, por ejemplo

541
00:24:35,940 --> 00:24:50,099
vale, pues por ejemplo

542
00:24:50,099 --> 00:24:52,960
la clase string, que la clase string ya está hecha

543
00:24:52,960 --> 00:24:54,519
la clase string ya está hecha

544
00:24:54,519 --> 00:24:56,680
pues la clase string tiene métodos para hacer cosas

545
00:24:56,680 --> 00:24:58,259
entonces

546
00:24:58,259 --> 00:25:00,640
cuando nosotros llamamos a

547
00:25:00,640 --> 00:25:02,539
por ejemplo a este método

548
00:25:02,539 --> 00:25:04,220
checkIndex de la clase string

549
00:25:04,220 --> 00:25:07,019
que habría que ver para qué es

550
00:25:07,019 --> 00:25:08,019
pero bueno, es para

551
00:25:08,019 --> 00:25:10,839
verificar algo del índice, dentro de la longitud

552
00:25:10,839 --> 00:25:13,039
es lo de menos, cuando llamamos a este método

553
00:25:13,039 --> 00:25:14,980
este método a su vez

554
00:25:14,980 --> 00:25:16,920
se basa llamando

555
00:25:16,920 --> 00:25:18,259
a este otro de esta clase

556
00:25:18,259 --> 00:25:20,440
llama a este método

557
00:25:20,440 --> 00:25:22,240
y fijaos que hace este método

558
00:25:22,240 --> 00:25:25,019
pues este método cuando ocurre una cosa

559
00:25:25,019 --> 00:25:27,019
que el index

560
00:25:27,019 --> 00:25:29,000
es menor que 0

561
00:25:29,000 --> 00:25:31,180
o mayor que la longitud

562
00:25:31,180 --> 00:25:32,099
del string

563
00:25:32,099 --> 00:25:34,900
silencio, ¿qué hace?

564
00:25:35,220 --> 00:25:36,980
hace esto, que esto hasta ahora no nos lo habíamos

565
00:25:36,980 --> 00:25:38,819
encontrado, no nos lo habíamos

566
00:25:38,819 --> 00:25:40,819
encontrado, vale, pues

567
00:25:40,819 --> 00:25:42,880
esta sentencia throw ¿qué hace?

568
00:25:43,539 --> 00:25:44,660
esta sentencia throw

569
00:25:44,660 --> 00:25:46,720
es la que hace que

570
00:25:46,720 --> 00:25:48,480
aparezca una instancia

571
00:25:48,480 --> 00:25:50,859
de un objeto de la excepción que yo he puesto

572
00:25:50,859 --> 00:25:52,319
aquí, que aparezca

573
00:25:52,319 --> 00:25:55,079
y en ese momento es cuando aparece la excepción.

574
00:25:55,900 --> 00:25:57,059
Entonces la máquina virtual

575
00:25:57,059 --> 00:25:58,920
cuando va ejecutando,

576
00:25:58,980 --> 00:26:00,920
va ejecutando, va ejecutando y se encuentra

577
00:26:00,920 --> 00:26:03,039
un throw. Se encuentra un throw

578
00:26:03,039 --> 00:26:04,839
pues cuando se encuentra el throw

579
00:26:04,839 --> 00:26:06,720
la máquina virtual dice, ojo,

580
00:26:06,940 --> 00:26:08,039
apareció una excepción.

581
00:26:08,599 --> 00:26:10,839
Apareció una excepción. Y en ese

582
00:26:10,839 --> 00:26:12,259
momento es cuando

583
00:26:12,259 --> 00:26:14,319
para la máquina virtual.

584
00:26:14,799 --> 00:26:15,980
Para la ejecución.

585
00:26:16,799 --> 00:26:18,940
Cuando la máquina virtual se encuentra un throw.

586
00:26:19,880 --> 00:26:20,720
Entonces la sentencia

587
00:26:20,720 --> 00:26:22,359
throw es la sentencia que hace

588
00:26:22,359 --> 00:26:24,599
que aparezca un objeto de la

589
00:26:24,599 --> 00:26:27,019
excepción correspondiente, que aparezca

590
00:26:27,019 --> 00:26:28,740
y la máquina

591
00:26:28,740 --> 00:26:30,240
virtual cuando llega a ella y dice

592
00:26:30,240 --> 00:26:32,579
toca lanzar excepción

593
00:26:32,579 --> 00:26:33,759
toca lanzarla

594
00:26:33,759 --> 00:26:36,519
pues lanzar excepción ¿qué significa?

595
00:26:37,140 --> 00:26:38,619
que la máquina virtual para el

596
00:26:38,619 --> 00:26:40,660
programa a menos que tengamos un try catch

597
00:26:40,660 --> 00:26:41,740
en esa sentencia

598
00:26:41,740 --> 00:26:44,599
¿vale? bueno pues las

599
00:26:44,599 --> 00:26:46,579
excepciones no es que aparezcan de la

600
00:26:46,579 --> 00:26:48,160
nada, las excepciones

601
00:26:48,160 --> 00:26:50,779
aparecen también porque alguien ha programado

602
00:26:50,779 --> 00:26:51,539
que aparezcan.

603
00:26:52,220 --> 00:26:54,500
Aparecen porque alguien ha programado que aparezcan

604
00:26:54,500 --> 00:26:55,900
cuando ha visto que algo no le gusta.

605
00:26:57,740 --> 00:26:58,640
Entonces, Java,

606
00:26:59,059 --> 00:27:00,279
cuando hace lo de dividir,

607
00:27:00,640 --> 00:27:02,940
cuando Java ve la esta de dividir,

608
00:27:03,160 --> 00:27:04,859
a su vez salta un código

609
00:27:04,859 --> 00:27:05,619
para hacer cosas.

610
00:27:06,619 --> 00:27:08,400
Ese código tendrá un

611
00:27:08,400 --> 00:27:10,279
si divisor igual a cero,

612
00:27:10,720 --> 00:27:10,960
throw.

613
00:27:12,059 --> 00:27:13,720
Luego las excepciones aparecen

614
00:27:13,720 --> 00:27:16,779
porque están programadas, porque alguien las ha programado

615
00:27:16,779 --> 00:27:18,359
cuando pasa algo que no gusta

616
00:27:18,359 --> 00:27:19,539
aparece

617
00:27:19,539 --> 00:27:21,720
cuando la máquina virtual

618
00:27:21,720 --> 00:27:24,180
a respeto de la ejecución llega al throne

619
00:27:24,180 --> 00:27:26,440
en ese momento es en el momento en el que

620
00:27:26,440 --> 00:27:28,460
la excepción nace

621
00:27:28,460 --> 00:27:29,079
y aparece

622
00:27:29,079 --> 00:27:32,640
y a partir de ahí que pasa, lo que ya hemos visto

623
00:27:32,640 --> 00:27:34,539
que no está capturada

624
00:27:34,539 --> 00:27:36,440
con el try-catch, se detiene

625
00:27:36,440 --> 00:27:38,980
que está capturada con el try-catch

626
00:27:38,980 --> 00:27:40,559
se hace lo que hay en el catch

627
00:27:40,559 --> 00:27:42,079
y se sigue, ¿vale?

628
00:27:42,079 --> 00:27:43,460
luego ese es el momento en el que aparece

629
00:27:43,460 --> 00:27:45,500
y ahí hay dos caminos

630
00:27:45,500 --> 00:27:49,240
Bueno, pues nosotros también podemos jugar con este throw

631
00:27:49,240 --> 00:27:51,380
Y hacer aparecer excepciones

632
00:27:51,380 --> 00:27:53,000
Y pasan cosas que no nos gustan

633
00:27:53,000 --> 00:27:55,640
¿Vale?

634
00:27:56,920 --> 00:27:57,819
Por ejemplo

635
00:27:57,819 --> 00:27:59,599
Vamos a

636
00:27:59,599 --> 00:28:02,579
A ver

637
00:28:02,579 --> 00:28:05,519
Muy rápidamente

638
00:28:05,519 --> 00:28:07,880
Para irnos con la idea un poco entendida

639
00:28:07,880 --> 00:28:08,700
Esto lo acabo de decir

640
00:28:08,700 --> 00:28:10,539
Porque lo del throw se habrá hecho un poco raro

641
00:28:10,539 --> 00:28:12,500
Muy así un poquito por encima

642
00:28:12,500 --> 00:28:14,200
Para acabar de entenderlo y ya nos vamos

643
00:28:14,200 --> 00:28:16,240
A ver

644
00:28:16,240 --> 00:28:18,859
vamos a hacer un proyecto, ejemplo excepciones

645
00:28:18,859 --> 00:28:36,500
vale, pues

646
00:28:36,500 --> 00:28:46,400
bueno, voy a hacer un paquete

647
00:28:46,400 --> 00:28:48,319
que siempre queda más bonito en un paquete, pero da igual

648
00:28:48,319 --> 00:28:50,660
vale, pues vamos a

649
00:28:50,660 --> 00:28:52,500
lanzar nosotros

650
00:28:52,500 --> 00:28:54,839
una excepción como programadores

651
00:28:54,839 --> 00:28:56,279
para avisar de que algo ha pasado

652
00:28:56,279 --> 00:28:58,220
y así entendemos un poquito

653
00:28:58,220 --> 00:29:00,140
cómo aparecen las excepciones

654
00:29:00,140 --> 00:29:01,640
vamos a lanzar nosotros una

655
00:29:01,640 --> 00:29:04,519
para ver cómo aparecen, hasta ahora nosotros nos hemos

656
00:29:04,519 --> 00:29:06,559
encontrado que las lanzaba

657
00:29:06,559 --> 00:29:08,019
código al que hemos llamado

658
00:29:08,019 --> 00:29:10,559
cuando hemos llamado a código

659
00:29:10,559 --> 00:29:12,200
nos hemos encontrado que la lanzaban

660
00:29:12,200 --> 00:29:14,519
y ya he explicado yo

661
00:29:14,519 --> 00:29:15,579
que es lo que ha ocurrido en realidad

662
00:29:15,579 --> 00:29:18,619
que cuando hemos llamado a ese código, la máquina virtual ha entrado

663
00:29:18,619 --> 00:29:19,740
se ha encontrado un throw

664
00:29:19,740 --> 00:29:22,519
y entonces ha aparecido la excepción

665
00:29:22,519 --> 00:29:24,039
pues vamos a hacer eso mismo nosotros

666
00:29:24,039 --> 00:29:25,819
que nos hemos encontrado que alguien ya ha hecho

667
00:29:25,819 --> 00:29:27,519
vamos a programarlo nosotros para entender un poco

668
00:29:27,519 --> 00:29:28,680
como aparece

669
00:29:28,680 --> 00:29:30,900
pues venga, vamos a hacer una clase

670
00:29:30,900 --> 00:29:35,519
pues venga, yo que sé, main

671
00:29:35,519 --> 00:29:42,720
y vamos a hacer un método

672
00:29:42,720 --> 00:29:44,940
para que alguien nos llame

673
00:29:44,940 --> 00:29:46,319
desde el main

674
00:29:46,319 --> 00:29:49,140
pues venga, vamos a hacer aquí un

675
00:29:49,140 --> 00:29:52,259
static void

676
00:29:52,259 --> 00:29:54,039
método

677
00:29:54,039 --> 00:29:56,380
al que le pasamos un numerito entero

678
00:29:56,380 --> 00:29:57,259
y ya está

679
00:29:57,259 --> 00:29:59,359
entonces este método

680
00:29:59,359 --> 00:30:02,380
adiós

681
00:30:02,380 --> 00:30:04,859
imagínate que tiene que hacer algo

682
00:30:04,859 --> 00:30:05,759
sin acritud

683
00:30:05,759 --> 00:30:07,440
que luego os enfadáis

684
00:30:07,440 --> 00:30:12,099
que este método tiene que hacer algo con n

685
00:30:12,099 --> 00:30:13,799
Cualquier cosa

686
00:30:13,799 --> 00:30:15,680
Pero si n es negativo

687
00:30:15,680 --> 00:30:18,579
A este método no le mola

688
00:30:18,579 --> 00:30:19,640
Que n sea negativo

689
00:30:19,640 --> 00:30:22,799
Porque lo que hace necesita que n sea positivo

690
00:30:22,799 --> 00:30:23,400
No le mola

691
00:30:23,400 --> 00:30:24,799
¿Vale?

692
00:30:26,319 --> 00:30:28,380
Entonces, aquí el que desarrolla

693
00:30:28,380 --> 00:30:29,680
Tiene muchas posibilidades

694
00:30:29,680 --> 00:30:32,180
Pues decir, a ver

695
00:30:32,180 --> 00:30:34,660
Voy a verificar si n es negativo

696
00:30:34,660 --> 00:30:36,339
Y si lo es

697
00:30:36,339 --> 00:30:37,700
Muestra un mensajito

698
00:30:37,700 --> 00:30:40,059
Bueno, es una forma, pero claro

699
00:30:40,059 --> 00:30:42,619
Tiene que estar alguien sentado en la consola

700
00:30:42,619 --> 00:30:44,099
Ahí para verlo

701
00:30:44,099 --> 00:30:48,579
¿Vale? Por ejemplo

702
00:30:48,579 --> 00:30:50,359
Si n es negativo, pues uno

703
00:30:50,359 --> 00:30:52,720
Podríamos avisar de lo que no nos gusta

704
00:30:52,720 --> 00:30:53,799
De esta manera

705
00:30:53,799 --> 00:30:58,400
A la es negativo

706
00:30:58,400 --> 00:31:06,410
Y luego aquí haríamos un retun

707
00:31:06,410 --> 00:31:07,349
Para terminar

708
00:31:07,349 --> 00:31:10,910
¿Vale?

709
00:31:12,430 --> 00:31:14,890
Y si es positivo, pues ya lo que fuera

710
00:31:14,890 --> 00:31:16,369
Que queremos hacer con ese número n

711
00:31:16,369 --> 00:31:19,509
¿Qué podemos querer hacer con un número n

712
00:31:19,509 --> 00:31:21,069
Que solo nos gusta hacer con los positivos?

713
00:31:21,069 --> 00:31:23,130
pues la raíz normalmente puede ser o algo así

714
00:31:23,130 --> 00:31:24,789
pues

715
00:31:24,789 --> 00:31:27,089
yo que sé, pues esto

716
00:31:27,089 --> 00:31:33,910
por ejemplo, esto mismo

717
00:31:33,910 --> 00:31:37,450
imaginaos que tenemos aquí un método

718
00:31:37,450 --> 00:31:41,630
que solo quiere operar, solo quiere

719
00:31:41,630 --> 00:31:43,890
trabajar si n es positivo

720
00:31:43,890 --> 00:31:45,829
o cero, si es negativo no quiere

721
00:31:45,829 --> 00:31:47,529
entonces claro

722
00:31:47,529 --> 00:31:49,769
aquí no hay forma de restringirlo

723
00:31:49,769 --> 00:31:50,650
mediante el parámetro

724
00:31:50,650 --> 00:31:53,890
porque el tipo de dato número positivo no existe

725
00:31:53,890 --> 00:31:56,109
existe el tipo de dato entero

726
00:31:56,109 --> 00:31:58,670
pero el tipo de dato de un número natural no existe

727
00:31:58,670 --> 00:32:00,970
a ver, podría ocurrir, podría haber un lenguaje

728
00:32:00,970 --> 00:32:03,029
de programación que tuviera un tipo de dato

729
00:32:03,029 --> 00:32:04,470
que fuera int positivo

730
00:32:04,470 --> 00:32:06,849
pero no es el caso, no existe

731
00:32:06,849 --> 00:32:08,990
entonces restringirlo por tipo de

732
00:32:08,990 --> 00:32:09,750
dato no podemos

733
00:32:09,750 --> 00:32:13,009
bueno, pues entonces tenemos que

734
00:32:13,009 --> 00:32:14,869
aquí programar

735
00:32:14,869 --> 00:32:16,529
de tal manera que avisemos, que

736
00:32:16,529 --> 00:32:19,069
concibamos, que consideremos que hacer si n es negativo

737
00:32:19,069 --> 00:32:21,069
bueno, pues esta sería una opción

738
00:32:21,069 --> 00:32:22,309
es decir, si n es negativo

739
00:32:22,309 --> 00:32:24,650
te aviso y no hago nada

740
00:32:24,650 --> 00:32:26,349
bueno, vale

741
00:32:26,349 --> 00:32:27,869
a ver, es una opción fea

742
00:32:27,869 --> 00:32:30,410
porque entonces necesitamos que haya alguien aquí

743
00:32:30,410 --> 00:32:38,730
necesitamos que haya

744
00:32:38,730 --> 00:32:39,730
alguien aquí sentado

745
00:32:39,730 --> 00:32:44,900
para enterarse de esto

746
00:32:44,900 --> 00:32:49,880
entonces si no hay alguien aquí sentado para enterarse de esto

747
00:32:49,880 --> 00:32:51,180
pues no

748
00:32:51,180 --> 00:32:53,700
y claro, no siempre hay un humano

749
00:32:53,700 --> 00:32:55,299
ahí sentado, ¿por qué?

750
00:32:55,900 --> 00:32:57,619
porque las salidas de los métodos

751
00:32:57,619 --> 00:32:59,559
lo que hace un método, muchas veces

752
00:32:59,559 --> 00:33:01,619
va a otro método o va a otro

753
00:33:01,619 --> 00:33:03,440
programa, va a otro programa

754
00:33:03,440 --> 00:33:05,099
y ese otro método

755
00:33:05,099 --> 00:33:07,019
al que va el resultado de esto

756
00:33:07,019 --> 00:33:08,440
no es un señor ahí sentado mirando

757
00:33:08,440 --> 00:33:11,339
entonces, la solución

758
00:33:11,339 --> 00:33:13,200
de avisar por consola en situaciones

759
00:33:13,200 --> 00:33:15,279
será útil y en otras no tendrá ningún sentido

760
00:33:15,279 --> 00:33:16,579
no tendrá ningún sentido

761
00:33:16,579 --> 00:33:19,380
bueno, pues cuál es la siguiente

762
00:33:19,380 --> 00:33:20,380
cosa que se puede hacer

763
00:33:20,380 --> 00:33:23,200
la hemos mencionado antes con el replay

764
00:33:23,200 --> 00:33:25,240
aviso con el valor

765
00:33:25,240 --> 00:33:25,839
de retorno

766
00:33:25,839 --> 00:33:28,319
aquí en este caso

767
00:33:28,319 --> 00:33:31,319
vale, este método se supone

768
00:33:31,319 --> 00:33:33,240
que si hace la raíz, hombre, debería devolverla

769
00:33:33,240 --> 00:33:35,160
porque si no es un poco tonto esto

770
00:33:35,160 --> 00:33:37,640
vale, entonces

771
00:33:37,640 --> 00:33:38,539
return

772
00:33:38,539 --> 00:33:40,900
y aquí

773
00:33:40,900 --> 00:33:43,019
return

774
00:33:43,019 --> 00:33:53,089
vale, pues esta sería

775
00:33:53,089 --> 00:33:54,670
otra opción, decir

776
00:33:54,670 --> 00:33:56,690
me las ingenio

777
00:33:56,690 --> 00:33:58,970
si es que puedo, para utilizar

778
00:33:58,970 --> 00:34:00,450
el valor de retorno como aviso

779
00:34:00,450 --> 00:34:03,029
y digo, y lo comento, porque si no

780
00:34:03,029 --> 00:34:04,910
lo comento, pues estoy siendo

781
00:34:04,910 --> 00:34:07,089
un programador horrible, lo comento

782
00:34:07,089 --> 00:34:09,349
y digo, a ver, que devuelve

783
00:34:09,349 --> 00:34:13,369
menos 1 si n es negativo

784
00:34:13,369 --> 00:34:17,420
¿qué devuelve?

785
00:34:17,599 --> 00:34:19,440
pues devuelve la raíz

786
00:34:19,440 --> 00:34:23,480
si n es mayor o igual que 0

787
00:34:23,480 --> 00:34:29,420
vale, pues aquí estoy avisando con el valor de retorno

788
00:34:29,420 --> 00:34:30,599
entonces el que me usa

789
00:34:30,599 --> 00:34:33,519
ya sabe que si ha devuelto menos 1

790
00:34:33,519 --> 00:34:34,960
el número es negativo

791
00:34:34,960 --> 00:34:38,719
esto de todas maneras estaría un poco mal hecho

792
00:34:38,719 --> 00:34:41,239
porque existen números para los cuales la raíz es menos 1

793
00:34:41,239 --> 00:34:43,599
entonces había confusión

794
00:34:43,599 --> 00:34:47,500
Si devuelves menos 1, oye, ¿estás haciendo la raíz de 1, que también es menos 1?

795
00:34:48,179 --> 00:34:49,639
¿O es que el número es negativo?

796
00:34:50,099 --> 00:34:56,199
Pero bueno, os lo digo como ejemplo de que cuando uno tiene que avisar de cosas relacionadas con lo que está pasando,

797
00:34:56,940 --> 00:34:59,420
pues tiene primero, opción, avisar por consola.

798
00:35:00,539 --> 00:35:03,380
Buena, si es que ese método lo va a usar alguien que está ahí sentado.

799
00:35:04,460 --> 00:35:06,619
Mala, si eso no va a ser así.

800
00:35:08,000 --> 00:35:11,480
Opción B, avisar con el valor de retorno si podemos.

801
00:35:11,480 --> 00:35:13,780
si eso no volvía a nada

802
00:35:13,780 --> 00:35:15,360
porque hay un voy, lo tengo clarísimo

803
00:35:15,360 --> 00:35:17,760
pues como el replace, te devuelve null

804
00:35:17,760 --> 00:35:19,860
si no está, por ejemplo

805
00:35:19,860 --> 00:35:21,860
pues así, menos uno si es

806
00:35:21,860 --> 00:35:23,679
negativo, la propia raíz

807
00:35:23,679 --> 00:35:25,559
si no lo fuera, puede avisar por valor de retorno

808
00:35:25,559 --> 00:35:27,599
y tres

809
00:35:27,599 --> 00:35:29,500
otra forma de avisar

810
00:35:29,500 --> 00:35:32,079
si ocurre lo que yo no quiero que ocurra

811
00:35:32,079 --> 00:35:33,420
que es que sea negativo

812
00:35:33,420 --> 00:35:35,639
lanzar una excepción

813
00:35:35,639 --> 00:35:37,860
esa sería la tercera forma de avisar

814
00:35:37,860 --> 00:35:38,780
y la mejor

815
00:35:38,780 --> 00:35:41,619
porque no tengo que usar el valor de retorno.

816
00:35:41,760 --> 00:35:42,440
No tengo que usarlo.

817
00:35:43,320 --> 00:35:44,539
Y en este caso sería el ideal

818
00:35:44,539 --> 00:35:46,820
porque el valor de retorno tiene una función

819
00:35:46,820 --> 00:35:49,300
que es el propio resultado del método.

820
00:35:49,699 --> 00:35:50,519
El propio resultado.

821
00:35:51,800 --> 00:35:53,579
Entonces, dejemos el valor de retorno

822
00:35:53,579 --> 00:35:55,059
para guardar el resultado del método

823
00:35:55,059 --> 00:35:57,579
y aviso de que ha pasado algo raro

824
00:35:57,579 --> 00:35:58,940
lanzando una excepción.

825
00:35:59,599 --> 00:36:02,059
Esa sería la tercera manera y la buena

826
00:36:02,059 --> 00:36:04,380
de avisar de que algo raro ha pasado

827
00:36:04,380 --> 00:36:05,400
lanzando una excepción.

828
00:36:06,039 --> 00:36:07,539
¿Y cómo se lanza una excepción?

829
00:36:07,539 --> 00:36:09,780
bueno, tendríamos que lanzarla en este punto

830
00:36:09,780 --> 00:36:11,739
aquí, que es donde

831
00:36:11,739 --> 00:36:12,559
ha pasado lo raro

832
00:36:12,559 --> 00:36:15,000
donde ha pasado lo raro es aquí

833
00:36:15,000 --> 00:36:17,559
cuando él es negativo, ¿cómo se lanza

834
00:36:17,559 --> 00:36:19,380
una excepción? pues

835
00:36:19,380 --> 00:36:21,119
escribiendo la sentencia

836
00:36:21,119 --> 00:36:21,980
throw

837
00:36:21,980 --> 00:36:25,280
la sentencia throw, lanzo la excepción

838
00:36:25,280 --> 00:36:26,440
¿y ahora qué tengo que lanzar ahí?

839
00:36:27,099 --> 00:36:29,019
tengo que lanzar un objeto

840
00:36:29,019 --> 00:36:31,119
de la clase exception

841
00:36:31,119 --> 00:36:33,579
asociada a esta cosa rara

842
00:36:33,579 --> 00:36:37,019
un objeto de la clase exception

843
00:36:37,019 --> 00:36:38,219
asociada a esta cosa rara

844
00:36:38,219 --> 00:36:40,940
hemos dicho ya que objetos

845
00:36:40,940 --> 00:36:43,280
excepción, perdón, que clases excepción

846
00:36:43,280 --> 00:36:45,019
hay ya un montón creadas

847
00:36:45,019 --> 00:36:47,139
cada una asociada a una cosa

848
00:36:47,139 --> 00:36:49,159
rara concreta, objeto nulo

849
00:36:49,159 --> 00:36:51,460
lo que pasa es que esta en particular

850
00:36:51,460 --> 00:36:52,639
que el número sea negativo

851
00:36:52,639 --> 00:36:55,179
eso por defecto no es nada

852
00:36:55,179 --> 00:36:56,840
malo, no es malo

853
00:36:56,840 --> 00:36:58,420
entonces

854
00:36:58,420 --> 00:37:00,019
así que tengo que hacer

855
00:37:00,019 --> 00:37:02,519
crearme yo mi propia excepción

856
00:37:02,519 --> 00:37:05,280
que eso ya lo dejaremos para el otro día

857
00:37:05,280 --> 00:37:07,119
pero que queremos reutilizar

858
00:37:07,119 --> 00:37:08,619
a ver si me deja, que no lo tengo claro

859
00:37:08,619 --> 00:37:10,840
como no tenemos tiempo a crear nuestra propia excepción

860
00:37:10,840 --> 00:37:12,559
que es lo que tendríamos que hacer, vamos a decir

861
00:37:12,559 --> 00:37:14,860
bueno, si pasa esta cosa rara voy a lanzar una excepción

862
00:37:14,860 --> 00:37:16,820
pero de las que ya están creadas, null pointer exception

863
00:37:16,820 --> 00:37:18,940
aunque no pega ahí, porque el problema aquí

864
00:37:18,940 --> 00:37:21,000
no es null pointer exception, el problema aquí

865
00:37:21,000 --> 00:37:22,219
es número negativo

866
00:37:22,219 --> 00:37:24,960
pero vamos a intentar, aunque yo creo

867
00:37:24,960 --> 00:37:26,420
que el constructor

868
00:37:26,420 --> 00:37:29,340
va a ser privado, sí que no me va a dejar

869
00:37:29,340 --> 00:37:30,000
lanzar esta

870
00:37:30,000 --> 00:37:32,659
pero bueno, voy a probar por si

871
00:37:32,659 --> 00:37:35,019
ah mira, sí que me deja

872
00:37:35,019 --> 00:37:37,500
no es privado el constructor de null pointer exception

873
00:37:37,500 --> 00:37:39,420
pues fijaos lo que estoy haciendo aquí

874
00:37:39,420 --> 00:37:41,599
lo que estoy haciendo aquí es

875
00:37:41,599 --> 00:37:43,400
si n es negativo

876
00:37:43,400 --> 00:37:45,239
estoy haciendo yo por código

877
00:37:45,239 --> 00:37:47,079
que se lance la excepción

878
00:37:47,079 --> 00:37:50,179
de tipo null pointer exception

879
00:37:50,179 --> 00:37:53,440
no es un aviso muy claro

880
00:37:53,440 --> 00:37:55,860
porque de lo que yo estoy avisando

881
00:37:55,860 --> 00:37:57,980
yo estoy avisando

882
00:37:57,980 --> 00:37:59,179
de que ha habido un problema

883
00:37:59,179 --> 00:38:01,039
de objeto nulo y no es verdad

884
00:38:01,039 --> 00:38:02,599
el problema no ha sido de objeto nulo

885
00:38:02,599 --> 00:38:04,980
pero bueno he cogido esa porque no hemos hecho

886
00:38:04,980 --> 00:38:06,280
una que se adapte a lo nuestro

887
00:38:06,280 --> 00:38:08,280
bueno, pues mi método ya está estupendo

888
00:38:08,280 --> 00:38:10,960
mi método ya recibe el valor

889
00:38:10,960 --> 00:38:12,579
que le gusta

890
00:38:12,579 --> 00:38:14,219
devuelve el valor de retorno

891
00:38:14,219 --> 00:38:16,960
que no le gusta, avisa lanzando

892
00:38:16,960 --> 00:38:18,440
una excepción, ¿vale?

893
00:38:18,739 --> 00:38:19,840
y magnífico

894
00:38:19,840 --> 00:38:22,039
esto está mucho mejor programado

895
00:38:22,039 --> 00:38:24,199
ahora nosotros ejecutamos esto

896
00:38:24,199 --> 00:38:26,639
ejecutamos nuestro main

897
00:38:26,639 --> 00:38:27,679
que llama a este método

898
00:38:27,679 --> 00:38:32,940
y efectivamente nos ha salido

899
00:38:32,940 --> 00:38:34,579
null pointer excepción

900
00:38:34,579 --> 00:38:36,820
el método nos ha avisado

901
00:38:36,820 --> 00:38:38,719
de que ha habido una excepción o un puente de excepción

902
00:38:38,719 --> 00:38:40,420
a ver, muy mal avisado

903
00:38:40,420 --> 00:38:42,599
claro, ha avisado

904
00:38:42,599 --> 00:38:43,920
de lo que yo le he dicho que avise

905
00:38:43,920 --> 00:38:46,559
ha avisado de lo que yo le he dicho que avise

906
00:38:46,559 --> 00:38:47,280
vale

907
00:38:47,280 --> 00:38:50,340
pero entendéis, lo que quiero que entendáis es

908
00:38:50,340 --> 00:38:52,500
que las excepciones cuando os han

909
00:38:52,500 --> 00:38:54,380
aparecido, cuando nos han aparecido

910
00:38:54,380 --> 00:38:56,239
ejecutando cosas, no es que ya se hayan

911
00:38:56,239 --> 00:38:58,260
generado de la nada, que la red roja

912
00:38:58,260 --> 00:38:59,860
la se haya escrito ahí uno que estaba ahí dentro

913
00:38:59,860 --> 00:39:02,480
no, cuando aparece una excepción

914
00:39:02,480 --> 00:39:05,059
es porque la máquina virtual

915
00:39:05,059 --> 00:39:07,019
se ha puesto a ejecutar lo que le hemos pedido

916
00:39:07,019 --> 00:39:08,960
y como consecuencia de entrar

917
00:39:08,960 --> 00:39:10,820
en los métodos, los métodos ir ejecutando

918
00:39:10,820 --> 00:39:12,340
se ha encontrado un throw

919
00:39:12,340 --> 00:39:14,500
entonces se ha encontrado un throw

920
00:39:14,500 --> 00:39:16,460
pues

921
00:39:16,460 --> 00:39:18,460
el throw es una sentencia más

922
00:39:18,460 --> 00:39:21,320
y el throw que hace, hace aparecer

923
00:39:21,320 --> 00:39:23,059
un objeto de este tipo

924
00:39:23,059 --> 00:39:26,750
te pone las letritas rojas

925
00:39:26,750 --> 00:39:28,469
correspondientes, ¿qué te pone letras rojas?

926
00:39:28,510 --> 00:39:30,030
lo que está configurado en esta clase

927
00:39:30,030 --> 00:39:32,630
que eso no lo hemos hecho nosotros

928
00:39:32,630 --> 00:39:35,170
porque la clase ya está hecha, te hace aparecer esos mensajitos

929
00:39:35,170 --> 00:39:37,050
correspondientes y para

930
00:39:37,050 --> 00:39:38,369
la ejecución, y la para

931
00:39:38,369 --> 00:39:40,929
eso es lo que hace la máquina virtual cuando se encuentra

932
00:39:40,929 --> 00:39:42,610
al centro, entonces es una sentencia más

933
00:39:42,610 --> 00:39:44,869
cuando nos han aparecido por tanto

934
00:39:44,869 --> 00:39:45,789
estas cosas aquí

935
00:39:45,789 --> 00:39:48,630
estas cosas

936
00:39:48,630 --> 00:39:50,829
era simplemente porque la máquina

937
00:39:50,829 --> 00:39:52,769
virtual, pipipipi, ha visto un throw

938
00:39:52,769 --> 00:39:54,570
y ya está, ha visto un throw

939
00:39:54,570 --> 00:39:56,710
nos ha puesto el mensaje y ha parado

940
00:39:56,710 --> 00:39:57,730
¿vale?

941
00:39:59,650 --> 00:40:00,849
entonces, nosotros ya

942
00:40:00,849 --> 00:40:03,090
como programadores que somos los que decidimos

943
00:40:03,090 --> 00:40:05,050
lo que hace el programa, como pasan

944
00:40:05,050 --> 00:40:06,889
las cosas, ¿cuándo

945
00:40:06,889 --> 00:40:08,889
pondremos un throw? Pues pondremos

946
00:40:08,889 --> 00:40:11,070
un throw cuando queramos avisar

947
00:40:11,070 --> 00:40:12,849
de que ha pasado una cosa muy rara que no

948
00:40:12,849 --> 00:40:14,789
debería pasar y queremos

949
00:40:14,789 --> 00:40:16,769
avisar lanzando

950
00:40:16,769 --> 00:40:18,809
un objeto excepción, porque para eso los

951
00:40:18,809 --> 00:40:20,869
usamos, para avisar de que han pasado cosas

952
00:40:20,869 --> 00:40:22,929
raras, no usamos los objetos

953
00:40:22,929 --> 00:40:25,269
de excepción para avisar de algo que no tiene importancia

954
00:40:25,269 --> 00:40:26,889
no, los usamos

955
00:40:26,889 --> 00:40:28,929
para avisar de que han pasado cosas raras

956
00:40:28,929 --> 00:40:31,630
porque sabemos que la implicación que tiene es que el programa

957
00:40:31,630 --> 00:40:33,570
para, entonces con el programa parar

958
00:40:33,570 --> 00:40:35,750
lo usamos si es que ha ocurrido

959
00:40:35,750 --> 00:40:37,269
algo raro, el throw

960
00:40:37,269 --> 00:40:40,860
y repito, aún así

961
00:40:40,860 --> 00:40:43,119
yo puedo salvarme de que el programa

962
00:40:43,119 --> 00:40:44,139
pare capturando

963
00:40:44,139 --> 00:40:46,579
imaginaos que aquí tengo otra sentencia

964
00:40:46,579 --> 00:40:47,840
esta

965
00:40:47,840 --> 00:40:51,239
si yo ejecuto mi programa

966
00:40:51,239 --> 00:40:53,039
ahora, ya sabemos

967
00:40:53,039 --> 00:40:54,219
que cuando yo ejecuto esto

968
00:40:54,219 --> 00:40:56,039
como la excepción ha saltado

969
00:40:56,039 --> 00:40:58,820
aquí, ni adiós ni nada

970
00:40:58,820 --> 00:41:00,440
porque aquí se paró

971
00:41:00,440 --> 00:41:02,039
aquí el programa se ha parado

972
00:41:02,039 --> 00:41:04,980
porque sabemos que esa es la consecuencia

973
00:41:04,980 --> 00:41:06,559
del throw que hay aquí dentro

974
00:41:06,559 --> 00:41:08,599
pero que yo

975
00:41:08,599 --> 00:41:10,920
no quiero que el programa pare porque es fundamental

976
00:41:10,920 --> 00:41:12,880
lo que viene después, que muestre la dios, lo que sea

977
00:41:12,880 --> 00:41:15,079
no quiero que pare, pues no pasa nada

978
00:41:15,079 --> 00:41:17,079
voy a capturar la excepción

979
00:41:17,079 --> 00:41:21,599
la capturo

980
00:41:21,599 --> 00:41:26,050
como hemos dicho antes

981
00:41:26,050 --> 00:41:35,360
la capturo

982
00:41:35,360 --> 00:41:37,380
y ahora que va a ocurrir

983
00:41:37,380 --> 00:41:39,840
el throw se va a ejecutar igualmente

984
00:41:39,840 --> 00:41:41,880
cuando haya método raíz menos 12

985
00:41:41,880 --> 00:41:43,980
el throw se va a ejecutar, pero la máquina

986
00:41:43,980 --> 00:41:45,860
virtual ya ni saca

987
00:41:45,860 --> 00:41:47,940
letras rojas, ni para el programa

988
00:41:47,940 --> 00:41:50,000
ni hace nada, lo que hace

989
00:41:50,000 --> 00:41:51,059
es lo que hay en el catch

990
00:41:51,059 --> 00:41:53,920
es lo que hace, luego si no está

991
00:41:53,920 --> 00:41:56,059
el try catch, saca

992
00:41:56,059 --> 00:41:57,920
letras rojas y para

993
00:41:57,920 --> 00:41:58,400
el programa

994
00:41:58,400 --> 00:42:01,519
si hay un try catch

995
00:42:01,519 --> 00:42:03,719
el throw se ejecuta igualmente

996
00:42:03,719 --> 00:42:05,860
porque el throw está, porque el número es negativo

997
00:42:05,860 --> 00:42:07,239
pero la máquina virtual

998
00:42:07,239 --> 00:42:09,880
no hace nada más, ni para el

999
00:42:09,880 --> 00:42:11,579
programa, ni saca de tarroja, ni nada

1000
00:42:11,579 --> 00:42:13,119
hace lo que hay en el catch

1001
00:42:13,119 --> 00:42:15,679
que en el catch hay algo, lo hace, que en el catch no hay nada

1002
00:42:15,679 --> 00:42:17,460
no lo hace, no hace nada

1003
00:42:17,460 --> 00:42:18,980
entonces cuando yo ejecute esto ahora

1004
00:42:18,980 --> 00:42:21,860
llamaremos a método raíz

1005
00:42:21,860 --> 00:42:23,800
método raíz entraremos

1006
00:42:23,800 --> 00:42:25,820
a método raíz, hará esto

1007
00:42:25,820 --> 00:42:27,500
bla bla bla, llegará el throw

1008
00:42:27,500 --> 00:42:29,960
una vez que llega el throw, ya está

1009
00:42:29,960 --> 00:42:31,679
el método este ya sí que termina

1010
00:42:31,679 --> 00:42:33,179
porque es un throw, esto es como si fuera un return

1011
00:42:33,179 --> 00:42:35,760
llega el throw, termina, subimos arriba

1012
00:42:35,760 --> 00:42:36,219
otra vez

1013
00:42:36,219 --> 00:42:38,679
como está capturada

1014
00:42:38,679 --> 00:42:40,099
como está capturada

1015
00:42:40,099 --> 00:42:41,900
ya ni se para

1016
00:42:41,900 --> 00:42:43,260
ni hay letras rojas

1017
00:42:43,260 --> 00:42:44,940
si no estuviera capturada

1018
00:42:44,940 --> 00:42:46,500
ya la segunda parte sería

1019
00:42:46,500 --> 00:42:48,039
parar la ejecución

1020
00:42:48,039 --> 00:42:49,039
y sacar las letras rojas

1021
00:42:49,039 --> 00:42:50,980
como está capturada

1022
00:42:50,980 --> 00:42:51,559
ni lo para

1023
00:42:51,559 --> 00:42:52,760
ni saca letras rojas

1024
00:42:52,760 --> 00:42:53,619
y se va al catch

1025
00:42:53,619 --> 00:42:54,519
se va ahí

1026
00:42:54,519 --> 00:42:55,920
hace eso

1027
00:42:55,920 --> 00:42:57,579
y luego continúa tan feliz

1028
00:42:57,579 --> 00:42:58,579
¿vale?

1029
00:43:00,139 --> 00:43:01,179
continúa tan feliz

1030
00:43:01,179 --> 00:43:02,320
aunque haya salido el throw

1031
00:43:02,320 --> 00:43:03,480
entonces ejecutamos esto

1032
00:43:03,480 --> 00:43:04,739
pues vale

1033
00:43:04,739 --> 00:43:07,059
Ha pasado esto y ya está

1034
00:43:07,059 --> 00:43:09,760
Ha salido la excepción

1035
00:43:09,760 --> 00:43:12,420
Pero a resulta de la excepción

1036
00:43:12,420 --> 00:43:13,199
No ha pasado nada

1037
00:43:13,199 --> 00:43:14,280
Porque en el catch no hay nada

1038
00:43:14,280 --> 00:43:15,659
Y luego ha seguido

1039
00:43:15,659 --> 00:43:17,699
¿Vale?

1040
00:43:19,199 --> 00:43:21,599
Venga, pues ahora sí que paramos aquí