Saltar navegación

Exception - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 5 de abril de 2024 por Stefano C.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

Estoy grabando, por lo tanto, si habláis, me dais vuestro consentimiento a que se graben vuestras voces, ¿vale? 00:00:01
Hoy vamos a ver un tema nuevo, que es un tema relativamente pequeño y relativamente fácil, ¿vale? 00:00:07
Que es el manejo de excepciones. Como todas las cosas en Java, pues la base es muy sencilla, 00:00:13
luego si me empiezo a hilar fino y a ir a cosas un poquito más complejas, pues puedo complicarlo cuanto me da la gana, ¿vale? 00:00:19
Una excepción es, en un cierto sentido, lo que es un error dentro de la programación en Java 00:00:27
¿Vale? Cuando hay un error dentro de mi programa 00:00:36
Lo que se detecta por el sistema, por la Javator Machine, pues se crea una excepción 00:00:41
¿Vale? Cuidado, hay distintos tipos de errores 00:00:48
¿Vale? El concepto de error es muy, muy, muy amplio 00:00:51
El error más feo y más malvado dentro de la programación es el error semántico. Es el que yo estoy calculando la media de 10 números y en vez de calcular la media de 10 números, calculo la suma de 10 números. 00:00:55
Pues eso, desde una perspectiva de programación, es perfecto 00:01:12
No hay errores de sintaxis, no hay errores que explota errores en los tipos de datos 00:01:17
O acceda a una posición de array que no tenía que acceder 00:01:25
No hay errores a nivel de programación 00:01:29
El error sois vosotros 00:01:31
Sois vosotros que cuando habéis hecho el algoritmo, cuando habéis pensado la fórmula 00:01:33
Que teníais que hacer, en vez de calcular la media de 10 números 00:01:37
habéis hecho la suma de 10 números 00:01:41
¿vale? no podéis decir 00:01:42
¡ah! malvado eclipse 00:01:45
que me estás calculando la suma 00:01:46
cuando tenías que calcularme la media 00:01:49
pues el problema es vuestro, sois vosotros 00:01:51
que os habéis equivocado, ¿vale? 00:01:53
esos son los errores semánticos y son los que 00:01:54
con el tiempo 00:01:57
son los que 00:01:58
os molestarán, ¿vale? 00:01:59
ahora lucháis, como sois 00:02:03
programadores iniciales, ¿vale? 00:02:05
desde iniciando ahora, lucháis también contra 00:02:06
los errores sintácticos, contra las excepciones 00:02:09
Que no sabéis que son 00:02:11
Contra las cosas rojas 00:02:12
Que aparecen de vez en cuando 00:02:14
Porque he explotado algo 00:02:16
Pero con el tiempo cuando esas cosas se mecanizarán 00:02:17
Y lo podéis trabajar normalmente 00:02:20
Se quedará en vuestra mente 00:02:24
El pensar el algoritmo 00:02:25
¿Por qué mi programa no está haciendo lo que yo quiero? 00:02:27
Porque en algún lado me he equivocado 00:02:30
Me he hecho un paso del algoritmo 00:02:32
O una operación que no tenía que hacer 00:02:34
Y la tengo que modificar 00:02:36
Y son los errores más difíciles de detectar 00:02:37
Porque no hay nada que te ayuda 00:02:40
En eso, vale 00:02:41
Sin embargo aquí estamos hablando 00:02:43
De errores un poquito distintos 00:02:46
Estamos hablando no de errores sintácticos 00:02:48
Porque quien pilla los errores sintácticos 00:02:50
¿Qué es un error sintáctico? 00:02:52
El sintáctico es 00:02:58
Se me ha olvidado el punto y coma 00:02:59
El error sintáctico es 00:03:00
He puesto public mi método 00:03:02
Abierta paréntesis, cerrada paréntesis 00:03:05
Y me falta algo allí para completarlo 00:03:07
¿Y quien pilla eso? 00:03:09
El compilador 00:03:11
El entorno de desarrollo 00:03:12
Que sustancialmente está pre-compilando 00:03:15
Todo constantemente 00:03:18
Me dice, aquí falta algo, me lo marca en rojo 00:03:19
Pero quien luego lo pillaría es el compilador 00:03:21
De Java 00:03:24
Os recuerdo que Java tiene dos fases 00:03:25
La compilación y luego la interpretación 00:03:27
Sin embargo, estos son otros tipos de errores 00:03:29
Son errores en tiempo de ejecución 00:03:32
O sea, yo lanzo el programa 00:03:34
Y mientras el programa funciona 00:03:36
Que es todo sintéticamente correcto 00:03:38
Pues ocurre un problema 00:03:40
¿Vale? El típico problema es 00:03:41
O dos típicos problemas que hemos visto varias veces 00:03:44
Intento acceder a una posición 00:03:46
De un array que no existe 00:03:48
Mi array es de 10 posiciones y yo accedo a la posición 15 00:03:50
¿Vale? 00:03:53
Sintácticamente 00:03:55
Yo he accedido a la posición de un entero 00:03:56
Entonces, perfecto 00:03:59
No hay problemas allí 00:04:00
Tengo mi array 00:04:02
Paréntesis cuadra, x 00:04:04
Paréntesis cuadra 00:04:06
Y yo no sé que valor tiene x 00:04:07
Y si ese x vale de 0 a 9 00:04:09
Me funciona perfectamente 00:04:11
Pero resulta que por un error mío semántico 00:04:13
En algún lado he metido en este x 15 00:04:16
Y entonces intenta acceder a la posición 15 00:04:19
Y no existe 00:04:21
Entonces es un error que a tiempo de compilación 00:04:22
No se puede encontrar 00:04:26
Donde se encuentra ese tiempo de ejecución 00:04:27
Cuando hay este tipo de error 00:04:30
Salta un exception 00:04:32
En particular la 00:04:33
Index out of bound exception 00:04:35
Para esta x 00:04:40
¿Vale? 00:04:41
Otra cosa 00:04:42
Yo tengo un objeto 00:04:43
Tengo una variable 00:04:44
Mi objeto 00:04:45
Obg 00:04:47
Por ahí 00:04:49
Y hago obg.nombre 00:04:51
Y de repente resulta que este obg es null 00:04:53
¿Por qué? 00:04:57
Porque no lo he inicializado en ningún lado 00:04:59
O porque me lo pasan por un parámetro en un método 00:05:01
Y me han pasado null 00:05:05
O me han pasado otro objeto que no ha sido inicializado 00:05:07
Entonces cuando yo tengo un objeto 00:05:09
Que no ha sido inicializado, no ha sido distanciado 00:05:12
Y le hago 00:05:14
Un accedo a un atributo suyo 00:05:15
O a un método suyo 00:05:17
¿Qué pasa? 00:05:19
No hay excepción 00:05:22
¿Lo puedo detectar esto 00:05:23
A nivel de compilación? 00:05:25
Probablemente no 00:05:27
Yo qué sé, me han pasado 00:05:28
Yo tengo un objeto como parámetro 00:05:30
Y no puedo prever si alguien 00:05:33
Me lo pasa, lo puedo controlar 00:05:35
Sí, pero a nivel de compilación 00:05:37
Esto está bien escrito 00:05:40
Luego el problema es que a nivel de 00:05:41
Cuando llego a tiempo de ejecución 00:05:43
Que tengo que hacer algo sobre este objeto 00:05:45
Y voy a buscar este objeto 00:05:47
Me encuentro que este objeto no existe 00:05:49
Y por lo tanto, la virtual machine 00:05:50
Se da cuenta y dice 00:05:54
Oye, paro, bloqueo la ejecución 00:05:55
Lanzando una excepción 00:05:58
Una excepción que 00:05:59
Sostancialmente lo que intenta hacer 00:06:01
Es avisarme de lo que ha pasado 00:06:03
Para que yo lo pueda corregir 00:06:06
O para que yo lo pueda capturar 00:06:08
Y ahora lo veremos 00:06:10
¿Vale? 00:06:12
Cuando un error ocurre, lo normal es que se detenga el programa 00:06:13
Y se proporciona un mensaje 00:06:16
Después de que explique el fallo 00:06:18
¿Vale? 00:06:19
Es lo básico 00:06:20
Ha habido un error, yo no sé qué hacer 00:06:21
Porque me esperaba de encontrarme un objeto aquí y no está 00:06:23
Me esperaba de encontrarme un objeto aquí y no está 00:06:26
O lo que sea 00:06:29
Pues no puedo seguir adelante 00:06:30
Haciendo como, ah, sí, bueno 00:06:32
aquí tenía que haber un número, me invento 00:06:33
el 3, pues no, no lo sé, tenía que 00:06:36
pillar un valor y no está este valor 00:06:37
por lo tanto, bloco 00:06:39
el programa, me paro 00:06:41
¿sí? y 00:06:43
cortesía del programador, normalmente 00:06:45
voy a explicar 00:06:47
que ha pasado, oye, estaba 00:06:49
intentando acceder al 00:06:51
array alumnos 00:06:53
y me he encontrado que 00:06:55
he intentado acceder a una posición que no está 00:06:57
¿vale? y esto depende de vosotros 00:06:59
lo veremos más adelante 00:07:01
Hay algunos errores que tienen un mensaje por defecto, como el array index out of bound te dice, oye, mira, he intentado acceder a esta posición y esta posición no está. 00:07:03
Pero normalmente en nuestros programas deberíamos tunear estos mensajes para que sean más relevantes, para que quien vea este mensaje diga, ah, mira, ha pasado esto. 00:07:17
Tened en cuenta también que estos tipos de mensajes no salen por System.out 00:07:27
Salen por System.er 00:07:33
Salen en rojo 00:07:35
Eso no debería, cada proceso tiene una entrada 00:07:37
Que nosotros utilizamos con el System.in para leer de teclado 00:07:45
Y dos salidas 00:07:49
Un output, que es el output normal en consola 00:07:50
Que sería como tu dialogas con el usuario que está usando tu programa 00:07:54
Y luego un output error, soundsystem.er 00:07:58
Que es por donde van los errores 00:08:01
En teoría tu este error, que normalmente sale por consola 00:08:04
Lo podrías redireccionar en un ficherito de log 00:08:09
Para que el usuario no vea los errores 00:08:13
Pero tu administrador, tu programador 00:08:16
Puedas ir a mirar ese fichero y ver que problema ha habido 00:08:19
Sobre todo cuando das mantenimiento 00:08:23
Hay que considerar que nosotros somos informáticos 00:08:26
Pero la gente que usa nuestros programas 00:08:28
Muchas veces no lo es 00:08:30
Entonces que le aparezcan pantallazos azules 00:08:32
Con escrito código 00:08:34
7.944 ha explotado todo 00:08:36
Pues no sé cuánto es user friendly 00:08:38
¿Sí? 00:08:41
Vale 00:08:43
Java proporciona un mecanismo 00:08:43
Para controlar situaciones que normalmente provocaría 00:08:47
Una interrupción de ejecución 00:08:48
Permitiendo gestionar el comportamiento 00:08:50
del programa en caso de error 00:08:52
o sea que tenemos un mecanismo 00:08:54
para que si explota 00:08:57
algo, en vez de decir 00:08:59
vale, aquí se ha acabado 00:09:01
yo pueda recoger 00:09:02
capturar esa excepción 00:09:04
e ir a analizarla 00:09:07
a ver, oye, mira, ¿qué ha pasado 00:09:09
de verdad? porque si yo me puedo 00:09:10
recuperar de este 00:09:13
error, pues me recupero 00:09:15
y sigo adelante con el programa 00:09:17
no hago que el programa explote 00:09:19
Si es un error demasiado grave 00:09:20
Que no puedo seguir adelante 00:09:23
Pues entonces explotaré 00:09:24
¿Si? 00:09:26
Más o menos la idea 00:09:29
Nosotros 00:09:30
Hasta ahora 00:09:35
Hemos intentado manejar 00:09:36
Los errores de forma pesimista 00:09:39
¿Vale? 00:09:41
La forma pesimista es sustancialmente 00:09:42
De si yo sé que puede surgir 00:09:45
Un error 00:09:47
Lo voy a comprobar 00:09:48
Por ejemplo, cuando nosotros decimos 00:09:50
Tengo un objeto que me han pasado por parámetro 00:09:52
¿Vale? 00:09:54
Y este objeto podría ser null 00:09:55
¿Qué hago yo para evitar que sea null? 00:09:57
If este objeto es not null 00:10:10
Entonces haz lo que tienes que hacer 00:10:12
¿Vale? 00:10:14
Esta es una forma de pensar 00:10:15
De que cada vez que paso por allí 00:10:17
Independientemente de que me hayan dado un objeto null o no 00:10:18
Voy a comprobar si esto es así 00:10:21
Y si no es así 00:10:24
Si hay un objeto real 00:10:26
Pues entonces uso el objeto 00:10:27
Si no hay este objeto real 00:10:29
Pues entonces 00:10:30
Hay un else o no hago nada 00:10:31
O lo que sea 00:10:35
¿Cuál es el problema de esto? 00:10:35
Es que normalmente en un 90% de los casos 00:10:38
Cuando yo uso un método 00:10:41
Que requiere un objeto 00:10:43
¿Quién llama este objeto? 00:10:45
¿Quién llama este método? 00:10:47
No me pasará un null 00:10:48
Me pasará el objeto sobre el que yo quiero trabajar 00:10:49
Si yo tengo un busca alumno 00:10:53
Y me pasas un alumno 00:10:55
Y me lo busca en un array 00:10:57
¿Vale? Pues yo me espero que lo que me estás 00:10:58
Pasando aquí como parámetro, el nombre 00:11:01
O un string con nombre, o un alumno 00:11:03
O un código, pues tenga significado 00:11:05
No sea null 00:11:07
Porque si es null no puede hacer nada 00:11:08
¿Vale? Entonces, el hecho de poner el if 00:11:10
Quiere decir que cada vez que 00:11:13
Ejecuto este método 00:11:15
Pierdo tiempo en ver 00:11:16
¿De verdad me has dado un código 00:11:19
Correcto? Ah sí, venga, entonces te lo busco 00:11:21
Y repito 00:11:23
95% de las veces 00:11:25
es que me han dado un código 00:11:26
un código real, que puede hacer 00:11:28
luego a lo mejor no está el alumno, pero el código 00:11:30
se puede utilizar, no sé si me explico 00:11:33
lo que quiere decir, entonces 00:11:34
el pesimista 00:11:36
lo que, los problemas que tiene 00:11:37
es que primero es difícil 00:11:41
ver todos los posibles fallos 00:11:42
o sea, yo te voy a decir, si este objeto 00:11:44
es nul, vale, y si este otro 00:11:47
código es mayor que 00:11:48
cero, y si este de aquí 00:11:50
debería hacer un montón de comprobaciones 00:11:52
Solo para ver si los datos son válidos 00:11:55
Y a este punto utilizarlos 00:11:56
Y a lo mejor algunas de esas comprobaciones 00:11:58
No las pienso 00:12:01
A lo mejor yo compruebo que alumno 00:12:03
No sea null 00:12:05
¿Vale? 00:12:07
Pero luego dentro de alumno 00:12:08
Me han creado un objeto alumno 00:12:11
Con todos los campos a null 00:12:13
Y entonces tengo un problema con él 00:12:14
La segunda cosa es que si los datos son correctos 00:12:16
Pues estoy sobrecargando 00:12:22
El programa con if innecesario 00:12:24
Estoy haciendo un if 00:12:26
Pero no sirve de nada 00:12:27
Porque si es correcto 00:12:29
Y entonces existe 00:12:30
El manejo de excepciones 00:12:33
Optimista 00:12:36
Que es 00:12:37
Yo programo 00:12:39
Pensando que todo sale bien 00:12:42
Sin ningún problema 00:12:44
Y lo que voy a hacer 00:12:46
Es marcar 00:12:48
Los códigos peligrosos 00:12:50
Las secciones de códigos con peligro 00:12:52
Donde pueda pasar algo 00:12:54
Malo, con un bloque 00:12:55
Try-catch 00:12:57
¿Vale? El bloque try 00:12:59
Es un bloque que dice, oye mira 00:13:02
Pruébalo, tú prueba a hacer esto 00:13:04
Por ejemplo, en el alumno 00:13:06
Me han pasado un alumno que se llama el alumno A 00:13:08
Pues A, A.getName 00:13:10
¿Vale? 00:13:12
Si esto A es null 00:13:14
Me explota 00:13:15
Pero en un 95% de los casos 00:13:17
A no será null y por lo tanto me funcionará 00:13:19
El día que explote, saltará una excepción, en este caso una null pointer exception 00:13:22
Si salta una excepción, tengo un bloque catch que me permite pillar esa excepción 00:13:33
Y en vez de explotar y parar todo, intentar ver qué ha pasado 00:13:40
Como por ejemplo, ver aquí, que oye mira, aquí compruebo y veo que es una null pointer exception 00:13:44
Y por lo tanto que el objeto que he intentado utilizar es null 00:13:51
Y mando un mensaje al usuario diciendo 00:13:54
El alumno que estás buscando no se puede buscar 00:13:58
Y en vez de acabar el programa 00:14:00
Vuelvo a mi menú inicial de poder buscar alumno 00:14:03
Crear un alumno y cosas por el estilo 00:14:07
No sé si me explico lo que quiero decir 00:14:09
Es parecido a un if 00:14:11
Pero mientras un if lo ejecutas todas las veces 00:14:14
Esto es un bloque que tú ejecutas normalmente 00:14:17
Que está preparado en el caso 00:14:21
Haya un error, a pillar el error 00:14:23
Pero las veces que no hay error 00:14:25
Pues esto 00:14:28
Va más 00:14:29
Más ligero 00:14:31
Con respecto al if que en vez tienes que hacer la comprobación 00:14:33
Es lo que hemos dicho 00:14:35
Si tú lo haces 00:14:42
Pesimista, el problema es que si metes el if 00:14:43
Tú estás comprobando 00:14:45
Tanto cuando los datos son buenos 00:14:47
Como cuando los datos son malos 00:14:49
O sea, estás gastando recursos de procesación 00:14:50
De procesamiento 00:14:53
Siempre 00:14:54
En vez de aquí, que tendrá un sobrecosto 00:14:55
Porque no es gratis el try 00:14:59
Pero es un sobrecosto menor 00:15:00
Con respecto a diciendo 00:15:03
Mira, tú trabajas como si todo fuera bien 00:15:04
Tú esperas que las cosas 00:15:07
Eres optimista, que las cosas van a funcionar bien 00:15:08
Y la vez que explota 00:15:11
Pues tienes un mecanismo que te lo recupera 00:15:12
Pero aquí no estás haciendo el if 00:15:15
Cada vez 00:15:17
¿Vale? Estás esperando a la vez que explote 00:15:18
Cuando explota, pues esto lo recoge 00:15:21
¿Y tengo que decir qué tipo de excepción va a haber? 00:15:23
Ahora, ahora, vayamos 00:15:25
No, el bloque try-catch 00:15:26
¿A qué serviría? 00:15:32
Por si puedes hacer un try-final 00:15:39
Pero 00:15:41
La idea es que tú 00:15:42
Si pruebas esto con un try 00:15:46
Es porque te esperas que aquí 00:15:48
Pueda ir algo mal 00:15:50
Y si algo va mal, pues 00:15:51
Tendrás que hacer algo, que puede ser nada 00:15:53
Aquí no pones nada y dices, vale, si explota no haga nada 00:15:56
Pero 00:15:58
Lo tienes que poner, ¿vale? 00:15:59
Para esto en Java se protege el código potencialmente 00:16:02
Peligroso usando una estructura 00:16:04
Tragic, ¿vale? Esta es la idea 00:16:06
Entonces, ejemplo de 00:16:08
Programación pesimista y optimista 00:16:12
Entre comillas 00:16:14
Vamos a ver este ejercicio 00:16:15
¿Vale? 00:16:19
Leo un entero desde 00:16:20
Teclado 00:16:23
¿Vale? 00:16:26
Leo dos enteros 00:16:28
¿Vale? El segundo entero 00:16:30
Podría ser cero 00:16:31
Porque nada aquí me lo dice 00:16:33
Y digo que si den 00:16:34
Que sería el denominador, el de abajo 00:16:37
Pues es 00:16:39
Distinto de cero 00:16:40
Pues entonces hago num dividido den 00:16:42
Hago la división 00:16:44
Y si no, diré, oye, mira 00:16:46
hay un error, ¿vale? que estoy comprobando 00:16:48
aquí, estoy haciendo una división 00:16:51
de este número entre este 00:16:53
número 00:16:55
el concepto es que no se puede dividir por cero 00:16:55
si hago cualquier número dividido por cero 00:16:59
me da un error, Java, error aritmético 00:17:01
¿sí? 00:17:03
entonces, ¿aquí qué estoy haciendo? estoy haciendo 00:17:04
una cosa pesimista, estoy diciendo, oye mira 00:17:07
voy a comprobar que dem no sea 00:17:09
cero, porque si es cero no puedo hacer 00:17:11
esta operación 00:17:13
¿sí? ahora, todas las 00:17:13
veces que este señor no sea 00:17:17
cero, esta será una operación 00:17:19
inútil 00:17:21
entonces 00:17:21
si yo me espero que 00:17:25
la gente que usa esto lo sepa 00:17:26
utilizar este método o lo que sea 00:17:29
y que entonces aquí no me 00:17:31
de ceros, porque no se puede 00:17:33
dividir por cero, pues 00:17:35
estoy haciendo esta operación 00:17:37
inútil cada vez que estoy usando 00:17:38
este programa, entonces como se hace 00:17:40
desde una forma 00:17:43
optimista 00:17:44
Pues leo el número 00:17:46
El numerador y el denominador 00:17:48
Y a este punto 00:17:51
Hago la operación 00:17:52
Pero esta operación, que sé que es la que podría ir mal 00:17:53
Porque aquí está haciendo 00:17:57
La división 00:17:58
Que si den es cero 00:18:00
Pues esta cosa aquí explotaría 00:18:01
¿Vale? Porque un número dividido en cero no me vale 00:18:03
Pues la pongo dentro de un bloc 00:18:06
Que trae 00:18:08
Tú prueba a hacer esto 00:18:09
Que va bien 00:18:12
Pues lo has hecho y sigues adelante 00:18:13
Te saltas esto y no hay ningún problema 00:18:15
Que aquí dentro explota algo 00:18:17
Pues entonces te vas a mirar en catch 00:18:20
Y por ejemplo aquí 00:18:23
Lo he hecho muy genérico 00:18:25
Pilla solo una excepción 00:18:26
Si ha explotado una excepción 00:18:27
Pues entonces te metes aquí 00:18:29
Y dices no es válido dividir por cero 00:18:31
Es como un if 00:18:33
Al fin y al cabo lógicamente sí 00:18:35
Pero cambia la forma con que se hace 00:18:37
El otro está haciendo un if directo 00:18:40
Mientras este de aquí lo intenta 00:18:42
Ejecuta normalmente 00:18:44
Y solo si la Java Virtual Machine explota 00:18:45
Pues a este punto recoge la excepción 00:18:48
Y hace lo que tiene que hacer 00:18:51
¿Vale? 00:18:52
Una de las ventajas de tener un nivel en el medio 00:18:53
Que es la Java Virtual Machine 00:18:56
Que sustantivamente me está interpretando las cosas 00:18:58
Entonces me puede ayudar en este sentido 00:19:00
Él interpreta este comando 00:19:02
Lo va a ejecutar 00:19:05
Si cuando interpreta este comando 00:19:06
Explota y entonces es la Java Virtual Machine 00:19:08
La que crea la excepción 00:19:11
Al darse cuenta que ha creado una excepción 00:19:12
Pues entonces va a buscar si hay un 00:19:14
Un bloque catch que pueda encajar con ese cc 00:19:16
Y si lo hay 00:19:18
Pues ejecuta eso, en vez de explotar 00:19:20
¿Dudas? 00:19:22
Vale 00:19:30
Existe una clase 00:19:30
Exception, que vosotros buscaréis 00:19:32
En Java 00:19:35
En Google 00:19:35
Java Exception 00:19:38
Y os vais a leer dentro del API 00:19:40
Todo lo que es relacionado con Exception 00:19:42
Para conocerla 00:19:45
A fondo, vale 00:19:46
Cuando hay uno de estos 00:19:47
Errores a tiempo de compilación 00:19:51
A tiempo de ejecución y cosas así 00:19:53
Es la Java Virtual Machine 00:19:55
Que se da cuenta que ha habido este error 00:19:57
Y lo que hace es crear 00:19:59
Un objeto exception 00:20:01
Que sostanzialmente es como un manejador de esta excepción 00:20:02
Es donde se coloca 00:20:05
La información sobre, oye, ¿qué ha pasado? 00:20:07
¿Ha pasado un error? Pues este es un objeto 00:20:09
Que si tú lo miras dentro 00:20:11
Tiene varios campos y varios métodos 00:20:13
Ahora veremos alguno de ellos 00:20:14
Y aquí dentro está escrito un poco 00:20:15
Lo que pensamos que ha pasado 00:20:17
¿Vale? 00:20:20
En base a esto tú puedes elegir 00:20:21
¿Qué hago? 00:20:23
Paro el programa pero aviso el usuario 00:20:24
No digo nada 00:20:28
Lo escribo en un fichero 00:20:29
Me recupero y vuelvo al menú inicial 00:20:30
Lanzo unas rutinas 00:20:33
Para apagar bien 00:20:36
Porque había abierto varios ficheros 00:20:38
Y varias conexiones 00:20:40
Y antes de apagar todo 00:20:41
Pues voy a cerrar estos ficheros 00:20:43
No lo sé 00:20:44
Te da la posibilidad de reaccionar 00:20:46
Frente a un error que no sea una reacción 00:20:49
De ha explotado todo, se ha parado el programa 00:20:51
Y se ha cerrado 00:20:53
En este objeto se va a dar información 00:20:54
Del relevante del error 00:20:59
Como quien lo ha producido 00:21:00
En que línea de código ha explotado esto 00:21:02
Cual es el método que ha hecho 00:21:05
Que ha provocado este error 00:21:06
Cuando 00:21:08
Que ha causado 00:21:10
Un mismo código peligroso 00:21:12
Podría causar distintos tipos de excepciones 00:21:17
Yo puedo marcar este código aquí 00:21:19
Donde hay un acceso a un 00:21:21
Array de objetos 00:21:23
Y pillado el objeto 00:21:25
En posición 3 00:21:28
Hace .name 00:21:29
Esto podría causar tanto una null pointer exception 00:21:30
Como una index out of bound exception 00:21:33
Lo que yo puedo hacer 00:21:36
Es crear 00:21:38
Varios 00:21:39
Catch 00:21:41
De cada una de las excepciones 00:21:42
A partir de las exceptions 00:21:45
Que es la clase, la superclase 00:21:47
Todas son exceptions, digamos así 00:21:49
Pues hay subclases 00:21:51
Más apropiadas para los varios errores 00:21:53
Como puede haber la null pointer exception 00:21:56
La number format exception 00:21:58
La hemos visto, la number format exception 00:22:01
Cuando tú lees nextint 00:22:03
Y escribes gato 00:22:10
Salta una norma 00:22:12
FormatException 00:22:14
Porque tú me has dicho que iba a salir un entero 00:22:14
Y el formato del número 00:22:18
No es correcto 00:22:21
Porque has escrito una letra 00:22:21
Un carácter 00:22:24
IOException 00:22:24
Esta es InputAutoException 00:22:26
Esta suele saltar cuando lo veremos 00:22:28
Al final de este trimestre 00:22:31
Cuando haremos accesos a ficheros 00:22:33
Lectura y escritura en ficheros 00:22:36
Pues esas son entradas y salidas 00:22:38
Y por lo tanto pueden causar 00:22:40
Y hay muchas más 00:22:41
Ahora veremos un esquema más adelante 00:22:45
¿Vale? 00:22:47
Estas excepciones se pueden manejar 00:22:48
De forma más fina, lo que decíamos antes 00:22:50
En vez de tener un único bloque 00:22:52
Como hemos hecho el ejemplo aquí 00:22:54
Que dice 00:22:56
Pilla 00:22:59
Una excepción cualquiera 00:23:01
Todas son exception, null pointer exception es una exception 00:23:03
Pues cae aquí 00:23:06
Number format exception es una exception 00:23:07
pues cae aquí, entonces estoy haciendo 00:23:11
cualquier excepción haya pasado aquí 00:23:13
pues se ejecuta esto, independientemente 00:23:15
de que sea lo que haya 00:23:17
hecho explotar mi programa 00:23:19
¿vale? ahora 00:23:21
en el ejemplo que hemos hecho antes, que yo estoy 00:23:23
accediendo a un array de objetos 00:23:25
y luego hago un método sobre este objeto 00:23:27
y puede ser que me equivoque 00:23:29
por distintas formas, puede ser que 00:23:31
o es un 00:23:33
null pointer exception o es un 00:23:35
index out of bound, pues lo que puedo hacer 00:23:37
es un manejo un poquito más fino 00:23:39
¿Cómo? Simplemente poniendo un solo 00:23:40
Bloque try 00:23:43
Pero poniendo varios bloques catch 00:23:44
Cada catch 00:23:47
Por una 00:23:48
De las excepciones más finas 00:23:50
O sea 00:23:53
Catch number format exception 00:23:54
Pues en el caso en que haya saltado 00:23:57
Una number format exception 00:23:59
Esto es lo que tienes que hacer 00:24:00
Catch arithmetic exception 00:24:02
En el caso en que haya saltado una excepción aritmética 00:24:05
Esto es lo que tienes que hacer 00:24:07
Catch null pointer exception 00:24:09
En caso de que sea un puntador a null 00:24:11
Pues esto es lo que tienes que hacer 00:24:14
Y cuantas me da la gana 00:24:15
¿Vale? 00:24:17
A ver si me desculpa 00:24:21
De esta forma conseguimos 00:24:22
Tractar excepciones diferentes 00:24:25
De forma diferente, este es el objetivo 00:24:27
Si no nos interesa manejarla de forma diferente 00:24:29
Puedo hacerlo más amplio 00:24:32
O sea, si yo digo 00:24:34
Por ejemplo, la null pointer exception la quiero hacer 00:24:35
De una forma, pero todas las demás 00:24:37
De otra, pues hago dos catch 00:24:39
El primer catch será null pointer 00:24:41
Exception, con su 00:24:43
Gestión, y luego la siguiente 00:24:45
Será un catch de exception 00:24:47
General, entonces si es null pointer 00:24:49
Pillará la primera, y en cualquier 00:24:51
Otro caso, pillará la siguiente 00:24:53
¿Si? 00:24:55
No, si 00:24:58
Pilla un catch 00:25:01
El catch más adecuado 00:25:01
No, porque o ha explotado con null 00:25:04
O ha explotado con index 00:25:11
O ha explotado cuando ha accedido al objeto 00:25:12
Y entonces es un null pointer 00:25:15
O ha explotado cuando ha accedido a la posición 00:25:17
Que no era dentro del array 00:25:19
Y entonces te ha dado la index out 00:25:21
Las dos no te las puedes dar 00:25:22
A lo mejor luego te habría dado también la siguiente 00:25:24
Pero dependiendo del orden 00:25:27
Con que la has ejecutado 00:25:29
O una o la otra antes 00:25:30
Por ahora nosotros no tenemos paralelismo 00:25:31
Es todo secuencial 00:25:35
Entonces cuando llego a la operación 00:25:36
Que me da el error, pues el error será ese 00:25:38
Existe también otra cláusula que puedo añadir 00:25:40
O sea, try, catch, catch, catch, catch, catch 00:25:47
Y al final puedo poner una cláusula finally 00:25:50
La cláusula finally es un trozo, un bloque 00:25:53
Que se ejecutará siempre 00:25:57
Tanto si no ha habido excepciones 00:26:00
Como si ha habido una excepción 00:26:04
Para que nos entendamos 00:26:06
Por ejemplo, aquí tengo un bloque 1 00:26:10
Luego tengo el try, bloque 2 00:26:15
Catch, arithmetic exception, bloque 3 00:26:17
Catch, exception, bloque 4 00:26:22
Y luego bloque 5 00:26:26
¿Vale? 00:26:27
Si no hay excepciones, todo va bien 00:26:28
Se ejecutará el bloque 1 00:26:31
Luego el bloque 2 00:26:33
Y luego el bloque 5 00:26:34
Los catch me lo certo 00:26:36
Si en la ejecución del bloque 2 00:26:40
Hubiese un error de tipo aritmético 00:26:43
O sea, un Arithmetic Exception 00:26:47
Se ejecuta el bloque 1 00:26:48
Se empieza a ejecutar el bloque 2 00:26:50
Aquí hay la Arithmetic Exception 00:26:53
Por lo tanto, se ejecutaría el bloque 3 00:26:55
Y después se saltaría el bloque 5 00:26:58
1, 2 con error 00:27:00
3, 5 00:27:02
¿Sí? 00:27:04
Si en vez el error es de otro tipo 00:27:06
Por ejemplo, un Null Pointer Exception 00:27:08
O un I.O. exception 00:27:09
Pues lo que haría es 00:27:12
Ejecuto el bloque 1, ejecuto el bloque 2 00:27:13
Donde salta el error 00:27:15
Porque el bloque protegido es este 00:27:17
Me saltaría esta catch de aquí 00:27:19
Que pero diría, no, esta no es una arithmetic exception 00:27:22
Es otra exception, es una I.O. exception 00:27:24
Por ejemplo, por lo tanto 00:27:26
Pilaría el segundo catch 00:27:27
Ejecutaría el bloque 4 00:27:29
Y una vez ejecutado el bloque 4 00:27:31
Sigue adelante con el bloque 5 00:27:33
Dudas hasta aquí 00:27:35
Tened en cuenta que si yo no pusiera 00:27:38
esto, cuando llega 00:27:41
aquí y explota 00:27:43
se acabó el programa, esto no lo ejecutará 00:27:44
nunca, en vez con 00:27:47
este mecanismo de try-catch 00:27:49
lo que estoy haciendo es recuperarme de un error 00:27:50
a tiempo de ejecución, ha habido el error 00:27:53
lo he pillado, lo he 00:27:55
gestionado 00:27:57
y sigue adelante 00:27:58
por ejemplo, cuando nosotros usamos una list 00:28:00
y no sabemos si la lista es nula o no 00:28:02
y decimos list.add 00:28:04
mi lista.add 00:28:06
pues a lo mejor la lista 00:28:08
es null, y por lo tanto aquí explota 00:28:11
y aquí me pongo un catch 00:28:13
null pointer exception 00:28:15
y si pillan null pointer exception, lo que hago es 00:28:16
que mi lista es igual a new 00:28:18
array list, paréntesis, paréntesis 00:28:20
y luego rehago la add 00:28:23
entonces he conseguido recuperarme 00:28:24
de este error y seguir allá 00:28:26
¿tú das? 00:28:28
en teoría sí 00:28:35
en teoría desde 00:28:37
el primero que encuentra es el que ejecuta 00:28:40
Entonces, si pusiera esto antes, pues me saltaría siempre exception, o sea, creo. 00:28:42
¿Te pone un mensaje o algo? 00:28:48
Si tú quieres, sí. 00:28:58
¿Dónde lo tienes el mensaje? 00:29:00
Este es el objeto que la, la, la llave de tool machine has creado, 00:29:02
donde está la información sobre lo que ha pasado, 00:29:08
y si tú haces un ae.getMessage, tendrás el mensaje que ha pasado allí. 00:29:12
que ha pasado allí, si tu no pones nada, no te hace nada, si tu pones system.auto.println 00:29:18
de ae.getmessage te escribirá el mensaje, lo mismo que aparece cuando explota y te aparece 00:29:27
ahí pasa, lo mismo que aparece, y si tu haces ae.printstack, no me acuerdo, lo veremos, 00:29:32
pues te escribe exactamente lo que ves normalmente, pero estas aquí y puedes recuperarte, no 00:29:40
No has perdido, no has apagado el ordenador, puedes escribir el mismo objeto, el mismo error y seguir adelante si quieres, recuperarlo y seguir adelante. 00:29:47
O este error, escribirlo en un fichero de log de, mira, hoy a esta hora ha pasado este error de aquí, para que luego tú cuando lo tienes en producción una semana, 00:29:55
después de una semana te vas a mirar los logs y ves, mira, tres veces a lo largo de esta semana ha dado una excepción porque este usuario ha intentado conectarse y ha pasado esto. 00:30:05
Y vas haciendo un plan de 00:30:12
¿Sí? 00:30:15
Cuidado en rojo 00:30:18
El orden es importante 00:30:20
Otra opción 00:30:21
Con un bloque finally 00:30:24
¿Vale? 00:30:25
Entonces, ¿qué pasa sin excepciones? 00:30:26
El bloque 1 se ejecuta 00:30:30
Luego se ejecuta el bloque 2 00:30:31
Después de haber ejecutado el bloque 2 00:30:33
Siempre se ejecuta el finally 00:30:35
Y luego se sigue adelante 00:30:37
¿Sí? 00:30:38
Excepción de tipo aritmético 00:30:41
Que es un arithmetic exception 00:30:42
Pues entonces bloque 1 00:30:44
En el bloque 2 hay el error 00:30:46
El bloque error 00:30:48
Se pilla, se ejecuta 00:30:50
Se ha recogido desde este catch 00:30:52
Por lo tanto va al bloque 3 00:30:54
Ejecuta el bloque 3 00:30:56
Luego está la final y que se ejecuta siempre 00:30:57
Entonces se ejecuta y después se pasa al bloque 5 00:31:00
Esto es algo que se hace 00:31:03
Tanto si hay error como si no 00:31:09
No necesariamente 00:31:11
es un bloque 00:31:14
puede poner lo que te haga, me llama a todos 00:31:29
métodos, while, truth 00:31:31
lo que sea 00:31:34
esto es más bien porque 00:31:35
si tú aquí hicieras una cosa 00:31:38
y luego aquí harías la misma 00:31:40
pues la idea es que tú 00:31:41
estas dos cosas las pongas aquí 00:31:44
y se ejecutará siempre así 00:31:46
y está referido a este bloque aquí 00:31:47
el ejemplo de antes de añadir a una lista 00:31:50
tú dices 00:31:52
Añadir a la lista 00:31:53
Pues a lo mejor la añado a la lista 00:31:54
Lo meto aquí 00:31:56
Y aquí hago otro hacer 00:31:56
No lo sé 00:31:59
Un ejemplo un poco feo 00:31:59
Pero no lo sé 00:32:00
¿Sí? 00:32:02
El exception de otro tipo diferente 00:32:06
Imaginémonos que yo estoy aquí 00:32:09
Try 00:32:10
Lo que pasa es que 00:32:11
El bloque 1 lo ejecuto 00:32:13
El bloque 2 explota una IO exception 00:32:15
Cuidado que no hay un catch 00:32:17
De IO exception 00:32:18
¿Vale? 00:32:19
Entonces no se ejecuta nada 00:32:20
Pero el finally sí se ejecuta 00:32:21
El 4 00:32:23
¿Vale? 00:32:24
Y después 00:32:25
No se ejecuta el 5 00:32:26
Porque ha explotado 00:32:28
No lo ha capturado 00:32:30
¿Sí? 00:32:31
Entonces aquí veis 00:32:33
La función 00:32:35
Si voy a exception 00:32:36
¿Qué método me encuentro? 00:32:40
Unos cuantos 00:32:41
Los vais a ver 00:32:42
¿Vale? 00:32:43
Los útiles 00:32:43
GetMessage 00:32:44
¿Vale? 00:32:45
Me devuelve un string 00:32:45
Este getMessage 00:32:47
Es el mensaje 00:32:48
Que me explica 00:32:49
Que ha pasado 00:32:50
Uno en pointer exception 00:32:50
Me dirá 00:32:51
El objeto 00:32:52
Que ha pedido 00:32:53
Es null 00:32:54
Un index out of bound exception me dirá 00:32:55
Has intentado acceder a la posición 13 00:32:57
La posición 13 no existe en el array 00:32:59
Un IO exception me dirá 00:33:01
Has alcanzado el final del fichero 00:33:03
Intentando leer más cosas 00:33:06
Pues me da 00:33:08
Un mensaje 00:33:10
Está claro que estos mensajes son muy genéricos 00:33:11
Porque valen en general 00:33:13
Cuando nosotros crearemos 00:33:15
Nuestras propias excepciones 00:33:18
Y lanzaremos nuestras propias excepciones 00:33:20
Pues entonces 00:33:22
Lo que podemos hacer es meter un mensaje 00:33:23
Más explícito y más interesante 00:33:26
Para nuestro caso, en nuestra situación 00:33:27
ToString, ¿vale? 00:33:30
El toString devuelve 00:33:37
Más o menos lo mismo, pero es una representación 00:33:39
De esta excepción, entonces ¿qué hace? 00:33:42
Devuelve la clase de la excepción 00:33:44
¿Qué clase es? 00:33:46
Por ejemplo, IOException 00:33:48
¿Vale? Concadenada con esta cosa 00:33:50
Entonces, es lo mismo 00:33:52
Es siempre el mensaje, pero además me da información 00:33:54
Sobre cuál es la clase 00:33:56
Digamos que esto es más orientado 00:33:57
Para que lo digas al usuario 00:34:00
Esto es más orientado para ti programador 00:34:01
Para ver qué excepción es 00:34:03
Exception de string es un constructor 00:34:06
Que me permite crear una excepción 00:34:10
Este string es el mensaje 00:34:11
Entonces si yo me quiero crear una 00:34:14
Excepción mía, lo puedo hacer 00:34:15
Creando 00:34:18
Exception x es igual a new exception 00:34:19
No has pedido que haga las cosas 00:34:22
Por favor 00:34:26
Esa es una excepción que luego lanzaré 00:34:26
Y me dirá como error 00:34:29
Pues no lo has pedido por favor 00:34:30
PrintStackTrace 00:34:31
Es lo que sale normalmente 00:34:35
Toda esa parrafada roja 00:34:38
Que sale normalmente 00:34:39
Me está diciendo 00:34:40
La traza de la pila 00:34:42
De llamadas 00:34:45
Que ha llegado a este error 00:34:46
O sea, muchas veces 00:34:48
Yo tengo un programa 00:34:49
Que llama add 00:34:50
Pero dentro de add 00:34:52
Se llama otro método 00:34:54
Que se llama otro método 00:34:55
Y es en este método aquí donde ha explotado 00:34:57
¿Vale? Entonces el print stack trace 00:34:59
Lo que me dice es, mira 00:35:01
Yo estaba en este método de aquí 00:35:03
Este método de aquí ha explotado 00:35:04
Y ha mandado, ha intentado 00:35:06
Ver si había una catch 00:35:09
En el método que lo ha llamado 00:35:11
Como no había una catch allí 00:35:13
Ha salido a tu método 00:35:15
A tu método add 00:35:17
Y allí no había una catch, entonces ha salido arriba 00:35:18
Hasta llegar a tu main 00:35:20
Y como no ha habido en ningún lado de estos 00:35:21
Una quechua que me ha recuperado este problema 00:35:24
Pues he explotado 00:35:26
Pero tú ves 00:35:28
Todas las llamadas que ha habido 00:35:29
Para saber dónde está de verdad el error 00:35:31
¿Entiende más o menos? 00:35:34
Si lo miráis 00:35:37
Cuando sale una de estas pantallazos rojos 00:35:38
Pues dentro hay todos los métodos 00:35:41
Algunos vuestros 00:35:42
Y algunos de clases que estáis utilizando 00:35:44
Que os hace entender 00:35:47
donde ha habido el error de verdad 00:35:50
entonces 00:35:52
así como se pueden capturar 00:35:56
excepciones, se pueden lanzar 00:35:58
excepciones, o sea yo puedo hacer 00:36:01
que mi programa en un determinado momento 00:36:03
diga, oye mira, si llegas aquí 00:36:04
y hay una determinada condición 00:36:06
pues explota, lanza 00:36:08
una condición, lanza una excepción 00:36:10
y imaginaos, normalmente esto se hace 00:36:12
en un método, yo tengo mi método 00:36:14
que hace cosas, y en un determinado 00:36:16
momento dice, oye mira, no puedo seguir 00:36:19
adelante, entonces lánzame una excepción 00:36:20
por ejemplo 00:36:23
si yo tengo el método divide 00:36:24
que pilla dos números 00:36:26
y divide el primero por el segundo 00:36:28
si entra aquí dentro 00:36:31
y se da cuenta que el segundo número 00:36:32
es igual a cero 00:36:34
podría lanzar una excepción 00:36:36
aritmética excepción 00:36:38
o mi excepción propia de 00:36:40
division divided by zero 00:36:42
excepción 00:36:45
para comunicarte 00:36:46
oye mira, no puedo seguir adelante 00:36:48
Porque me estás intentando hacer una división por cero 00:36:50
Es mi método que la lanza 00:36:52
Ahora, quien usa mi método 00:36:58
Puede hacer una try-catch 00:37:00
Para intentar recolectar esa excepción 00:37:02
Es un mecanismo de funcionamiento 00:37:04
Imagínate que tú estás haciendo algo complejo 00:37:09
Estás haciendo tu propia 00:37:12
Linked list 00:37:13
¿Vale? 00:37:16
Como hemos hecho nosotros 00:37:17
Mi lista es 00:37:18
Y quieres que cuando alguien intente poner 00:37:19
Un objeto nuevo en la lista 00:37:22
Y este objeto es null 00:37:23
Tú lo avises que no lo puede hacer 00:37:24
Y en vez de decir, no hago nada 00:37:27
Si él añade null y no pasa nada 00:37:29
Mágicamente, pues lo que hago es 00:37:32
Crearme una excepción que sea 00:37:34
Has añadido null exception 00:37:35
Y cuando yo 00:37:38
Estoy implementando mi método 00:37:40
Y voy allí 00:37:42
Y digo, el objeto que me has pasado es null 00:37:44
Y el objeto que me has pasado es null 00:37:46
Pues lanza 00:37:48
La excepción 00:37:50
Has pasado un efecto null 00:37:51
¿Vale? 00:37:53
¿Qué hace esto? 00:37:55
Hace que el método art que estoy creando yo 00:37:56
Pues otros cuando lo usan 00:37:59
Puedan ponerlo dentro de un try catch 00:38:02
Y poner un catch de 00:38:04
Has añadido un null exception 00:38:05
Y en el caso en que 00:38:08
Alguien intenta añadir algo 00:38:09
Pues recogen esa cosa aquí 00:38:11
Y ven que ha pasado 00:38:13
Porque has intentado añadir un null 00:38:15
O no querías 00:38:16
O a lo mejor si lo querías 00:38:17
Y cuando pasa eso es una señal para hacer otra cosa 00:38:19
No sé 00:38:22
Este es el mecanismo 00:38:22
Luego para qué sirve 00:38:24
Depende del momento 00:38:26
¿Sí? 00:38:28
Vamos a hacer unos ejemplitos 00:38:29
De ejercicios 00:38:30
¿Vale? 00:38:32
¿Cómo se lanza una excepción? 00:38:32
Con el comando throw 00:38:34
Lanzar 00:38:35
Depende 00:38:36
Habrá situaciones en que a lo mejor no hay unir 00:38:45
A lo mejor 00:38:48
Pero sí 00:38:49
O sea 00:38:49
No hay que existe 00:38:50
O programas de una forma o programas de otra 00:38:51
¿Vale? 00:38:53
Además la programación optimista 00:38:54
La puedes hacer 00:38:57
Porque alguien te está lanzando las excepciones 00:38:59
Si alguien no lanza las excepciones 00:39:01
Pues entonces no 00:39:02
Tú dices, si yo hago la 00:39:03
Nextint 00:39:06
Y podría ser que explote 00:39:07
Pero yo digo 00:39:11
Cruzo los dedos y sigo adelante 00:39:12
Pero esto porque quien ha implementado la Nextint 00:39:14
Dentro 00:39:17
En un determinado momento 00:39:18
Pues si pasa esta cosa aquí, explota 00:39:19
O si tú explotas de otra forma 00:39:21
En una cache allí dentro 00:39:24
Pues lanza esta excepción aquí 00:39:26
Esto podría ir en una cache 00:39:28
Cosa se complica 00:39:30
¿Sí? 00:39:32
Pero la idea es que 00:39:34
Si esto, el try-catch 00:39:36
Es para pillar una excepción 00:39:38
Capturar una excepción 00:39:41
Quiere decir que alguien la lanza en algún lado de la excepción 00:39:42
¿Y cómo se lanza una excepción? 00:39:45
Pues así 00:39:47
¿Vale? 00:39:47
Yo puedo comandar en un determinado momento 00:39:50
de mi programa 00:39:52
o si llegas aquí y hay determinadas 00:39:54
condiciones, pues aquí no puedes 00:39:56
seguir adelante, lanza una excepción 00:39:58
para que diga, oye mira, aquí 00:40:00
nos bloqueamos y esta excepción 00:40:02
empezará a subir 00:40:04
a quien me ha llamado a mí 00:40:06
a quien ha llamado el que me ha llamado a mí 00:40:08
a quien ha llamado el que no ha llamado el que no ha llamado a mí 00:40:10
hasta llegar al main 00:40:12
en la esperanza que por algún lado haya un catch 00:40:13
que la rejoja 00:40:16
si no hay ningún catch y llega al main 00:40:17
pues entonces el programa se para 00:40:20
El objetivo que se le pasa 00:40:21
El objeto que se le pasa a Tro 00:40:27
Tiene que ser de la clase Exception 00:40:29
O de cualquier subclase que extienda esta 00:40:31
Incluido 00:40:33
Una clase mía 00:40:34
Que me creo yo 00:40:38
De clase miException 00:40:39
ExtendsException 00:40:41
Y me hago mis propias excepciones 00:40:43
Cuando un programa es suficientemente complejo 00:40:45
Y hay cosas que pueden pasar 00:40:48
Por ejemplo, en esto de las alumnos 00:40:49
Escuela y cosas por el estilo 00:40:52
Pues yo podría crear 00:40:53
Excepciones del tipo 00:40:55
Alumnos ya existentes 00:40:57
Exception 00:40:59
Que si alguien intenta crear un nuevo alumno 00:41:00
Que ya existe porque tiene el mismo código 00:41:02
Pues explote 00:41:04
Con una excepción 00:41:05
Luego será recogida y que siga 00:41:07
Throw 00:41:11
En el momento que se hace el throw 00:41:14
Se sale inmediatamente del bloco de código actual 00:41:17
Yo estoy en un bloque, lanzo el throw 00:41:19
Pues salgo, típicamente este es un método 00:41:21
Este método en determinado momento 00:41:23
Lanza la throw, pues se sale del método 00:41:25
Y se vuelve arriba 00:41:27
A quien ha llamado 00:41:29
Si el bloque tiene asociado una cláusula 00:41:30
Catch 00:41:33
Adecuada para este tipo de excepción 00:41:34
O sea que hay una catch con la excepción correcta 00:41:37
Con la excepción que he lanzado 00:41:40
Pues entonces se entra 00:41:42
En el cuerpo de ese catch 00:41:43
Y se ejecuta 00:41:46
Si no, se sale de ese bloque 00:41:47
también y se va 00:41:50
al llamante 00:41:51
al bloque superior 00:41:53
y así, así, así, hasta 00:41:55
dos opciones, o llego 00:41:57
a una cláusula catch apropiada 00:41:59
y entonces la ejecuto y luego sigo 00:42:01
adelante en el programa 00:42:03
o llego al main 00:42:05
y una vez llegado al main no puedo 00:42:07
subir más y entonces el programa se va 00:42:09
proceso continuo hasta llegar al 00:42:11
método main de la aplicación, si ahí tampoco 00:42:15
existe una cláusula catch adecuada 00:42:17
La máquina virtual finaliza su ejecución 00:42:19
Con un mensaje de error 00:42:22
Luego existe otra cosa 00:42:23
Que no es throw 00:42:29
Sino que es throws 00:42:30
¿Vale? 00:42:32
Y esto no se usa dentro del código 00:42:33
Se usa donde se declara 00:42:36
Un método 00:42:39
O sea, public void 00:42:39
Mi método 00:42:43
Que pilla sus parámetros 00:42:44
Y después throws 00:42:45
IOException 00:42:47
¿Qué quiere decir? 00:42:49
Quiere decir que por algún lado de este método 00:42:50
Por ejemplo aquí está el método F 00:42:53
Que puede lanzar una excepción de clase E 00:42:55
Pues sería esto, public void 00:42:58
El método throws E 00:42:59
Quiere decir que dentro del cuerpo de F 00:43:02
Del cuerpo de F 00:43:05
En algún lado 00:43:05
Puede ser que salte una excepción E 00:43:07
Pero yo no la capturo allí 00:43:11
En automático esto salta por arriba 00:43:14
Es como avisar a quien usa F 00:43:17
De, oye, mira, mi método F puede lanzar excepciones de este tipo 00:43:21
Por lo tanto, si quieres usar F, no lo uses directamente 00:43:27
Ponlo dentro de un try-catch 00:43:31
Y haz un catch de esta excepción 00:43:33
¿Se me explica? 00:43:37
Es como avisar a quien va a usar mis métodos 00:43:40
Que como es posible que explote una determinada cosa 00:43:44
Pues lo tienes que gestionar 00:43:47
Tienes que tener en cuenta 00:43:48
Que cada vez que usas f 00:43:50
Puede ser que te encuentres una excepción e 00:43:51
Y por lo tanto 00:43:54
Ponlo en un try catch 00:43:55
Con un catch de excepción e 00:43:57
¿Si? 00:43:58
Esto sirve para que potenciales de f 00:44:02
Sepan a qué atenerse 00:44:04
A qué puede pasar 00:44:05
Si un método lanza más de un tipo de excepciones 00:44:07
Se puede poner throws 00:44:10
Con las excepciones separadas 00:44:11
O sea, ioException 00:44:13
Coma null pointer exception 00:44:15
Coma no sé qué exception 00:44:16
¿Dudas hasta aquí? 00:44:18
Cuando en un código utilizamos 00:44:25
Métodos que lanzan potencialmente excepciones 00:44:26
Es decir, que su procedido tiene throws 00:44:29
Estamos obligados a hacer una de estas dos cosas 00:44:31
¿Vale? 00:44:34
Entonces, yo soy un método 00:44:35
Un código 00:44:37
Que usa un método como este 00:44:38
¿Sí? 00:44:41
Puede hacer dos cosas 00:44:44
O protejo la llamada de F 00:44:45
Con un bloque try-catch 00:44:48
Función 1 00:44:50
O indico 00:44:51
En el prototipo de este método 00:44:54
O sea, el método que usa F 00:44:56
Que él también 00:44:58
Lanza esta excepción 00:45:00
Imaginamos el método 00:45:02
Otro método 00:45:05
Que dentro usa este método de aquí 00:45:07
Pues o cuando llamo F 00:45:10
Lo pongo en un try-catch 00:45:13
O en el prototipo del 00:45:15
Otro método, pongo public void 00:45:17
Otro método, paréntesis, paréntesis 00:45:19
Trous y también 00:45:21
¿Sí? 00:45:23
Es en un cierto sentido de 00:45:26
¿Quién va a ocuparse 00:45:27
De esta excepción? 00:45:29
Y tengo dos opciones, o me ocupo yo 00:45:30
O lo dejo por arriba 00:45:32
Será quien me llama a mí que se escupe de eso 00:45:35
¿Sí? 00:45:37
Luego tú como programador 00:45:42
Tendrás que encontrar 00:45:44
Donde es el sitio mejor 00:45:46
Donde se ejecuta esa 00:45:48
Donde se captura esa ejecución 00:45:50
Hay situaciones en las que 00:45:52
En cuanto pase, pues te compensa 00:45:54
Pillarla allí, pero 00:45:56
Tú imagínate que 00:45:57
Imagínate esto 00:45:59
Que yo tengo un método 00:46:02
Es el método A 00:46:10
¿Vale? 00:46:11
Que hace cosas 00:46:13
Luego llama este método F 00:46:15
Luego hacer otras cosas 00:46:17
Y entonces 00:46:19
Y aquí tengo el método f 00:46:22
Que throws 00:46:23
La excepción 00:46:25
Entonces cuando yo uso esto 00:46:28
Aquí pues tengo dos opciones 00:46:37
La primera es ponerlo dentro de un track edge 00:46:39
Si lo pongo dentro de un track edge 00:46:41
Recuperaré esta excepción 00:46:43
Y luego puedo seguir 00:46:45
Trabajando con esto 00:46:47
O sea, que si tú quieres que en el caso en que f falle 00:46:48
Mi método a siga igualmente haciendo cosas 00:46:53
Pues entonces el try catch lo pongo aquí 00:46:57
Pero imagínate que tú quieres que si a ha llegado a f 00:46:59
Si f falla, a no siga adelante haciendo cosas 00:47:03
A también tiene que explotar 00:47:06
Pues entonces no le pongo un try catch aquí 00:47:08
Y pongo que este también throws i 00:47:10
Entonces cuando esto explota 00:47:14
Llega aquí 00:47:20
No encuentra un try-catch 00:47:20
Pero lo tanto sale de aquí también 00:47:22
E irá a 00:47:26
El método X 00:47:27
Que era un método 00:47:28
Que en un determinado momento llamaba 00:47:30
Y aquí tengo lo mismo 00:47:32
O he puesto un try-catch aquí 00:47:36
O he puesto que un 00:47:38
ThrowsException 00:47:40
Y así hasta llegar al main 00:47:42
Si llega el main 00:47:44
Y el main no tiene un track edge 00:47:45
Esto delega la responsabilidad 00:47:47
Del manejo a otras clases invocantes 00:47:55
Y de ahí viene el sentido 00:47:57
De printStackTrace 00:47:59
¿Vale? 00:48:01
Si aquí es donde explota 00:48:05
Y hago un printStackTrace 00:48:07
Pues lo que me dirá es 00:48:09
Mira, yo estaba en la F cuando ha explotado 00:48:13
Y entonces 00:48:16
Se lo ha mandado a la E 00:48:17
Que ha explotado también 00:48:18
Y entonces la han mandado a X 00:48:20
Que me dice 00:48:22
La pila de llamadas que ha habido 00:48:23
Y por qué ha explotado 00:48:26
¿Dónde ha explotado? 00:48:27
¿Se entiende? 00:48:29
Si la excepción lanzada es hija de RuntimeException 00:48:31
No es necesario manejarla 00:48:36
Vamos a verlo 00:48:38
Aquí 00:48:40
¿Vale? 00:48:42
Ahora volvemos sobre este tema 00:48:44
Todos son throwable 00:48:45
Se pueden lanzar 00:48:48
¿Vale? 00:48:50
Y dentro de las cosas que se pueden lanzar 00:48:51
Hay dos cosas 00:48:55
Errores y excepciones 00:48:56
Los errors, que son troubles también 00:48:59
Pues son errores graves 00:49:02
Son errores que normalmente no dependen de vosotros directamente 00:49:04
Sino errores de la máquina virtual 00:49:07
¿Vale? 00:49:10
Y que no deberían ser manejados 00:49:11
Ha habido un fallo tan grave que el programa tiene que acabar 00:49:13
¿Vale? 00:49:17
Como por ejemplo, virtual machine error 00:49:17
Hay un error de la máquina virtual 00:49:19
Pues no puedes hacer nada 00:49:21
El error no es tuyo, es de la máquina virtual 00:49:23
Search on error 00:49:25
Ni siquiera que se que es 00:49:27
Pero pensad 00:49:28
Si vosotros creáis 00:49:30
Demasiadas llamadas de método 00:49:33
Ponéis un while true 00:49:35
Llamar un método 00:49:37
Y que dentro de este método 00:49:38
Llama este método 00:49:39
Entonces la pila de llamadas de método 00:49:41
Crece, crece, crece 00:49:44
Hasta llegar a un momento 00:49:46
En que la virtual job machine 00:49:48
Ha ocupado toda la RAM 00:49:50
Y no puede hacer otra llamada 00:49:51
La RAM que tiene a disposición 00:49:53
Pues esto es un error de este tipo 00:49:56
Ya no puedo hacer nada 00:49:58
Exploto 00:49:59
Esto es de aquí 00:50:00
Si pasan, es grave 00:50:03
Hay que entender que es 00:50:06
Pero no se hace un try catch 00:50:07
Esto es un error 00:50:09
Sin embargo las excepciones 00:50:10
Son errores a tiempo de ejecución 00:50:14
Que si pueden ser manejados 00:50:15
manejados son manejables 00:50:18
y recuperables 00:50:20
puede ser que este error de aquí se me pasa 00:50:22
quiera acabar mi programa 00:50:24
pero puede ser que este error de aquí se me pasa 00:50:26
esta excepción de aquí se me pasa 00:50:28
pues me recupere de la excepción y siga adelante 00:50:30
¿vale? he insertado 00:50:33
un alumno que ya existía, pues me salta 00:50:34
alumno existente exception 00:50:36
pero yo de allí me recupero y vuelvo 00:50:38
al menú principal 00:50:40
diciendo un mensaje de error de, oye, este alumno 00:50:41
no lo puedo insertar porque ya existe 00:50:44
y vuelvo al menú principal, no acabo 00:50:46
Mi programa 00:50:48
Dentro de Exception 00:50:49
Hay dos tipos de Exception 00:50:52
Hay la Runtime Exception 00:50:54
Y las otras 00:50:56
¿Vale? 00:50:58
Las Runtime Exception son errores 00:50:59
Que pero son bastante habituales 00:51:03
Suelen pasar mucho 00:51:05
Como por ejemplo 00:51:07
El Null Pointer Exception 00:51:09
O como por ejemplo el Index Outbound Exception 00:51:10
¿Vale? 00:51:13
Estos errores de aquí 00:51:14
No se vigilan 00:51:15
O mejor 00:51:19
No se vigilan siempre 00:51:20
¿Cuántas veces vosotros habéis hecho 00:51:22
Objeto.nombre 00:51:24
Objeto.metodo 00:51:27
Y lo habéis puesto 00:51:29
En un bloque try-catch 00:51:31
Ninguno 00:51:33
Porque no lo conocí 00:51:35
Sin embargo ha funcionado 00:51:36
Pero al llamar un método 00:51:38
Podría haber lanzado una null pointer exception 00:51:40
De hecho a veces la ha lanzado 00:51:42
Cuando vosotros hacéis el next int 00:51:44
El next int puede lanzar un number format exception 00:51:46
¿Lo habéis puesto en un track edge? 00:51:49
¿Por qué esto? 00:51:52
Porque el coste computacional 00:51:55
De controlar absolutamente 00:51:58
Todas estas cosas 00:52:00
Es demasiado elevado para hacerlo 00:52:01
Pensad todas las veces que habéis usado 00:52:03
Un array 00:52:05
Todas las veces que habéis usado un array 00:52:06
Os habéis puesto la posibilidad de un index out of bound exception 00:52:09
Pues habrías tenido que poner un try que he hecho 00:52:12
Diciendo que si es una interrupción 00:52:15
Haz algo 00:52:16
Pues llega un momento en que este tipo de excepciones 00:52:17
Se dice, mira, oye, se asume que pueden pasar 00:52:20
Las puedes controlar si quieres 00:52:23
Pero no es obligatorio 00:52:25
Para que el coste computacional 00:52:27
El sobrecoste computacional 00:52:30
De tener cuidado de estas cosas 00:52:31
Pues en un cierto sentido 00:52:33
Se quita a la máquina virtual 00:52:35
Y se da al programador 00:52:37
Sois vosotros que tenéis que tener cuidado 00:52:39
Con no salir de la red 00:52:42
No la mat 00:52:44
Y estos son como 00:52:45
Arithmetic exception 00:52:49
Index at all 00:52:51
Null pointer exception 00:52:52
Todas estas son 00:52:54
Las otras 00:52:55
Cualquier otra que no derive de esta de aquí 00:52:58
Que no herede de esta de aquí 00:53:01
Pues tenéis que 00:53:03
Manejarla 00:53:05
Estas se pueden 00:53:06
No manejar 00:53:09
Esta de aquí si 00:53:10
Y tenéis dos métodos para manejarla 00:53:11
La primera es 00:53:14
Try catch 00:53:15
Y el segundo es 00:53:19
Throw 00:53:20
O sea, o la manejáis vosotros 00:53:22
O avisáis a quien os usa 00:53:26
Que es posible que explote 00:53:28
¿Sí? 00:53:30
Pero sería demasiado costoso 00:53:42
A nivel computacional 00:53:45
Comprobar absolutamente 00:53:46
Que todas las veces que usas un objeto 00:53:48
Pues que este objeto no se anude 00:53:50
¿Veis? 00:53:52
No es obligatorio 00:53:56
Es que se te obliga a no hacerlo 00:53:58
Y de hecho, en determinados casos 00:54:00
Tú lo puedes poner 00:54:03
Un uso de un objeto dentro de un try catch 00:54:04
Y hacer un catch de null pointer exception 00:54:06
¿Veis? 00:54:09
Pero normalmente 00:54:11
Si tú no lo haces 00:54:12
Él no te va a decir nada 00:54:14
Entonces cuando lo haces 00:54:15
Si tú estás usando un objeto 00:54:18
Que viene de ti 00:54:20
Porque es un método interno privado 00:54:22
Que usas tú 00:54:24
Y sabes que cada vez que lo haces 00:54:25
Le pasas un objeto que no es null 00:54:26
Pues lo obvias 00:54:29
Si en vez es un método público 00:54:30
Que otros pueden utilizar 00:54:32
Y pueden ser malvados 00:54:34
Y pasarte como objeto un null 00:54:36
Pues entonces dentro deberías 00:54:39
Comprobar 00:54:41
O con un if 00:54:43
Si quieres hacer programación 00:54:44
Pesimista 00:54:46
O poniendo su uso 00:54:48
Dentro de un try-catch 00:54:50
Y hacer un catch de exception o de lo que sea 00:54:51
Que si explota por alguna razón 00:54:54
Pues te avise por qué 00:54:55
¿Si? 00:54:57
Y esto es esquemita 00:55:00
¿Vale? 00:55:02
Todos son throwables 00:55:03
Hay los errores 00:55:04
Que son como virtual machine error 00:55:07
No class definition found error 00:55:09
Assertion error 00:55:12
Stack over flow error 00:55:13
Stack over flow error es lo que decía antes 00:55:15
Del que viene el sitio web Stack Overflow 00:55:17
Y luego están las excepciones 00:55:20
Dentro de las excepciones hay varias excepciones 00:55:24
Todas estas 00:55:26
Como la Class Not Found Exception 00:55:27
O la IO Exception 00:55:29
Que puede ser Interrupted Exception 00:55:31
End of File Exception 00:55:33
Connection Not Found Exception 00:55:35
Todas las excepciones de entrada y salida 00:55:37
Y luego están las Runtime Exception 00:55:39
Estas 00:55:42
Son las que podéis no comprobar 00:55:43
Estas hay que comprobarla siempre 00:55:46
Si yo tengo un método 00:55:49
Que throws IOException 00:55:50
Pues la tengo que poner en un trajecho 00:55:53
Si yo tengo métodos 00:55:56
Que lanzan estas cosas de aquí 00:55:57
Puedo evitarlo 00:55:59
Como es el caso del NextInt 00:56:00
O del 00:56:02
Otros que hemos hecho 00:56:04
Y aquí están cosas 00:56:06
Como IndexAutoBoundException 00:56:08
IllegalArgumentException 00:56:11
Del que deriva 00:56:13
NumberFormatException 00:56:14
ClassCastException 00:56:16
Alguna vez lo hemos visto 00:56:19
Cuando te equivocas a hacer un casting 00:56:20
De clases 00:56:23
ArithmeticException 00:56:24
Como la división por cero 00:56:26
NullPointerException 00:56:27
NoSuchElementException 00:56:29
NegativeArraySizeException 00:56:32
¿Qué cosa parece? 00:56:34
NotaNumber 00:56:38
NotaNumber yo creo que es NormalFormatException 00:56:39
O sea, un ArithmeticException 00:56:42
No sé, no pondré 00:56:43
¿Vale? 00:56:48
Y, últimas dos transparencias y acabamos, excepciones personalizadas, es decir, que dentro de mi programa complejo yo puedo crear mis propias excepciones, ¿cómo las creo? 00:56:50
Pues me creo una clase 00:57:03
Digo que soy hijo 00:57:05
De otra clase, por ejemplo 00:57:07
Puedo ser hijo de Exception 00:57:09
O puedo ser hijo de Runtime Exception 00:57:11
O puedo ser hijo de 00:57:14
Troubles, mejor que no 00:57:16
¿Vale? Normalmente 00:57:17
Tiramos de aquí 00:57:19
¿Vale? O sea, Extends Exception 00:57:20
Y creo Public Class 00:57:23
Mi excepción, Extend Exception 00:57:25
Y ahora allí dentro puedo 00:57:27
Sobrescribir todos los métodos que yo quiero 00:57:29
Utilizando lo básico 00:57:31
De Exception, entonces aquí tendré el GetMessage 00:57:33
Tendré el 00:57:35
PrintStack, etc, etc 00:57:37
Y lo puedo 00:57:39
O llamar directamente el de mi padre 00:57:40
O reescribir 00:57:43
Para que haga lo que yo quiero hacer 00:57:45
De esta forma puedo hacer 00:57:47
Excepciones más orientadas 00:57:49
Más personalizadas a lo que quiero hacer 00:57:51
Por ejemplo 00:57:53
Tengo la 00:57:55
Public DivideByZeroException 00:57:57
¿Vale? 00:58:00
Que extend arithmetic exception 00:58:01
Este es el constructor 00:58:03
¿Vale? 00:58:06
Que usa el constructor de mi padre 00:58:07
Sin ningún problema 00:58:09
Y luego tengo un programa 00:58:11
Que es un método que es dividir 00:58:13
¿Vale? 00:58:15
Que lanza divide by exception 00:58:15
Entonces, quien usa 00:58:17
Dividir de estos dos números 00:58:19
Sabe que se expone a la posibilidad 00:58:21
De lanzar esto 00:58:23
Lo tiene que manejar 00:58:24
Es una runtime exception 00:58:27
Por lo tanto, no está obligado 00:58:44
¿Vale? 00:58:46
Pero tú sabes que cuando vas a usar dividir 00:58:48
Puede ser que lance una 00:58:50
Divide by 0 exception 00:58:52
Luego, haz tú lo que quieras con eso 00:58:54
¿Sí? 00:58:56
Si esto, en vez de extender a aritmética exception 00:58:57
Extender a exception directamente 00:59:01
Pues serías obligado 00:59:03
¿Sí? 00:59:04
Si el denominador 00:59:06
Es igual a 0 00:59:09
Lanza una nueva 00:59:10
Divided by zero exception 00:59:13
Diciendo error 00:59:15
O error has dividido por cero 00:59:15
Y si no devuelve esta cosa aquí 00:59:17
Ya está 00:59:24
Entonces 00:59:26
Quien usa dividir 00:59:28
Debería poner un try 00:59:30
Dividir tres coma cero 00:59:31
Catch 00:59:35
Divided by zero exception 00:59:36
Esto es esta cosa aquí 00:59:39
Porque 00:59:47
porque esto es un ejemplo 00:59:51
de estoy lanzando mi propia 00:59:53
excepción, pero 00:59:55
tú tienes exception, tú podrías hacer 00:59:57
exception, pero entonces no estás usando esta, estás usando 00:59:59
excepción 01:00:01
la clase igualmente se llama alumno, pero quiero que 01:00:02
el mensaje se llame 01:00:11
esto no es tanto el mensaje, el mensaje lo pones aquí 01:00:12
esto es el tipo de error que lanzas 01:00:17
¿vale? entonces 01:00:19
la cuestión es, si tú haces un 01:00:20
programa de tres líneas 01:00:23
donde tiene que explotar porque 01:00:25
Usas exception y se acabó 01:00:27
Si tú haces un programa serio 01:00:30
Un sistema muy grande 01:00:31
Donde pueden haber varios errores de tipo distinto 01:00:32
Si siempre lanzas exception 01:00:35
Pues sí, de aquí se puede saber el error 01:00:37
Pero no sabes el tipo de error 01:00:40
Esto es para jerarquizar 01:00:42
Y organizar los errores 01:00:43
Si lo piensas, esto también 01:00:44
Podría ser todos errores 01:00:46
Pues lanzamos errores y cualquier cosa pasa 01:00:49
Pero lo que están haciendo es 01:00:51
Te lo están dividiendo por categoría 01:00:52
Para que tú sepas, además del mensaje de error 01:00:54
En qué tipo de error has hecho 01:00:57
Estamos haciendo una tipificación de errores 01:01:00
Entonces dentro de tu escuela 01:01:02
Tendrás el alumno repetido exception 01:01:04
Tendrás el no puedo añadir alumno exception 01:01:08
El no puedo borrar alumno exception 01:01:13
Y te creas varios tipos que se lanzarán donde se tienen que lanzar 01:01:15
Es posible que varios métodos lancen el mismo tipo de errores 01:01:19
Esto es un nombre inventado 01:01:24
Podría haberlo llamado 01:01:39
Exploitation Exception 01:01:40
¡Tudas! 01:01:42
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
11
Fecha:
5 de abril de 2024 - 14:28
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
1h′ 01′ 50″
Relación de aspecto:
4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
Resolución:
960x720 píxeles
Tamaño:
163.85 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid