0
00:00:00,000 --> 00:00:07,000
Vale, todo lo que digáis puede ser grabado en este vídeo.

1
00:00:07,000 --> 00:00:14,000
Entonces, estamos hablando de excepciones.

2
00:00:14,000 --> 00:00:26,000
Y las excepciones, hemos visto que son estos errores que ocurren a tiempo de ejecución,

3
00:00:26,000 --> 00:00:34,000
de que menos mal no podía saber que existían antes, podía imaginar que sí podían explotar algo,

4
00:00:34,000 --> 00:00:37,000
pero que no puedo estar seguro de que va a pasar o no.

5
00:00:37,000 --> 00:00:44,000
Y que entonces hemos visto que hay este sistema del try-catch, que me permite decir, tú inténtalo,

6
00:00:44,000 --> 00:00:48,000
trae, y si algo pasa, catch.

7
00:00:48,000 --> 00:00:59,000
Hemos visto que tenemos el objeto exception, que es la llave que la maquina intenta crear,

8
00:00:59,000 --> 00:01:06,000
y lo más preciso posible con respecto a la...

9
00:01:22,000 --> 00:01:27,000
Entonces, ¿cómo se lanzan las excepciones?

10
00:01:27,000 --> 00:01:34,000
Es decir, ¿cómo puedo hacer yo que en un determinado momento la ejecución de mi programa,

11
00:01:34,000 --> 00:01:40,000
en un cierto momento se dé cuenta que algo aquí está yendo mal,

12
00:01:40,000 --> 00:01:46,000
y diga, oye mira, en este momento sí pasa esta cosa o bajo determinadas condiciones,

13
00:01:46,000 --> 00:01:50,000
lo único que puedes hacer es explotar y lanzar una excepción.

14
00:01:51,000 --> 00:01:58,000
Esta excepción luego podrá ser capturada con el try-catch que hemos visto antes.

15
00:01:58,000 --> 00:02:02,000
Entonces yo tendré este método que lanza las excepciones,

16
00:02:02,000 --> 00:02:05,000
no lo pronunciaré nunca más, nunca viene.

17
00:02:05,000 --> 00:02:09,000
Las exceptions las tendré dentro de un try-catch,

18
00:02:09,000 --> 00:02:15,000
y si llega a lanzar la excepción, pues lo recogerá el catch apropiado.

19
00:02:15,000 --> 00:02:22,000
Entonces, para lanzar esta excepción se usa el comando throw.

20
00:02:24,000 --> 00:02:28,000
Entonces, en un determinado momento de mi programa,

21
00:02:28,000 --> 00:02:31,000
de un método o de algo que estoy programando,

22
00:02:31,000 --> 00:02:34,000
le puedo decir que if no sé qué no sé cuánto,

23
00:02:34,000 --> 00:02:37,000
si pasa esto, si la cosa no va bien,

24
00:02:37,000 --> 00:02:41,000
o tengo que indicar que aquí mi programa tiene que fallar

25
00:02:41,000 --> 00:02:44,000
porque no puede seguir adelante porque ha tenido un problema,

26
00:02:44,000 --> 00:02:47,000
puedo lanzar una excepción.

27
00:02:47,000 --> 00:02:50,000
Claramente crearé este objeto exception,

28
00:02:50,000 --> 00:02:56,000
o crearé un objeto de una clase mía que es la xException,

29
00:02:56,000 --> 00:02:59,000
que es hereda de exception,

30
00:02:59,000 --> 00:03:02,000
y una vez que he creado ese objeto, lo lanzo.

31
00:03:05,000 --> 00:03:08,000
Lo que se le pasa, o sea, el objeto este de aquí,

32
00:03:08,000 --> 00:03:13,000
tiene que ser o exception o una subclase de exception.

33
00:03:13,000 --> 00:03:15,000
Lo que decíamos antes.

34
00:03:15,000 --> 00:03:19,000
Por lo tanto, incluirá todos los métodos que hemos visto antes,

35
00:03:19,000 --> 00:03:23,000
más si yo estoy haciendo un manejo de excepciones,

36
00:03:23,000 --> 00:03:25,000
míos, personales,

37
00:03:25,000 --> 00:03:28,000
entonces a lo mejor yo puedo necesitar algunas cosas más,

38
00:03:28,000 --> 00:03:31,000
algunos datos más o algunos métodos más,

39
00:03:31,000 --> 00:03:35,000
y como me estoy creando mi propia clase que está en excepciones,

40
00:03:35,000 --> 00:03:37,000
puedo añadir lo que me da la gana,

41
00:03:37,000 --> 00:03:40,000
además de lo que hace exception normalmente.

42
00:03:41,000 --> 00:03:45,000
Digamos que exception me da la infraestructura,

43
00:03:45,000 --> 00:03:49,000
el esqueleto general de que todas las excepciones tienen que tener,

44
00:03:49,000 --> 00:03:52,000
y a eso yo le añado lo que yo necesito.

45
00:03:57,000 --> 00:03:59,000
Cuando se usa el throw,

46
00:03:59,000 --> 00:04:02,000
se sale inmediatamente del bloco de código actual.

47
00:04:02,000 --> 00:04:04,000
Es decir, que cuando llego a ejecutar un throw,

48
00:04:04,000 --> 00:04:08,000
quiero decir que allí es que tengo que bloquear la ejecución.

49
00:04:08,000 --> 00:04:12,000
No es que lanzo el throw y luego sigo con los datos que están detrás.

50
00:04:12,000 --> 00:04:14,000
Porque si llego a ejecutar uno de estos,

51
00:04:14,000 --> 00:04:21,000
quiere decir que ya ha llegado el momento de hacer saber

52
00:04:21,000 --> 00:04:25,000
a quién ha lanzado o quién está trabajando con este método,

53
00:04:25,000 --> 00:04:27,000
que aquí ha habido un error.

54
00:04:27,000 --> 00:04:29,000
Si hay un error, no puedo seguir adelante.

55
00:04:29,000 --> 00:04:31,000
Si yo estoy haciendo una división por cero,

56
00:04:31,000 --> 00:04:33,000
no puedo decir que hago una división por cero

57
00:04:33,000 --> 00:04:36,000
y sigo adelante utilizando el resultado de esta operación.

58
00:04:37,000 --> 00:04:40,000
Si yo intento acceder a una celda que no existe

59
00:04:40,000 --> 00:04:43,000
y luego desde esta celda tengo que sacar los datos

60
00:04:43,000 --> 00:04:44,000
y hacer algo con esos datos,

61
00:04:44,000 --> 00:04:47,000
si no he podido sacar, pues no puedo seguir adelante.

62
00:04:48,000 --> 00:04:51,000
Si el bloqueo está asociado a la cláusula catch adecuada,

63
00:04:51,000 --> 00:04:53,000
para el tipo de excepción generada,

64
00:04:53,000 --> 00:04:55,000
se ejecuta ese cuerpo de catch.

65
00:04:55,000 --> 00:04:57,000
O sea que si yo cuando lanzo throw,

