1
00:00:00,430 --> 00:00:07,629
Voy a grabar la segunda parte de la teoría, por lo tanto, si habláis, me autorizáis a grabar vuestra voz.

2
00:00:08,150 --> 00:00:19,089
Vale, entonces, a continuación de lo que hemos dicho antes del bloque final, etc., etc., vamos a ver cuáles son los métodos que la clase Exception nos proporciona.

3
00:00:19,089 --> 00:00:37,670
Entonces, hemos ya visto que existe una cosa que se llama API. Hemos visto que, sustancialmente, todas las clases ya existentes en el JDK, en el Java Development Kit de Java, pues están documentadas en este catálogo de clases, etc.

4
00:00:37,670 --> 00:00:49,030
Es buena costumbre y deberíais aprenderla ya, cada vez que veáis una clase nueva, iros al API y echarle un vistazo.

5
00:00:49,450 --> 00:00:57,009
Entender cuál es la filosofía de la clase, entender qué puede hacer y por qué lo hace, y sobre todo entender qué métodos tiene.

6
00:00:57,009 --> 00:01:19,730
Veréis que después de un cierto tiempo que leéis estas cosas, pues muchas clases, hay como una filosofía detrás del Java y entonces cada vez que un método empieza con is, sabéis que devuelve un booleano y que te está preguntando si una característica es verdadera o falsa.

7
00:01:19,730 --> 00:01:32,049
Si hay has, pues entonces está mirando algunas cosas y está viendo si hay un objeto más de una colección o de una categoría que tenga una determinada condición, etc.

8
00:01:32,329 --> 00:01:41,530
O sea que cuanto más tiempo perdáis en leer estas cosas, más luego en un futuro vais a entender también otras clases con mayor rapidez.

9
00:01:41,670 --> 00:01:44,250
Porque dice, ah, este es un método parecido a otro que he visto.

10
00:01:44,250 --> 00:02:08,689
Cuando aquí, por ejemplo, han aparecido null pointer exception, number format exception, IO exception, no dudo mínimamente que vosotros hayáis ido al API del 22, no al API 17, y os habéis leído un poquito estas tres clases para entender qué son.

11
00:02:08,689 --> 00:02:11,069
os lo voy a explicar

12
00:02:11,069 --> 00:02:13,229
como si no lo hubieseis hecho

13
00:02:13,229 --> 00:02:15,569
¿vale? pero sé que ya lo sabéis

14
00:02:15,569 --> 00:02:17,449
¿sí? es que me gusta perder tiempo

15
00:02:17,449 --> 00:02:18,969
entonces

16
00:02:18,969 --> 00:02:21,389
en Exception hay algunos

17
00:02:21,389 --> 00:02:22,669
métodos básicos que luego

18
00:02:22,669 --> 00:02:25,129
hereditarán todas las demás

19
00:02:25,129 --> 00:02:27,090
teniendo en cuenta que las otras

20
00:02:27,090 --> 00:02:29,189
que existen como NullPointerException

21
00:02:29,189 --> 00:02:31,469
a lo mejor puede tener métodos

22
00:02:31,469 --> 00:02:33,409
o funcionalidades distintas

23
00:02:33,409 --> 00:02:34,590
con respecto a Exception

24
00:02:34,590 --> 00:02:37,449
típicas y propias solo de NullPointerException

25
00:02:37,449 --> 00:02:51,569
Esto lo podemos saber solo mirando el API. Y por otro lado, lo veremos dentro de un ratito, nosotros podemos crear nuestras propias excepciones, ¿vale? Nuestros errores propios de nuestro programa, de nuestra aplicación, ¿vale?

26
00:02:51,569 --> 00:03:13,870
Entonces, cuando yo me creo mi propia excepción y heredo de exception, también puedo añadir yo algunos métodos o algunas funcionalidades que dentro de mi aplicación y dentro del contexto de mi problema y dentro del contexto de esta excepción, pues tiene sentido que haya ese método.

27
00:03:13,870 --> 00:03:36,889
Nadie me lo prohíbe. Es como una herencia normal que hemos visto ya antes. Yo estoy pillando toda otra clase y a este punto puedo usarla igual, puedo extenderla, puedo añadir cosas, puedo sobreescribir algunos de estos métodos y hacer que en vez de que haga lo básico haga otra cosa o que haga lo básico y luego una cosa más.

28
00:03:36,889 --> 00:03:40,810
Todas estas cosas las hemos visto cuando hemos visto herencia. ¿Os acordáis?

29
00:03:41,870 --> 00:03:44,810
Entonces, mensajitos, métodos posibles.

30
00:03:45,229 --> 00:03:51,810
GetMessage, cada excepción, al momento de ser creada, pues se le asocia un mensaje.

31
00:03:52,389 --> 00:03:58,210
Ese mensaje me dice más o menos una descripción genérica del problema.

32
00:03:58,330 --> 00:04:02,949
Cuando yo alguna vez, os habéis equivocado, ha salido rojo y os he dicho, lee el error.

33
00:04:02,949 --> 00:04:16,329
Y vosotros la primera línea os dice, ha salido un R-index autobound, has intentado acceder al número 7 de esta rama. Y había solo 6 posiciones. Esa es el message.

34
00:04:16,329 --> 00:04:19,449
El toString lo que hace es

35
00:04:19,449 --> 00:04:24,949
Una parte es el getMessage mismo

36
00:04:24,949 --> 00:04:26,949
Pero le añade una

37
00:04:26,949 --> 00:04:29,290
Sostancialmente le dice también

38
00:04:29,290 --> 00:04:30,350
Qué clase es

39
00:04:30,350 --> 00:04:32,709
Es una descripción del objeto

40
00:04:32,709 --> 00:04:35,110
Así como el toString quiere ser

41
00:04:35,110 --> 00:04:38,529
El toString es una descripción textual del objeto

42
00:04:38,529 --> 00:04:42,350
Sobre el que se llama este método

43
00:04:42,350 --> 00:04:44,730
ExceptionString es un constructor

44
00:04:44,730 --> 00:04:46,449
para crear una nueva clase

45
00:04:46,449 --> 00:04:48,350
donde este string es lo que

46
00:04:48,350 --> 00:04:50,550
se devolverá cuando se hace el getMessage

47
00:04:50,550 --> 00:04:52,470
o sea que yo puedo crear una nueva excepción

48
00:04:52,470 --> 00:04:54,029
diciendo newException de

49
00:04:54,029 --> 00:04:55,930
has tecleado mal el número

50
00:04:55,930 --> 00:04:58,149
y eso será el

51
00:04:58,149 --> 00:05:00,430
message que saldrá en el error

52
00:05:00,430 --> 00:05:02,990
y luego está el printStackTrace

53
00:05:02,990 --> 00:05:04,129
que es

54
00:05:04,129 --> 00:05:06,689
lo que sale siempre en rojo

55
00:05:06,689 --> 00:05:08,490
que es las

56
00:05:08,490 --> 00:05:10,350
llamadas de las

57
00:05:10,350 --> 00:05:12,629
varios métodos

58
00:05:12,629 --> 00:05:14,290
desde tu método

