1 00:00:00,560 --> 00:00:09,960 Voy a grabar esta clase, por lo tanto, si habláis, me autorizáis a grabar vuestra boca. 2 00:00:10,859 --> 00:00:14,359 Entonces, lo que vamos a ver hoy es el concepto de manejo de excepciones. 3 00:00:14,500 --> 00:00:23,420 Nosotros hemos visto en programas anteriores que a veces Java no consigue hacer lo que tiene que hacer. 4 00:00:24,079 --> 00:00:28,699 Aquí hay varios tipos de errores, varios tipos de problemas. 5 00:00:28,699 --> 00:00:37,700 El primer error, y más fácil, son los errores sintácticos o, dicho de esta forma, los errores resolvibles a tiempo de compilación. 6 00:00:38,700 --> 00:00:42,100 Eso porque Java, ¿cómo es Java? ¿Interpretado o compilado? 7 00:00:43,159 --> 00:00:43,859 Six, seven. 8 00:00:44,859 --> 00:00:45,460 ¡Six, seven! 9 00:00:46,880 --> 00:00:47,399 Ambas. 10 00:00:48,320 --> 00:00:49,240 Ambas, ¿vale? 11 00:00:49,619 --> 00:00:54,539 Entonces, si os acordáis, antes se compila en bytecode y después se interpreta desde bytecode. 12 00:00:55,060 --> 00:00:58,960 El compilador, la fase de compilador, una cosa interesante que nos proporciona 13 00:00:58,960 --> 00:01:05,819 es que sustancialmente nos permite encontrar pequeños errores de sintaxis. 14 00:01:06,519 --> 00:01:10,000 O sea, si yo he escrito mal el código, él me lo marca y me dice, 15 00:01:10,120 --> 00:01:12,040 no, mira, aquí esta palabra no podía estar. 16 00:01:12,480 --> 00:01:15,840 Oye, mira, has usado una variable, esta variable no existe, no la has declarado antes. 17 00:01:15,840 --> 00:01:20,260 Oye, estás llamando un método y este método no existe, no lo has declarado. 18 00:01:20,640 --> 00:01:23,980 Todas estas cosas son las cosas que os salen en el IDE, os salen en Eclipse. 19 00:01:23,980 --> 00:01:26,579 marcadas en rojos hay un error 20 00:01:26,579 --> 00:01:28,700 y vosotros 21 00:01:28,700 --> 00:01:30,719 sin ni siquiera haber 22 00:01:30,719 --> 00:01:32,200 arrancado el programa 23 00:01:32,200 --> 00:01:34,519 ya sabéis que ese programa no va a funcionar 24 00:01:34,519 --> 00:01:36,400 y que necesitáis modificarle 25 00:01:36,400 --> 00:01:36,739 cambiar 26 00:01:36,739 --> 00:01:40,459 una vez que no tenéis errores 27 00:01:40,459 --> 00:01:42,319 de compilación, no tenéis 28 00:01:42,319 --> 00:01:43,939 marcado nada de rojo 29 00:01:43,939 --> 00:01:46,640 lanzáis vuestro programa y vuestro programa funciona 30 00:01:46,640 --> 00:01:48,439 seguramente, correcto 31 00:01:48,439 --> 00:01:52,900 arranca 32 00:01:52,900 --> 00:01:54,340 se ejecuta 33 00:01:54,340 --> 00:02:00,840 Pero luego podría no hacer para nada lo que vosotros queréis que haga. 34 00:02:01,180 --> 00:02:04,260 Vosotros habéis hecho un programa para calcular el área del triángulo 35 00:02:04,260 --> 00:02:07,459 y lo que hace es calcular lado por lado. 36 00:02:08,360 --> 00:02:12,039 El programa funciona, te da un resultado, tú le pones lado 3 y se te dice, 37 00:02:12,039 --> 00:02:13,280 claro, 3 por 3, 9. 38 00:02:13,860 --> 00:02:18,180 Pero esa no es el área del triángulo, es el área del cuadrado. 39 00:02:19,240 --> 00:02:21,939 Estos son errores semánticos. 40 00:02:21,939 --> 00:02:25,960 y eso no hay nadie que os lo resuelva. 41 00:02:26,740 --> 00:02:28,360 Esos son problemas vuestros. 42 00:02:28,699 --> 00:02:30,120 Habéis programado mal. 43 00:02:31,860 --> 00:02:34,360 Eso es entender cuál es el problema, 44 00:02:34,639 --> 00:02:36,900 entender cuál es el algoritmo para solucionarlo 45 00:02:36,900 --> 00:02:38,259 e implementarlo bien. 46 00:02:38,639 --> 00:02:40,580 Si hacéis errores en el algoritmo, 47 00:02:40,699 --> 00:02:41,639 el problema es vuestro. 48 00:02:44,460 --> 00:02:47,259 Y luego está un tercer tipo de errores, 49 00:02:47,259 --> 00:02:48,340 digamos así, ¿vale? 50 00:02:48,340 --> 00:03:01,110 Que son cosas que técnicamente estarían bien, pero que en esa situación concreta de esa ejecución 51 00:03:01,110 --> 00:03:06,969 ha pasado algo que sustancialmente los ha transformado en mal. 52 00:03:07,530 --> 00:03:08,090 ¿Me explico? 53 00:03:08,590 --> 00:03:11,930 Por ejemplo, yo te he dicho, dame un número, y tú has escrito gato. 54 00:03:12,669 --> 00:03:12,849 ¿Vale? 55 00:03:13,069 --> 00:03:16,370 Mi código no tenía errores semánticos. 56 00:03:16,849 --> 00:03:19,650 Mi código no tenía errores sintácticos. 57 00:03:19,710 --> 00:03:34,289 Mi código es sólido, pero en el momento en que yo te pido un número y tú me estás dando un string, estás generando tu usuario un error a tiempo de ejecución, no en tiempo de compilación. 58 00:03:35,289 --> 00:03:42,629 En compilación no había error porque tú leías un int, pero como ahora tú has dicho léete un int y me has dado un string, pues ahí hay un problema. 59 00:03:42,629 --> 00:03:46,849 Java reacciona a este tipo de errores 60 00:03:46,849 --> 00:03:49,270 a errores que digamos se ejecutan 61 00:03:49,270 --> 00:03:53,189 o sea, se salen cuando hay una ejecución 62 00:03:53,189 --> 00:03:56,129 con dos grandes categorías 63 00:03:56,129 --> 00:03:59,449 los errores y las excepciones 64 00:03:59,449 --> 00:04:02,669 los errores son chungos 65 00:04:02,669 --> 00:04:04,789 los errores es 66 00:04:04,789 --> 00:04:07,509 cuidado que aquí ha pasado algo 67 00:04:07,509 --> 00:04:10,069 demasiado grande 68 00:04:10,069 --> 00:04:13,490 aquí la java virtual machine 69 00:04:13,490 --> 00:04:14,629 ha colapsado 70 00:04:14,629 --> 00:04:17,709 no puedes hacer nada para recuperar 71 00:04:17,709 --> 00:04:19,110 error 72 00:04:19,110 --> 00:04:22,810 o una excepción 73 00:04:22,810 --> 00:04:25,050 aquí ha pasado algo 74 00:04:25,050 --> 00:04:26,990 que no me esperaba 75 00:04:26,990 --> 00:04:29,449 normalmente el programa funciona 76 00:04:29,449 --> 00:04:31,250 en este caso excepcional 77 00:04:31,250 --> 00:04:32,990 pues no ha funcionado 78 00:04:32,990 --> 00:04:35,449 las excepciones 79 00:04:36,189 --> 00:04:37,310 se pueden 80 00:04:37,310 --> 00:04:39,449 recuperar, o sea, tú puedes decir 81 00:04:39,449 --> 00:04:41,689 vale, muy bien, si pasa 82 00:04:41,689 --> 00:04:43,490 algo así, no 83 00:04:43,490 --> 00:04:45,290 no colapses 84 00:04:45,290 --> 00:04:47,329 déjamela a mí 85 00:04:47,329 --> 00:04:49,550 y yo te digo cómo recuperarte 86 00:04:49,550 --> 00:04:50,970 de este posible 87 00:04:50,970 --> 00:04:52,250 error 88 00:04:52,250 --> 00:04:54,269 ¿se entiende más o menos? 89 00:04:55,189 --> 00:04:55,350 ¿sí? 90 00:04:56,490 --> 00:04:59,949 entonces, una excepción es un error 91 00:04:59,949 --> 00:05:01,769 un fallo en un programa que ocurre 92 00:05:01,769 --> 00:05:02,990 en tiempo de ejecución 93 00:05:02,990 --> 00:05:05,490 no saltará nunca una excepción 94 00:05:05,490 --> 00:05:07,850 mientras estás compilando, mientras estás aplicando 95 00:05:07,850 --> 00:05:09,089 códigos, cuando le das al play 96 00:05:09,089 --> 00:05:14,310 Paso al play, llego a un array, intento leer la primera posición del array, 97 00:05:14,649 --> 00:05:18,430 el array es null, y por lo tanto me da una null pointer exception. 98 00:05:20,110 --> 00:05:25,069 Tú me dices, dame un número, yo te escribo gato, por lo tanto no es un número, 99 00:05:25,410 --> 00:05:31,829 te lanzo un arithmetic number exception o una number format exception, no me acuerdo cómo sea. 100 00:05:32,569 --> 00:05:32,689 ¿Sí? 101 00:05:33,870 --> 00:05:34,990 ¿Qué cosa podrías decir? 102 00:05:34,990 --> 00:05:39,370 Cuando un error ocurre, lo más normal es que se detenga el programa. 103 00:05:39,370 --> 00:05:41,970 Nosotros hemos visto que hasta ahora sale un mensaje en rojo. 104 00:05:42,170 --> 00:05:42,850 ¿Por qué sale en rojo? 105 00:05:46,379 --> 00:05:53,680 Porque en vez que en system.out.println, escribe en system.er.println. 106 00:05:54,060 --> 00:06:00,560 Si vosotros en cualquiera de vuestros programas, en vez de system.out ponéis en system.er, el mensaje sale en rojo. 107 00:06:01,240 --> 00:06:05,920 Vosotros tenéis dos canales de salida y un canal de entrada en cada programa. 108 00:06:05,920 --> 00:06:07,620 ¿vale? el canal del programa 109 00:06:07,620 --> 00:06:09,180 de entrada es el system in 110 00:06:09,180 --> 00:06:16,139 y el sistema out 111 00:06:16,139 --> 00:06:19,040 es la salida 112 00:06:19,040 --> 00:06:20,019 estándar 113 00:06:20,019 --> 00:06:21,379 de tu programa 114 00:06:21,379 --> 00:06:23,899 pero además tu programa, tu proceso 115 00:06:23,899 --> 00:06:26,399 siempre tiene un tercer canal de salida 116 00:06:26,399 --> 00:06:28,060 o sea, un segundo canal de salida 117 00:06:28,060 --> 00:06:29,519 o un tercer canal de comunicación 118 00:06:29,519 --> 00:06:32,339 que es el canal por donde 119 00:06:32,339 --> 00:06:33,680 mandas los errores 120 00:06:33,680 --> 00:06:36,139 ¿vale? porque normalmente tú quieres decir 121 00:06:36,139 --> 00:06:37,959 una cosa al usuario que te está usando 122 00:06:37,959 --> 00:06:43,699 y una cosa distinta al programador que te ha programado por si pasa algo, ¿sí? 123 00:06:44,180 --> 00:06:48,680 Es el concepto de que tú, si te llama tu cliente y te dice, 124 00:06:48,680 --> 00:06:53,060 oye, me está dando este error de aquí, pues tú vas allí y te vas a mirar 125 00:06:53,060 --> 00:06:58,680 el canal secreto de administradores y vas a mirar qué te ha dicho en el error, 126 00:06:58,800 --> 00:07:04,000 porque al usuario le dirá, no me puedo conectar, 127 00:07:04,519 --> 00:07:07,819 pero tú por debajo te habrías escrito, no me puedo conectar por esta razón de aquí, 128 00:07:07,819 --> 00:07:09,740 porque el IP no funciona 129 00:07:09,740 --> 00:07:11,959 porque no he podido generar no sé qué fichero 130 00:07:11,959 --> 00:07:13,740 y cosas por el estilo. Entonces tú 131 00:07:13,740 --> 00:07:15,980 entiendes esa jerga, entonces lo pones 132 00:07:15,980 --> 00:07:17,959 allí, el otro no. Se pueden 133 00:07:17,959 --> 00:07:19,819 redireccionar estos canales 134 00:07:19,819 --> 00:07:21,399 para que escriban en ficheros. 135 00:07:21,759 --> 00:07:23,800 Que es lo que se suele hacer, los famosos 136 00:07:23,800 --> 00:07:25,879 ficheros de Londres. Entonces 137 00:07:25,879 --> 00:07:27,860 los errores y los problemas se 138 00:07:27,860 --> 00:07:29,600 escriben dentro de un fichero 139 00:07:29,600 --> 00:07:31,240 conectado al system.er 140 00:07:31,240 --> 00:07:34,100 para que escriba en estos ficheros 141 00:07:34,100 --> 00:07:35,720 y entonces tú como 142 00:07:35,720 --> 00:07:37,720 administrador, cuando hay un programa 143 00:07:37,720 --> 00:07:39,879 que no funciona, vas a mirar los ficheros 144 00:07:39,879 --> 00:07:42,139 de log de error, y allí te encuentras 145 00:07:42,139 --> 00:07:43,100 cuáles son los problemas. 146 00:07:44,540 --> 00:07:44,980 ¿Dudas? 147 00:07:46,420 --> 00:07:47,939 ¿Con lo que has dicho entonces 148 00:07:47,939 --> 00:07:50,120 por la tercera salida 149 00:07:50,120 --> 00:07:52,019 podríamos crear nuestros propios 150 00:07:52,019 --> 00:07:54,740 errores para el futuro? 151 00:07:55,259 --> 00:07:57,500 No exactamente. Sí puedes hacer 152 00:07:57,500 --> 00:07:59,120 lo que acabas de decir, de otra forma. 153 00:07:59,620 --> 00:08:01,300 Eso es simplemente que tú puedes escribir 154 00:08:01,300 --> 00:08:02,920 mensajes, digamos, 155 00:08:02,920 --> 00:08:04,680 en dos canales. 156 00:08:04,959 --> 00:08:06,839 Uno es el canal orientado 157 00:08:06,839 --> 00:08:08,860 a hablar con quien te está usando, 158 00:08:08,860 --> 00:08:17,740 y otro es el es el canal donde tú vas a meter los errores vale en eclipse o en básico lo que 159 00:08:17,740 --> 00:08:25,100 hacen es escribir en el mismo sitio la consola pero luego se pueden redireccionar para que 160 00:08:25,100 --> 00:08:31,420 escriban en un fichero para que escriban en un socket y lo mande por internet entonces 161 00:08:31,420 --> 00:08:36,740 tú te recibes en tu ordenador hoy mira había un error en este sistema o cosa por estilo se puede 162 00:08:36,740 --> 00:08:39,360 cambia la cosa 163 00:08:39,360 --> 00:08:41,419 entonces tú tienes esas dos cosas 164 00:08:41,419 --> 00:08:43,899 una es los mensajes normales 165 00:08:43,899 --> 00:08:45,659 que te esperas, que hablas con el 166 00:08:45,659 --> 00:08:47,200 usuario, con quien te está usando 167 00:08:47,200 --> 00:08:49,639 y otro, que puedes usar o no 168 00:08:49,639 --> 00:08:50,700 para los errores 169 00:08:50,700 --> 00:08:53,279 pero esto es un poquito distinto 170 00:08:53,279 --> 00:08:55,840 tú puedes crearte tus propios errores 171 00:08:55,840 --> 00:08:57,340 pero con muchas excepciones 172 00:08:57,340 --> 00:08:58,600 y lo veremos dentro de un rato 173 00:08:58,600 --> 00:09:00,559 ok 174 00:09:00,559 --> 00:09:03,779 Java proporciona un mecanismo para controlar 175 00:09:03,779 --> 00:09:05,860 situaciones que normalmente provocarían 176 00:09:05,860 --> 00:09:07,320 una interrupción de ejecución, ¿vale? 177 00:09:07,659 --> 00:09:09,700 Cuando vosotros, cuando yo digo 178 00:09:09,700 --> 00:09:11,720 que explota el programa, que separa 179 00:09:11,720 --> 00:09:13,600 la Java Vector Machine, es porque ha habido 180 00:09:13,600 --> 00:09:15,879 uno de estos errores, de estas excepciones, 181 00:09:16,320 --> 00:09:17,620 y nadie ha 182 00:09:17,620 --> 00:09:19,000 controlado esta excepción. 183 00:09:19,899 --> 00:09:21,620 Si esta excepción escala, escala, 184 00:09:21,720 --> 00:09:23,320 escala, y llega al main, 185 00:09:23,559 --> 00:09:25,480 y nadie en el main dice, mira, 186 00:09:25,820 --> 00:09:27,940 cuando te pasa esto, tienes que solucionarlo 187 00:09:27,940 --> 00:09:29,779 de esta forma, pues la única cosa 188 00:09:29,779 --> 00:09:31,879 que puede hacer él es, oye, mira, lo siento 189 00:09:31,879 --> 00:09:33,139 mucho, aquí se acaba. 190 00:09:33,799 --> 00:09:35,519 Si tú dices, oye, soy un escáner, 191 00:09:35,679 --> 00:09:37,039 léete un número, ¿vale? 192 00:09:37,159 --> 00:09:39,919 Tú lees un número y te dan en vez de un string 193 00:09:39,919 --> 00:09:42,120 y tú no le has explicado al programa 194 00:09:42,120 --> 00:09:44,440 qué hacer cuando te dan un string, 195 00:09:44,960 --> 00:09:46,240 pues lo único que se puede hacer 196 00:09:46,240 --> 00:09:47,820 es parar la llave de tu máquina y decir, 197 00:09:47,899 --> 00:09:49,220 tío, de aquí no puedo seguir. 198 00:09:50,139 --> 00:09:53,019 Pero, sin embargo, si tú allí haces 199 00:09:53,019 --> 00:09:54,379 lo que tienes que hacer para decirle 200 00:09:54,379 --> 00:09:57,759 cuando te pase una cosa que no es un número, 201 00:09:58,240 --> 00:09:59,840 tú le tienes que decir, oye, 202 00:10:00,120 --> 00:10:01,940 te he pedido un número, no otra cosa, 203 00:10:01,940 --> 00:10:04,679 y volver a pedírselo, pues entonces 204 00:10:04,679 --> 00:10:08,019 él ya no explota. Él se mantendrá allí, 205 00:10:08,159 --> 00:10:10,759 controlará la excepción y volverá a pedirte el mundo. 206 00:10:11,120 --> 00:10:12,179 Pero eso tienes que decir tú. 207 00:10:13,100 --> 00:10:21,149 Para manejar los errores, lo hemos dicho ya 208 00:10:21,149 --> 00:10:23,350 en episodios anteriores, hay dos 209 00:10:23,350 --> 00:10:26,690 formas, ¿vale? Una es la forma pesimista 210 00:10:26,690 --> 00:10:29,690 y otra la forma optimista, digamos así. 211 00:10:29,789 --> 00:10:32,330 La forma pesimista es, oye, mira, 212 00:10:32,769 --> 00:10:35,529 yo sé que va a haber errores, va a haber 213 00:10:35,529 --> 00:10:37,629 cosas problemáticas. 214 00:10:37,870 --> 00:10:40,070 Pues voy a rellenar mi código 215 00:10:40,070 --> 00:10:42,149 de comprobaciones 216 00:10:42,149 --> 00:10:43,110 de ifs 217 00:10:43,110 --> 00:10:45,350 para minimizar 218 00:10:45,350 --> 00:10:47,409 la posibilidad que haya un error. 219 00:10:49,049 --> 00:10:49,370 Entonces, 220 00:10:49,870 --> 00:10:52,090 si mi programa explotaría 221 00:10:52,090 --> 00:10:53,470 al meterle un número negativo, 222 00:10:53,629 --> 00:10:55,669 yo voy a comprobar, oye, si el número 223 00:10:55,669 --> 00:10:57,590 es negativo, no hagas nada. 224 00:10:57,590 --> 00:10:59,190 Y si es positivo, sigue adelante. 225 00:11:00,110 --> 00:11:01,970 Y si tú me tenías que dar un string, 226 00:11:02,090 --> 00:11:03,909 voy a comprobar que sea un string. 227 00:11:03,909 --> 00:11:05,690 Y si el string es null, pues me paro. 228 00:11:05,769 --> 00:11:07,289 Si no, todo es cuniz. 229 00:11:08,169 --> 00:11:10,610 El problema de este mecanismo 230 00:11:10,610 --> 00:11:15,649 es que primero encontrar todos los posibles fallos 231 00:11:15,649 --> 00:11:17,029 es complejo. 232 00:11:18,110 --> 00:11:21,950 A lo mejor un caso concreto no se te ha pasado por acá 233 00:11:21,950 --> 00:11:26,929 y a lo mejor necesitarías una condición booleana gigantesca 234 00:11:26,929 --> 00:11:28,029 para cubrir ese caso. 235 00:11:29,769 --> 00:11:32,330 Y si los datos son correctos, 236 00:11:32,330 --> 00:11:34,049 estoy sobrecargando el sistema 237 00:11:34,049 --> 00:11:35,929 con los innecesarios. O sea, 238 00:11:36,149 --> 00:11:38,070 por cada vez que yo ejecuto mi programa 239 00:11:38,070 --> 00:11:39,570 que todo iría bien, 240 00:11:39,909 --> 00:11:42,610 te piden un número y te dan un número 241 00:11:42,610 --> 00:11:44,850 tenía que ser positivo y es positivo. 242 00:11:44,970 --> 00:11:46,750 Tú estás preguntando, ¿ma es un número? 243 00:11:47,289 --> 00:11:48,190 Así, entonces sigue adelante. 244 00:11:48,450 --> 00:11:50,370 ¿Ma es positivo? Sí, sigue adelante. 245 00:11:50,649 --> 00:11:52,889 Estás haciendo comprobaciones innecesarias. 246 00:11:54,450 --> 00:11:56,629 Si, en situaciones en las que 247 00:11:56,629 --> 00:11:58,389 estadísticamente es 248 00:11:58,389 --> 00:11:59,950 bastante improbable 249 00:11:59,950 --> 00:12:02,269 que te pongan 250 00:12:02,330 --> 00:12:07,269 Dados mal, por ejemplo, este es un sistema que utilizan otros informáticos y entonces 251 00:12:07,269 --> 00:12:13,450 saben lo que tienen que hacer, pues tú estás gastando recursos para nada. 252 00:12:13,450 --> 00:12:19,769 Entonces se contrapone al manejo de excepciones optimista. 253 00:12:19,769 --> 00:12:22,149 ¿Cómo es optimista? 254 00:12:22,149 --> 00:12:29,730 Optimista es decir, pues tranquilo, todo irá bien, tú ejecútalo y trabaja, no va a pasar 255 00:12:29,730 --> 00:12:30,730 nada. 256 00:12:30,730 --> 00:12:32,870 la mayoría de las veces, no va a pasar 257 00:12:32,870 --> 00:12:33,970 nada. ¡Qué bien! 258 00:12:35,269 --> 00:12:37,230 Pero yo marco 259 00:12:37,230 --> 00:12:38,629 algunos 260 00:12:38,629 --> 00:12:40,490 trozos de código diciendo, ¡eh, mira! 261 00:12:41,210 --> 00:12:43,009 Si cuando tú estás aquí, que tranquilo 262 00:12:43,009 --> 00:12:44,669 que no va a pasar nada, pero si 263 00:12:44,669 --> 00:12:46,610 en el caso aquí pasara 264 00:12:46,610 --> 00:12:48,730 algo, te voy a dejar unas 265 00:12:48,730 --> 00:12:50,570 instrucciones para intentar 266 00:12:50,570 --> 00:12:52,710 recuperarte. Estas instrucciones 267 00:12:52,710 --> 00:12:53,750 pueden pasar del 268 00:12:53,750 --> 00:12:56,230 escribe un mensaje de error 269 00:12:56,230 --> 00:12:58,289 y colapsa, a 270 00:12:58,289 --> 00:13:00,750 escribe este mensaje en un fichero 271 00:13:00,750 --> 00:13:02,470 y colapsa. Ah, oye, 272 00:13:02,570 --> 00:13:04,429 no colapses y te explico 273 00:13:04,429 --> 00:13:05,909 cómo recuperarte de este error. 274 00:13:06,889 --> 00:13:09,820 ¿Sí? Proteger 275 00:13:09,820 --> 00:13:11,980 el código potencialmente peligroso 276 00:13:11,980 --> 00:13:14,240 implica una estructura 277 00:13:14,240 --> 00:13:14,980 try-catch. 278 00:13:15,759 --> 00:13:17,639 Sostantialmente, prueba a hacer una cosa 279 00:13:17,639 --> 00:13:19,700 y pilla los posibles errores. 280 00:13:22,320 --> 00:13:22,659 ¿Dudas? 281 00:13:24,759 --> 00:13:25,559 Yo 282 00:13:25,559 --> 00:13:26,940 entiendo las 283 00:13:26,940 --> 00:13:28,759 dos opciones 284 00:13:28,759 --> 00:13:31,860 y para mí personalmente 285 00:13:31,860 --> 00:13:33,080 me parece un poco la optimista 286 00:13:33,080 --> 00:13:35,559 pero no sé 287 00:13:35,559 --> 00:13:37,159 cuál es la diferencia entre una y otra 288 00:13:37,159 --> 00:13:39,720 entre el programa de manera optimista 289 00:13:39,720 --> 00:13:41,879 y de manera pesimista, porque para mí personalmente 290 00:13:41,879 --> 00:13:43,700 diría, joder, pues lo hago todo 291 00:13:43,700 --> 00:13:45,659 de manera optimista y ya está 292 00:13:45,659 --> 00:13:47,700 pero ¿qué tiene de malo? 293 00:13:47,700 --> 00:13:48,639 a diferencia del otro 294 00:13:48,639 --> 00:13:50,799 no 295 00:13:50,799 --> 00:13:53,659 no hay ni bueno ni malo 296 00:13:53,659 --> 00:13:55,899 ¿vale? el concepto es que 297 00:13:55,899 --> 00:13:57,500 en determinadas 298 00:13:57,500 --> 00:13:59,820 circunstancias te compensa 299 00:13:59,820 --> 00:14:01,580 usar uno, en determinadas 300 00:14:01,580 --> 00:14:03,860 circunstancias te compensa hacer otro. 301 00:14:03,940 --> 00:14:05,279 Esto no es gratis. 302 00:14:06,019 --> 00:14:07,379 ¿Vale? O sea, aquí 303 00:14:07,379 --> 00:14:09,799 haces un cierto sobrecarga 304 00:14:09,799 --> 00:14:11,500 cuando haces este código, 305 00:14:11,860 --> 00:14:13,820 algo tiene que estar allí cuidando 306 00:14:13,820 --> 00:14:15,460 de decir, oye, mira, que si pasa algo, 307 00:14:15,620 --> 00:14:17,840 lo tengo que recuperar, no puede explotar sin nada. 308 00:14:17,980 --> 00:14:19,200 ¿Vale? Pero no es gratis. 309 00:14:19,559 --> 00:14:21,799 Tampoco el IF es gratis. Preguntarse si esto 310 00:14:21,799 --> 00:14:23,840 es así. Ahora, hay situaciones 311 00:14:23,840 --> 00:14:25,860 en que una cosa la puedes hacer y la otra 312 00:14:25,860 --> 00:14:26,019 no. 313 00:14:27,500 --> 00:14:36,799 O al revés. Esto de leer un número y que en vez de leer un gato, no lo puedes considerar con un string. 314 00:14:37,179 --> 00:14:43,000 Porque el error no te sale en lo he metido en una variable y ahora puedo comprobar esa variable. 315 00:14:43,679 --> 00:14:49,080 El error te sale antes. Cuando tú intentas poner algo en una variable que puede contener Intel, estás poniendo un string. 316 00:14:49,440 --> 00:14:52,259 Entonces, colapsa antes que tú puedas hacer un if sobre esa variable. 317 00:14:52,879 --> 00:14:54,639 Entonces, ahí, por ejemplo, no puedes usar el if. 318 00:14:54,639 --> 00:14:57,440 hay otras situaciones 319 00:14:57,440 --> 00:14:59,179 en el que tú no quieres 320 00:14:59,179 --> 00:15:01,259 gestionarlos con excepciones 321 00:15:01,259 --> 00:15:02,559 o no tienes una excepción 322 00:15:02,559 --> 00:15:04,879 válida para ese contexto 323 00:15:04,879 --> 00:15:07,059 y entonces quieres comprobar 324 00:15:07,059 --> 00:15:09,059 que lo que estás metiendo 325 00:15:09,059 --> 00:15:11,240 los datos que estás metiendo sean correctos 326 00:15:11,240 --> 00:15:12,299 a través de ETH 327 00:15:12,299 --> 00:15:15,059 eso depende 328 00:15:15,059 --> 00:15:16,980 un poco del proyecto y de 329 00:15:16,980 --> 00:15:19,100 dónde estás, hay estos dos medios 330 00:15:19,100 --> 00:15:20,559 el ETH 331 00:15:20,559 --> 00:15:23,179 es asegurarse que antes de utilizar 332 00:15:23,179 --> 00:15:24,960 los datos, los datos sean correctos 333 00:15:24,960 --> 00:15:27,240 el try es intentarlo 334 00:15:27,240 --> 00:15:29,080 y si va mal me recupero 335 00:15:29,080 --> 00:15:31,220 del error, son dos enfoques 336 00:15:31,220 --> 00:15:32,980 distintos, el try catch 337 00:15:32,980 --> 00:15:34,419 se utiliza más 338 00:15:34,419 --> 00:15:36,960 a nivel de cosas 339 00:15:36,960 --> 00:15:39,000 que puedan lanzar excepciones en lo que 340 00:15:39,000 --> 00:15:39,919 se tiene que utilizar 341 00:15:39,919 --> 00:15:43,100 el otro, a lo mejor 342 00:15:43,100 --> 00:15:44,200 hay algunas situaciones 343 00:15:44,200 --> 00:15:46,980 que compensa 344 00:15:46,980 --> 00:15:49,179 decir, los ejemplitos que hemos hecho nosotros 345 00:15:49,179 --> 00:15:51,220 me tienes que dar un número positivo 346 00:15:51,220 --> 00:15:53,100 pues vale, compruebo que el número 347 00:15:53,100 --> 00:15:54,960 sea positivo porque si es negativo 348 00:15:54,960 --> 00:15:56,220 quiero hacer una cosa distinta 349 00:15:56,220 --> 00:15:58,600 considera que el try catch lo que hace es 350 00:15:58,600 --> 00:16:00,600 si va mal 351 00:16:00,600 --> 00:16:02,860 utilizar ese valor 352 00:16:02,860 --> 00:16:05,059 pero allí ya algo ha ido 353 00:16:05,059 --> 00:16:05,440 mal 354 00:16:05,440 --> 00:16:09,120 si lo podía prevenir a lo mejor no lo ha sido 355 00:16:09,120 --> 00:16:09,379 ¿vale? 356 00:16:11,000 --> 00:16:12,820 es sutil, se puede hacer 357 00:16:12,820 --> 00:16:14,740 muchas veces se pueden hacer las dos cosas 358 00:16:14,740 --> 00:16:17,080 hay veces como el ejemplo anterior que no 359 00:16:17,080 --> 00:16:18,860 se puede hacer por ejemplo el list 360 00:16:18,860 --> 00:16:20,600 y se tiene que hacer con try catch 361 00:16:20,600 --> 00:16:24,500 casos concretos, una regla 362 00:16:24,500 --> 00:16:25,940 concreta de cuándo es el uno o el otro, 363 00:16:26,460 --> 00:16:28,179 no te la sabré yo. 364 00:16:28,860 --> 00:16:28,980 ¿Vale? 365 00:16:32,639 --> 00:16:33,600 Tened en cuenta que 366 00:16:33,600 --> 00:16:36,159 esto también a lo mejor lo entenderás 367 00:16:36,159 --> 00:16:37,759 mejor en 10 años 368 00:16:37,759 --> 00:16:39,759 después que has trabajado en una empresa. 369 00:16:40,159 --> 00:16:42,059 ¿Vale? Aquí la clave 370 00:16:42,059 --> 00:16:44,179 es saber que hay las dos herramientas, 371 00:16:44,279 --> 00:16:45,559 las dos posibilidades de hacer las cosas, 372 00:16:45,759 --> 00:16:47,519 y llega un momento de una vida y dirás, oye, mira, 373 00:16:47,600 --> 00:16:48,820 aquí esto encaja perfecto. 374 00:16:48,820 --> 00:17:11,920 es que depende me explico tú imagínate que yo tengo un campo edad y yo no quiero poner una 375 00:17:11,920 --> 00:17:18,359 edad negativa. Si alguien me dice edad menos 7, eso no es un error. El tráquecho no hace nada. 376 00:17:19,079 --> 00:17:25,700 El tráquecho dice, perfecto, metele menos 7. Ahora, otra cosa es que después de la edad, 377 00:17:25,700 --> 00:17:31,960 yo voy a hacer un cálculo que si el número es negativo, por ejemplo, voy a hacer una raíz 378 00:17:31,960 --> 00:17:37,299 cuadrada o qué sé yo, y si el número es negativo, me da un error. Pues entonces allí sí que podría 379 00:17:37,299 --> 00:17:42,799 tratarlo con un trackech. Pero el número ya está en la variable, no sé si me explico. 380 00:17:42,799 --> 00:18:01,319 Entonces, ejemplo de pesimista contra optimista, ¿vale? Entonces, vosotros sabéis que si yo divido 381 00:18:01,319 --> 00:18:08,700 un número por cero, explota. Aritmética excepción. No se puede dividir un número por cero, ¿vale? 382 00:18:08,700 --> 00:18:10,940 entonces, pesimista 383 00:18:10,940 --> 00:18:13,160 hay un main, tengo un scanner 384 00:18:13,160 --> 00:18:15,099 digo, dame un entero, me dan 385 00:18:15,099 --> 00:18:16,599 un entero y me pregunto 386 00:18:16,599 --> 00:18:19,019 si el denominador es distinto 387 00:18:19,019 --> 00:18:20,779 de cero, pues entonces 388 00:18:20,779 --> 00:18:22,579 haz la operación, y si no 389 00:18:22,579 --> 00:18:24,880 dices algo 390 00:18:24,880 --> 00:18:26,680 aquí no hay un else, pero 391 00:18:26,680 --> 00:18:28,980 sigues con la 392 00:18:28,980 --> 00:18:29,759 programación, ¿vale? 393 00:18:30,819 --> 00:18:32,839 aquí no explota 394 00:18:32,839 --> 00:18:34,700 porque si el denominador es cero 395 00:18:34,700 --> 00:18:36,660 no hará la operación, ¿vale? 396 00:18:36,660 --> 00:18:43,480 No escribirá esta línea de códigos, pero no la ejecuta y por lo tanto no es nuestro, ¿vale? 397 00:18:44,079 --> 00:18:49,900 Pero todas las veces que yo le pongo, como tengo en el nominador, un número que no es cero, 398 00:18:50,519 --> 00:18:53,039 yo tendré que hacer este if, ¿vale? 399 00:18:53,759 --> 00:18:55,880 Y que me dirá, sí, no es cero, y me escribirá la cosa. 400 00:18:56,359 --> 00:18:57,619 Es como una operación esta. 401 00:18:57,759 --> 00:19:03,180 Si yo sé que esto prácticamente no va a pasar nunca, o sea, a lo mejor es un gasto innecesario. 402 00:19:03,180 --> 00:19:12,619 A nivel de 3K, yo no hago el if, simplemente hago esta división y pruebo a hacer esta división. 403 00:19:13,319 --> 00:19:20,799 En el caso en que explote una excepción, lo que hago es escribir este número no es válido o recuperarme o cosas por el estilo. 404 00:19:20,940 --> 00:19:24,400 Esto no hace explotar el programa, el programa sigue adelante. 405 00:19:24,400 --> 00:19:26,519 Si yo quito 406 00:19:26,519 --> 00:19:28,319 Este de aquí y pongo solo 407 00:19:28,319 --> 00:19:30,700 Llave, llave, no hace nada 408 00:19:30,700 --> 00:19:32,799 No escribe nada, no cambia nada y sigue adelante 409 00:19:32,799 --> 00:19:34,119 Exactamente como hacía este 410 00:19:34,119 --> 00:19:37,119 Ha habido un error 411 00:19:37,119 --> 00:19:38,740 Pero se ha recuperado el error 412 00:19:38,740 --> 00:19:39,400 Y sigue adelante 413 00:19:39,400 --> 00:19:42,359 Esto porque hay alguien 414 00:19:42,359 --> 00:19:44,640 Que se ha encargado de 415 00:19:44,640 --> 00:19:46,700 Hacer este error, veis que estamos en el main 416 00:19:46,700 --> 00:19:48,140 Pero el 417 00:19:48,140 --> 00:19:50,539 El código que da problemas 418 00:19:50,539 --> 00:19:51,460 Está protegido 419 00:19:51,460 --> 00:19:53,819 Si yo quitar el track edge 420 00:19:53,819 --> 00:19:56,299 cuando esto se ejecuta, da una excepción 421 00:19:56,299 --> 00:19:57,200 no hay nadie 422 00:19:57,200 --> 00:20:00,200 que gestiona, que controla esta excepción 423 00:20:00,200 --> 00:20:02,140 estoy en el made, por lo tanto 424 00:20:02,140 --> 00:20:03,539 la java esto machine se para 425 00:20:03,539 --> 00:20:05,440 y me da un error de excepción 426 00:20:05,440 --> 00:20:05,960 ¿qué pasa con esto? 427 00:20:07,339 --> 00:20:13,480 dudad, vale, existe una clase 428 00:20:13,480 --> 00:20:15,420 que se llama exception, lo podéis encontrar en el 429 00:20:15,420 --> 00:20:17,759 API, vale, exception es 430 00:20:17,759 --> 00:20:19,859 una clase 431 00:20:19,859 --> 00:20:21,500 de alto nivel 432 00:20:21,500 --> 00:20:23,160 de las que heredan 433 00:20:23,160 --> 00:20:25,140 la mayoría de los 434 00:20:25,140 --> 00:20:27,240 de las clases que acaban con 435 00:20:27,240 --> 00:20:35,599 bla bla bla excepción. Null pointer exception, aritmetic exception, stackable flow exception, etc. 436 00:20:35,599 --> 00:20:44,339 No sé si era un exception, no lo recuerdo bien. Pero bueno. Cuando en este tema, la JVM crea un 437 00:20:44,339 --> 00:20:49,920 objeto de la clase exception. O sea, cuando hay este tipo de error, que se ha estropeado, 438 00:20:49,920 --> 00:20:56,980 la JVM va a recopilar datos su por qué ha habido este error y lo esguarda, crea un objeto 439 00:20:56,980 --> 00:20:59,019 rellenando sus atributos, un objeto 440 00:20:59,019 --> 00:21:01,059 de tipo excepción. ¿Vale? Este objeto. 441 00:21:06,680 --> 00:21:07,859 Entonces, si yo dentro 442 00:21:07,859 --> 00:21:09,279 del ramacatch, 443 00:21:09,799 --> 00:21:11,259 dentro de esta variable, 444 00:21:11,779 --> 00:21:13,839 tendré una referencia al objeto 445 00:21:13,839 --> 00:21:15,920 excepción que ha creado la JavectorMachine. 446 00:21:16,259 --> 00:21:17,440 Entonces, le podré preguntar, 447 00:21:17,559 --> 00:21:19,559 mira qué ha pasado, dame una 448 00:21:19,559 --> 00:21:21,559 descripción de por qué has explotado, 449 00:21:21,940 --> 00:21:23,700 dame una descripción de lo que ha 450 00:21:23,700 --> 00:21:25,440 pasado, de cuál es el contexto, 451 00:21:25,839 --> 00:21:27,880 se puede hacer varias cosas sobre 452 00:21:27,880 --> 00:21:29,619 la excepción. 453 00:21:29,700 --> 00:21:38,089 En este objeto se guarda información sobre el error, quién lo ha producido, dónde se ha producido, qué ha causado errores, etc. 454 00:21:38,809 --> 00:21:42,789 Un mismo código peligroso podría causar distintos tipos de excepciones. 455 00:21:43,250 --> 00:21:47,210 Aquí podría ser que ponga un try, luego varias líneas de código y un catch. 456 00:21:47,789 --> 00:21:53,609 Y puede ser que allí haya explotado por un null pointer exception, haya explotado por un number format exception, 457 00:21:53,609 --> 00:21:59,170 haya explotado porque no ha podido leer un fichero, la IO exception, input output exception. 458 00:21:59,170 --> 00:22:02,309 y podría ser que yo no lo sé 459 00:22:02,309 --> 00:22:03,809 si lo pongo así 460 00:22:03,809 --> 00:22:07,650 sea cual sea 461 00:22:07,650 --> 00:22:10,009 el error, la excepción 462 00:22:10,009 --> 00:22:11,750 que ha saltado, pues 463 00:22:11,750 --> 00:22:12,349 llevo aquí 464 00:22:12,349 --> 00:22:15,710 porque una null pointer exception 465 00:22:15,710 --> 00:22:18,049 es una excepción 466 00:22:18,049 --> 00:22:18,849 porque la he dado 467 00:22:18,849 --> 00:22:21,509 la IO exception es una excepción 468 00:22:21,509 --> 00:22:23,970 entonces aquí estoy pillando algo genérico 469 00:22:23,970 --> 00:22:26,309 y sea cual sea el error 470 00:22:26,309 --> 00:22:27,450 voy a ver que pasa 471 00:22:27,450 --> 00:22:29,769 sin embargo 472 00:22:29,769 --> 00:22:33,210 se puede manejar 473 00:22:33,210 --> 00:22:34,990 las excepciones de una forma un poquito 474 00:22:34,990 --> 00:22:36,849 más fina. O sea, decir que 475 00:22:36,849 --> 00:22:39,190 oye, mira, si tú el error que ha habido 476 00:22:39,190 --> 00:22:40,750 era un all pointer exception, 477 00:22:41,349 --> 00:22:42,970 haz esto. Pero si 478 00:22:42,970 --> 00:22:44,470 en vez de no era un all pointer exception, 479 00:22:44,589 --> 00:22:46,690 era otro tipo de error, pues 480 00:22:46,690 --> 00:22:47,890 haz una cosa distinta. 481 00:22:48,769 --> 00:22:50,210 Y esto se hace 482 00:22:50,210 --> 00:22:52,670 así. 483 00:22:54,670 --> 00:22:55,349 Encontré 484 00:22:55,349 --> 00:22:58,509 y luego digo, catch arithmetic 485 00:22:58,509 --> 00:23:00,630 exception. Pues aquí dentro 486 00:23:00,630 --> 00:23:02,509 este bloque 3 se ejecutará 487 00:23:02,509 --> 00:23:04,309 si es sólo si la excepción 488 00:23:04,309 --> 00:23:06,410 que ha explotado es una aritmética 489 00:23:06,410 --> 00:23:06,849 exception. 490 00:23:08,210 --> 00:23:10,289 Si no, se ejecutará esto 491 00:23:10,289 --> 00:23:12,089 porque aquí dentro caen 492 00:23:12,089 --> 00:23:13,750 todas las otras excepciones posibles. 493 00:23:15,549 --> 00:23:15,630 ¿Ve? 494 00:23:15,750 --> 00:23:17,829 Tened en cuenta que el orden cuenta. 495 00:23:18,589 --> 00:23:20,130 Si yo esto lo inverto, 496 00:23:20,589 --> 00:23:22,309 la aritmética exception no la 497 00:23:22,309 --> 00:23:24,250 ejecutaré nunca, porque siempre pillará 498 00:23:24,250 --> 00:23:26,309 la primera como, ah, sí, es una excepción. 499 00:23:28,410 --> 00:23:28,769 ¿Entiendes? 500 00:23:28,769 --> 00:23:28,869 ¿Ve? 501 00:23:32,069 --> 00:23:36,430 Entonces, en una situación como esta, yo estaría ejecutando el bloque 1, ¿vale? 502 00:23:36,849 --> 00:23:41,890 Si no hay ninguna excepción, ejecuto el bloque 2 y luego voy al bloque 5. 503 00:23:43,210 --> 00:23:44,230 Sin ningún problema. 504 00:23:45,369 --> 00:23:49,470 Si salta una excepción de tipo aritmético, yo ejecutaría el bloque 1, 505 00:23:49,710 --> 00:23:54,529 el bloque 2 lo ejecutaría parcialmente, asterisco, hasta donde salta el error. 506 00:23:55,029 --> 00:23:57,789 Donde salta el error, entraría en el bloque 3. 507 00:23:58,190 --> 00:24:00,650 Ejecutaría el bloque 3 y luego me iría al bloque 5. 508 00:24:02,069 --> 00:24:08,890 Si en vez sale una excepción que no es una aritmética excepción, cualquier otra excepción, 509 00:24:09,349 --> 00:24:15,069 pues bloque 1, bloque 2 a mitad, saltaría al bloque 4 y seguiría por bloque 4. 510 00:24:16,730 --> 00:24:17,130 ¿Dudas? 511 00:24:19,819 --> 00:24:22,519 Existe también una cláusula opcional. 512 00:24:23,160 --> 00:24:26,359 Esto es un try, catch, catch, catch, catch. 513 00:24:26,759 --> 00:24:28,859 Se puede poner un finally. 514 00:24:28,859 --> 00:24:36,539 el finales en cualquier caso después que has hecho lo que tiene que hacer ejecuta esta parte 515 00:24:38,799 --> 00:24:44,079 como si fuera una parte que tanto que explote como que no así que la tiene que ejecutar pues 516 00:24:44,079 --> 00:24:57,420 entonces la pongo en un final por ejemplo si no hay excepciones ejecuta la primera luego 517 00:24:57,420 --> 00:25:01,680 ejecuta el bloque 2 entero, no ha habido excepciones, ejecuta el finally porque 518 00:25:01,680 --> 00:25:06,180 esto se ejecuta siempre y luego va a ser bloque cíclico. 519 00:25:06,180 --> 00:25:11,180 ¿El finally sería como el default de un switch o el else to need? 520 00:25:11,180 --> 00:25:18,660 No, porque tú estás ejecutando tanto el 2 como el 4, o ejecutas esto o ejecutas esto. 521 00:25:18,660 --> 00:25:25,819 Finally es literalmente lo que dice, try, prueba a hacer esto, pilla estas excepciones 522 00:25:25,819 --> 00:25:35,640 y al final hace esto. Entonces, si no hay excepciones, el bloque 1, bloque 2, bloque 523 00:25:35,640 --> 00:25:46,720 finally y bloque 5. Ahora, si hay una excepción de tipo aritmético, entonces sería bloque 524 00:25:46,720 --> 00:25:53,960 1, bloque 2 es donde hay la excepción, ejecutaría el bloque 3, después se ejecuta el finally 525 00:25:53,960 --> 00:25:56,559 porque el final se ejecuta y después sigue con el fin. 526 00:25:59,440 --> 00:26:05,940 Cualquier tipo de excepción diferente ejecutaría el bloque 1, 527 00:26:06,960 --> 00:26:09,500 el bloque 2 a mitad y saltaría el final. 528 00:26:10,160 --> 00:26:14,000 Porque no hay ningún catch que está pillando este tipo de excepciones, 529 00:26:14,200 --> 00:26:15,859 pero el final se ejecuta de verdad. 530 00:26:16,619 --> 00:26:20,420 Tened en cuenta que como no se ha pillado el catch, 531 00:26:20,799 --> 00:26:21,920 el bloque 5 no llega. 532 00:26:22,259 --> 00:26:25,839 Se ejecuta el 4 y se ha cerrado. 533 00:26:26,099 --> 00:26:38,319 Entonces, ¿qué hay en la clase Exception? 534 00:26:38,740 --> 00:26:46,400 La clase Exception tiene varias cosas, tiene varios parámetros, etcétera, etcétera, que hay útil. 535 00:26:46,400 --> 00:26:54,940 Hay un getMessage que devuelve un string, que es una descripción de por qué ha ocurrido el error. 536 00:26:54,940 --> 00:27:05,339 Entonces, yo desde dentro si uso e.getMessage sabré por qué ha explotado, ¿vale? 537 00:27:05,339 --> 00:27:07,559 Uso e porque la excepción se llama e. 538 00:27:07,559 --> 00:27:15,660 Si uso, si estoy aquí, debería hacer ae.getMessage, ¿sí? 539 00:27:15,660 --> 00:27:19,680 ToString, algo parecido, ¿vale? 540 00:27:19,680 --> 00:27:22,759 Porque el getMessage te da solo el mensaje de error, 541 00:27:23,160 --> 00:27:27,559 el toString te da una representación del objeto entero. 542 00:27:27,779 --> 00:27:29,579 Entonces incluye el mensaje de error, 543 00:27:29,720 --> 00:27:31,940 pero te da también qué clase es, etc. 544 00:27:34,140 --> 00:27:36,500 ReceptionString es el constructor de la clase, ¿vale? 545 00:27:36,559 --> 00:27:39,140 Sirve porque tú puedes crear una excepción tuya. 546 00:27:42,019 --> 00:27:47,420 PrintStackTrace es lo que veis cuando ha habido uno de estos errores, 547 00:27:47,420 --> 00:27:50,140 que salen todos los métodos que estaban 548 00:27:50,140 --> 00:27:52,000 llamando. Este es un error 549 00:27:52,000 --> 00:27:54,160 que ha pasado en este método, que había sido 550 00:27:54,160 --> 00:27:55,900 llamado desde este método, que había sido llamado 551 00:27:55,900 --> 00:27:57,859 desde este método, que había sido llamado 552 00:27:57,859 --> 00:27:58,839 este. Es 553 00:27:58,839 --> 00:28:02,299 imprime una traza, 554 00:28:02,740 --> 00:28:04,259 una descripción 555 00:28:04,259 --> 00:28:06,400 de la pila de llamadas 556 00:28:06,400 --> 00:28:07,220 de métodos. 557 00:28:09,680 --> 00:28:12,220 Esta es la misma stack de los stack overflow. 558 00:28:17,799 --> 00:28:18,740 Hasta aquí 559 00:28:18,740 --> 00:28:21,839 control de excepciones, ¿vale? 560 00:28:22,119 --> 00:28:23,819 Entonces, relativamente sencillo, 561 00:28:23,920 --> 00:28:24,279 existen 562 00:28:24,279 --> 00:28:28,220 métodos por ahí 563 00:28:28,220 --> 00:28:30,259 que si funcionan mal 564 00:28:30,259 --> 00:28:31,819 pueden lanzar una excepción 565 00:28:31,819 --> 00:28:34,400 y que tú tienes que 566 00:28:34,400 --> 00:28:36,240 controlar con 567 00:28:36,240 --> 00:28:37,599 un try-catch, ¿vale? 568 00:28:37,960 --> 00:28:40,180 Entonces, existen excepciones 569 00:28:40,180 --> 00:28:42,500 que puedes 570 00:28:42,500 --> 00:28:43,500 controlar o no. 571 00:28:44,140 --> 00:28:45,779 Por ejemplo, la null pointer exception. 572 00:28:46,839 --> 00:28:48,119 Si tú la controlas bien, 573 00:28:48,119 --> 00:28:50,339 si tú no la controlas, te arriesga 574 00:28:50,339 --> 00:28:52,200 pero hay a tú 575 00:28:52,200 --> 00:28:54,099 ¿vale? existen 576 00:28:54,099 --> 00:28:56,259 excepciones en vez que si tú 577 00:28:56,259 --> 00:28:58,619 tienes un método que lanza esa excepción 578 00:28:58,619 --> 00:29:00,059 y no has hecho un try catch 579 00:29:00,059 --> 00:29:02,039 el mismo compilador te avisa 580 00:29:02,039 --> 00:29:04,640 te dice no, este método aquí no lo puedes 581 00:29:04,640 --> 00:29:06,299 llamar si no lo pones dentro del try catch 582 00:29:06,299 --> 00:29:08,180 ¿vale? ahora veremos 583 00:29:08,180 --> 00:29:10,480 de un tipo y cuáles son 584 00:29:10,480 --> 00:29:11,420 ¿vale? 585 00:29:12,160 --> 00:29:14,319 pero técnicamente tú puedes hacer 586 00:29:14,319 --> 00:29:16,299 puedes capturar 587 00:29:16,299 --> 00:29:18,279 las excepciones, pero puedes hacer 588 00:29:18,279 --> 00:29:20,339 métodos que lanzan 589 00:29:20,339 --> 00:29:22,180 una excepción. Tú puedes 590 00:29:22,180 --> 00:29:23,920 hacer que a un determinado momento, 591 00:29:24,039 --> 00:29:26,299 mientras estás trabajando, dices, y si llegas aquí 592 00:29:26,299 --> 00:29:28,359 y las condiciones son estas, 593 00:29:29,299 --> 00:29:30,079 pues para 594 00:29:30,079 --> 00:29:32,079 la ejecución y lanza 595 00:29:32,079 --> 00:29:34,099 una excepción. Porque hemos llegado a un 596 00:29:34,099 --> 00:29:36,019 punto en que no puedo seguir adelante. 597 00:29:37,019 --> 00:29:38,039 ¿Vale? Es como un 598 00:29:38,039 --> 00:29:40,019 punto de bloqueo de, oye, yo 599 00:29:40,019 --> 00:29:41,960 desde aquí no puedo seguir, a menos 600 00:29:41,960 --> 00:29:43,859 que alguien nos recoja esta 601 00:29:43,859 --> 00:29:46,000 excepción y me diga cómo hacerlo, 602 00:29:46,299 --> 00:29:53,059 yo aquí ha acabado no tengo los datos para seguir adelante para lanzar una 603 00:29:53,059 --> 00:30:00,059 excepción se usa el comando true lanza y la excepción que quiero lanzar 604 00:30:00,059 --> 00:30:04,619 no puedo crear una new excepción excepción e igual new excepción le pongo 605 00:30:04,619 --> 00:30:10,740 dentro el mensaje que quiero que ponga y luego la lanzo 606 00:30:11,420 --> 00:30:15,200 el objeto que se le pasa a true tiene que ser de la clase excepción o una 607 00:30:15,200 --> 00:30:20,420 cualquier subclase que la extienda incluso excepciones personales que os podéis crear 608 00:30:20,420 --> 00:30:27,920 vosotros puedes crear la clase mi excepción que extends exception y luego hacer mi excepción 609 00:30:27,920 --> 00:30:36,619 e es igual a new mi excepción y a ese punto throw e luego hacemos pruebas 610 00:30:38,519 --> 00:30:44,059 que hace el throw sale inmediatamente del bloque del código actual cuando encuentro un throw he 611 00:30:44,059 --> 00:30:51,400 acabado, allí voy a mi padre, a quien me ha llamado. Si allí dentro tenemos, estaba en un 612 00:30:51,400 --> 00:31:02,960 try-catch y tengo un catch asociado a la excepción que he lanzado, pues entonces se recupera y se 613 00:31:02,960 --> 00:31:13,019 hace ese código. Si no, salgo de ese bloque también y me voy a quien me había llamado. O sea, se va 614 00:31:13,019 --> 00:31:19,720 para arriba si yo tengo el método busca que hace el error y el método busca lo había llamado el 615 00:31:19,720 --> 00:31:26,259 método haz algo vale entonces yo voy a mirar si haz algo tiene un try catch o no si no lo tiene 616 00:31:26,259 --> 00:31:33,079 va al que lo había llamado y si no lo tiene va al que lo había llamado hasta llegar al main si ninguno 617 00:31:33,079 --> 00:31:43,160 ha hecho un try-catch nunca, pues allá es cuando bloqueo la JVM y se ha acabado totalmente. 618 00:31:43,160 --> 00:31:49,960 Si en cualquiera de las stack de la pila de llamadas uno ha puesto un try-catch, 619 00:31:49,960 --> 00:31:57,759 pues eso es el que recupera, o sea, que captura la excepción y a ver qué me dice. 620 00:31:57,759 --> 00:32:02,400 proceso continuo está llegado al método main 621 00:32:02,400 --> 00:32:04,559 si nadie lo ha hecho, pues es fatal 622 00:32:04,559 --> 00:32:09,210 esta otra cláusula 623 00:32:09,210 --> 00:32:10,470 que no es trow 624 00:32:10,470 --> 00:32:11,549 es trow 625 00:32:11,549 --> 00:32:15,150 con la s de tercera persona 626 00:32:15,150 --> 00:32:17,890 en inglés 627 00:32:17,890 --> 00:32:19,309 se usa 628 00:32:19,309 --> 00:32:21,990 en las declaraciones de los métodos 629 00:32:21,990 --> 00:32:23,670 para decir que 630 00:32:23,670 --> 00:32:24,930 avisar 631 00:32:24,930 --> 00:32:27,509 que oye, quien use este método f 632 00:32:27,509 --> 00:32:29,390 que sepas 633 00:32:29,390 --> 00:32:31,569 que este método puede lanzar 634 00:32:31,569 --> 00:32:33,390 un determinado tipo de excepción. 635 00:32:35,089 --> 00:32:35,309 Entonces, 636 00:32:35,730 --> 00:32:37,230 cuando yo voy a usar el método F, 637 00:32:37,950 --> 00:32:39,670 sé que al usarlo 638 00:32:39,670 --> 00:32:41,750 debería meterlo 639 00:32:41,750 --> 00:32:42,970 dentro de un try-catch 640 00:32:42,970 --> 00:32:45,710 que recupere este tipo de excepción. 641 00:32:47,490 --> 00:32:49,430 Esto lo veremos que algunos métodos 642 00:32:49,430 --> 00:32:51,089 cuando vamos en el API, me dice 643 00:32:51,089 --> 00:32:52,950 este método, throws, no sé qué. 644 00:32:53,329 --> 00:32:55,490 Entonces, cuando yo lo lanzo, tengo que comprobar 645 00:32:55,490 --> 00:32:56,650 que este método 646 00:32:56,650 --> 00:33:00,109 esté bien. Lo veremos por ejemplo 647 00:33:00,109 --> 00:33:03,430 en los ficheros, en la gestión de ficheros 648 00:33:03,430 --> 00:33:05,670 todas las IOException 649 00:33:05,670 --> 00:33:08,789 necesitan ser tratadas de esta forma. 650 00:33:09,869 --> 00:33:11,589 Si un método lanza más de una excepción 651 00:33:11,589 --> 00:33:14,789 se indicará detrás de TROs. O sea, TROs de 1 652 00:33:14,789 --> 00:33:16,970 con MET2, con MET3, con MET4. 653 00:33:25,990 --> 00:33:29,049 Para no que utilicemos métodos que lanzan por detrás de excepciones 654 00:33:29,049 --> 00:33:32,170 o lo protegemos o no lo protegemos. Esto lo hemos dicho ya 655 00:33:32,170 --> 00:33:37,809 sustancialmente, pero luego lo vemos en la práctica. 656 00:33:37,809 --> 00:33:41,710 La última cosa que me interesa, sustancialmente, porque luego están las 657 00:33:41,710 --> 00:33:45,369 excepciones personalizadas, que a lo mejor lo vemos en otro día así, 658 00:33:45,369 --> 00:33:50,589 es la jerarquía de excepciones. Todas las excepciones son throwable, o sea, se 659 00:33:50,589 --> 00:33:57,289 pueden lanzar, pero dentro de throwable hay dos tipos, hay los errores o las excepciones, 660 00:33:57,289 --> 00:33:59,089 lo que decimos al principio 661 00:33:59,089 --> 00:34:01,250 los errores son errores graves 662 00:34:01,250 --> 00:34:03,369 de allí no te recuperas, es un problema 663 00:34:03,369 --> 00:34:04,769 interno de la JavaScript Machine 664 00:34:04,769 --> 00:34:07,329 ha acabado la memoria, pues si ha acabado la memoria 665 00:34:07,329 --> 00:34:08,369 no puedes hacer nada 666 00:34:08,369 --> 00:34:11,230 también porque la rama está muy cara 667 00:34:11,230 --> 00:34:13,469 ¿sí? entonces estos son 668 00:34:13,469 --> 00:34:15,130 los que son bla bla bla error 669 00:34:15,130 --> 00:34:16,289 bla bla bla error 670 00:34:16,289 --> 00:34:17,849 ¿sí? 671 00:34:19,289 --> 00:34:21,090 mientras que las excepciones son errores 672 00:34:21,090 --> 00:34:23,269 manejables o recuperables, esto algo 673 00:34:23,269 --> 00:34:25,150 puede hacer, puede hacer un try catch para 674 00:34:25,150 --> 00:34:27,010 intentar solucionar el problema 675 00:34:27,010 --> 00:34:29,730 Y aquí dentro hay dos tipos. 676 00:34:30,530 --> 00:34:33,670 Hay la RuntimeException y las otras. 677 00:34:35,010 --> 00:34:40,130 Si soy RuntimeException, son errores que pueden pasar, 678 00:34:40,650 --> 00:34:45,849 pero que son tan habituales, son tan comunes, 679 00:34:46,869 --> 00:34:48,409 que no hace... 680 00:34:48,409 --> 00:34:52,809 O sea, que tú puedes decidir de poner un trackecho o no. 681 00:34:53,550 --> 00:34:55,110 Por ejemplo, el NullPointerException. 682 00:34:55,110 --> 00:34:58,469 Null pointer exception es muy común 683 00:34:58,469 --> 00:35:00,269 Si tú dijeras, oye no 684 00:35:00,269 --> 00:35:02,030 Lo tienes que, siempre que 685 00:35:02,030 --> 00:35:04,070 Hay la posibilidad de un null pointer exception 686 00:35:04,070 --> 00:35:04,929 Tienes que hacer algo 687 00:35:04,929 --> 00:35:07,469 Pues mi código estaría lleno de try-catch 688 00:35:07,469 --> 00:35:09,469 Porque cualquier cosa que tú utilices 689 00:35:09,469 --> 00:35:10,829 Cualquier objeto podría ser null 690 00:35:10,829 --> 00:35:12,389 ¿Sí? 691 00:35:13,010 --> 00:35:15,150 Entonces se te rellenaría todo de try-catch 692 00:35:15,150 --> 00:35:17,409 Entonces ellos dicen, vale, no 693 00:35:17,409 --> 00:35:19,869 La null pointer exception 694 00:35:19,869 --> 00:35:21,889 Es una runtime exception 695 00:35:21,889 --> 00:35:23,630 Y la runtime exception 696 00:35:23,630 --> 00:35:25,349 puedes decidir de no 697 00:35:25,349 --> 00:35:28,510 no capturarlas 698 00:35:28,510 --> 00:35:29,949 de dejarlas sin trigger 699 00:35:29,949 --> 00:35:32,650 sin embargo 700 00:35:32,650 --> 00:35:34,889 las que no son runtime exception 701 00:35:34,889 --> 00:35:37,050 pues sí que tienen que ser 702 00:35:37,050 --> 00:35:37,929 capturadas siempre 703 00:35:37,929 --> 00:35:39,690 y son las que decía antes 704 00:35:39,690 --> 00:35:41,989 si aquí como por ejemplo 705 00:35:41,989 --> 00:35:44,090 aquí son ejemplos que no veremos nunca 706 00:35:44,090 --> 00:35:46,510 si tú intentas hacer un método 707 00:35:46,510 --> 00:35:48,010 que lanza una de estas 708 00:35:48,010 --> 00:35:49,630 excepciones de aquí 709 00:35:49,630 --> 00:35:52,090 no te permite el compilador 710 00:35:52,090 --> 00:35:54,070 de compilar el código si tú no lo has 711 00:35:54,070 --> 00:35:55,030 puesto dentro del tránsito. 712 00:36:00,119 --> 00:36:02,639 Esto es un poco la estructura 713 00:36:02,639 --> 00:36:04,440 de lo que hay por aquí. Todos son 714 00:36:04,440 --> 00:36:06,619 trouble. Aquí están los errores, como por 715 00:36:06,619 --> 00:36:08,099 ejemplo una virtual machine error 716 00:36:08,099 --> 00:36:10,480 que aquí hereda 717 00:36:10,480 --> 00:36:12,380 el out of memory error. No tengo 718 00:36:12,380 --> 00:36:13,619 memoria, no puedo ejecutar. 719 00:36:14,440 --> 00:36:16,480 El, no lo sé, stack 720 00:36:16,480 --> 00:36:17,340 overflow error. 721 00:36:19,340 --> 00:36:20,559 Y si no están las 722 00:36:20,559 --> 00:36:22,360 excepciones, de aquí están la 723 00:36:22,360 --> 00:36:24,480 runtime exception, que son las que 724 00:36:24,480 --> 00:36:26,239 pueden ser no controlables 725 00:36:26,239 --> 00:36:28,360 y todas las otras excepciones. 726 00:36:29,380 --> 00:36:30,460 ¿Sí? Estas 727 00:36:30,460 --> 00:36:32,139 hay que controlarlas siempre, 728 00:36:33,039 --> 00:36:34,300 como por ejemplo todas las 729 00:36:34,300 --> 00:36:36,280 IOException, por eso cuando veremos 730 00:36:36,280 --> 00:36:38,300 ficheros, pues estaremos siempre con 731 00:36:38,300 --> 00:36:38,739 try-catch. 732 00:36:40,300 --> 00:36:42,260 Estas en vez de son las que, oye, 733 00:36:42,320 --> 00:36:44,400 mira, por ejemplo, array index 734 00:36:44,400 --> 00:36:46,420 autobound. Nosotros 735 00:36:46,420 --> 00:36:48,619 no hemos usado nunca try-catch, 736 00:36:48,880 --> 00:36:50,179 pero sí hemos usado los 737 00:36:50,179 --> 00:36:52,460 arrays, y podría ser que 738 00:36:52,460 --> 00:36:54,119 habríamos podido acceder 739 00:36:54,119 --> 00:36:56,500 fuera. De hecho, algunos ejercicios 740 00:36:56,500 --> 00:36:57,659 os han dado ese error. 741 00:36:58,300 --> 00:37:00,320 Pero no te esfuerza a 742 00:37:00,320 --> 00:37:02,300 crearlo porque si no, deberías 743 00:37:02,300 --> 00:37:04,260 estar todo dentro de lo que has hecho constantemente. 744 00:37:04,880 --> 00:37:06,280 ¿Vale? Entonces, estos errores aquí 745 00:37:06,280 --> 00:37:07,920 son errores muy comunes 746 00:37:07,920 --> 00:37:10,139 que pero te dicen, oye, mira, si quieres lo haces 747 00:37:10,139 --> 00:37:10,539 y no, no. 748 00:37:11,960 --> 00:37:12,119 ¿Sí? 749 00:37:13,639 --> 00:37:16,300 Y excepciones personalizadas me puedo crear 750 00:37:16,300 --> 00:37:17,760 mis propias excepciones 751 00:37:17,760 --> 00:37:19,940 y luego lanzarlas. 752 00:37:21,179 --> 00:37:21,380 ¿Vale? 753 00:37:21,380 --> 00:37:24,280 miramos esto para entender 754 00:37:24,280 --> 00:37:26,539 imaginaos, aquí me estoy creando 755 00:37:26,539 --> 00:37:28,739 una divide by 0 exception 756 00:37:28,739 --> 00:37:30,739 que estende una aritmética exception 757 00:37:30,739 --> 00:37:32,159 esta es una clase mía 758 00:37:32,159 --> 00:37:34,719 hago lo que tengo que hacer aquí dentro 759 00:37:34,719 --> 00:37:36,639 y aquí tengo un método 760 00:37:36,639 --> 00:37:39,019 el método dividir que pilla dos números 761 00:37:39,019 --> 00:37:41,280 y que puede lanzar 762 00:37:41,280 --> 00:37:42,820 la divide by 0 exception 763 00:37:42,820 --> 00:37:45,159 lo estoy avisando 764 00:37:45,159 --> 00:37:46,559 entonces, quien use 765 00:37:46,559 --> 00:37:48,699 dividir con dos valores, debería 766 00:37:48,699 --> 00:37:50,659 ponerlo dentro de un try catch porque podría 767 00:37:50,659 --> 00:37:55,659 saltarla divideByZeroException, ¿entiendes? 768 00:37:55,659 --> 00:37:59,659 Pero como la divideByZeroException 769 00:37:59,659 --> 00:38:01,659 extiende la ArithmeticException 770 00:38:01,659 --> 00:38:06,659 y la ArithmeticException es una RuntimeException, 771 00:38:06,659 --> 00:38:11,659 por si no uso el Tracker, no me dice nada. 772 00:38:11,659 --> 00:38:18,579 ¿Sí? Vale. Y con esto,