66
00:04:57,000 --> 00:05:01,000
esto está en un try catch y hay un catch para esa excepción,

67
00:05:01,000 --> 00:05:03,000
pues se ejecuta ese catch.

68
00:05:03,000 --> 00:05:07,000
Si no, se sale directamente del bloqueo

69
00:05:07,000 --> 00:05:09,000
o del método donde estoy

70
00:05:09,000 --> 00:05:14,000
y se lanzará esta excepción

71
00:05:14,000 --> 00:05:17,000
a quien me ha llamado y de allí a quien me ha llamado

72
00:05:17,000 --> 00:05:18,000
y de allí a quien me ha llamado

73
00:05:18,000 --> 00:05:22,000
hasta que encontre una cláusula catch

74
00:05:22,000 --> 00:05:24,000
que me permite depillarme.

75
00:05:25,000 --> 00:05:28,000
Es decir, imaginaos que yo tengo el método A

76
00:05:28,000 --> 00:05:31,000
que llama al método B, que llama al método C

77
00:05:31,000 --> 00:05:34,000
y es en el método C donde se lanza la excepción,

78
00:05:34,000 --> 00:05:36,000
donde se hace la throw.

79
00:05:36,000 --> 00:05:39,000
Lo que se intentará hacer es

80
00:05:39,000 --> 00:05:42,000
volver atrás en las llamadas

81
00:05:42,000 --> 00:05:45,000
hasta buscar si uno de estos métodos

82
00:05:45,000 --> 00:05:47,000
tiene un try catch con un catch

83
00:05:47,000 --> 00:05:50,000
que pille este tipo de excepción.

84
00:05:50,000 --> 00:05:51,000
Entonces, si el try catch

85
00:05:51,000 --> 00:05:54,000
yo lo he metido directamente en el método C,

86
00:05:54,000 --> 00:05:56,000
pues usaré el catch de ese método.

87
00:05:56,000 --> 00:05:59,000
En cierto sentido, al explotar la excepción,

88
00:05:59,000 --> 00:06:02,000
el método mismo intenta recuperarse.

89
00:06:02,000 --> 00:06:04,000
Si en vez de no lo he hecho así,

90
00:06:04,000 --> 00:06:06,000
el método C no tiene ningún try catch,

91
00:06:06,000 --> 00:06:08,000
podría ser que el método B,

92
00:06:08,000 --> 00:06:10,000
el que llamaba al método C,

93
00:06:10,000 --> 00:06:12,000
tenga un try catch

94
00:06:12,000 --> 00:06:14,000
y que el método B al método C

95
00:06:14,000 --> 00:06:17,000
haya sido llamado dentro del try.

96
00:06:17,000 --> 00:06:19,000
Entonces, en este caso voy a mirar

97
00:06:19,000 --> 00:06:21,000
si algún catch de ese bloque

98
00:06:21,000 --> 00:06:24,000
me permite pillar esta excepción.

99
00:06:24,000 --> 00:06:26,000
Y si no, voy al método A.

100
00:06:26,000 --> 00:06:27,000
Y si no llego al método A,

101
00:06:27,000 --> 00:06:28,000
llegaré a un cierto momento

102
00:06:28,000 --> 00:06:32,000
que llegaré al main, digamos,

103
00:06:32,000 --> 00:06:33,000
al que ha lanzado,

104
00:06:33,000 --> 00:06:37,000
y a ese punto no he manejado la excepción.

105
00:06:37,000 --> 00:06:41,000
Si no he manejado la excepción, ¿qué pasa?

106
00:06:41,000 --> 00:06:43,000
Pasa lo que ha pasado hasta ahora

107
00:06:43,000 --> 00:06:44,000
cuando salía una excepción.

108
00:06:44,000 --> 00:06:45,000
¿Qué os ha pasado ahora?

109
00:06:45,000 --> 00:06:51,000
Hasta hoy no hemos gestionado ninguna excepción

110
00:06:51,000 --> 00:06:53,000
y si yo llego arriba, arriba, arriba, arriba

111
00:06:53,000 --> 00:06:55,000
y nadie ha hecho un try catch,

112
00:06:55,000 --> 00:06:57,000
nadie ha hecho algo para manejarla,

113
00:06:57,000 --> 00:07:00,000
pues simplemente bloqueo la ejecución del programa

114
00:07:00,000 --> 00:07:02,000
y te escribo un pantallazo de

115
00:07:02,000 --> 00:07:04,000
hoy mira, ha pasado esto.

116
00:07:04,000 --> 00:07:05,000
Y se acabó.

117
00:07:05,000 --> 00:07:09,000
No has gestionado el error.

118
00:07:09,000 --> 00:07:12,000
¿Sí?

119
00:07:12,000 --> 00:07:13,000
El proceso continúa hasta llegar

120
00:07:13,000 --> 00:07:14,000
al método main de la aplicación.

121
00:07:14,000 --> 00:07:17,000
Si ahí tampoco existe una causa catch adecuada,

122
00:07:17,000 --> 00:07:20,000
la máquina Java virtual finaliza su ejecución

123
00:07:20,000 --> 00:07:22,000
y da un mensaje error.

124
00:07:22,000 --> 00:07:27,000
¿Dudas?

125
00:07:27,000 --> 00:07:31,000
También está otra cosa que es el throws, ¿vale?

126
00:07:31,000 --> 00:07:33,000
Con la S.

127
00:07:33,000 --> 00:07:35,000
Este de aquí es algo que se pone

128
00:07:35,000 --> 00:07:38,000
no dentro del cuerpo de un método

129
00:07:38,000 --> 00:07:40,000
sino en el prototipo del método,

130
00:07:40,000 --> 00:07:42,000
en la declaración del método,

131
00:07:42,000 --> 00:07:43,000
como es aquí, ¿vale?

132
00:07:43,000 --> 00:07:46,000
Por ejemplo, public void método F

133
00:07:46,000 --> 00:07:47,000
que no pilla parámetros,

134
00:07:47,000 --> 00:07:50,000
throws, una excepción.

135
00:07:50,000 --> 00:07:52,000
Esto quiere decir que estás declarando

136
00:07:52,000 --> 00:07:55,000
que el método F,

137
00:07:55,000 --> 00:07:57,000
dentro de su ejecución,

138
00:07:57,000 --> 00:08:00,000
puede en un determinado momento

139
00:08:00,000 --> 00:08:05,000
lanzar una excepción de tipo E.

140
00:08:05,000 --> 00:08:07,000
Tú estás diciendo sustancialmente

141
00:08:07,000 --> 00:08:09,000
a quién te va a utilizar,

142
00:08:09,000 --> 00:08:11,000
a quién va a utilizar F,

143
00:08:11,000 --> 00:08:14,000
cuidado que cuando usas F

144
00:08:14,000 --> 00:08:17,000
el resultado podría ser que explote

145
00:08:17,000 --> 00:08:19,000
porque F hace determinadas operaciones

146
00:08:19,000 --> 00:08:21,000
como por ejemplo hacerse un array

147
00:08:21,000 --> 00:08:23,000
y haga un determinado momento