59
00:05:14,290 --> 00:05:16,350
Que es donde se ha verificado el error

60
00:05:16,350 --> 00:05:17,790
A que este método por debajo

61
00:05:17,790 --> 00:05:19,350
Llamaba otro método, que llamaba otro método

62
00:05:19,350 --> 00:05:22,449
Normalmente las primeras una o dos líneas

63
00:05:22,449 --> 00:05:24,610
Es parte de vuestro código

64
00:05:24,610 --> 00:05:26,290
Y luego desde allí

65
00:05:26,290 --> 00:05:27,689
Ya sale de vuestro código

66
00:05:27,689 --> 00:05:30,350
Y se va a meter en alguna clase

67
00:05:30,350 --> 00:05:32,209
De Java API que estaba por debajo

68
00:05:32,209 --> 00:05:34,589
Que vosotros no sabéis que estáis utilizando

69
00:05:34,589 --> 00:05:36,550
Pero en realidad si estáis utilizando

70
00:05:36,550 --> 00:05:36,769
¿Vale?

71
00:05:37,310 --> 00:05:40,449
Si yo hago un system.autoprintln

72
00:05:40,449 --> 00:05:42,649
Pues por debajo estaré utilizando

73
00:05:42,649 --> 00:05:44,689
clases que no tengo ni idea de cuáles son

74
00:05:44,689 --> 00:05:46,889
porque no lo quiero

75
00:05:46,889 --> 00:05:48,610
saber. Yo no quiero saber cómo se escribe

76
00:05:48,610 --> 00:05:50,550
en pantalla. Yo quiero que todo sea

77
00:05:50,550 --> 00:05:52,610
abstracto, todo sea

78
00:05:52,610 --> 00:05:54,550
ocultado. Es que yo le diga

79
00:05:54,550 --> 00:05:56,689
simplemente, escribe en pantalla y él lo hace.

80
00:05:57,589 --> 00:05:58,790
¿Sí? ¿Dudas?

81
00:06:02,209 --> 00:06:02,709
Algunas

82
00:06:02,709 --> 00:06:04,649
cosas de estas pueden servir para

83
00:06:04,649 --> 00:06:06,589
dialogar con el usuario, como el message.

84
00:06:07,110 --> 00:06:08,670
Otras cosas, el print stack

85
00:06:08,670 --> 00:06:10,750
trace, al usuario no se

86
00:06:10,750 --> 00:06:12,089
lo debería decir nunca.

87
00:06:12,649 --> 00:06:23,970
Tú escribes el Printerstack 3, el usuario colapsa porque no entiende todas esas cosas parrafadas de términos técnicos que no le interesan.

88
00:06:24,449 --> 00:06:29,589
A él le interesa saber, no me des una palabra, dame un número.

89
00:06:35,439 --> 00:06:38,680
Entonces, ¿cómo se lanzan las excepciones?

90
00:06:38,680 --> 00:06:42,360
Porque, claro, nosotros hemos visto que podemos capturar las excepciones.

91
00:06:42,360 --> 00:06:45,579
Pero, claro, ¿cómo se lanza?

92
00:06:46,199 --> 00:06:48,060
Entonces hay dos cosillas

93
00:06:48,060 --> 00:06:50,180
Ahora hablaremos del tema

94
00:06:50,180 --> 00:06:53,019
Pero sostancialmente para lanzar una excepción

95
00:06:53,019 --> 00:06:54,220
Existe el comando throw

96
00:06:54,220 --> 00:06:55,980
Literalmente lanzar

97
00:06:55,980 --> 00:06:56,920
Throw, catch

98
00:06:56,920 --> 00:07:00,759
Son así de simpáticos los programadores

99
00:07:00,759 --> 00:07:03,420
Entonces yo me puedo en un determinado momento

100
00:07:03,420 --> 00:07:04,860
En un programa mío

101
00:07:04,860 --> 00:07:07,540
Decir, y si pasa esta cosa de aquí

102
00:07:07,540 --> 00:07:10,079
Créame un objeto excepción

103
00:07:10,079 --> 00:07:11,240
Y lánzalo

104
00:07:11,240 --> 00:07:27,779
Eso quiere decir que si llegaré a ese punto de la ejecución del código, asumo que mi método ha acabado porque ha habido un error y que voy a avisar posiblemente el llamante de este método.

105
00:07:28,459 --> 00:07:38,500
Quien ha llamado a este método ha ejecutado hasta aquí. Aquí ha habido el error y ahora yo te aviso a ti, llamante, que ha pasado algo, que ha habido un error.

106
00:07:38,500 --> 00:07:40,139
y hay dos opciones

107
00:07:40,139 --> 00:07:42,079
o el llamante

108
00:07:42,079 --> 00:07:44,920
había hecho la llamada en un try catch

109
00:07:44,920 --> 00:07:47,920
y entonces si yo lanzo la excepción

110
00:07:47,920 --> 00:07:50,279
él la recoge y hace lo que tiene que hacer

111
00:07:50,279 --> 00:07:53,319
o el llamante

112
00:07:53,319 --> 00:07:55,379
no estaba en un try catch

113
00:07:55,379 --> 00:07:58,560
y por lo tanto él también no sabe cómo seguir

114
00:07:58,560 --> 00:08:01,959
y elevará esta excepción

115
00:08:01,959 --> 00:08:03,620
a quien ha llamado a él

116
00:08:03,620 --> 00:08:07,019
para arriba, para arriba, para arriba, para arriba

117
00:08:07,019 --> 00:08:08,920
hasta llegar a un momento en que llegas al main

118
00:08:08,920 --> 00:08:11,019
y si el main lanza una excepción

119
00:08:11,019 --> 00:08:12,540
nadie la puede recoger

120
00:08:12,540 --> 00:08:14,319
y se cierra todo

121
00:08:14,319 --> 00:08:18,870
entonces si yo tengo el main

122
00:08:18,870 --> 00:08:20,329
que llama el método

123
00:08:20,329 --> 00:08:22,389
calculaDivision

124
00:08:22,389 --> 00:08:23,949
que llama el método

125
00:08:23,949 --> 00:08:26,470
leeteUnNumero

126
00:08:26,470 --> 00:08:29,290
y resulta que cuando lee un 0 al denominador

127
00:08:29,290 --> 00:08:30,949
pues lanza una excepción

128
00:08:30,949 --> 00:08:32,950
de esta, este lanza

129
00:08:32,950 --> 00:08:34,990
la recoge el método

130
00:08:34,990 --> 00:08:36,629
del medio que dirá

131
00:08:36,629 --> 00:08:38,850
si tiene un try catch pues hará lo que tiene

132
00:08:38,850 --> 00:08:40,570
que hacer, como por ejemplo, avisar al usuario

133
00:08:40,570 --> 00:08:42,649
mira, los datos que me has dado no son correctos

134
00:08:42,649 --> 00:08:44,789
e intentarlo otra vez, si en vez de

135
00:08:44,789 --> 00:08:46,610
no tienen un try que he hecho, pues lo que hará es

136
00:08:46,610 --> 00:08:48,549
pasarlo al main, el main dirá, ya está

137
00:08:48,549 --> 00:08:50,690
y a ese punto, el error

138
00:08:50,690 --> 00:08:52,309
como estamos acostumbrados a verlos

139
00:08:52,309 --> 00:08:54,909
en los ejercicios

140
00:08:54,909 --> 00:08:56,750
que hemos hecho antes de manejar

141
00:08:56,750 --> 00:08:58,509
excepciones, dudas?

142
00:09:00,330 --> 00:09:00,570
vale

143
00:09:00,570 --> 00:09:02,690
el objeto que se pasa a throw

144
00:09:02,690 --> 00:09:04,789
tiene que ser de la clase exception

145
00:09:04,789 --> 00:09:06,629
o de cualquier subclase que la

146
00:09:06,629 --> 00:09:08,769
extienda, vale, incluyendo excepciones

147
00:09:08,769 --> 00:09:10,950
personalizadas, que veremos a continuación

148
00:09:10,950 --> 00:09:12,330
dudas hasta aquí

149
00:09:12,330 --> 00:09:14,250
entonces si en algún lado puedo hacer throw

150
00:09:14,250 --> 00:09:16,850
throw, cuando lanzo

151
00:09:16,850 --> 00:09:18,850
el throw se sale inmediatamente del bloque del código

152
00:09:18,850 --> 00:09:20,929
actual, si yo estaba en un bloque, cuando ejecuto

153
00:09:20,929 --> 00:09:22,789
el throw, este bloque se ha acabado

154
00:09:22,789 --> 00:09:23,370
salgo

155
00:09:23,370 --> 00:09:27,029
si el bloque tiene asociado

156
00:09:27,029 --> 00:09:28,669
a una cláusula catch, vale, o sea

157
00:09:28,669 --> 00:09:30,850
estoy en un try catch, pues adecuada

158
00:09:30,850 --> 00:09:32,289
para el tipo de recepción

159
00:09:32,289 --> 00:09:34,809
generada, se ejecuta el cuerpo de la

160
00:09:34,809 --> 00:09:36,149
cláusula catch, si no, no

161
00:09:36,149 --> 00:09:38,570
si no, se sale

162
00:09:38,570 --> 00:09:40,610
inmediatamente del bloque o del método

163
00:09:40,610 --> 00:09:42,269
dentro del cual se está

164
00:09:42,269 --> 00:09:44,590
en el que se produjo la etc

165
00:09:44,590 --> 00:09:46,509
y se busca la cláusula catch

166
00:09:46,509 --> 00:09:48,330
apropiada, o sea, lo que decía que

167
00:09:48,330 --> 00:09:50,629
se va por arriba, tú tienes un try catch

168
00:09:50,629 --> 00:09:53,049
no, se va por arriba, tú tienes un try catch

169
00:09:53,049 --> 00:09:54,649
no, para arriba, hasta llegar

170
00:09:54,649 --> 00:09:56,730
a alguien que lo tenga o llegar al main

171
00:09:56,730 --> 00:09:58,570
el proceso continúa

172
00:09:58,570 --> 00:10:00,649
hasta llegar al método main de la aplicación

173
00:10:00,649 --> 00:10:02,809
si allí tampoco existe una cláusula catch

174
00:10:02,809 --> 00:10:04,350
adecuada, la máquina virtual

175
00:10:04,350 --> 00:10:06,610
de Java finaliza su ejecución

176
00:10:06,610 --> 00:10:07,970
con un mensaje de error

177
00:10:07,970 --> 00:10:14,830
¿es el método

178
00:10:14,830 --> 00:10:15,909
llamante

179
00:10:15,909 --> 00:10:18,549
el que tiene

180
00:10:18,549 --> 00:10:20,309
que gestionar la

181
00:10:20,309 --> 00:10:22,429
posible excepción

182
00:10:22,429 --> 00:10:23,549
de un método llamado?

183
00:10:34,649 --> 00:10:35,250
pregunta

184
00:10:35,250 --> 00:10:40,570
¿es el método

185
00:10:40,570 --> 00:10:41,649
llamante

186
00:10:41,649 --> 00:10:43,610
el encargado

187
00:10:43,610 --> 00:10:44,830
de gestionar

188
00:10:44,830 --> 00:10:46,610
la excepción

189
00:10:46,610 --> 00:10:48,909
la posible excepción

190
00:10:48,909 --> 00:10:51,090
de un método llamado

191
00:10:51,090 --> 00:10:53,929
porque es falso

192
00:10:53,929 --> 00:11:00,720
puede gestionarlo más abajo

193
00:11:00,720 --> 00:11:02,279
y puede gestionarlo más arriba

194
00:11:02,279 --> 00:11:06,200
puede ser el mismo método llamado

195
00:11:06,200 --> 00:11:08,259
que se gestione de alguna forma

196
00:11:08,259 --> 00:11:09,120
el error

197
00:11:09,120 --> 00:11:11,779
y puede ser que no sea yo el llamante

198
00:11:11,779 --> 00:11:12,419
más sea

199
00:11:12,419 --> 00:11:14,940
quien me ha llamado a mi

200
00:11:14,940 --> 00:11:17,860
o puede que no sea

201
00:11:17,860 --> 00:11:22,029
gestionado. ¿Dudas?

202
00:11:24,250 --> 00:11:24,509
Vale.

203
00:11:25,610 --> 00:11:26,669
Luego está TRUE.

204
00:11:28,750 --> 00:11:29,590
¿Vosotros

205
00:11:29,590 --> 00:11:30,850
que sabéis el inglés

206
00:11:30,850 --> 00:11:33,590
podéis notar la diferencia?

207
00:11:35,389 --> 00:11:36,230
Efectivamente.

208
00:11:37,330 --> 00:11:39,289
¿Es una S de plural

209
00:11:39,289 --> 00:11:41,509
o una S de tercera persona?

210
00:11:42,549 --> 00:11:43,429
Eso.

211
00:11:43,970 --> 00:11:44,169
¿Vale?

212
00:11:45,029 --> 00:11:47,049
Nosotros podemos definir

213
00:11:47,049 --> 00:11:49,389
en el código de un método F

214
00:11:49,389 --> 00:11:51,490
cuando nosotros decidimos

215
00:11:51,490 --> 00:11:59,350
hacemos el prototipo vale cuando nosotros definimos public void mi método con estos

216
00:11:59,350 --> 00:12:08,710
parámetros allí le podemos decir y este método lanza puede lanzar esta excepción entonces le

217
00:12:08,710 --> 00:12:18,549
ponemos throws y esta excepción vale como aquí public void método f throws esto es como avisar

218
00:12:18,549 --> 00:12:20,990
quién va a utilizar f

219
00:12:20,990 --> 00:12:23,029
que en algún lado

220
00:12:23,029 --> 00:12:25,350
de este código es posible

221
00:12:25,350 --> 00:12:27,230
que ocurra una excepción

222
00:12:27,230 --> 00:12:27,370
e

223
00:12:27,370 --> 00:12:31,110
entonces yo que voy a usar

224
00:12:31,110 --> 00:12:32,929
f y sé que puede

225
00:12:32,929 --> 00:12:35,029
lanzar una excepción e

226
00:12:35,029 --> 00:12:36,470
pues de tipo e

227
00:12:36,470 --> 00:12:39,309
puede ser null pointer exception

228
00:12:39,309 --> 00:12:40,490
o lo que sea

229
00:12:40,490 --> 00:12:42,710
pues lo que hago es que cuando

230
00:12:42,710 --> 00:12:45,009
llamo f lo pondré en un

231
00:12:45,009 --> 00:12:46,690
try catch con un catch

232
00:12:46,690 --> 00:12:48,389
de esta posible excepción

233
00:12:48,389 --> 00:13:17,019
Pero en un cierto senso lo estás haciendo. Solo que tú estás diciendo a quien va a usar F, cuidado, esto puede pasar. Gestionalo tú. No lo estoy gestionando yo. Esto no está gestionado en el método F, porque si no, me lo pongo y lo hago yo.

234
00:13:17,019 --> 00:13:20,519
Ahora, también es posible que yo te esté diciendo

235
00:13:20,519 --> 00:13:22,799
Yo no sé cómo lo quieres gestionar

236
00:13:22,799 --> 00:13:25,440
Yo te estoy diciendo que puede ocurrir

237
00:13:25,440 --> 00:13:30,340
Te estoy avisando que esto es un problema posible

238
00:13:30,340 --> 00:13:33,120
Ahora, ¿cómo lo quieres gestionar?

239
00:13:33,340 --> 00:13:34,340
Pues eso es un problema tuyo

240
00:13:34,340 --> 00:13:37,679
Puedes ignorarlo, puedes intentarlo otra vez

241
00:13:37,679 --> 00:13:39,539
Puedes que si ocurre ese error

242
00:13:39,539 --> 00:13:41,559
Puedes pillar un valor por defecto

243
00:13:41,559 --> 00:13:44,159
En vez de utilizar el valor que estabas intentando calcular

244
00:13:44,159 --> 00:13:46,379
Puedes avisar el usuario

245
00:13:46,379 --> 00:13:47,340
Puedes escribir en un

246
00:13:47,340 --> 00:13:49,960
Tú decides que se hace

247
00:13:49,960 --> 00:13:51,779
Yo te estoy diciendo que puede pasar

248
00:13:51,779 --> 00:13:56,279
Si en el código método F

249
00:13:56,279 --> 00:13:57,919
Se lanza una excepción de clase E

250
00:13:57,919 --> 00:13:59,799
En el prototipo del método

251
00:13:59,799 --> 00:14:02,120
Debemos indicarlo con la palabra reservada throws

252
00:14:02,120 --> 00:14:04,220
Esto sirve para que

253
00:14:04,220 --> 00:14:06,279
Potenciales usuarios de F

254
00:14:06,279 --> 00:14:07,659
Sepan a qué atenerse

255
00:14:07,659 --> 00:14:10,019
Sepan que F puede lanzar esto

256
00:14:10,019 --> 00:14:11,220
Lo veremos cuando por ejemplo

257
00:14:11,220 --> 00:14:13,539
Veremos los accesos a ficheros

258
00:14:13,539 --> 00:14:16,200
Y veremos que leer de fichero

259
00:14:16,200 --> 00:14:18,720
puede causar una IOException

260
00:14:18,720 --> 00:14:20,519
y entonces tú cuando usas

261
00:14:20,519 --> 00:14:22,360
la read para leer en el fichero

262
00:14:22,360 --> 00:14:24,340
tendrás que meterla en un try-catch

263
00:14:24,340 --> 00:14:26,620
y gestionar una eventual

264
00:14:26,620 --> 00:14:28,500
explosión de la IOException

265
00:14:28,500 --> 00:14:38,279
no me acuerdo

266
00:14:38,279 --> 00:14:40,340
creo que no

267
00:14:40,340 --> 00:14:44,019
creo que eso era un warning

268
00:14:44,019 --> 00:14:45,980
a otro nivel, ¿vale?

269
00:14:46,000 --> 00:14:47,840
porque este de aquí, y ahora veremos

270
00:14:47,840 --> 00:14:49,379
ahora hilamos más fino

271
00:14:49,379 --> 00:14:52,519
hay algunas excepciones que si tú no la controlas

272
00:14:52,519 --> 00:14:54,200
no pasa nada, pero hay otras excepciones

273
00:14:54,200 --> 00:14:56,059
Que estás forzado a controlarla

274
00:14:56,059 --> 00:14:58,460
Te da error si no la controlas

275
00:14:58,460 --> 00:14:59,519
Ahora llegamos a eso

276
00:14:59,519 --> 00:15:02,860
Si un método lanza más de un tipo de excepciones

277
00:15:02,860 --> 00:15:05,840
Se indicarán detrás de trolls separados por coma, ¿vale?

278
00:15:05,860 --> 00:15:10,960
Entonces, este método de aquí lanza esto y esto y esto y esto y esto

279
00:15:10,960 --> 00:15:15,100
Controlas tú

280
00:15:15,100 --> 00:15:16,419
Lanzar excepciones, ¿vale?

281
00:15:17,700 --> 00:15:21,940
Cuando en un código utilizamos métodos que lanzan potencialmente excepciones

282
00:15:21,940 --> 00:15:24,519
Tengo dos opciones, ¿vale?

283
00:15:24,519 --> 00:15:34,159
O sea, tengo un método, tengo un código que utiliza métodos que lanzan potenciales excepciones, ¿vale?

284
00:15:34,320 --> 00:15:38,059
Es decir, que estos métodos que estoy utilizando tienen un trowse, ¿vale?

285
00:15:38,299 --> 00:15:39,480
Puede hacer dos cosas.

286
00:15:40,100 --> 00:15:43,240
O proteger la llamada de este método con un try-catch.

287
00:15:43,620 --> 00:15:49,000
O sea, yo tengo mi código, pongo try, lanzo el método que puede explotar, catch, recojo la explosión.

288
00:15:49,000 --> 00:16:00,919
¿Sí? O la segunda opción es el código que yo estoy haciendo, asumiendo que sea un método, decir que también este método puede lanzar esa excepción.

289
00:16:00,919 --> 00:16:10,639
Entonces, si el método que he llamado lanza una IOException, yo en vez de recogerla digo, vale, si pasara, yo también lanzo esta.

290
00:16:11,220 --> 00:16:13,779
Sustancialmente paso la pelota a quien me ha llamado.

291
00:16:15,159 --> 00:16:30,200
A veces puede tener sentido principalmente de cara a si tu método es tan genérico que no sabes cómo en la aplicación quieres arreglar

292
00:16:30,200 --> 00:16:32,379
este posible problema, pues entonces dice

293
00:16:32,379 --> 00:16:34,299
vale, el método sigue aquí

294
00:16:34,299 --> 00:16:36,259
sé que puede pasar este error cuando

295
00:16:36,259 --> 00:16:38,019
llamo este método de aquí, por lo tanto digo

296
00:16:38,019 --> 00:16:39,679
también yo puedo generar este error

297
00:16:39,679 --> 00:16:42,139
que sea quien me ha llamado a mí

298
00:16:42,139 --> 00:16:44,440
el que gestione según la aplicación

299
00:16:44,440 --> 00:16:44,980
que está haciendo

300
00:16:44,980 --> 00:16:47,360
sí, más o menos

301
00:16:47,360 --> 00:16:50,320
el concepto es siempre el mismo

302
00:16:50,320 --> 00:16:52,220
¿vale? o sea, el error se

303
00:16:52,220 --> 00:16:54,059
crea en un lado y luego se va

304
00:16:54,059 --> 00:16:56,220
escalando hacia arriba hasta

305
00:16:56,220 --> 00:16:58,220
o encontrar un try catch

306
00:16:58,220 --> 00:17:00,179
que lo recoja con el catch

307
00:17:00,179 --> 00:17:01,279
correcto

308
00:17:01,279 --> 00:17:02,580
o el catch

309
00:17:02,580 --> 00:17:06,480
del tipo

310
00:17:06,480 --> 00:17:08,359
de la excepción que ha saltado

311
00:17:08,359 --> 00:17:10,259
o un padre

312
00:17:10,259 --> 00:17:12,259
una super clase

313
00:17:12,259 --> 00:17:13,140
de esa excepción

314
00:17:13,140 --> 00:17:15,799
o va para arriba

315
00:17:15,799 --> 00:17:18,559
hasta llegar al main y el main cierra todo

316
00:17:18,559 --> 00:17:23,519
esto delega la responsabilidad del manejo

317
00:17:23,519 --> 00:17:25,279
a otras clases invocantes

318
00:17:25,279 --> 00:17:27,400
y de allí tiene el sentido del

319
00:17:27,400 --> 00:17:28,599
print stack trace

320
00:17:28,599 --> 00:17:31,920
porque si esto crea la excepción

321
00:17:31,920 --> 00:17:33,539
y luego lo pasa al llamante

322
00:17:33,539 --> 00:17:35,140
que dice lo lanzo por arriba

323
00:17:35,140 --> 00:17:36,319
que lo lanza por arriba

324
00:17:36,319 --> 00:17:39,740
se está creando una pila

325
00:17:39,740 --> 00:17:40,599
de llamadas

326
00:17:40,599 --> 00:17:43,400
y el printStackTrace

327
00:17:43,400 --> 00:17:45,400
lo que me hace es la traza

328
00:17:45,400 --> 00:17:47,539
de esta pila para decir quién ha llamado

329
00:17:47,539 --> 00:17:49,339
quién y quién ha explotado quién

330
00:17:49,339 --> 00:17:51,740
y cómo hemos llegado

331
00:17:51,740 --> 00:17:53,539
aquí, yo tenía este método

332
00:17:53,539 --> 00:17:54,980
que había llamado esto, que había llamado esto

333
00:17:54,980 --> 00:17:57,079
este ha generado el error

334
00:17:57,079 --> 00:17:59,380
que le ha pasado a esto y este no lo ha gestionado

335
00:17:59,380 --> 00:18:01,200
le ha pasado a este, este no lo ha gestionado

336
00:18:01,200 --> 00:18:02,799
le ha pasado a este, este no lo ha gestionado

337
00:18:02,799 --> 00:18:03,839
era el main ha explotado

338
00:18:03,839 --> 00:18:07,480
pero te estoy diciendo lo que ha pasado

339
00:18:07,480 --> 00:18:11,220
si la excepción lanzada es hija

340
00:18:11,220 --> 00:18:13,480
de runtime exception, no es necesario

341
00:18:13,480 --> 00:18:16,529
manejarla

342
00:18:16,529 --> 00:18:18,009
o sea, yo tengo exception

343
00:18:18,009 --> 00:18:21,009
tendré un montón de excepciones

344
00:18:21,009 --> 00:18:22,930
pero tendré también una

345
00:18:22,930 --> 00:18:25,390
excepción particular que es runtime exception

346
00:18:25,390 --> 00:18:26,869
si

347
00:18:26,869 --> 00:18:28,710
la excepción

348
00:18:28,710 --> 00:18:31,589
que explota es runtime exception

349
00:18:31,589 --> 00:18:35,250
o hija de runtime exception, no es necesario

350
00:18:35,250 --> 00:18:38,230
poner un try-catch. Eso no quiere decir

351
00:18:38,230 --> 00:18:40,670
que funcionaría. No. Explota igualmente.

352
00:18:41,009 --> 00:18:43,549
Pero no te fuerza a explotar,

353
00:18:43,630 --> 00:18:46,410
a manejarla. Y os hago una pregunta.

354
00:18:47,269 --> 00:18:48,730
¿Vosotros conocéis null pointer exception?

355
00:18:50,069 --> 00:18:52,809
¿Conocéis a reindex out of bound exception?

356
00:18:53,430 --> 00:18:56,029
¿Cuántas veces os ha pasado

357
00:18:56,029 --> 00:18:58,730
y no lo habéis puesto en un try catch

358
00:18:58,730 --> 00:19:02,190
siempre, vale

359
00:19:02,190 --> 00:19:04,089
y Java no te avisa

360
00:19:04,089 --> 00:19:06,829
oye mira, tienes un array

361
00:19:06,829 --> 00:19:08,490
podrías leer

362
00:19:08,490 --> 00:19:10,349
fuera de los rangos

363
00:19:10,349 --> 00:19:12,470
haz un try catch para un array

364
00:19:12,470 --> 00:19:14,170
index out of bound

365
00:19:14,170 --> 00:19:16,089
Java no te avisa

366
00:19:16,089 --> 00:19:17,630
diciendo, oye mira tienes un objeto

367
00:19:17,630 --> 00:19:20,490
podría ser null, no lo uses

368
00:19:20,490 --> 00:19:21,930
antes comprueba que no es null

369
00:19:21,930 --> 00:19:24,150
o ponlo en un try catch y pilla

370
00:19:24,150 --> 00:19:25,490
en el pointer exception, ¿por qué?

371
00:19:25,490 --> 00:19:33,230
Porque tanto null point of exception como array index of exception derivan de runtime exception.

372
00:19:33,910 --> 00:19:44,630
Son excepciones tan comunes que sería una sobrecarga extrema estar pendiente de ellas constantemente.

373
00:19:45,190 --> 00:19:50,329
Entonces se asume que no lo tienes que hacer, lo tienes que comprobar,

374
00:19:50,329 --> 00:19:53,750
Tienes que tener cuidado con estos

375
00:19:53,750 --> 00:19:55,730
Pero si no lo haces

376
00:19:55,730 --> 00:19:56,730
No te voy a bloquear

377
00:19:56,730 --> 00:19:59,130
No te voy a dar un error en tiempo de compilación

378
00:19:59,130 --> 00:20:01,210
Diciendo, eh, no has comprobado

379
00:20:01,210 --> 00:20:03,349
Que aquí podría saltar una null pointer exception

380
00:20:03,349 --> 00:20:05,710
Todas las runtime exceptions

381
00:20:05,710 --> 00:20:06,549
Son de este tipo

382
00:20:06,549 --> 00:20:09,450
Pueden explotar, pueden pasar

383
00:20:09,450 --> 00:20:11,809
Pero si tú no las manejas

384
00:20:11,809 --> 00:20:12,990
Allá tú

