1
00:00:01,520 --> 00:00:06,559
Vale, entonces, si habláis, me autorizáis a grabar vuestras voces.

2
00:00:06,980 --> 00:00:12,539
Vamos a ver un poquito rápidamente qué es el manejo de excepciones en Java.

3
00:00:13,259 --> 00:00:19,199
Es decir, cuando surgen algún tipo de errores a tiempo de ejecución en Java,

4
00:00:19,199 --> 00:00:27,140
¿qué puedo hacer para intentar evitar que mi programa deje de funcionar y en un cierto sentido se recupere?

5
00:00:27,140 --> 00:00:45,140
La idea del manejo de excepciones es que errores pueden surgir y hay un mogollón de errores posibles, pero hasta ahora nosotros frente a cualquier tipo de error mi programa se acababa, pero quiero intentar evitar que esto pase.

6
00:00:45,140 --> 00:00:51,899
A los usuarios no les gusta que mi programa se bloquee o se apague solo o que se destruya.

7
00:00:52,520 --> 00:01:00,280
Como mínimo, si se tiene que destruir porque no puede seguir adelante, ha sido un error crítico, pues que al menos me diga algo.

8
00:01:00,619 --> 00:01:07,099
Me diga, oye, mira, lo que has hecho está muy mal. Cuanto más detallado puedo ser, mejor.

9
00:01:07,939 --> 00:01:13,260
Luego depende también del tipo de manejo de errores para quien lo hago.

10
00:01:13,260 --> 00:01:37,780
Si estoy intentando hablar al usuario y hacerle entender algo o si son más bien mensajes técnicos derivantes a quien haga el mantenimiento técnico de esos programas y esos códigos, que sepa que este código es una determinada cosa, a mí me viene un código raro, yo usuario no lo entiendo, pero el desarrollador sí que podrá entenderlo, ¿vale?

11
00:01:37,780 --> 00:01:41,019
El concepto es que una excepción es un error

12
00:01:41,019 --> 00:01:44,680
Un fallo del programa que ocurre en tiempo de ejecución

13
00:01:44,680 --> 00:01:48,640
A tiempo de compilación nosotros hacemos errores constantemente

14
00:01:48,640 --> 00:01:50,200
No ponemos un punto y coma

15
00:01:50,200 --> 00:01:52,719
Usamos un método que no existe

16
00:01:52,719 --> 00:01:55,340
Extendemos una clase strata

17
00:01:55,340 --> 00:02:00,079
Y no hemos implementado todos los métodos de la clase strata

18
00:02:00,079 --> 00:02:04,920
Estos son errores que se pueden sacar a tiempo de compilación

19
00:02:04,920 --> 00:02:06,799
O sea, antes de ejecutar el programa

20
00:02:06,799 --> 00:02:16,300
ya el compilador o el entorno de desarrollo puede hacerme una revisión de lo que he escrito

21
00:02:16,300 --> 00:02:17,939
y decirme, mira, aquí hay un problema.

22
00:02:18,060 --> 00:02:23,460
Típico también meter un double dentro de variable int.

23
00:02:23,840 --> 00:02:28,979
Él sabe que aquí hay una caja para int, tú estás poniendo un valor que es un double,

24
00:02:29,319 --> 00:02:31,699
lo puede detectar antes de ejecutar el programa.

25
00:02:32,460 --> 00:02:36,340
Otros errores en vez no se pueden detectar.

26
00:02:36,340 --> 00:02:47,780
Cuando yo le digo scan.nextint diciendo que voy a leer un número, no puedo saber a tiempo de compilación que el usuario malvado en vez de un número pondrá gato.

27
00:02:48,719 --> 00:02:54,860
Entonces, allí no puedo hacer nada a nivel de compilador de decir, oye, mira que aquí hay un error.

28
00:02:55,520 --> 00:02:57,319
Porque el error podría no haberlo.

29
00:02:57,659 --> 00:03:02,340
Será solo en el momento en que ejecuto que este error se podría manifestar.

30
00:03:03,080 --> 00:03:07,460
Estos errores que se manifiestan a tiempo de ejecución son las excepciones.

31
00:03:09,080 --> 00:03:14,879
Cuando un error ocurre, lo más normal es que se detenga el programa y se proporcione un mensaje de explique el fallo.

32
00:03:15,139 --> 00:03:21,599
Vosotros estaréis acostumbrados cuando hay un null pointer exception, cuando hay un index out of bound exception,

33
00:03:21,599 --> 00:03:31,080
vuestro programa se acaba, sale un listado de cosas en rojo y allí se acabó.

34
00:03:31,080 --> 00:03:55,659
Es lo que estamos haciendo hasta ahora. Ese listado de cosas en rojo que salen es un system.out.println. Vuestro programa tiene tres canales de comunicación siempre.

35
00:03:55,659 --> 00:04:24,699
Un input, system.in, que nosotros lo hemos visto en scanner, se lo pasamos como parámetro al scanner. Un system.out, que es el que escribe en consola, que es el que usamos nosotros ahora para decir cosas al usuario. Y luego está un system.er, que es igual a un system.out, pero está pensado para que tú escribas mensajes de errores, más que para comunicarte con el usuario, sería para comunicarte con desarrolladores que van a ver este error.