148
00:08:23,000 --> 00:08:24,000
que si hace de malo el array

149
00:08:24,000 --> 00:08:30,000
pues te lanzaría un índice autobando derecho.

150
00:08:30,000 --> 00:08:33,000
De esta forma, yo desde fuera

151
00:08:33,000 --> 00:08:35,000
que voy a utilizar F,

152
00:08:35,000 --> 00:08:40,000
quiero meterlo dentro del try-catch

153
00:08:40,000 --> 00:08:43,000
que pille ese tipo de excepción.

154
00:08:43,000 --> 00:08:46,000
En vez de E puede ser índice autobando derecho.

155
00:08:46,000 --> 00:08:50,000
E sería una excepción genérica de la clase E.

156
00:08:50,000 --> 00:08:52,000
Si en el código método F

157
00:08:52,000 --> 00:08:54,000
se lanza una excepción de la clase E,

158
00:08:54,000 --> 00:08:56,000
sea cual sea porque la has creado tú,

159
00:08:56,000 --> 00:08:58,000
es una clase tuya o una de que ya existe,

160
00:08:58,000 --> 00:09:00,000
pues entonces en el prototipo

161
00:09:00,000 --> 00:09:03,000
deberías poner throws E.

162
00:09:03,000 --> 00:09:06,000
Es un modo para decir

163
00:09:06,000 --> 00:09:08,000
mira, aquí hay un problema

164
00:09:08,000 --> 00:09:10,000
pero no lo voy a gestionar yo,

165
00:09:10,000 --> 00:09:12,000
lo voy a pasar por arriba.

166
00:09:12,000 --> 00:09:14,000
Quien me llama tiene que estar consciente

167
00:09:14,000 --> 00:09:16,000
que aquí puede haber un error

168
00:09:16,000 --> 00:09:19,000
y entonces lo tiene que manejar él.

169
00:09:19,000 --> 00:09:22,000
Y yo no te voy a manejar directamente

170
00:09:22,000 --> 00:09:24,000
porque yo no siempre,

171
00:09:24,000 --> 00:09:26,000
desde mi perspectiva optimista quizás,

172
00:09:26,000 --> 00:09:28,000
yo voy a hacer las cosas con E

173
00:09:28,000 --> 00:09:31,000
pero si explotara, explotará con esta excepción

174
00:09:31,000 --> 00:09:33,000
y entonces se va a avanzar.

175
00:09:33,000 --> 00:09:35,000
Esto pasa por ejemplo en cosas como

176
00:09:35,000 --> 00:09:37,000
el acceso a ficheros.

177
00:09:37,000 --> 00:09:38,000
Si tú accesas a ficheros,

178
00:09:38,000 --> 00:09:40,000
podría ser que el fichero no exista

179
00:09:40,000 --> 00:09:43,000
y que tú intentes leer un fichero que no existe.

180
00:09:43,000 --> 00:09:45,000
Entonces algunos métodos

181
00:09:45,000 --> 00:09:46,000
para creación de ficheros,

182
00:09:46,000 --> 00:09:48,000
para buscar ficheros y cosas por el estilo

183
00:09:48,000 --> 00:09:52,000
lanzan errores de tipo IOException,

184
00:09:52,000 --> 00:09:54,000
Input Output Exception.

185
00:09:54,000 --> 00:09:55,000
Y tú dices,

186
00:09:55,000 --> 00:09:58,000
tiene quien va a crear el fichero,

187
00:09:58,000 --> 00:10:00,000
manejar el fichero,

188
00:10:00,000 --> 00:10:01,000
que tener en cuenta

189
00:10:01,000 --> 00:10:02,000
que podría en algún momento

190
00:10:02,000 --> 00:10:04,000
haber una IOException

191
00:10:04,000 --> 00:10:06,000
y que entonces tendrá que manejar

192
00:10:06,000 --> 00:10:08,000
y ver qué pasa cuando va a saltar

193
00:10:08,000 --> 00:10:10,000
una de estas excepciones.

194
00:10:11,000 --> 00:10:14,000
Esto sirve para que potenciales usuarios de EFE

195
00:10:14,000 --> 00:10:16,000
sepan a qué atenerse.

196
00:10:16,000 --> 00:10:18,000
Yo sé que si voy a utilizar EFE

197
00:10:18,000 --> 00:10:19,000
me puede pasar esto,

198
00:10:19,000 --> 00:10:21,000
por lo tanto, lo voy a manejar.

199
00:10:21,000 --> 00:10:23,000
Si un método lanza más de un tipo de excepciones

200
00:10:23,000 --> 00:10:24,000
se indican detrás de throws

201
00:10:24,000 --> 00:10:26,000
separadas por comas.

202
00:10:26,000 --> 00:10:27,000
Por ejemplo, público EFE,

203
00:10:27,000 --> 00:10:30,000
throws E1, E2, E3.

204
00:10:30,000 --> 00:10:32,000
Esto E1, E2, E3 no son objetos,

205
00:10:32,000 --> 00:10:34,000
son clases.

206
00:10:34,000 --> 00:10:36,000
Son excepciones.

207
00:10:41,000 --> 00:10:44,000
Siempre lanza las excepciones.

208
00:10:44,000 --> 00:10:46,000
¿Cuándo en un código utilizamos

209
00:10:46,000 --> 00:10:49,000
métodos que lanzan potencialmente excepciones?

210
00:10:49,000 --> 00:10:51,000
Siempre todavía tengo throws.

211
00:10:51,000 --> 00:10:52,000
Estamos obligados a hacer

212
00:10:52,000 --> 00:10:54,000
una de estas dos cosas.

213
00:10:54,000 --> 00:10:56,000
Vamos a ver si yo tengo un código

214
00:10:56,000 --> 00:10:58,000
y en este código estoy utilizando

215
00:10:58,000 --> 00:11:01,000
un método que tiene declarado un throws.

216
00:11:01,000 --> 00:11:03,000
Puede hacer dos cosas.

217
00:11:03,000 --> 00:11:05,000
O proteger esta llamada del método

218
00:11:05,000 --> 00:11:07,000
con un try catch.

219
00:11:07,000 --> 00:11:09,000
Proteger esta llamada del método

220
00:11:09,000 --> 00:11:11,000
con un try catch, fenomenal.

221
00:11:11,000 --> 00:11:15,000
O decir que yo también lanzo esa excepción.

222
00:11:15,000 --> 00:11:17,000
¿Arriba?

223
00:11:17,000 --> 00:11:21,000
Yo soy un método que lanza la excepción.

224
00:11:21,000 --> 00:11:23,000
Tengo otro método que usa ese método

225
00:11:23,000 --> 00:11:25,000
que lanza la excepción.

226
00:11:25,000 --> 00:11:27,000
Tiene dos opciones.

227
00:11:27,000 --> 00:11:29,000
O manejo la excepción,

228
00:11:29,000 --> 00:11:31,000
o la lanzo para ti.

229
00:11:31,000 --> 00:11:33,000
Y será quien me ha llamado a mí

230
00:11:34,000 --> 00:11:36,000
a hacer algo.