385
00:20:12,990 --> 00:20:33,349
A ver, eso es un warning

386
00:20:33,349 --> 00:20:35,450
Y eso deriva de

387
00:20:35,450 --> 00:20:37,049
Abrir y cerrar recursos

388
00:20:37,049 --> 00:20:39,349
que nosotros todavía no sabemos que son

389
00:20:39,349 --> 00:20:40,730
porque no sabemos de

390
00:20:40,730 --> 00:20:43,150
stream, no sabemos

391
00:20:43,150 --> 00:20:45,089
que es un input stream o un output stream

392
00:20:45,089 --> 00:20:47,369
no sabemos si escribir en fichero, no sabemos si escribir

393
00:20:47,369 --> 00:20:49,150
no entendemos muy bien

394
00:20:49,150 --> 00:20:50,990
esto de recibir datos

395
00:20:50,990 --> 00:20:53,069
desde Scanner, que hace Scanner no lo sabemos

396
00:20:53,069 --> 00:20:55,069
por lo tanto por ahora lo dejamos allí

397
00:20:55,069 --> 00:20:56,289
en el aire, ¿vale?

398
00:20:57,630 --> 00:20:58,109
posiblemente

399
00:20:58,109 --> 00:21:00,809
no me acuerdo exactamente el error que te da

400
00:21:00,809 --> 00:21:02,890
¿vale? pero sostancialmente

401
00:21:02,890 --> 00:21:05,210
cuando tú abres una lectura

402
00:21:05,210 --> 00:21:06,849
desde el teclado deberías

403
00:21:06,849 --> 00:21:09,230
cuando ya no la usas más, cerrar el recurso

404
00:21:09,230 --> 00:21:10,789
para evitar memory leak

405
00:21:10,789 --> 00:21:12,930
¿vale? dejar de haber

406
00:21:12,930 --> 00:21:15,009
dejado allí un objeto scanner

407
00:21:15,009 --> 00:21:16,690
que no vas a utilizar nunca jamás

408
00:21:16,690 --> 00:21:18,970
pero que te ocupa memoria, porque tienes

409
00:21:18,970 --> 00:21:21,109
una referencia y luego en un

410
00:21:21,109 --> 00:21:22,930
ciclo siguiente construyes otro y lo

411
00:21:22,930 --> 00:21:25,069
dejas allí, construyes otro y llega un momento

412
00:21:25,069 --> 00:21:27,349
que tienes un montón de objetos con referencias

413
00:21:27,349 --> 00:21:28,470
que pero no usarás nunca

414
00:21:28,470 --> 00:21:31,009
¿vale? entonces en un cierto sentido te está diciendo

415
00:21:31,009 --> 00:21:33,190
cuando ya la has usado, lo deberías

416
00:21:33,190 --> 00:21:35,109
cerrar ¿vale? ahora

417
00:21:35,109 --> 00:21:35,750
no sé

418
00:21:35,750 --> 00:21:39,529
No creo que cerrarlo te pueda lanzar

419
00:21:39,529 --> 00:21:41,089
Una excepción, no me acuerdo

420
00:21:41,089 --> 00:21:41,930
¿Vale?

421
00:21:55,650 --> 00:21:57,529
No, pero eso es un try con recursos

422
00:21:57,529 --> 00:22:00,890
Él hace un try abierta paréntesis

423
00:22:00,890 --> 00:22:02,829
Pone allí el escáner

424
00:22:02,829 --> 00:22:03,829
Cerrada paréntesis

425
00:22:03,829 --> 00:22:05,029
Y luego hace una cosa

426
00:22:05,029 --> 00:22:07,410
Es una cosa un poquito distinta

427
00:22:07,410 --> 00:22:09,650
Es una versión de try un poquito más compleja

428
00:22:09,650 --> 00:22:11,950
Existe el try con recursos

429
00:22:11,950 --> 00:22:14,569
Donde tú, cuando lanzas el try

430
00:22:14,569 --> 00:22:15,630
Aquí

431
00:22:15,630 --> 00:22:17,650
Entre esto y esto

432
00:22:17,650 --> 00:22:20,170
declaras unos recursos

433
00:22:20,170 --> 00:22:22,549
esos recursos solo existirán

434
00:22:22,549 --> 00:22:24,390
dentro de este bloque

435
00:22:24,390 --> 00:22:26,630
de aquí, y cuando acaba el bloque

436
00:22:26,630 --> 00:22:28,490
o acaba el final o cosas por el estilo

437
00:22:28,490 --> 00:22:30,430
se cerrarán de forma automática

438
00:22:30,430 --> 00:22:32,509
y se utiliza mucho

439
00:22:32,509 --> 00:22:34,410
en cosas como scanner, como

440
00:22:34,410 --> 00:22:36,230
lectura de ficheros

441
00:22:36,230 --> 00:22:38,430
como mandar cosas por internet

442
00:22:38,430 --> 00:22:40,130
etc, etc, etc, vale, pero

443
00:22:40,130 --> 00:22:42,309
por ahora a nosotros nos interesa

444
00:22:42,309 --> 00:22:42,970
relativamente poco

445
00:22:42,970 --> 00:22:47,950
no los necesitamos

446
00:22:47,950 --> 00:22:55,170
por ahora. Entonces, jerarquía de excepciones, para entender un poquito cómo es, existe

447
00:22:55,170 --> 00:23:04,450
el concepto de throwable, o sea, un objeto lanzable. Dentro de throwable hay dos tipos

448
00:23:04,450 --> 00:23:11,609
de cosas que heredan de throwable, que son errores y excepciones. Error and exception.

449
00:23:12,529 --> 00:23:17,329
Error es un error grave. Es un error grave que no debería ser manejado.

450
00:23:17,450 --> 00:23:23,190
No es un, oye, mira, te has equivocado a escribir el nombre y has empezado por número.

451
00:23:23,609 --> 00:23:28,950
O, oye, mira, te he pedido un número y me has dado una letra.

452
00:23:29,049 --> 00:23:30,930
No, es un error de la Java Virtual Machine.

453
00:23:31,369 --> 00:23:32,869
La Java Virtual Machine se ha quedado sin memoria.

454
00:23:34,369 --> 00:23:40,329
Has intentado acceder a una zona de memoria que el sistema operativo no te permite.

455
00:23:40,329 --> 00:23:47,230
Son cosas que no deberían ser manejadas porque son tan graves que no te recuperes de eso.

456
00:23:47,549 --> 00:23:48,369
Hay un error serio.

457
00:23:48,970 --> 00:23:49,190
Sal.

458
00:23:49,750 --> 00:23:50,470
Eso es un error.

459
00:23:52,190 --> 00:24:00,170
Sin embargo, luego están las exceptions, que son los errores manejables o recuperables más relacionados con lo que estoy haciendo yo.

460
00:24:00,769 --> 00:24:09,430
Eso de que, oye, mira, el Java Termination está funcionando, el sistema está funcionando, pero ha habido un error en tu aplicación.

461
00:24:09,430 --> 00:24:11,789
Haz algo para recuperarlo

462
00:24:11,789 --> 00:24:15,089
Y dentro de Exception hay dos tipos