36
00:04:24,699 --> 00:04:42,379
De hecho, muchas veces este System.er, en vez de que escriba en consola, como hacemos nosotros normalmente porque no lo tocamos, se redirecciona a un fichero. De esta forma, cuando hay errores, no aparecen al usuario, pero se apuntan en un fichero de log por ahí en algún lado.

37
00:04:42,379 --> 00:04:48,319
De esta forma, en cierto momento, si viene el técnico y dice, mira, me pasan estos errores, a veces me hace caos,

38
00:04:48,660 --> 00:04:55,220
pues el técnico puede acceder al fichero de log y ver qué ha pasado, cuáles han sido los errores

39
00:04:55,220 --> 00:05:01,519
y en qué días normalmente, quién es el usuario que las ha hecho, etc., etc., etc.,

40
00:05:01,519 --> 00:05:05,399
para intentar sacar algo en claro de qué está pasando.

41
00:05:07,519 --> 00:05:11,500
Entonces, cuando pasa una excepción, nosotros veremos en system.error,

42
00:05:11,500 --> 00:05:17,339
Entonces los que ven rojo salen toda esa información que sustancialmente es la pila de llamadas de métodos.

43
00:05:17,680 --> 00:05:23,939
Es decir, quién ha llamado qué, quién, qué ha llamado quién, qué ha llamado quién, qué ha llamado quién, hasta dónde se ha verificado el error.

44
00:05:24,720 --> 00:05:37,019
Entonces si yo tengo un index out of bound exception, pues me la he hecho en esta línea de mi programa, que ha llamado un método de otra clase que era siempre mi programa,

45
00:05:37,019 --> 00:05:41,199
pero este método estaba usando un array que entonces era la clase que gestiona el array

46
00:05:41,199 --> 00:05:47,959
que ya no es mi programa, ya es JDK, ya es algo a nivel más de Java Virtual Machine

47
00:05:47,959 --> 00:05:51,980
y de allí abajo, abajo, abajo, hasta llegar a los puntos donde se ha explotado

48
00:05:51,980 --> 00:05:57,819
yo puedo seguir esas llamadas para saber qué ha pasado, dónde ha sido el error

49
00:05:57,819 --> 00:06:03,180
cuál es la línea que la ha provocado, pero a quién llamaba y quién estaba ejecutando en ese momento el procesador

50
00:06:03,180 --> 00:06:06,439
para saber, para enterarme un poquito más de qué ha pasado en ese momento

51
00:06:06,439 --> 00:06:09,519
Yo proporciono un mecanismo

52
00:06:09,519 --> 00:06:11,519
Para controlar situaciones que normalmente provocarían

53
00:06:11,519 --> 00:06:13,040
Interrupciones en ejecución

54
00:06:13,040 --> 00:06:15,600
Permitiendo gestionar el comportamiento

55
00:06:15,600 --> 00:06:16,860
Del programa en caso de error

56
00:06:16,860 --> 00:06:18,040
¿Cuál es ese mecanismo?

57
00:06:27,000 --> 00:06:29,480
¿El único mecanismo que sabéis vosotros de gestión de errores?

58
00:06:30,860 --> 00:06:31,079
No

59
00:06:31,079 --> 00:06:32,699
Try-catch

60
00:06:32,699 --> 00:06:35,600
El try-catch es un mecanismo

61
00:06:35,600 --> 00:06:36,620
De ejecutar

62
00:06:36,620 --> 00:06:39,939
Este programa, este trozo de código

63
00:06:39,939 --> 00:06:42,160
Si pasa algo

64
00:06:42,160 --> 00:06:44,079
Recoge

65
00:06:44,079 --> 00:06:46,800
sketch la excepción que ha sido lanzada

66
00:06:46,800 --> 00:06:50,100
y a ese punto en vez de acabar el programa

67
00:06:50,100 --> 00:06:53,240
ejecuta otro código

68
00:06:53,240 --> 00:06:55,699
que sustancialmente lo que debería hacer es

69
00:06:55,699 --> 00:06:58,220
o terminar bien el programa

70
00:06:58,220 --> 00:07:01,939
diciendo, mira ha habido un error, lo siento mucho, ha pasado esto, hasta luego

71
00:07:01,939 --> 00:07:04,379
o intentar recuperarse

72
00:07:04,379 --> 00:07:07,720
decir, mira los datos que me has dado no están correctos

73
00:07:07,720 --> 00:07:10,899
o has intentado un acceso que no podías o lo que sea

74
00:07:10,899 --> 00:07:13,740
y volver al menú principal diciendo

75
00:07:13,740 --> 00:07:19,839
venga, inténtalo otra vez, porque ha fallado la operación, pero el programa sigue funcionando.

76
00:07:22,790 --> 00:07:30,069
Cuando yo pienso en los errores, a este tipo de cosas que pueden pasar, hay dos formas de gestionarlo.

77
00:07:30,189 --> 00:07:34,269
Uno es el manejo de errores o la programación pesimista.

78
00:07:34,509 --> 00:07:40,949
La programación pesimista es intentar crear formas, crear código que evita los errores.

79
00:07:40,949 --> 00:07:46,329
proteger zonas peligrosas usando if o usando algún tipo de comando

80
00:07:46,329 --> 00:07:51,449
que pueda verificar que lo que estás haciendo es correcto antes de hacerlo

81
00:07:51,449 --> 00:07:58,350
por ejemplo preguntarse si un objeto no es null antes de utilizarlo

82
00:07:58,350 --> 00:08:01,649
entonces si yo hago un if mi objeto not null

83
00:08:01,649 --> 00:08:07,189
estoy activamente verificando que este objeto no sea null

84
00:08:07,189 --> 00:08:09,870
si es null te diré, oye mira no lo puedo usar

85
00:08:09,870 --> 00:08:26,689
Si no es null, ya lo puedo utilizar, evitando así un null pointer exception. Es pesimista porque principalmente estoy sobrecargando el programa de muchos if.

86
00:08:26,689 --> 00:08:31,290
En un programa normalmente, la mayoría de las veces

87
00:08:31,290 --> 00:08:35,070
Los objetos que uso no deberían ser null

88
00:08:35,070 --> 00:08:36,490
Debería ser algo

89
00:08:36,490 --> 00:08:38,870
Yo estoy en una secretaría para alumnos

90
00:08:38,870 --> 00:08:40,250
Estoy gestionando alumnos

91
00:08:40,250 --> 00:08:43,169
Mientras gestiono los alumnos, los cargo de la memoria

92
00:08:43,169 --> 00:08:44,970
Los uso, los actualizo y cosas por el estilo

93
00:08:44,970 --> 00:08:47,610
Siempre me espero que esté trabajando con un alumno

94
00:08:47,610 --> 00:08:50,090
Es difícil que haya buscado un alumno

95
00:08:50,090 --> 00:08:51,809
Y justo ese alumno me haya dado null

96
00:08:51,809 --> 00:08:54,110
Y entonces ahora estoy trabajando con un objeto null

97
00:08:54,110 --> 00:08:57,610
Sin embargo, en la modalidad pesimista

98
00:08:57,610 --> 00:08:59,549
Lo que estoy haciendo es comprobando

99
00:08:59,549 --> 00:09:01,169
Cada vez que uso un objeto

100
00:09:01,169 --> 00:09:02,889
Si ese objeto es bueno

101
00:09:02,889 --> 00:09:05,090
Y a lo mejor hace 3, 4, 5 comprobaciones

102
00:09:05,090 --> 00:09:07,250
De maestro es null, maestro es mayor que 0

103
00:09:07,250 --> 00:09:09,049
Y esto

104
00:09:09,049 --> 00:09:11,870
Sobrecarga el programa

105
00:09:11,870 --> 00:09:12,870
Crea más

106
00:09:12,870 --> 00:09:15,429
O sea, lo hace más lento

107
00:09:15,429 --> 00:09:17,629
Porque en un 99%

108
00:09:17,629 --> 00:09:19,289
De las veces esto iría todo bien

109
00:09:19,289 --> 00:09:22,070
Porque no es null y el valor es mayor que 0

110
00:09:22,070 --> 00:09:23,990
Pero yo lo estoy comprobando igualmente

111
00:09:23,990 --> 00:09:44,169
Cada vez, ¿vale? Serían estos if innecesarios. Y también, trabajando así, es bastante complejo identificar todos los posibles problemas. Y que este objeto podría ser nul, pero que este proyecto podría ser no nul, pero dentro tiene otra referencia a otro objeto y esa sea nul.

112
00:09:44,169 --> 00:09:49,029
podría tener este valor que es mayor que 1 pero menor que 0

113
00:09:49,029 --> 00:09:50,710
entonces, ¿me entendéis?

114
00:09:50,970 --> 00:09:55,649
o sea, se necesita mucha experiencia y mucho control de todos los posibles errores

115
00:09:55,649 --> 00:09:59,070
y cuando llegamos a sistemas muy complejos

116
00:09:59,070 --> 00:10:06,590
pues que se me olvide alguno de estos tipos de controles es posible

117
00:10:06,590 --> 00:10:09,590
entonces está el manejo de excepciones optimista

118
00:10:09,590 --> 00:10:11,929
el manejo de excepciones optimista es un poco decir

119
00:10:11,929 --> 00:10:14,429
cuando hay un trozo de código peligroso

120
00:10:14,429 --> 00:10:15,889
que podría dar problemas

121
00:10:15,889 --> 00:10:17,389
que podría hacer un acceso a null

122
00:10:17,389 --> 00:10:19,629
que podría hacer un acceso fuera del array

123
00:10:19,629 --> 00:10:22,509
pues tú ejecútalo

124
00:10:22,509 --> 00:10:25,409
asumimos que no haya fallos

125
00:10:25,409 --> 00:10:28,830
las veces que haya fallos