231
00:11:36,000 --> 00:11:38,000
Depende un poco de cómo queréis

232
00:11:38,000 --> 00:11:43,000
estructurar vuestro programa.

233
00:11:43,000 --> 00:11:45,000
Esto delega la responsabilidad

234
00:11:45,000 --> 00:11:47,000
de manejo a otras clases invocantes.

235
00:11:47,000 --> 00:11:49,000
Y de ahí viene el sentido

236
00:11:49,000 --> 00:11:51,000
del print stack trace.

237
00:11:51,000 --> 00:11:53,000
El print stack trace que me permite saber

238
00:11:53,000 --> 00:11:55,000
todas las llamadas de

239
00:11:55,000 --> 00:11:59,000
quién me ha llamado a mí, etc.

240
00:11:59,000 --> 00:12:01,000
Para saber más o menos

241
00:12:01,000 --> 00:12:03,000
dónde es que ha explotado

242
00:12:03,000 --> 00:12:05,000
y quién estaba llamando

243
00:12:05,000 --> 00:12:07,000
para saber quién se debería haber

244
00:12:07,000 --> 00:12:09,000
encargado de eso.

245
00:12:09,000 --> 00:12:11,000
Y ver un poco.

246
00:12:11,000 --> 00:12:13,000
Si la excepción lanzada es hija

247
00:12:13,000 --> 00:12:15,000
de runtime exception,

248
00:12:15,000 --> 00:12:17,000
no es necesario manejarla.

249
00:12:17,000 --> 00:12:19,000
Esto es interesante.

250
00:12:21,000 --> 00:12:23,000
Tenerlo por ahora allí.

251
00:12:23,000 --> 00:12:25,000
Hago esta transparencia aquí

252
00:12:25,000 --> 00:12:27,000
y luego os lo digo.

253
00:12:27,000 --> 00:12:29,000
Pero hay excepciones especiales

254
00:12:29,000 --> 00:12:31,000
si lo que se está lanzando

255
00:12:31,000 --> 00:12:33,000
es una runtime excepción

256
00:12:33,000 --> 00:12:35,000
o hijos de la runtime excepción,

257
00:12:35,000 --> 00:12:37,000
no estoy obligado

258
00:12:37,000 --> 00:12:39,000
a ni hacer la trace

259
00:12:39,000 --> 00:12:41,000
ni hacer el breakage.

260
00:12:45,000 --> 00:12:47,000
Vosotros habéis

261
00:12:49,000 --> 00:12:51,000
utilizado

262
00:12:51,000 --> 00:12:53,000
arrays.

263
00:12:55,000 --> 00:12:57,000
¿Os ha salido alguna vez

264
00:12:57,000 --> 00:12:59,000
una excepción?

265
00:12:59,000 --> 00:13:01,000
¿No habéis puesto nunca un breakage?

266
00:13:03,000 --> 00:13:05,000
Acceder por allí

267
00:13:05,000 --> 00:13:07,000
puede causar una excepción

268
00:13:07,000 --> 00:13:09,000
pero nadie os ha obligado

269
00:13:09,000 --> 00:13:11,000
a usar un breakage para pillar.

270
00:13:11,000 --> 00:13:13,000
¿Os habéis hecho divisiones?

271
00:13:15,000 --> 00:13:17,000
X dividido A

272
00:13:17,000 --> 00:13:19,000
siendo una variable.

273
00:13:19,000 --> 00:13:21,000
¿Y si esa A era cero, no debería haber explotado?

274
00:13:21,000 --> 00:13:23,000
¿No habéis protegido

275
00:13:23,000 --> 00:13:25,000
ese código con breakage?

276
00:13:25,000 --> 00:13:27,000
Nos ha dado un error de

277
00:13:27,000 --> 00:13:29,000
oye mira, aquí habría debido

278
00:13:29,000 --> 00:13:31,000
proteger este código.

279
00:13:31,000 --> 00:13:33,000
Porque estas excepciones

280
00:13:33,000 --> 00:13:35,000
tanto divide by zero

281
00:13:35,000 --> 00:13:37,000
como reindex out of bound

282
00:13:37,000 --> 00:13:39,000
son hijas

283
00:13:39,000 --> 00:13:41,000
de runtime excepción.

284
00:13:41,000 --> 00:13:43,000
Entonces nos obliga

285
00:13:43,000 --> 00:13:45,000
a manejarlas.

286
00:13:45,000 --> 00:13:47,000
Hay otras como por ejemplo

287
00:13:47,000 --> 00:13:49,000
la IOException

288
00:13:49,000 --> 00:13:51,000
que si vuestro programa, si vuestro método

289
00:13:51,000 --> 00:13:53,000
lanza una IOException

290
00:13:53,000 --> 00:13:55,000
os da un error a tiempo de compilación

291
00:13:55,000 --> 00:13:57,000
si no la habéis puesto

292
00:13:57,000 --> 00:13:59,000
en un breakage.

293
00:14:19,000 --> 00:14:21,000
Dependiendo del tipo de excepciones que hay

294
00:14:21,000 --> 00:14:23,000
hay excepciones que las tienes que manejar

295
00:14:23,000 --> 00:14:25,000
si o si.

296
00:14:37,000 --> 00:14:39,000
Todas las excepciones

297
00:14:39,000 --> 00:14:41,000
como son hijas de,

298
00:14:41,000 --> 00:14:43,000
hijas de, etc.

299
00:14:43,000 --> 00:14:45,000
crean una jerarquía.

300
00:14:45,000 --> 00:14:47,000
Entonces la clase por arriba

301
00:14:47,000 --> 00:14:49,000
de todas las excepciones

302
00:14:49,000 --> 00:14:51,000
es la clase throwable.

303
00:14:51,000 --> 00:14:53,000
Se llama throwable y parece una

304
00:14:53,000 --> 00:14:55,000
interfaz, pero no es una

305
00:14:55,000 --> 00:14:57,000
interfaz, es una clase.

306
00:14:57,000 --> 00:14:59,000
Sustancialmente cualquier

307
00:14:59,000 --> 00:15:01,000
error que pueda surgir

308
00:15:01,000 --> 00:15:03,000
y que se pueda lanzar ese error

309
00:15:03,000 --> 00:15:05,000
es de la clase throwable.

310
00:15:05,000 --> 00:15:07,000
Y luego hay dos posibles

311
00:15:07,000 --> 00:15:09,000
tipologías de errores

312
00:15:09,000 --> 00:15:11,000
en general.

313
00:15:11,000 --> 00:15:13,000
Lo que son error,

314
00:15:13,000 --> 00:15:15,000
la clase error y todos los que derivan

315
00:15:15,000 --> 00:15:17,000
de error, que son errores

316
00:15:17,000 --> 00:15:19,000
graves.

317
00:15:19,000 --> 00:15:21,000
Errores que si explotan

318
00:15:21,000 --> 00:15:23,000
es un problema realmente

319
00:15:23,000 --> 00:15:25,000
serio para mi programa porque

320
00:15:25,000 --> 00:15:27,000
tampoco tengo mucho