463
00:24:15,089 --> 00:24:18,190
Hay el Runtime Exception y las demás

464
00:24:18,190 --> 00:24:22,089
El Runtime Exception son errores habituales de ejecución

465
00:24:22,089 --> 00:24:26,269
Y como son tan habituales y debería estar constantemente mirando

466
00:24:26,269 --> 00:24:30,029
Si eso pasa o no, pues llega un momento en que no está obligado

467
00:24:30,029 --> 00:24:34,789
A declarar su manejo o vigilarlo o cosas por el estilo

468
00:24:34,789 --> 00:24:39,210
Sería un costo computacional demasiado grande

469
00:24:39,210 --> 00:24:41,549
estar constantemente vigilando

470
00:24:41,549 --> 00:24:43,190
todos los accesos

471
00:24:43,190 --> 00:24:45,329
a todos los arrays y todos los

472
00:24:45,329 --> 00:24:47,150
objetos que no se anule, cosa por el estilo.

473
00:24:47,950 --> 00:24:49,089
¿Vale? Por lo tanto, dice

474
00:24:49,089 --> 00:24:50,890
hazlo tú. ¿Vale?

475
00:24:52,109 --> 00:24:53,190
Arithmetic exception,

476
00:24:53,549 --> 00:24:55,329
index out of bound

477
00:24:55,329 --> 00:24:57,009
exception, null pointer exception,

478
00:24:57,150 --> 00:24:59,250
son todos ejemplos de runtime exception.

479
00:25:00,250 --> 00:25:01,069
Y luego están los demás.

480
00:25:02,130 --> 00:25:03,410
Las demás excepciones

481
00:25:03,410 --> 00:25:05,490
sí estás obligado

482
00:25:05,490 --> 00:25:06,089
a

483
00:25:06,089 --> 00:25:08,809
manejarlas.

484
00:25:09,210 --> 00:25:24,769
¿Vale? Es decir, que si yo lanzo una excepción que no sea una RuntimeException, si yo no lo meto, el método que lanza esa excepción, no lo meto en un TryCatch, pues no me va a funcionar, me va a dar un error a tiempo de compilación.

485
00:25:24,769 --> 00:25:39,170
Me va a decir, mira, estás usando este método, este método está declarado que throws esta excepción, esta excepción no es del tipo de RuntimeException, por lo tanto, si quieres usar este método, necesitas ponerlo en un TryCatch.

486
00:25:39,210 --> 00:25:46,329
Ir y cachear esta posible excepción

487
00:25:46,329 --> 00:25:52,190
Entonces, excepciones que obligan a quien use código que las pueda lanzar

488
00:25:52,190 --> 00:25:56,890
Las maneje o avisa a los demás

489
00:25:56,890 --> 00:25:58,890
Siempre tengo las dos opciones

490
00:25:58,890 --> 00:26:03,369
O, vale, muy bien, uso este método aquí, este método es peligroso

491
00:26:03,369 --> 00:26:04,789
Lo gestiono yo

492
00:26:04,789 --> 00:26:08,710
O, oye, mira, uso este método, este método es peligroso

493
00:26:08,710 --> 00:26:10,329
Y el mismo peligro

494
00:26:10,329 --> 00:26:11,950
Lo hago mío

495
00:26:11,950 --> 00:26:13,750
En el sentido, si él throws

496
00:26:13,750 --> 00:26:15,589
No sé qué exception

497
00:26:15,589 --> 00:26:18,309
Pues yo también throws no sé qué exception

498
00:26:18,309 --> 00:26:20,289
De esta forma, si explota él

499
00:26:20,289 --> 00:26:22,049
Pues yo voy a pasar la pelota

500
00:26:22,049 --> 00:26:24,130
A quien me ha llamado a mí

501
00:26:24,130 --> 00:26:24,490
Ya está

502
00:26:24,490 --> 00:26:28,329
Por ejemplo, CertificationAutoException

503
00:26:28,329 --> 00:26:30,009
CloneNoSupportedException

504
00:26:30,009 --> 00:26:31,069
Y otros más, ¿vale?

505
00:26:31,150 --> 00:26:33,789
Esto es un poquito un esquemita generalizado

506
00:26:33,789 --> 00:26:35,490
De object

507
00:26:35,490 --> 00:26:37,690
De object viene throwable, error

508
00:26:37,690 --> 00:26:40,190
posibles errores, como por ejemplo

509
00:26:40,190 --> 00:26:42,549
out of memory error, oye, se ha acabado

510
00:26:42,549 --> 00:26:44,170
la RAM, no es que tú te puedas

511
00:26:44,170 --> 00:26:46,190
recuperar del hecho que se ha acabado la RAM

512
00:26:46,190 --> 00:26:47,210
¿sí?

513
00:26:49,470 --> 00:26:50,309
stack overflow

514
00:26:50,309 --> 00:26:52,170
error, ¿vale?

515
00:26:52,289 --> 00:26:54,309
este de aquí os puede sonar

516
00:26:54,309 --> 00:26:56,190
de algo, stack overflow

517
00:26:56,190 --> 00:26:56,869
suena

518
00:26:56,869 --> 00:27:00,089
a web, ¿vale? viene de aquí probablemente

519
00:27:00,089 --> 00:27:02,309
stack overflow, la stack es

520
00:27:02,309 --> 00:27:04,450
esta pila de llamo, que llamo, que llamo

521
00:27:04,450 --> 00:27:05,849
que llamo, que llamo, que llamo

522
00:27:05,849 --> 00:27:07,029
que llamo, que llamo, que llamo

523
00:27:07,029 --> 00:27:08,630
y que pasa si yo

524
00:27:08,630 --> 00:27:11,890
hago un while true donde dentro

525
00:27:11,890 --> 00:27:13,089
llamo este mismo método

526
00:27:13,089 --> 00:27:17,509
que se vuelve a llamar, se vuelve a llamar, se vuelve a llamar

527
00:27:17,509 --> 00:27:19,569
llega un momento en que la stack

528
00:27:19,569 --> 00:27:20,849
la pila de llamadas

529
00:27:20,849 --> 00:27:23,329
se llena, porque estamos

530
00:27:23,329 --> 00:27:25,430
en un ordenador y todos los recursos

531
00:27:25,430 --> 00:27:27,569
de un ordenador son finitos

532
00:27:27,569 --> 00:27:29,390
no hay ordenadores

533
00:27:29,390 --> 00:27:30,890
con recursos infinitos

534
00:27:30,890 --> 00:27:32,910
puede tardar menos o más

535
00:27:32,910 --> 00:27:34,710
pero llega un momento en que se...

536
00:27:34,710 --> 00:27:37,490
Y si yo llego allí, he hecho tantas llamadas

537
00:27:37,490 --> 00:27:39,789
Que cuando llego a la siguiente

538
00:27:39,789 --> 00:27:41,650
No la puedo hacer porque no tengo

539
00:27:41,650 --> 00:27:43,369
Los recursos, pues salta

540
00:27:43,369 --> 00:27:45,690
Un Stack Overflow error

541
00:27:45,690 --> 00:27:47,309
¿Y qué hago? ¿Cómo me recupero?