126
00:10:28,830 --> 00:10:31,309
en vez de haberlo comprobado cada vez

127
00:10:31,309 --> 00:10:33,129
hasta cuando no haya fallos para estar seguro

128
00:10:33,129 --> 00:10:35,330
pues las veces que explotará

129
00:10:35,330 --> 00:10:36,370
que dará problemas

130
00:10:36,370 --> 00:10:39,710
pues allí te escribiré un trocito de código

131
00:10:39,710 --> 00:10:44,049
para qué tienes que hacer cuando pasan estas cosas.

132
00:10:44,610 --> 00:10:45,789
Y este es el try catch.

133
00:10:46,309 --> 00:10:51,110
El try selecciona un trozo de código, esto se ejecutará.

134
00:10:51,450 --> 00:10:54,289
Si va todo bien, el catch no sirve de nada.

135
00:10:55,049 --> 00:10:58,490
Si dentro de este trozo de código pasa algún problema,

136
00:10:59,629 --> 00:11:06,730
el catch podrá recuperar ese error y ejecutar un código que se ejecuta.

137
00:11:06,730 --> 00:11:21,730
Tened en cuenta que el try no se ejecuta completamente. Si en la primera línea del try es donde surge el error, porque hago un null pointer exception y luego hay otras 10 líneas de código, estas otras 10 líneas de código no se han ejecutado.

138
00:11:21,730 --> 00:11:30,870
En el momento en que se lanza la excepción, en el momento en que ocurre la excepción, pues se interrumpe el bloque try y se pasa al bloque catch.

139
00:11:32,049 --> 00:11:41,309
Este de aquí podría ser uno muy genérico, porque cualquier excepción se pilla en el catch, luego veremos que podemos hilar un poquito más fino.

140
00:11:41,450 --> 00:11:46,870
Es decir, si la excepción era esta, hace una cosa, pero si la excepción era esta otra, hace una cosa distinta.

141
00:11:46,870 --> 00:11:48,950
dudas hasta aquí

142
00:11:48,950 --> 00:11:53,840
entonces esto sería lo mismo

143
00:11:53,840 --> 00:11:55,500
en versión

144
00:11:55,500 --> 00:11:57,580
pesimista y optimista

145
00:11:57,580 --> 00:11:59,899
¿vale? en versión pesimista por ejemplo

146
00:11:59,899 --> 00:12:01,340
yo pillo dos números

147
00:12:01,340 --> 00:12:04,080
num denominador y antes de hacer

148
00:12:04,080 --> 00:12:06,039
num dividido den

149
00:12:06,039 --> 00:12:07,600
¿vale? que sería una fracción

150
00:12:07,600 --> 00:12:09,799
pues lo que hago es comprobar

151
00:12:09,799 --> 00:12:11,320
que el denominador no sea cero

152
00:12:11,320 --> 00:12:14,120
porque si divido por cero me daría un error aritmética

153
00:12:14,120 --> 00:12:15,840
una excepción aritmética

154
00:12:15,840 --> 00:12:17,659
una divided by zero

155
00:12:17,659 --> 00:12:18,379
¿vale?

156
00:12:18,379 --> 00:12:21,419
Entonces, cada vez que yo hago esta operación

157
00:12:21,419 --> 00:12:22,879
Pasaré por este if

158
00:12:22,879 --> 00:12:26,039
Y todas las veces que yo daré un then

159
00:12:26,039 --> 00:12:27,120
Que no sea cero

160
00:12:27,120 --> 00:12:30,240
Pues igualmente haré este if y lo comprobaré

161
00:12:30,240 --> 00:12:30,980
¿Sí? Entonces

162
00:12:30,980 --> 00:12:33,059
Si esto lo hago un millón de veces

163
00:12:33,059 --> 00:12:34,779
Haré hecho un millón de veces este if

164
00:12:34,779 --> 00:12:37,159
Independientemente que el then sea cero o no

165
00:12:37,159 --> 00:12:39,860
La versión optimista

166
00:12:39,860 --> 00:12:42,320
Es decir, yo esto lo guardo en un try-catch

167
00:12:42,320 --> 00:12:45,019
Si por si acaso aquí salta una

168
00:12:45,019 --> 00:12:46,360
Divide by zero exception

169
00:12:46,360 --> 00:12:48,460
o ArithmeticException o lo que sea

170
00:12:48,460 --> 00:12:51,139
pues lo recojo con esta excepción de aquí

171
00:12:51,139 --> 00:12:52,779
te digo, oye mira, no es válido

172
00:12:52,779 --> 00:12:54,159
hacer esto

173
00:12:54,159 --> 00:12:55,399
y sigo adelante

174
00:12:55,399 --> 00:12:57,360
si esto lo hago un millón de veces

175
00:12:57,360 --> 00:12:59,480
pues a lo mejor esta parte de aquí

176
00:12:59,480 --> 00:13:01,460
la ejecutaré unas cuantas veces

177
00:13:01,460 --> 00:13:02,159
pocas veces

178
00:13:02,159 --> 00:13:05,179
cuando hay una división por cero