321
00:15:29,000 --> 00:15:31,000
control sobre eso.

322
00:15:31,000 --> 00:15:33,000
Son errores que

323
00:15:33,000 --> 00:15:35,000
no derivan

324
00:15:35,000 --> 00:15:37,000
casi siempre de mi código.

325
00:15:37,000 --> 00:15:39,000
Son errores

326
00:15:39,000 --> 00:15:41,000
que van más allá del código

327
00:15:41,000 --> 00:15:43,000
que estoy escribiendo yo, como por ejemplo

328
00:15:43,000 --> 00:15:45,000
virtual machine error.

329
00:15:45,000 --> 00:15:47,000
Si la máquina virtual machine

330
00:15:47,000 --> 00:15:49,000
hace un error, yo no he

331
00:15:49,000 --> 00:15:51,000
implementado la virtual machine.

332
00:15:51,000 --> 00:15:53,000
Yo la he bajado e instalado.

333
00:15:53,000 --> 00:15:55,000
Y como es software eso también,

334
00:15:55,000 --> 00:15:57,000
podrá tener errores.

335
00:15:57,000 --> 00:15:59,000
Si explota la virtual machine,

336
00:15:59,000 --> 00:16:01,000
¿qué hago?

337
00:16:01,000 --> 00:16:03,000
O hacerse un error que no me acuerdo que es.

338
00:16:03,000 --> 00:16:05,000
Pero son errores

339
00:16:05,000 --> 00:16:07,000
serios, errores a nivel

340
00:16:07,000 --> 00:16:09,000
de infraestructura que estoy

341
00:16:09,000 --> 00:16:11,000
utilizando yo.

342
00:16:11,000 --> 00:16:13,000
Si tengo mi infraestructura que me permite

343
00:16:13,000 --> 00:16:15,000
trabajar con Java, mi programa está por encima de esta infraestructura.

344
00:16:15,000 --> 00:16:17,000
Si hay un problema a nivel

345
00:16:17,000 --> 00:16:19,000
de infraestructura que me permite

346
00:16:19,000 --> 00:16:21,000
trabajar con Java, pues ese es un error.

347
00:16:25,000 --> 00:16:27,000
Y luego están las excepciones, que son siempre hijas

348
00:16:27,000 --> 00:16:29,000
de throwable, pero sí que son

349
00:16:29,000 --> 00:16:31,000
las mías que puedo manejar.

350
00:16:33,000 --> 00:16:35,000
Estas de aquí, los errores,

351
00:16:35,000 --> 00:16:37,000
no deben ser manejados

352
00:16:37,000 --> 00:16:39,000
y normalmente no pasan, y espero que no pasen.

353
00:16:39,000 --> 00:16:41,000
Si pasan, pues tendré

354
00:16:41,000 --> 00:16:43,000
que ir a mirar

355
00:16:43,000 --> 00:16:45,000
la instalación del JBK

356
00:16:45,000 --> 00:16:47,000
y cosas por estilo de por qué ha pasado eso.

357
00:16:47,000 --> 00:16:49,000
Sin embargo, las excepciones son

358
00:16:49,000 --> 00:16:51,000
cosas que yo sí puedo gestionar dentro

359
00:16:51,000 --> 00:16:53,000
de mis

360
00:16:53,000 --> 00:16:55,000
programas y que tengo

361
00:16:55,000 --> 00:16:57,000
muchas veces que manejar.

362
00:16:57,000 --> 00:16:59,000
Dentro de las excepciones, que son manejables

363
00:16:59,000 --> 00:17:01,000
o me puedo recuperar de ellos

364
00:17:01,000 --> 00:17:03,000
sin problema,

365
00:17:03,000 --> 00:17:05,000
pero haciendo algo,

366
00:17:05,000 --> 00:17:07,000
es parte de mi programación, es parte de mi algoritmo

367
00:17:07,000 --> 00:17:09,000
recuperarme de estos errores, de este tipo de errores,

368
00:17:09,000 --> 00:17:11,000
pues hay la Runtime Exception

369
00:17:11,000 --> 00:17:13,000
y las otras.

370
00:17:13,000 --> 00:17:15,000
La Runtime Exception

371
00:17:15,000 --> 00:17:17,000
son las que hemos visto ahora, que son

372
00:17:17,000 --> 00:17:19,000
errores que son tan habituales

373
00:17:19,000 --> 00:17:21,000
que pueden pasar

374
00:17:21,000 --> 00:17:23,000
tan a menudo, es normal

375
00:17:23,000 --> 00:17:25,000
que puedan pasar,

376
00:17:25,000 --> 00:17:27,000
que no tiene sentido

377
00:17:27,000 --> 00:17:29,000
manejarlas y vigilarlas constantemente,

378
00:17:29,000 --> 00:17:31,000
porque sobrecargarían

379
00:17:31,000 --> 00:17:33,000
muchísimo el código.

380
00:17:33,000 --> 00:17:35,000
Imaginaos que cada división que hacéis

381
00:17:35,000 --> 00:17:37,000
tenéis que ponerle hoy, pero cuidado que

382
00:17:37,000 --> 00:17:39,000
no se pueda explotar,

383
00:17:39,000 --> 00:17:41,000
pues

384
00:17:41,000 --> 00:17:43,000
haría todo mucho más

385
00:17:43,000 --> 00:17:45,000
engordoso, ¿vale?

386
00:17:45,000 --> 00:17:47,000
Y por lo tanto, no se requiere que se haga,

387
00:17:47,000 --> 00:17:49,000
se puede hacer,

388
00:17:49,000 --> 00:17:51,000
pero no se requiere.

389
00:17:51,000 --> 00:17:53,000
Y ejemplos de eso son como Arithmetic Exception,

390
00:17:53,000 --> 00:17:55,000
Index Outbound Exception,

391
00:17:55,000 --> 00:17:57,000
Null Pointer Exception, también cuando vosotros

392
00:17:57,000 --> 00:17:59,000
habéis utilizado objetos

393
00:17:59,000 --> 00:18:01,000
y lo habéis puesto a NULL y lo habéis

394
00:18:01,000 --> 00:18:03,000
utilizado, allí no habéis hecho otra excepción,

395
00:18:03,000 --> 00:18:05,000
esta otra excepción no la hemos usado nunca.

396
00:18:05,000 --> 00:18:07,000
Y aún así, la excepción puede saltar.

397
00:18:07,000 --> 00:18:09,000
Pero como Null Pointer Exception

398
00:18:09,000 --> 00:18:11,000
es hija de Runtime Exception,

399
00:18:11,000 --> 00:18:13,000
pues no se requiere.

400
00:18:13,000 --> 00:18:15,000
¿Vale?

401
00:18:15,000 --> 00:18:17,000
Sin embargo, todas las demás,

402
00:18:17,000 --> 00:18:19,000
las que no son hijas de Runtime Exception,

403
00:18:19,000 --> 00:18:21,000
sí, ¿vale?

404
00:18:21,000 --> 00:18:23,000
En el sentido que cuando yo hago