542
00:27:47,329 --> 00:27:49,609
No me puedo recuperar, es que tengo una pila que está creciendo

543
00:27:49,609 --> 00:27:51,769
Demasiado, ¿vale? El error es tuyo

544
00:27:51,769 --> 00:27:53,390
Pero es que el sistema no se puede

545
00:27:53,390 --> 00:27:54,230
Recuperar de eso

546
00:27:54,230 --> 00:27:57,650
Luego están las Exception

547
00:27:57,650 --> 00:27:59,410
De Exception están

548
00:27:59,410 --> 00:28:01,269
La Runtime Exception, que son

549
00:28:01,269 --> 00:28:03,069
Estas muy, muy comunes

550
00:28:03,069 --> 00:28:06,390
Y entonces no tengo que gestionarlas

551
00:28:06,390 --> 00:28:08,170
Y aquí hay ArithmeticException

552
00:28:08,170 --> 00:28:10,609
Como por ejemplo cuando hago una división por cero

553
00:28:10,609 --> 00:28:10,869
Creo

554
00:28:10,869 --> 00:28:14,349
Hay NegativeArraySizeException

555
00:28:14,349 --> 00:28:16,750
NullPointerException

556
00:28:16,750 --> 00:28:18,930
NoSuchElementException

557
00:28:18,930 --> 00:28:20,470
Creo que NoSuchElementException

558
00:28:20,470 --> 00:28:24,029
Salía en algún lado de Scanner

559
00:28:24,029 --> 00:28:24,650
Puede ser

560
00:28:24,650 --> 00:28:29,829
IndexAutoBoundException

561
00:28:29,829 --> 00:28:30,910
Etcétera, etcétera

562
00:28:30,910 --> 00:28:32,390
Y luego están estas otras

563
00:28:32,390 --> 00:28:34,990
Estas otras son excepciones básicas

564
00:28:34,990 --> 00:28:37,250
Como por ejemplo la Class Not Found Exception

565
00:28:37,250 --> 00:28:39,390
La Interrupted Exception

566
00:28:39,390 --> 00:28:41,589
La End of File Exception

567
00:28:41,589 --> 00:28:42,789
La...

568
00:28:42,789 --> 00:28:45,809
Todas estas son I.O. Exception

569
00:28:45,809 --> 00:28:49,549
Aquí volveremos cuando empezaremos a ver algo de entrada-salida

570
00:28:49,549 --> 00:28:51,609
De escribir y leer de ficheros

571
00:28:51,609 --> 00:28:53,750
Entonces saldrán estas cosas de aquí

572
00:28:53,750 --> 00:28:55,690
¿Dudas?

573
00:28:58,950 --> 00:28:59,210
Vale

574
00:28:59,210 --> 00:29:01,349
Nos queda reciente poco

575
00:29:01,349 --> 00:29:05,750
Para empezar a probar algunas de estas cosas

576
00:29:05,750 --> 00:29:09,029
Existen también las excepciones personalizadas

577
00:29:09,029 --> 00:29:13,170
O sea, en algún momento yo puedo crear mis propias excepciones

578
00:29:13,170 --> 00:29:15,450
Una excepción es una clase, ¿vale?

579
00:29:15,710 --> 00:29:18,950
Simplemente hago public class a mi excepción standException

580
00:29:18,950 --> 00:29:21,470
Y he creado una nueva clase

581
00:29:21,470 --> 00:29:25,569
Si standException soy de esas que tienen que ser controladas

582
00:29:25,569 --> 00:29:34,049
Si standRuntimeException, pues son de estas que no hace falta que sea controlada

583
00:29:34,049 --> 00:29:39,230
Lo que se suele hacer cuando se crea una excepción personalizada

584
00:29:39,230 --> 00:29:41,130
Es crear un constructor del estilo

585
00:29:41,130 --> 00:29:46,190
Mi excepción pilla un string y lo que hace es super s

586
00:29:46,190 --> 00:29:49,130
Hace lo mismo que hace exception

587
00:29:49,130 --> 00:29:52,890
Porque al fin y al cabo la excepción lo que interesa es que tenga un mensajito de error

588
00:29:52,890 --> 00:29:58,329
De esta forma se pueden crear objetos de esta clase con un mensaje personalizado

589
00:29:58,329 --> 00:30:03,769
Asociado al método getMessage que luego puedo sobreescribir o puedo utilizar directamente

590
00:30:03,769 --> 00:30:05,529
El de exception

591
00:30:05,529 --> 00:30:07,349
Este es un ejemplo

592
00:30:07,349 --> 00:30:08,130
¿Vale?

593
00:30:08,130 --> 00:30:09,769
Yo tengo public

594
00:30:09,769 --> 00:30:11,990
Divide by zero exception

595
00:30:11,990 --> 00:30:14,210
Que extiende arithmetic exception

596
00:30:14,210 --> 00:30:16,069
Por ejemplo, he extendido

597
00:30:16,069 --> 00:30:16,970
Esta

598
00:30:16,970 --> 00:30:21,650
Aquí le he colgado debajo

599
00:30:21,650 --> 00:30:22,390
Una

600
00:30:22,390 --> 00:30:25,769
Excepción particular

601
00:30:25,769 --> 00:30:27,410
Que no es aritmética en general

602
00:30:27,410 --> 00:30:29,150
Pero es dividir por cero

603
00:30:29,150 --> 00:30:31,789
Que sostancialmente

604
00:30:31,789 --> 00:30:33,809
Tiene un constructor, divide by zero exception

605
00:30:33,809 --> 00:30:36,069
String message, super message

606
00:30:36,069 --> 00:30:41,049
Y luego aquí tengo un public double dividir

607
00:30:41,049 --> 00:30:42,430
Que pilla dos números

608
00:30:42,430 --> 00:30:46,190
Y puede lanzar divide by zero exception

609
00:30:46,190 --> 00:30:49,789
Entonces cuando alguien usa dividir

610
00:30:49,789 --> 00:30:55,349
Sabe que se puede encontrar con una división by zero

611
00:30:55,349 --> 00:30:59,569
Si el denominador es cero

612
00:30:59,569 --> 00:31:02,589
Pues entonces este método lanzará

613
00:31:02,589 --> 00:31:03,890
Un nuevo objeto

614
00:31:03,890 --> 00:31:06,150
DivideByZeroException con escrito

615
00:31:06,150 --> 00:31:06,910
Error

616
00:31:06,910 --> 00:31:09,349
O podría escribir has dividido por cero

617
00:31:09,349 --> 00:31:12,410
O denominador no válido

618
00:31:12,410 --> 00:31:14,509
Si no

619
00:31:14,509 --> 00:31:16,750
Como esto

620
00:31:16,750 --> 00:31:17,930
Como si tuviera aquí

621
00:31:17,930 --> 00:31:19,390
Una corchete corchete

622
00:31:19,390 --> 00:31:21,890
Pues entonces devolverá la división

623
00:31:21,890 --> 00:31:24,359
Lo das

624
00:31:24,359 --> 00:31:26,359
Se entiende

625
00:31:26,359 --> 00:31:33,740
Y con esto se acaba la teoría