179
00:13:05,179 --> 00:13:06,580
tened en cuenta que igualmente

180
00:13:06,580 --> 00:13:08,720
el try-catch no es gratis

181
00:13:08,720 --> 00:13:10,980
o sea, marcar un trozo de código

182
00:13:10,980 --> 00:13:13,220
y vigilarlo porque si explota

183
00:13:13,220 --> 00:13:14,259
pues si yo pillo un catch

184
00:13:14,259 --> 00:13:16,659
pues tendrá su coste computacional

185
00:13:16,659 --> 00:13:18,980
pero técnicamente debería ser inferior

186
00:13:18,980 --> 00:13:20,700
a hacer explícitamente un if

187
00:13:20,700 --> 00:13:22,820
sobre todo si luego este if

188
00:13:22,820 --> 00:13:24,759
es complejo, porque un if

189
00:13:24,759 --> 00:13:26,820
facilita si está bien, si yo para

190
00:13:26,820 --> 00:13:28,860
encontrarme den tengo que acceder a un

191
00:13:28,860 --> 00:13:30,639
método, hacer una llamada de método, el método

192
00:13:30,639 --> 00:13:32,960
hace una operación y de ahí saca un dato

193
00:13:32,960 --> 00:13:34,779
y cuando este dato lo comparo a

194
00:13:34,779 --> 00:13:36,799
otras cosas, pues puede ser más complejo

195
00:13:36,799 --> 00:13:39,039
hacer este if que hacer simplemente un traquecho

196
00:13:39,039 --> 00:13:40,620
¿Dudas?

197
00:13:44,870 --> 00:13:46,009
Clase exception

198
00:13:46,009 --> 00:13:48,610
Cuando hay una excepción

199
00:13:48,610 --> 00:13:51,230
La Java Return Machine crea un objeto de la clase Exception

200
00:13:51,230 --> 00:13:52,789
O sea, existe una clase

201
00:13:52,789 --> 00:13:55,649
Todas las excepciones que hemos visto nosotros

202
00:13:55,649 --> 00:13:58,450
ArrayIndexOutOfBoundException

203
00:13:58,450 --> 00:14:00,149
IOException

204
00:14:00,149 --> 00:14:02,570
NullPointerException

205
00:14:02,570 --> 00:14:05,110
Todas son de una clase

206
00:14:05,110 --> 00:14:07,389
Son heredan de una clase

207
00:14:07,389 --> 00:14:09,129
Que se llama Exception

208
00:14:09,129 --> 00:14:11,570
Exception luego heredará de otras cosas

209
00:14:11,570 --> 00:14:13,789
Hasta llegar a Object

210
00:14:13,789 --> 00:14:17,870
En este objeto se guarda la información relevante del error

211
00:14:17,870 --> 00:14:21,950
Entonces, este es como un paquete de información

212
00:14:21,950 --> 00:14:23,649
Que crea la Java Virtual Machine

213
00:14:23,649 --> 00:14:25,830
Cuando hay un error en tiempo de ejecución

214
00:14:25,830 --> 00:14:30,389
Diciendo, toda la información que puede ser relevante

215
00:14:30,389 --> 00:14:33,309
Sobre este error, la empaqueto en un objeto

216
00:14:33,309 --> 00:14:35,570
¿Quién ha producido el objeto?

217
00:14:35,909 --> 00:14:37,090
¿Cuándo lo ha producido?

218
00:14:37,429 --> 00:14:38,629
¿Qué ha causado el error?

219
00:14:40,929 --> 00:14:43,710
¿En qué método se ha pasado eso?

220
00:14:43,789 --> 00:14:45,750
etc, etc, etc, todo empaquetado

221
00:14:45,750 --> 00:14:47,570
bonito para que yo luego lo recoja

222
00:14:47,570 --> 00:14:48,549
sería esto

223
00:14:48,549 --> 00:14:57,259
sería esto, veis que aquí

224
00:14:57,259 --> 00:14:59,220
exception e, esto es como

225
00:14:59,220 --> 00:15:00,679
poner int x

226
00:15:00,679 --> 00:15:03,240
pues esto estoy creando una variable e

227
00:15:03,240 --> 00:15:04,539
de tipo exception

228
00:15:04,539 --> 00:15:06,720
que será un objeto

229
00:15:06,720 --> 00:15:09,080
exception, y yo luego allí

230
00:15:09,080 --> 00:15:11,200
podré hacer algo con este objeto, podré hacer

231
00:15:11,200 --> 00:15:13,200
e.printstack

232
00:15:14,100 --> 00:15:15,200
o e.getMessage

233
00:15:16,240 --> 00:15:16,620
o e.

234
00:15:17,000 --> 00:15:18,860
y todos los métodos que puedan haber

235
00:15:18,860 --> 00:15:20,039
en esa excepción

236
00:15:20,039 --> 00:15:22,320
o sea que

237
00:15:22,320 --> 00:15:24,960
también aquí estamos usando

238
00:15:24,960 --> 00:15:27,039
mucho el concepto de

239
00:15:27,039 --> 00:15:28,919
herencia