405
00:18:23,000 --> 00:18:25,000
un método que puede lanzar

406
00:18:25,000 --> 00:18:27,000
una excepción

407
00:18:27,000 --> 00:18:29,000
que no sea Runtime Exception,

408
00:18:29,000 --> 00:18:31,000
pues sí que tengo que utilizar

409
00:18:31,000 --> 00:18:33,000
un Trag-Etch o Throws.

410
00:18:35,000 --> 00:18:37,000
¿Vale?

411
00:18:37,000 --> 00:18:39,000
Como por ejemplo,

412
00:18:39,000 --> 00:18:41,000
Certificate Exception,

413
00:18:41,000 --> 00:18:43,000
Clone No Support Exception,

414
00:18:43,000 --> 00:18:45,000
y esto es un dibujito

415
00:18:45,000 --> 00:18:47,000
de la jerarquía, ¿vale?

416
00:18:47,000 --> 00:18:49,000
Tenemos los Throwable, que claramente

417
00:18:49,000 --> 00:18:51,000
son una clase, por lo tanto, de Object.

418
00:18:51,000 --> 00:18:53,000
Dentro de Throwable

419
00:18:53,000 --> 00:18:55,000
hay Error o Exception,

420
00:18:55,000 --> 00:18:57,000
los Error son Virtual Machine Error,

421
00:18:57,000 --> 00:18:59,000
No Class Default Error,

422
00:18:59,000 --> 00:19:01,000
Assertion Error,

423
00:19:01,000 --> 00:19:03,000
Stack Overflow Error,

424
00:19:03,000 --> 00:19:05,000
Stack Overflow Send Back.

425
00:19:05,000 --> 00:19:07,000
¿Vale?

426
00:19:07,000 --> 00:19:09,000
Stack Overflow, por ejemplo,

427
00:19:09,000 --> 00:19:11,000
es cuando yo llamo un método

428
00:19:11,000 --> 00:19:13,000
que llamo otro método,

429
00:19:13,000 --> 00:19:15,000
que llamo otro método,

430
00:19:15,000 --> 00:19:17,000
imaginaos que hacéis un while

431
00:19:17,000 --> 00:19:19,000
donde yo llamo

432
00:19:19,000 --> 00:19:21,000
al mismo método que hace este while.

433
00:19:21,000 --> 00:19:23,000
Entonces lo llamo otra vez,

434
00:19:23,000 --> 00:19:25,000
lo llamo otra vez,

435
00:19:25,000 --> 00:19:27,000
y llega un momento que ha hecho

436
00:19:27,000 --> 00:19:29,000
infinitas llamadas.

437
00:19:29,000 --> 00:19:31,000
Cada llamada se mete en una stack,

438
00:19:31,000 --> 00:19:33,000
este llama a este, que llama a este,

439
00:19:33,000 --> 00:19:35,000
y llega un momento que mi memoria

440
00:19:35,000 --> 00:19:37,000
no me permite llamar más.

441
00:19:37,000 --> 00:19:39,000
O sea, allí, Stack Overflow.

442
00:19:39,000 --> 00:19:41,000
¿Vale?

443
00:19:41,000 --> 00:19:43,000
Y estas son cosas

444
00:19:43,000 --> 00:19:45,000
de errores.

445
00:19:45,000 --> 00:19:47,000
Hace poco nada. ¿Vale?

446
00:19:47,000 --> 00:19:49,000
Sin embargo, están las excepciones,

447
00:19:49,000 --> 00:19:51,000
y aquí hay un montón de Class Not Found

448
00:19:51,000 --> 00:19:53,000
Exception, Illegal Access,

449
00:19:53,000 --> 00:19:55,000
Interrupted.

450
00:19:55,000 --> 00:19:57,000
¿Vale? Interrupted, por ejemplo,

451
00:19:57,000 --> 00:19:59,000
es cuando

452
00:19:59,000 --> 00:20:01,000
tú puedes desde

453
00:20:01,000 --> 00:20:03,000
un hilo de ejecución

454
00:20:03,000 --> 00:20:05,000
interrumpir otro hilo de ejecución

455
00:20:05,000 --> 00:20:07,000
y que él diga, mira, yo estaba

456
00:20:07,000 --> 00:20:09,000
haciendo cosas y ahora sé que alguien

457
00:20:09,000 --> 00:20:11,000
me ha mandado una señal.

458
00:20:11,000 --> 00:20:13,000
¿Vale? Cuando se manda esta señal,

459
00:20:13,000 --> 00:20:15,000
se lanza una Interrupted Exception que se puede

460
00:20:15,000 --> 00:20:17,000
recoger y por lo tanto hacer algo.

461
00:20:17,000 --> 00:20:19,000
¿Vale?

462
00:20:21,000 --> 00:20:23,000
Aquí están las IO Exception,

463
00:20:23,000 --> 00:20:25,000
por ejemplo, que tienen otras

464
00:20:25,000 --> 00:20:27,000
cosas por aquí también, y todas

465
00:20:27,000 --> 00:20:29,000
estas

466
00:20:29,000 --> 00:20:31,000
sí que tengo que manejarlas.

467
00:20:31,000 --> 00:20:33,000
¿Vale? Sin embargo,

468
00:20:33,000 --> 00:20:35,000
hay otra rama que es la

469
00:20:35,000 --> 00:20:37,000
Runtime Exception, y estas de aquí

470
00:20:37,000 --> 00:20:39,000
no requieren un manejo

471
00:20:39,000 --> 00:20:41,000
explícito. Las puedo recoger,

472
00:20:41,000 --> 00:20:43,000
pero no es requerido.

473
00:20:43,000 --> 00:20:45,000
¿Vale? Y aquí están todas las cosas

474
00:20:45,000 --> 00:20:47,000
muy, muy comunes, como esto de

475
00:20:47,000 --> 00:20:49,000
Index Outbound,

476
00:20:49,000 --> 00:20:51,000
como...

477
00:20:51,000 --> 00:20:53,000
otras que podamos haber visto,

478
00:20:53,000 --> 00:20:55,000
Null Pointer Exception,

479
00:20:57,000 --> 00:20:59,000
Negative Array Size

480
00:20:59,000 --> 00:21:01,000
Exception.

481
00:21:05,000 --> 00:21:07,000
Ese es el Number Format Exception

482
00:21:07,000 --> 00:21:09,000
que está aquí.

483
00:21:15,000 --> 00:21:17,000
Sí,

484
00:21:17,000 --> 00:21:19,000
entonces esto lo echáis un vistazo.

485
00:21:19,000 --> 00:21:21,000
Aún así, Eclipse los ha hecho a la mano.

486
00:21:21,000 --> 00:21:23,000
Si vosotros usáis un método

487
00:21:23,000 --> 00:21:25,000
que

488
00:21:25,000 --> 00:21:27,000
nos muestra una excepción que requiere

489
00:21:27,000 --> 00:21:29,000
ser manejada, os la marca.

490
00:21:29,000 --> 00:21:31,000
Os dice, oye, mira, aquí tiene que poner

491
00:21:31,000 --> 00:21:33,000
un Try Catch. Es más, botón derecho, añade

492
00:21:33,000 --> 00:21:35,000
el Try Catch, y te lo añade él.

493
00:21:35,000 --> 00:21:37,000
¿Sí? Por ahora yo creo que

494
00:21:37,000 --> 00:21:39,000
no hemos visto cosas así, porque no hemos visto

495
00:21:39,000 --> 00:21:41,000
las excepciones. Ahora algunos métodos

496
00:21:41,000 --> 00:21:43,000
que veremos, pues, sí que lo

497
00:21:43,000 --> 00:21:45,000
necesitarán. ¿Vale?

498
00:21:47,000 --> 00:21:49,000
En todo esto, ¿vale?, hay

499
00:21:49,000 --> 00:21:51,000
una marea, como hemos visto ahora,

500
00:21:51,000 --> 00:21:53,000
de

501
00:21:53,000 --> 00:21:55,000
excepciones que ya

502
00:21:55,000 --> 00:21:57,000
se pueden, que existen,

503
00:21:57,000 --> 00:21:59,000
y que la Java Extra Machine, el API, me

504
00:21:59,000 --> 00:22:01,000
proporciona para que yo la pueda utilizar,

505
00:22:01,000 --> 00:22:03,000
y eso no quita que yo me pueda crear

506
00:22:03,000 --> 00:22:05,000
mis propias excepciones.

507
00:22:05,000 --> 00:22:07,000
¿Vale? Que se basarán sobre

508
00:22:07,000 --> 00:22:09,000
mi sistema concreto.

509
00:22:09,000 --> 00:22:11,000
Errores que

510
00:22:11,000 --> 00:22:13,000
no usan

511
00:22:13,000 --> 00:22:15,000
mecanismos generales

512
00:22:15,000 --> 00:22:17,000
de Java, como por ejemplo

513
00:22:17,000 --> 00:22:19,000
los Arrays, sino que es un error

514
00:22:19,000 --> 00:22:21,000
propio del programa que estoy creando yo.

515
00:22:21,000 --> 00:22:23,000
¿Vale? Claramente los programitas

516
00:22:23,000 --> 00:22:25,000
que hacemos nosotros, esto tiene muy poco

517
00:22:25,000 --> 00:22:27,000
sentido. ¿Vale? Esto

518
00:22:27,000 --> 00:22:29,000
empieza a crear un error propio

519
00:22:29,000 --> 00:22:31,000
de un sistema, es cuando el sistema

520
00:22:31,000 --> 00:22:33,000
empieza a ser ya suficientemente complejo.

521
00:22:33,000 --> 00:22:35,000
Un programita de

522
00:22:35,000 --> 00:22:37,000
calcúlame los primeros 20

523
00:22:37,000 --> 00:22:39,000
números de Fibonacci,

524
00:22:39,000 --> 00:22:41,000
pues, no es que tienes

525
00:22:41,000 --> 00:22:43,000
Fibonacci exception.

526
00:22:43,000 --> 00:22:45,000
Lo puedes inventar

527
00:22:45,000 --> 00:22:47,000
a la hora de practicar con eso,

528
00:22:47,000 --> 00:22:49,000
como haremos nosotros, pero claramente esto ya

529
00:22:49,000 --> 00:22:51,000
sería un sistema un poco más avanzado.

530
00:22:51,000 --> 00:22:53,000
Creas tus propias excepciones,

531
00:22:53,000 --> 00:22:55,000
pues, esto. ¿Vale?

532
00:22:55,000 --> 00:22:57,000
¿Y cómo la creo?

533
00:22:57,000 --> 00:22:59,000
Pues, puedo

534
00:22:59,000 --> 00:23:01,000
crear haciendo, heredando

535
00:23:01,000 --> 00:23:03,000
de Trovavol o alguna

536
00:23:03,000 --> 00:23:05,000
de sus hijos

537
00:23:05,000 --> 00:23:07,000
o hijas de Trovavol.

538
00:23:07,000 --> 00:23:09,000
¿Vale? En particular,

539
00:23:09,000 --> 00:23:11,000
desde Exception. ¿Sí?

540
00:23:11,000 --> 00:23:13,000
Entonces cuando yo creo mi excepción,

541
00:23:13,000 --> 00:23:15,000
creo una public class a mi excepción

542
00:23:15,000 --> 00:23:17,000
que está en Exception, y allí ya tengo

543
00:23:17,000 --> 00:23:19,000
todo lo que tiene Exception

544
00:23:19,000 --> 00:23:21,000
más lo que yo quiero.

545
00:23:21,000 --> 00:23:23,000
Pero lo que se suele hacer es

546
00:23:23,000 --> 00:23:25,000
crear un constructor de este estilo

547
00:23:25,000 --> 00:23:27,000
¿Vale? Para que utilice

548
00:23:27,000 --> 00:23:29,000
el mensaje

549
00:23:29,000 --> 00:23:31,000
que tienen todas las Exception.

550
00:23:31,000 --> 00:23:33,000
¿Sí? Entonces luego puedo

551
00:23:33,000 --> 00:23:35,000
utilizar el toString, el

552
00:23:35,000 --> 00:23:37,000
getMessage

553
00:23:37,000 --> 00:23:39,000
que hemos visto antes de Exception, porque

554
00:23:39,000 --> 00:23:41,000
como la extendo, y si no

555
00:23:41,000 --> 00:23:43,000
creo un constructor como este,

556
00:23:43,000 --> 00:23:45,000
pues, el message

557
00:23:45,000 --> 00:23:47,000
de error se queda vacío

558
00:23:47,000 --> 00:23:49,000
y por lo tanto cuando luego explota

559
00:23:49,000 --> 00:23:51,000
pues no me da un mensaje.

560
00:23:51,000 --> 00:23:53,000
¿Sí?

561
00:23:53,000 --> 00:23:55,000
Y de esta forma puedo crear objetos de esta clase

562
00:23:55,000 --> 00:23:57,000
con un mensaje personalizado.

563
00:23:57,000 --> 00:23:59,000
¿Sí? Que sea asociado al

564
00:23:59,000 --> 00:24:01,000
getMessage.

565
00:24:01,000 --> 00:24:03,000
La idea es que luego yo me cree

566
00:24:03,000 --> 00:24:05,000
new miException

567
00:24:05,000 --> 00:24:07,000
y entre paréntesis le pondré

568
00:24:07,000 --> 00:24:09,000
comillas

569
00:24:09,000 --> 00:24:11,000
el error que ha pasado desde aquí.

570
00:24:11,000 --> 00:24:13,000
Dos puntos. No me gustan el número 3.

571
00:24:13,000 --> 00:24:15,000
Haciendo referencia

572
00:24:15,000 --> 00:24:17,000
a la StefanoException

573
00:24:17,000 --> 00:24:19,000
de antes. ¿Vale?

574
00:24:19,000 --> 00:24:21,000
¡Ejemplo!

575
00:24:21,000 --> 00:24:23,000
Por lo tanto, yo me creo

576
00:24:23,000 --> 00:24:25,000
public divideByZeroException