240
00:15:28,919 --> 00:15:30,679
¿vale? porque todos son excepciones

241
00:15:30,679 --> 00:15:32,200
pero luego dentro veremos que hay

242
00:15:32,200 --> 00:15:35,000
distintas, entonces si yo

243
00:15:35,000 --> 00:15:36,679
uso una referencia de tipo exception

244
00:15:36,679 --> 00:15:38,379
puedo utilizar los métodos de exception

245
00:15:38,379 --> 00:15:40,480
pero si luego puedo hacer un downcasting

246
00:15:40,480 --> 00:15:42,720
de esta excepción a otras excepciones

247
00:15:42,720 --> 00:15:44,639
más pequeñas, más concretas

248
00:15:44,639 --> 00:15:46,440
y utilizar los métodos de ellas

249
00:15:46,440 --> 00:15:53,139
Un mismo código peligroso podría causar distintos tipos de excepciones

250
00:15:53,139 --> 00:15:56,399
La Java Art Machine creará un objeto a su clase más apropiada

251
00:15:56,399 --> 00:15:59,200
Si el error ha sido porque ha cedido fuera de un array

252
00:15:59,200 --> 00:16:01,960
Será un array index out of bound

253
00:16:01,960 --> 00:16:04,600
Si el error ha sido porque el array era null

254
00:16:04,600 --> 00:16:06,299
Pues será una null pointer exception

255
00:16:06,299 --> 00:16:08,919
Si es un error porque escribí en un fichero

256
00:16:08,919 --> 00:16:09,980
El fichero no existe

257
00:16:09,980 --> 00:16:11,860
Será una input out of exception

258
00:16:11,860 --> 00:16:13,340
Una IO exception

259
00:16:13,340 --> 00:16:14,919
entonces aquí

260
00:16:14,919 --> 00:16:16,879
hay la numpointer exception

261
00:16:16,879 --> 00:16:19,080
numperformate exception

262
00:16:19,080 --> 00:16:20,980
ioexception, io mogollón

263
00:16:20,980 --> 00:16:25,340
manejo de excepciones finos

264
00:16:25,340 --> 00:16:26,899
es decir que cuando yo hago un catch

265
00:16:26,899 --> 00:16:29,299
en vez de poner algo así grueso

266
00:16:29,299 --> 00:16:31,440
de píllame una cualquier excepción

267
00:16:31,440 --> 00:16:33,039
y allí hago algo

268
00:16:33,039 --> 00:16:34,840
pues yo puedo decir

269
00:16:34,840 --> 00:16:37,559
oye mira te voy a dar varios bloques catch

270
00:16:37,559 --> 00:16:39,000
y este catch

271
00:16:39,000 --> 00:16:41,279
lo usarás si es una input

272
00:16:41,279 --> 00:16:43,220
autoexception, este catch

273
00:16:43,220 --> 00:16:45,480
si es una RuntimeException

274
00:16:45,480 --> 00:16:47,100
este de aquí si es

275
00:16:47,100 --> 00:16:49,159
una NumberFormatException

276
00:16:49,159 --> 00:16:51,539
de esta forma podría dar mensajes

277
00:16:51,539 --> 00:16:53,179
distintos en base

278
00:16:53,179 --> 00:16:54,919
a lo que ha explotado, si me dice

279
00:16:54,919 --> 00:16:57,139
ArrayIndex.topBound te diré

280
00:16:57,139 --> 00:16:59,139
oye mira has intentado acceder fuera

281
00:16:59,139 --> 00:17:01,159
del array y por favor revisa

282
00:17:01,159 --> 00:17:03,139
la posición, si en vez es un

283
00:17:03,139 --> 00:17:05,099
NullPointerException te diré, oye mira el objeto

284
00:17:05,099 --> 00:17:07,000
al que intentas acceder es null

285
00:17:07,000 --> 00:17:08,900
y por lo tanto no puede acceder

286
00:17:08,900 --> 00:17:11,160
en vez de dar siempre el mismo error de error

287
00:17:11,160 --> 00:17:12,980
cuanto más

288
00:17:12,980 --> 00:17:15,019
y lamos finos, luego es más fácil

289
00:17:15,019 --> 00:17:17,380
para los administradores, para los desarrolladores

290
00:17:17,380 --> 00:17:19,279
entender qué ha pasado

291
00:17:19,279 --> 00:17:20,359
y por qué ha ido mal

292
00:17:20,359 --> 00:17:23,299
y por qué ha habido problemas, ha habido errores

293
00:17:23,299 --> 00:17:24,359
en este programa

294
00:17:24,359 --> 00:17:26,980
adicionalmente existe

295
00:17:26,980 --> 00:17:29,059
un cache especial

296
00:17:29,059 --> 00:17:30,319
que es el bloque finally

297
00:17:30,319 --> 00:17:32,880
que es un bloque que se ejecuta

298
00:17:32,880 --> 00:17:34,980
siempre, tanto

299
00:17:34,980 --> 00:17:36,940
que haya habido un error

300
00:17:36,940 --> 00:17:38,579
como que no haya habido un error

301
00:17:38,579 --> 00:17:41,640
siempre se ejecutan las líneas

302
00:17:41,640 --> 00:17:42,819
dentro de finally

303
00:17:42,819 --> 00:17:47,200
Por lo tanto, imaginémonos una cosa de ese estilo

304
00:17:47,200 --> 00:17:51,400
Está el bloque 1, luego está un try, está el bloque 2

305
00:17:51,400 --> 00:17:55,839
Luego está un catch de ArithmeticException, ArithmeticException

306
00:17:55,839 --> 00:18:01,519
Bloque 3, ExceptionError, bloque 4 y bloque 5

307
00:18:01,519 --> 00:18:03,980
¿Qué pasa si no hay excepciones?

308
00:18:03,980 --> 00:18:07,680
Que se ejecuta el bloque 1, luego se ejecuta el bloque 2

309
00:18:07,680 --> 00:18:10,039
Y al final se ejecuta el bloque 5

310
00:18:10,039 --> 00:18:14,579
El bloque 3 y el bloque 4 nunca se ejecutarán porque no ha habido excepciones

311
00:18:14,579 --> 00:18:17,380
¿Qué pasa si hay una excepción de tipo aritmético?

312
00:18:17,900 --> 00:18:22,119
Si empieza el bloque 1, el bloque 2 se ejecuta pero solo parcialmente

313
00:18:22,119 --> 00:18:26,539
Porque en un determinado momento de este bloque habrá un error aritmético

314
00:18:26,539 --> 00:18:31,180
Cuando explota la aritmética exception, pues se ejecuta el bloque 3

315
00:18:31,180 --> 00:18:35,019
Y cuando se acaba el bloque 3, se ejecutará el bloque 5

316
00:18:35,019 --> 00:18:37,460
Se sigue después del bloque try-catch

317
00:18:37,460 --> 00:18:40,619
O la pregunta, ¿dentro del bloque C podría haber otro try-catch?

318
00:18:42,220 --> 00:18:43,619
Sí, tranquilamente

319
00:18:43,619 --> 00:18:47,140
Que dentro de este de aquí, o sea, dentro de un catch

320
00:18:47,140 --> 00:18:48,859
Podría poner un try-catch

321
00:18:48,859 --> 00:18:52,019
La idea es que en un determinado momento

322
00:18:52,019 --> 00:18:54,519
Debería intentar de hacer cosas y explotar

323
00:18:54,519 --> 00:18:58,880
Debería recuperarme o acabar o cosa por el estilo

324
00:18:58,880 --> 00:19:02,019
Pero si fuera necesario, imaginaos que yo intento escribir en un fichero

325
00:19:02,019 --> 00:19:05,359
Y ese fichero no existe, me salta una IO exception

326
00:19:05,359 --> 00:19:10,180
Pues aquí digo, vale, si no puedes escribir en el fichero que te han dicho

327
00:19:10,180 --> 00:19:15,420
Crea tú un fichero por defecto y ahora intenta escribirlo allí

328
00:19:15,420 --> 00:19:18,380
Y si me pasa otro error porque el disco duro está lleno

329
00:19:18,380 --> 00:19:21,740
Entonces no puedo crear eso, pues allí habría otro try catch dentro del catch

330
00:19:21,740 --> 00:19:22,619
¿Me explico?

331
00:19:23,640 --> 00:19:24,339
Por ejemplo

332
00:19:24,339 --> 00:19:29,000
Imaginamos que en vez de salte una null pointer exception

333
00:19:29,000 --> 00:19:33,240
Pues ejecuta el primero y en el dos en un determinado momento hace una null pointer exception

334
00:19:33,240 --> 00:19:39,559
dice es una aritmética excepción no por lo tanto este bloque no se ejecuta sería este de aquí que

335
00:19:39,559 --> 00:19:45,079
es una excepción general pillaría todas las excepciones que no sean ésta por lo tanto se

336
00:19:45,079 --> 00:19:54,799
ejecuta el bloque 4 y luego después el bloque 5 sí si le añadimos el final y vale sin excepciones

337
00:19:54,799 --> 00:20:01,859
es bloque 1 hace el bloque trae completo luego después hace el final y luego después el bloque 5

338
00:20:01,859 --> 00:20:05,059
si hay una excepción de tipo aritmético

339
00:20:05,059 --> 00:20:06,619
lo que haría es el bloque 1

340
00:20:06,619 --> 00:20:08,119
el bloque 2 a mitad

341
00:20:08,119 --> 00:20:10,740
explota la aritmética exception

342
00:20:10,740 --> 00:20:12,200
ejecuta el bloque 3

343
00:20:12,200 --> 00:20:14,480
a este punto hace un finally

344
00:20:14,480 --> 00:20:17,380
o sea ejecuta también lo que está en el bloque 4

345
00:20:17,380 --> 00:20:18,960
y después sigue con el programa

346
00:20:18,960 --> 00:20:22,039
después del track edge

347
00:20:22,039 --> 00:20:25,200
si fuera una excepción de otro tipo