577
00:24:25,000 --> 00:24:27,000
¿Vale?

578
00:24:27,000 --> 00:24:29,000
Que extende ArithmeticException

579
00:24:29,000 --> 00:24:31,000
Me creo una nueva excepción

580
00:24:31,000 --> 00:24:33,000
que extende

581
00:24:33,000 --> 00:24:35,000
una excepción aritmética

582
00:24:35,000 --> 00:24:37,000
que es dividir por cero.

583
00:24:37,000 --> 00:24:39,000
¿Vale? Entonces,

584
00:24:39,000 --> 00:24:41,000
aquí tengo un public

585
00:24:41,000 --> 00:24:43,000
divideByZeroException stringMessage

586
00:24:43,000 --> 00:24:45,000
superMessage.

587
00:24:45,000 --> 00:24:47,000
Y ya está. Te hago una nueva

588
00:24:47,000 --> 00:24:49,000
excepción que

589
00:24:49,000 --> 00:24:51,000
tiene solo un constructor que me permite

590
00:24:51,000 --> 00:24:53,000
construir un constructor con un mensaje.

591
00:24:53,000 --> 00:24:55,000
¿Cómo la uso?

592
00:24:55,000 --> 00:24:57,000
¿Cómo lo hago?

593
00:24:57,000 --> 00:24:59,000
¿Cómo lo hago?

594
00:24:59,000 --> 00:25:01,000
¿Cómo lo hago?

595
00:25:01,000 --> 00:25:03,000
No sé si se ve mejor.

596
00:25:03,000 --> 00:25:05,000
¡Ahhh!

597
00:25:05,000 --> 00:25:07,000
¡Ahhh!

598
00:25:07,000 --> 00:25:09,000
Así.

599
00:25:09,000 --> 00:25:11,000
Vale. Deja así.

600
00:25:11,000 --> 00:25:13,000
Entonces, aquí tengo

601
00:25:13,000 --> 00:25:15,000
public doubleDivide. Este es un

602
00:25:15,000 --> 00:25:17,000
método, ¿vale? No sé, en otra clase

603
00:25:17,000 --> 00:25:19,000
voy a utilizar este método

604
00:25:19,000 --> 00:25:21,000
de aquí, que dice, dame

605
00:25:21,000 --> 00:25:23,000
un número, un numerador y un

606
00:25:23,000 --> 00:25:25,000
denominador. Vale, fenomenal.

607
00:25:25,000 --> 00:25:27,000
Y este método de aquí lanza

608
00:25:27,000 --> 00:25:29,000
divideByZeroException.

609
00:25:29,000 --> 00:25:31,000
¿Vale? Entonces, ¿quién va a utilizar

610
00:25:31,000 --> 00:25:33,000
este señor de aquí?

611
00:25:33,000 --> 00:25:35,000
Sabrá, tendrá escrito

612
00:25:35,000 --> 00:25:37,000
por algún lado que este método podría

613
00:25:37,000 --> 00:25:39,000
lanzar esta excepción.

614
00:25:39,000 --> 00:25:41,000
¿Vale? Como esta excepción

615
00:25:41,000 --> 00:25:43,000
deriva, si no me equivoco, de

616
00:25:43,000 --> 00:25:45,000
RuntimeException, pues posiblemente

617
00:25:45,000 --> 00:25:47,000
puedo no manejarla.

618
00:25:47,000 --> 00:25:49,000
¿Sí? Pero sí puedo

619
00:25:49,000 --> 00:25:51,000
manejarla. Este es como un

620
00:25:51,000 --> 00:25:53,000
un aviso.

621
00:25:53,000 --> 00:25:55,000
Oye, esto puede pasar.

622
00:25:55,000 --> 00:25:57,000
Luego tú sabrás que tienes que hacer.

623
00:25:57,000 --> 00:25:59,000
Si es

624
00:25:59,000 --> 00:26:01,000
hija de RuntimeException,

625
00:26:01,000 --> 00:26:03,000
pues entonces puedes o no

626
00:26:03,000 --> 00:26:05,000
manejarla si no fuera

627
00:26:05,000 --> 00:26:07,000
hija de RuntimeException, tienes.

628
00:26:07,000 --> 00:26:09,000
Y te lo dice. ¿Vale?

629
00:26:09,000 --> 00:26:11,000
¿Y cómo funciona? Que si el denominador

630
00:26:11,000 --> 00:26:13,000
que me has dado es cero,

631
00:26:13,000 --> 00:26:15,000
lanza un nuevo

632
00:26:15,000 --> 00:26:17,000
divideByZeroException con escrito error.

633
00:26:17,000 --> 00:26:19,000
Este error podría ser un poquito

634
00:26:19,000 --> 00:26:21,000
más interesante, como decir

635
00:26:21,000 --> 00:26:23,000
has intentado dividir por cero.

636
00:26:23,000 --> 00:26:25,000
¿Sí?

637
00:26:25,000 --> 00:26:27,000
Y si no,

638
00:26:27,000 --> 00:26:29,000
si esto no lo hace,

639
00:26:29,000 --> 00:26:31,000
returna doubleNum

640
00:26:31,000 --> 00:26:33,000
dividido por doubleNum.

641
00:26:33,000 --> 00:26:35,000
¿Sí?

642
00:26:35,000 --> 00:26:37,000
Si no es cero, lo puedes hacer.

643
00:26:37,000 --> 00:26:39,000
Fijaos que aquí es un if, no tiene

644
00:26:39,000 --> 00:26:41,000
las paréntesis, porque si no tiene paréntesis

645
00:26:41,000 --> 00:26:43,000
solo esto entra en el if.

646
00:26:43,000 --> 00:26:45,000
¿Hace falta

647
00:26:45,000 --> 00:26:47,000
hacer el cast de double

648
00:26:47,000 --> 00:26:49,000
en ambos?

649
00:26:49,000 --> 00:26:51,000
¿El número pariado? ¿Solo por curiosidad?

650
00:26:51,000 --> 00:26:53,000
¿O se podría hacer double y entre

651
00:26:53,000 --> 00:26:55,000
paréntesis?

652
00:26:55,000 --> 00:26:57,000
Yo creo que con uno solo es suficiente.

653
00:26:57,000 --> 00:26:59,000
Es que no es más extraño.

654
00:26:59,000 --> 00:27:01,000
Yo creo que esto es más bien por

655
00:27:01,000 --> 00:27:03,000
¿cómo se dice?

656
00:27:03,000 --> 00:27:05,000
Por

657
00:27:05,000 --> 00:27:07,000
complejo y

658
00:27:07,000 --> 00:27:09,000
por formalidad.

659
00:27:09,000 --> 00:27:11,000
Quiero que esta operación sea entre double

660
00:27:11,000 --> 00:27:13,000
para que sea, pero no.

661
00:27:13,000 --> 00:27:15,000
Con que uno sea double ya la operación es entre double.

662
00:27:17,000 --> 00:27:19,000
¿Dudas?

663
00:27:19,000 --> 00:27:21,000
Y estas son las excepciones.