348
00:20:25,200 --> 00:20:26,200
diferente

349
00:20:26,200 --> 00:20:29,480
pues haría el bloque 1

350
00:20:29,480 --> 00:20:30,880
luego el bloque 2

351
00:20:30,880 --> 00:20:31,980
y explotaría

352
00:20:31,980 --> 00:20:33,740
Haría el finally

353
00:20:33,740 --> 00:20:36,119
Y luego posiblemente acabaría

354
00:20:36,119 --> 00:20:38,619
Porque no se ha pillado

355
00:20:38,619 --> 00:20:41,359
La excepción

356
00:20:41,359 --> 00:20:43,279
Aquí no hay un catch

357
00:20:43,279 --> 00:20:44,220
De exception

358
00:20:44,220 --> 00:20:46,039
Por lo tanto el programa acabaría

359
00:20:46,039 --> 00:20:47,940
Si yo la excepción no la recojo

360
00:20:47,940 --> 00:20:49,279
El programa termina

361
00:20:49,279 --> 00:20:51,559
Entonces no llegaría nunca al 5

362
00:20:51,559 --> 00:20:52,759
Pero si el 4

363
00:20:52,759 --> 00:20:57,730
El finally es como un

364
00:20:57,730 --> 00:21:00,609
Una cosa final

365
00:21:00,609 --> 00:21:01,490
Que haces

366
00:21:01,490 --> 00:21:04,390
antes de decir ya está, aquí hemos llegado

367
00:21:04,390 --> 00:21:06,470
pero si has pillado

368
00:21:06,470 --> 00:21:08,309
el catch, la excepción

369
00:21:08,309 --> 00:21:09,829
no ha llegado a la Java Virtual Machine

370
00:21:09,829 --> 00:21:12,309
entonces no se ha bloqueado, entonces sigue adelante

371
00:21:12,309 --> 00:21:13,769
entonces después de haber hecho el finally

372
00:21:13,769 --> 00:21:16,230
sigo adelante, si en vez es una

373
00:21:16,230 --> 00:21:18,609
excepción que no he manejado

374
00:21:18,609 --> 00:21:19,769
y por lo tanto

375
00:21:19,769 --> 00:21:22,269
ha subido hasta llegar a un momento en que

376
00:21:22,269 --> 00:21:23,589
el programa se tiene que acabar

377
00:21:23,589 --> 00:21:26,109
pero igualmente el finally se ejecuta porque por ejemplo

378
00:21:26,109 --> 00:21:28,329
en ese momento tú guardas los datos importantes

379
00:21:28,329 --> 00:21:30,430
en un fichero, escribes en pantalla

380
00:21:30,430 --> 00:21:32,470
el resultado parcial actual para que

381
00:21:32,470 --> 00:21:34,490
no se pierda todo y a ese punto

382
00:21:34,490 --> 00:21:36,549
ya le dices a la máquina virtual haz lo tuyo

383
00:21:36,549 --> 00:21:38,390
como el programador me ha dicho que

384
00:21:38,390 --> 00:21:40,890
no tengo que recoger esta excepción

385
00:21:40,890 --> 00:21:41,970
y por lo tanto

386
00:21:41,970 --> 00:21:44,109
tiene que acabar, porque

387
00:21:44,109 --> 00:21:46,329
si no recoges la excepción quiere decir que

388
00:21:46,329 --> 00:21:47,930
quieres que se acabe allí

389
00:21:47,930 --> 00:21:50,710
de forma bruta el programa

390
00:21:50,710 --> 00:21:52,430
pero al menos esta parte finally

391
00:21:52,430 --> 00:21:54,670
te ha permitido hacer una última pincelada

392
00:21:54,670 --> 00:21:55,410
antes de

393
00:21:55,410 --> 00:21:58,269
explotar

394
00:21:58,269 --> 00:22:00,109
¿Vale? Se me ha

395
00:22:00,109 --> 00:22:02,029
quejado Rosa de que

396
00:22:02,029 --> 00:22:03,930
usáis la palabra explotar

397
00:22:03,930 --> 00:22:05,849
como término técnico

398
00:22:05,849 --> 00:22:07,589
en sus exámenes.

399
00:22:08,210 --> 00:22:10,009
Por favor, explotar

400
00:22:10,009 --> 00:22:11,250
no es técnico.

401
00:22:15,410 --> 00:22:17,069
No, tampoco.

402
00:22:20,160 --> 00:22:21,539
Que, extrañamente, son las cosas

403
00:22:21,539 --> 00:22:23,740
que os quedan. Yo puedo estar 45 minutos

404
00:22:23,740 --> 00:22:25,339
hablando de excepciones y

405
00:22:25,339 --> 00:22:27,039
que es una excepción, nunca lo he oído.

406
00:22:27,460 --> 00:22:28,940
Pero, exploto. Mira, hablamos de ti.

407
00:22:30,279 --> 00:22:31,059
Pues nada, que

408
00:22:31,059 --> 00:22:32,940
me paro, que es acabado.

409
00:22:32,940 --> 00:22:34,559
Acabaremos el jueves