Saltar navegación

Manejo Exception parte1 - 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 21 de febrero de 2023 por Stefano C.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, voy a grabar, entonces si habláis, dais el consentimiento para ver, para estar grabados, ¿vale? 00:00:00
Hoy vamos a ver manejo de distracciones, ¿vale? 00:00:07
Hasta ahora, de vez en cuando, nuestro programa ha hecho cosas raras, ¿vale? 00:00:11
Normalmente nuestros programas funcionan y llegan hasta el final y hacen lo que tienen que hacer 00:00:17
pero de vez en cuando el programa explota 00:00:23
y de vez en cuando sale una serie de mensajes en rojo en la consola 00:00:27
donde dice que ha habido una excepción, ¿vale? 00:00:33
Típicamente son la NullPointerException que hemos visto nosotros 00:00:36
y otra excepción que hemos visto la ReindexOutOfBoundsException, ¿vale? 00:00:40
Estas son las dos excepciones que grosso modo hemos visto 00:00:46
A lo mejor alguno de vosotros ha tenido la suerte de ver otras excepciones raras 00:00:49
pero hasta ahora no sabíamos bien qué era, ¿vale? 00:00:53
Hoy vamos a entender un poquito mejor qué es una excepción 00:00:58
y después vamos a ver cómo podemos manejar estas excepciones 00:01:03
cómo evitamos que el programa explote cuando explota 00:01:09
y sobre todo cómo podemos hacer nuestros propios mensajes de errores 00:01:14
digamos así, para que nuestro programa en situaciones de dificultad 00:01:19
pueda avisar a quien está llamando nuestros métodos 00:01:25
que algo malo ha pasado y eventualmente recuperarnos de un posible error 00:01:30
¿Vale? 00:01:37
¿Qué es una excepción? ¿Vale? 00:01:38
Es un error, es un fallo del programa, ¿vale? 00:01:40
que pero se verifica en tiempo de ejecución 00:01:43
¿Vale? 00:01:50
Hasta ahora nosotros hemos visto, hemos hablado de programaciones, cosas así 00:01:51
y deberíais haber entendido que hay dos momentos en nuestros ejercicios 00:01:57
un momento es cuando vosotros estáis escribiendo el código allí poniendo sintaxis 00:02:05
y cosas por el estilo 00:02:12
y luego hay otro momento en que pensáis de haber hecho un buen trabajo 00:02:13
y le dais al botón verde para arrancar el programa y lo ejecutáis, ¿vale? 00:02:17
Hay dos grandes tipos de, podríamos decir tres, pongamos dos 00:02:22
grandes tipos de errores, ¿vale? 00:02:28
El primero son los errores a tiempo de compilación, ¿vale? 00:02:31
Estos errores son los que os da Java cuando vosotros intentáis arrancar 00:02:35
y el programa ni arranca y os dice, ay mira, no lo puedo compilar, ¿vale? 00:02:39
Los errores a tiempo de compilación suelen ser principalmente errores sintácticos, ¿vale? 00:02:45
Si vosotros en vez de int x igual a 3, habéis escrito int igual a 3 00:02:53
se os marca y allí hay un error 00:02:58
ese es un error a tiempo de compilación porque si intentáis compilar os sale un error 00:03:01
diciendo, ay mira, no puedo compilar porque aquí hay un error 00:03:06
aquí la sintaxis no es correcta 00:03:09
después de int me espero un nombre, tú no lo has puesto, has puesto un igual 00:03:11
y por lo tanto no funciona 00:03:17
Estos son errores sencillos, digamos así, son errores que hasta la máquina puede entender 00:03:18
y entonces te puede prevenir y decir, ay mira, antes de que tú sigas adelante 00:03:27
que sepas que aquí hay un error, si yo lanzo este programa no puede funcionar 00:03:32
Error a tiempo de compilación, ¿vale? 00:03:35
Cuando vosotros habéis resuelto todos los errores que se pueden encontrar a tiempo de compilación 00:03:39
entonces no tenéis marcado ningún error en vuestro Java, lo podéis arrancar 00:03:44
y eso no garantiza que vuestro programa funcione, ¿vale? 00:03:47
Pueden todavía ocurrir fallos de dos tipos, ¿vale? 00:03:51
Podríamos decir, salgan de muchos, pero pongámoslos en dos tipos 00:03:56
Uno son las excepciones, ¿vale? 00:04:00
Las excepciones son estos errores que no son a tiempo de compilación 00:04:02
son a tiempo de producción, o sea, he lanzado el programa 00:04:07
y llega un momento en que el programa hace alguna operación que no puede hacer 00:04:10
que es un error, que es un fallo, que, por ejemplo, lo que hemos visto 00:04:22
por ejemplo, intento llamar un método, acceder a un valor, a un atributo 00:04:27
de un objeto que no ha sido instanciado y por lo tanto es nul 00:04:33
cuando yo llego allí, tengo esta referencia, esta referencia va a ser nul 00:04:38
e intento acceder a unos trozos de memoria de esta referencia que es nul 00:04:41
no puedo, entonces, ¿es un error sintáctico? 00:04:45
No, porque yo he dicho, y x punto activa método uno, ¿vale? 00:04:49
Eso sintácticamente es perfecto, pero a la hora de ejecución 00:04:54
cuando he llegado a ejecutarlo, no tenía un objeto detrás de esta referencia 00:04:58
y por lo tanto, error, y este error hace saltar una ejecución de tipo nul pointer exception 00:05:03
o yo me pongo a recorrer un array, empiezo a posición cero, posición uno, posición dos 00:05:11
y llega un momento en que llega a la posición treinta seis 00:05:17
pero mi array tenía solo treinta cinco posiciones 00:05:20
y entonces al acceder a una posición que no está en mi array 00:05:23
¿podía yo al nivel de sintaxis saberlo? 00:05:26
Pues no, ¿vale? 00:05:30
No lo sé cuánto es grande un array a tiempo de compilación 00:05:32
¿será la ejecución que a lo mejor lo hace más grande o más pequeño? 00:05:36
No lo sé 00:05:38
Pero a tiempo de ejecución, cuando intento acceder a una celda que no está en mi array 00:05:39
entonces a una porción de memoria que no pertenece a mi array 00:05:44
pues ahí explota también y hace otro tipo de excepción, otro tipo de fallo 00:05:47
que es la array index out of bind exception 00:05:52
y así como con muchos, ¿vale? 00:05:55
Para completar, antes de seguir con las excepciones 00:05:59
el tercer tipo de errores que podrías averiguar son los errores difíciles de verdad 00:06:02
que son los errores semánticos 00:06:08
o sea, yo quería hacer, calcular la área del cuadrado 00:06:11
y en vez de lado por lado he puesto lado más lado 00:06:15
eso funciona perfectamente pero no hace lo que tú querías hacer 00:06:19
y eso es lo que vosotros de verdad tenéis que saber manejar 00:06:25
¿vale? 00:06:30
Es decir, los sintácticos lo hace el eclipse 00:06:31
¿vale? 00:06:34
Estos errores aquí de funcionamiento a nivel de excepciones 00:06:35
pues se manejarán las excepciones cuando ocurran 00:06:40
yo sabré cuando puede... 00:06:43
sé que cuando accedo a un array y puede haber un array index out of bound 00:06:44
pues tendré que tenerlo en mente 00:06:48
pero el problema es que si mi programa no hace, no resuelve el problema que tenga que resolver 00:06:50
pues allí es el problema serio 00:06:57
¿vale? 00:06:59
Si yo estoy haciendo un sistema de cuentas bancarias 00:07:00
y pongo errores semánticos de que a cada vez que hago una transferencia 00:07:04
en vez de sumar o restar, dependiendo de si pillo o saco 00:07:07
suma siempre, pues eso es un error 00:07:11
¿vale? 00:07:13
y eso no hay nadie que me lo diga 00:07:14
no hay ni excepciones, ni mecanismos de Java 00:07:16
eso lo tengo que saber yo 00:07:19
¿vale? 00:07:21
y saber que el algoritmo está mal hecho 00:07:22
¿sí? 00:07:24
vale 00:07:26
cuando pasa un error serio 00:07:30
no estamos hablando entonces ni de errores semánticos ni de errores sintácticos 00:07:33
estamos hablando de los errores de fallos a tiempo de ejecución 00:07:36
pues lo más probable es que el programa llegue allí 00:07:40
enfrente a este fallo 00:07:46
y como no sabe qué hacer con este fallo 00:07:48
porque dice accede a la posición 35 de un arreo y de 30 posiciones 00:07:51
¿y qué hago ahora? 00:07:55
como no puede hacerlo, lo más normal es que el programa se detenga 00:07:57
¿vale? 00:08:01
lo que hago es bloqueo el programa 00:08:02
aquí se ha acabado 00:08:04
y te doy un mensaje de error 00:08:05
que intenta explicar el fallo 00:08:07
¿vale? 00:08:09
cuanto mejor está hecha la expresión que salta 00:08:10
más es... 00:08:13
tiene significado el mensaje que me dan 00:08:15
y por lo tanto entiendo 00:08:18
yo podría decir 00:08:20
error, error en el array 00:08:21
tú dices 00:08:24
sí, pero ¿qué error es? 00:08:25
pues a lo mejor he escrito mal 00:08:26
he escrito un string cuando tenía que poner un int 00:08:28
¿qué error es? 00:08:31
o podría poner 00:08:32
error en acceso a una posición no aceptable del array 00:08:33
tú dices 00:08:40
vale, esto ya es más concreto 00:08:41
pero aún así 00:08:44
¿qué posición he intentado acceder? 00:08:45
¿vale? 00:08:46
o te puedo dar un mensaje 00:08:47
error en acceso a la posición 35 del array 00:08:48
entonces ya sabes que has accedido a la posición 35 00:08:52
que es un error 00:08:55
cuanto más el mensaje está definido 00:08:56
mejor para quien tiene que resolver 00:09:00
o intentar resolver ese mensaje 00:09:02
díselo tú 00:09:11
que si no lo grabo 00:09:12
vale 00:09:17
Java nos proporciona un mecanismo 00:09:18
para controlar estas situaciones 00:09:21
¿vale? 00:09:23
y la idea es que 00:09:24
yo puedo decidir como programador 00:09:26
qué hacer con estas situaciones 00:09:28
¿explota mi programa? 00:09:29
¿lo dejo explotar? 00:09:31
es una posibilidad 00:09:33
es una posibilidad 00:09:34
¿vale? 00:09:35
es una posibilidad de accidente peligrosa 00:09:36
en el sentido que 00:09:38
si lo dejo explotar 00:09:40
y es una cosa que está en producción 00:09:41
y se bloquea 00:09:42
pues alguien tendrá que reiniciarlo 00:09:43
o mirar qué ha pasado 00:09:45
¿vale? 00:09:46
y entonces podría ser que 00:09:47
si es un programita que estoy haciendo para mí 00:09:48
¿qué más da? 00:09:50
si es un programa que 00:09:51
hace parte de un sistema 00:09:53
y ahora el sistema no puede utilizar ese servicio 00:09:54
porque se ha bloqueado 00:09:56
pues puede ser un problema más 00:09:57
lo que intentamos hacer 00:09:59
es intentar recuperarse 00:10:01
de un error 00:10:03
o sea yo hacer 00:10:04
a la posición famosa 00:10:05
35 de este array 00:10:06
que no existe 00:10:07
pues intentar 00:10:08
pillar este error 00:10:09
y decir 00:10:10
oye mira no 00:10:11
ha habido un error 00:10:12
has intentado acceder ahí 00:10:13
pues 00:10:14
caos 00:10:15
pero 00:10:16
reempezamos 00:10:17
reinicializamos 00:10:18
volvamos al principio 00:10:19
añadamos objetos a esta posición 36 00:10:20
no lo sé 00:10:25
lo que se puede hacer 00:10:26
para intentar 00:10:27
solucionar ese error 00:10:28
¿vale? 00:10:30
esta es un poco la idea 00:10:31
que vamos a hacer con 00:10:32
cuando estos tipos de errores 00:10:34
podemos enfrentarnos a ellos 00:10:38
asumiendo que existen 00:10:40
de dos formas 00:10:42
¿vale? 00:10:43
que impropiamente 00:10:44
llamaremos 00:10:45
pesimista y optimista 00:10:46
¿vale? 00:10:47
la forma pesimista 00:10:48
de manejar 00:10:50
estos tipos de errores 00:10:51
es pensar 00:10:52
que algo irá mal 00:10:53
¿vale? 00:10:54
entonces 00:10:55
lo que voy a hacer 00:10:56
plagar 00:10:58
código 00:11:00
de IFS 00:11:01
intentando 00:11:02
comprobar 00:11:04
absolutamente 00:11:05
todo 00:11:06
entonces 00:11:07
me pregunto 00:11:08
si el array 00:11:09
es nul 00:11:10
pues entonces 00:11:11
haz esto 00:11:12
si el array 00:11:13
no es nul 00:11:14
pero intentas acceder 00:11:15
a una posición 00:11:16
mayor de su tamaño 00:11:17
entonces 00:11:18
haz esto 00:11:19
voy comprobando 00:11:20
absolutamente 00:11:21
todo 00:11:22
¿vale? 00:11:23
es pesimista 00:11:24
en el sentido 00:11:25
que tú 00:11:26
estás poniendo 00:11:27
un montón 00:11:28
de código 00:11:29
un montón 00:11:30
de IF 00:11:31
un montón 00:11:32
de condiciones 00:11:33
un montón 00:11:34
de comprobaciones 00:11:35
porque te esperas 00:11:36
que algo mal 00:11:37
irá 00:11:38
¿vale? 00:11:39
este mecanismo 00:11:40
aquí 00:11:41
tiene un par 00:11:42
de problemas 00:11:43
¿vale? 00:11:44
el primero 00:11:45
es que el más complejo 00:11:46
sea mi sistema 00:11:47
más difícil 00:11:48
prever 00:11:49
todos los posibles 00:11:50
fallos 00:11:51
que puedan ocurrir 00:11:52
en este sistema 00:11:53
¿vale? 00:11:54
y que cada vez 00:11:55
que yo acceda a un array 00:11:56
tenga que comprobar 00:11:57
si es nul 00:11:58
si tiene 00:11:59
si me han pedido 00:12:00
menos que cero 00:12:01
si me han pedido 00:12:02
más del máximo 00:12:03
de la longitud 00:12:04
si me han pedido 00:12:05
un ímper 00:12:06
veces un string 00:12:07
si me han pedido 00:12:08
un long 00:12:09
veces un string 00:12:10
pues 00:12:11
se complica 00:12:12
¿vale? 00:12:13
y que 00:12:14
cuando todo funciona 00:12:16
correctamente 00:12:17
estoy 00:12:18
sobrecargando 00:12:19
mi programa 00:12:20
con un montón 00:12:21
de comprobaciones 00:12:22
que me dirán 00:12:23
no no 00:12:24
tranquilo 00:12:25
está todo bien 00:12:26
pero lo estoy haciendo 00:12:27
constantemente 00:12:28
¿vale? 00:12:29
si por cada acceso 00:12:30
a mi array 00:12:31
¿vale? 00:12:32
por cada celda 00:12:33
me tengo que preguntar 00:12:34
si están nules 00:12:35
si están 00:12:36
menos que cero 00:12:37
si están 00:12:38
más de 75 00:12:39
estoy haciendo 00:12:40
tres comprobaciones 00:12:41
por cosas normales 00:12:42
y si estas tres comprobaciones 00:12:43
de un for 00:12:44
desde int i 00:12:45
igual a cero 00:12:46
hasta int menor 00:12:47
de array 00:12:48
punto lento 00:12:49
pues posiblemente 00:12:50
estoy haciendo 00:12:51
un montón 00:12:52
de comprobaciones 00:12:53
inútiles 00:12:54
porque nunca será 00:12:55
menor que cero 00:12:56
o mayor que uno 00:12:57
¿vale? 00:12:58
entonces 00:12:59
esta es una forma 00:13:00
de manejar 00:13:01
los errores 00:13:02
¿si? 00:13:03
pero 00:13:04
no necesariamente 00:13:05
es la mejor 00:13:06
se puede hacer 00:13:07
una combinación 00:13:08
o sea que 00:13:09
algunas cosas 00:13:10
si que se pueden 00:13:11
manejar 00:13:12
nosotros muchas veces 00:13:13
hemos dicho 00:13:14
mira cuando entro 00:13:15
en este objeto 00:13:16
a lo mejor 00:13:17
compruebo 00:13:18
que sea nulo 00:13:19
si esta nulo o no 00:13:20
¿vale? 00:13:21
también porque 00:13:22
no tenemos 00:13:23
nosotros 00:13:24
no tenemos 00:13:25
la posibilidad 00:13:26
de gestionarlo 00:13:27
con excepciones 00:13:28
y por lo tanto 00:13:29
tampoco podemos 00:13:30
hacer mucho 00:13:31
¿vale? 00:13:32
y si no 00:13:33
esta el enfoque 00:13:34
optimista 00:13:35
el enfoque optimista 00:13:36
dice mira 00:13:37
en un 95% 00:13:38
99% 00:13:39
de las veces 00:13:40
hay un ato 00:13:41
que harán acceso 00:13:42
a una posición 00:13:43
concreta 00:13:44
que existe 00:13:45
harán acceso 00:13:46
a un objeto 00:13:47
que si existe 00:13:48
o sea que 00:13:49
no vale la pena 00:13:50
de ponernos 00:13:51
a hacer 00:13:52
un montón de 00:13:53
y pensar 00:13:54
que algo 00:13:55
irá mal 00:13:56
porque 00:13:57
normalmente 00:13:58
las cosas 00:13:59
van bien 00:14:00
¿vale? 00:14:01
¿y que hago? 00:14:02
pues 00:14:03
pongo un 00:14:04
alerta 00:14:05
un alarma 00:14:06
que 00:14:07
la vez 00:14:08
de estas 100 00:14:09
que van mal 00:14:10
ahí constantemente 00:14:11
comprobando 00:14:12
lo que hago es 00:14:13
cuando irá mal 00:14:14
pues 00:14:15
gestionaré yo 00:14:16
el error 00:14:17
¿vale? 00:14:18
y esto se hace 00:14:19
protegiendo 00:14:20
entre comillas 00:14:21
el código 00:14:22
potencialmente 00:14:23
peligroso 00:14:24
es hablar 00:14:25
del trozo 00:14:26
de código 00:14:27
que podría 00:14:28
dar problemas 00:14:29
utilizando 00:14:30
una estructura 00:14:31
que se llama 00:14:32
try-catch 00:14:33
¿vale? 00:14:34
try-catch 00:14:35
está por 00:14:36
try 00:14:37
en el sentido 00:14:38
prueba 00:14:39
catch 00:14:40
recoge 00:14:41
pilla 00:14:42
la excepción 00:14:43
que ha explotado 00:14:44
y hace algo 00:14:45
¿vale? 00:14:48
entonces 00:14:49
a nivel sintáctico 00:14:51
sería una cosa 00:14:52
como un try 00:14:53
luego un bloque 00:14:55
este es el bloque 00:14:56
de código 00:14:57
protegido 00:14:58
el código 00:14:59
que 00:15:00
potencialmente 00:15:01
podría explotar 00:15:02
por ejemplo 00:15:03
un acceso a un array 00:15:04
por ejemplo 00:15:05
un acceso 00:15:06
a un objeto 00:15:07
que podría ser 00:15:08
null 00:15:09
o cosa por el estilo 00:15:10
¿vale? 00:15:11
después 00:15:13
de este bloque 00:15:14
protegido 00:15:15
pongo un catch 00:15:16
lo que voy a recoger 00:15:18
por ejemplo 00:15:19
una excepción 00:15:20
de tipo 00:15:21
una cosa 00:15:22
como esta aquí 00:15:23
me dice 00:15:24
que si 00:15:25
mientras estoy 00:15:26
haciendo 00:15:27
el código 00:15:28
protegido 00:15:29
en el try 00:15:30
salta una 00:15:31
cualquier excepción 00:15:32
de cualquier tipo 00:15:33
interrumpe 00:15:34
lo que 00:15:35
estás haciendo 00:15:36
en el try 00:15:37
vas a ejecutar 00:15:38
el bloque 00:15:39
que viene 00:15:40
después del catch 00:15:41
¿vale? 00:15:44
entonces 00:15:45
si yo ejecutaré 00:15:46
este bloque de aquí 00:15:47
el que está 00:15:48
detrás del catch 00:15:49
solo si 00:15:51
durante la ejecución 00:15:52
del try 00:15:53
haya ocurrido 00:15:55
una excepción 00:15:56
cualquiera 00:15:57
si yo aquí dentro 00:15:58
acero a un objeto 00:15:59
que es null 00:16:00
pues 00:16:01
ejecutaré este trozo 00:16:02
de código 00:16:03
si yo aquí dentro 00:16:04
acero a una posición 00:16:05
de un array 00:16:06
una posición 00:16:07
buena 00:16:08
pues ejecutaré 00:16:09
este trozo 00:16:10
¿vale? 00:16:12
¿y qué hago aquí? 00:16:13
pues aquí voy a hacer 00:16:14
lo que me da 00:16:15
la gang 00:16:16
¿vale? 00:16:17
por ejemplo 00:16:18
decir 00:16:19
ay mira 00:16:20
si intento deshacer 00:16:21
un objeto 00:16:22
este objeto es null 00:16:23
por lo tanto 00:16:24
salta la excepción 00:16:25
pues 00:16:26
inicializo ese objeto 00:16:27
y lo vuelvo a deshacer 00:16:28
¿vale? 00:16:29
si todo esto 00:16:30
lo pongo en un while 00:16:31
por ejemplo 00:16:32
y llego aquí 00:16:33
y se entra aquí dentro 00:16:34
se entra aquí dentro 00:16:36
se ve 00:16:38
que 00:16:39
entonces 00:16:40
ejecutando esto de aquí 00:16:41
podría 00:16:42
setar un booleano 00:16:43
a un cierto valor 00:16:44
para decir 00:16:45
oye mira 00:16:46
que cuando sale de aquí 00:16:47
comprueba este booleano 00:16:48
y si este booleano 00:16:49
es true 00:16:50
sigues adelante 00:16:51
y si este booleano 00:16:52
es false 00:16:53
vuelves a rehacerlo 00:16:54
porque algo ha ido mal 00:16:55
porque este objeto 00:16:56
no ha funcionado 00:16:57
o podría decir 00:16:58
oye mira 00:16:59
si llegas aquí 00:17:01
quiere decir 00:17:02
que ha habido un error 00:17:03
a este punto 00:17:04
lo escribo en pantalla 00:17:05
oye mira usuario 00:17:06
ha habido un error 00:17:07
no has dado 00:17:08
los parámetros correctos 00:17:09
el error 00:17:10
el programa 00:17:11
no puede continuar 00:17:12
mira el fichero 00:17:13
no se que 00:17:14
para un log 00:17:15
donde ha escrito 00:17:16
más detalladamente 00:17:17
lo que ha pasado 00:17:18
hasta luego 00:17:19
y mueres 00:17:20
¿vale? 00:17:21
podrías 00:17:23
aquí dentro 00:17:24
decirle 00:17:25
mira usuario 00:17:26
ha pasado un problema 00:17:27
que no puede recuperar 00:17:28
el programa 00:17:29
por lo tanto 00:17:30
lo que hago es 00:17:31
apagar todo 00:17:32
y reiniciar 00:17:33
el programa 00:17:34
desde cero 00:17:35
¿vale? 00:17:36
y aquí luego harás 00:17:37
todo los 00:17:38
la información 00:17:39
y la cosa 00:17:40
que tienes que hacer 00:17:41
para resetear 00:17:42
todo lo que has hecho 00:17:43
hasta ahora 00:17:44
hasta cero 00:17:45
y volver al principio 00:17:46
depende de ti 00:17:47
¿vale? 00:17:48
el concepto es que 00:17:49
esto no es una solución 00:17:50
al error 00:17:51
es un mecanismo 00:17:52
que te permite 00:17:53
de manejar el error 00:17:54
dudas 00:17:55
es un 00:17:56
pseudo if 00:17:57
a un nivel 00:17:58
abstracto 00:17:59
que te permite 00:18:00
manejar 00:18:01
el error 00:18:02
es un pseudo if 00:18:03
a un nivel 00:18:04
abstracto 00:18:05
que te dice 00:18:06
si esto no funciona 00:18:07
entonces hace esto 00:18:08
en el caso del try 00:18:09
solo 00:18:10
se activaría 00:18:11
si hay un error fatal 00:18:12
¿no? 00:18:13
no ocurriría 00:18:14
si yo ejecuto 00:18:15
el try 00:18:16
y no hay ninguna excepción 00:18:17
sigue adelante 00:18:18
se salta la parte 00:18:19
que he hecho 00:18:20
y sigue adelante 00:18:21
sin problema 00:18:22
y veo que 00:18:23
pones 00:18:24
es como que 00:18:25
inicias una variable 00:18:26
excepción 00:18:27
llamada e 00:18:28
sí 00:18:29
aquí dentro 00:18:30
excepción e 00:18:31
la idea 00:18:32
una excepción 00:18:33
la llave virtual machine 00:18:34
empaqueta 00:18:35
objeto 00:18:37
de tipo 00:18:38
excepción 00:18:39
¿vale? 00:18:40
donde dentro 00:18:41
intenta meter 00:18:42
la información 00:18:43
relevante 00:18:44
ahora lo veremos 00:18:45
de esta excepción 00:18:46
por ejemplo 00:18:47
que método 00:18:49
se estaba 00:18:50
ejecutando 00:18:51
de los que estaban aquí 00:18:52
que ha causado 00:18:53
esta excepción 00:18:54
¿vale? 00:18:55
que mensaje 00:18:57
está esta excepción 00:18:58
cuando esta excepción 00:18:59
ha explotado 00:19:00
ese mensaje 00:19:01
se ha puesto allí 00:19:02
de error 00:19:03
¿vale? 00:19:04
si tiene algo 00:19:05
de esta información 00:19:06
yo la puedo encontrar en e 00:19:07
es un objeto 00:19:09
de tipo excepción 00:19:10
que podéis ir a mirar 00:19:11
en la API 00:19:12
y ver todos los métodos 00:19:13
que tiene aquí 00:19:14
en particular 00:19:15
ahora lo veremos 00:19:16
algunos 00:19:17
aquí puedes poner 00:19:18
el mensaje de error 00:19:19
e.getMessage 00:19:20
creo que es 00:19:21
una cosa de ese estilo 00:19:22
e.getStack 00:19:24
que es 00:19:25
todas las llamadas 00:19:26
de métodos 00:19:27
que se han hecho 00:19:28
hasta llegar 00:19:29
a este error 00:19:30
este método 00:19:31
ha llamado 00:19:32
el método 00:19:33
calcularia 00:19:34
que ha llamado 00:19:35
el método 00:19:36
math.random 00:19:37
que ha llamado 00:19:38
el método 00:19:39
no se que 00:19:40
y aquí es donde ha explotado 00:19:41
¿vale? 00:19:42
para que tu puedas ver 00:19:43
de tus métodos 00:19:44
cual estaban 00:19:45
en ese momento 00:19:46
llamándose 00:19:47
uno a otro 00:19:48
y saber 00:19:49
que ha pasado 00:19:50
donde está el punto 00:19:51
en el que ha explotado 00:19:52
el programa 00:19:53
porque has hecho 00:19:54
una división 00:19:55
por cero 00:19:56
y entonces 00:19:57
te ha explotado 00:19:58
¿si? 00:19:59
tened en cuenta 00:20:00
que yo aquí estoy 00:20:01
utilizando exception 00:20:02
esta de aquí 00:20:03
sería una 00:20:04
la excepción 00:20:05
más general 00:20:06
posible 00:20:07
¿vale? 00:20:08
es la clase 00:20:09
excepción 00:20:10
más alta 00:20:11
y luego 00:20:12
a partir de aquí 00:20:13
heredarán 00:20:14
un montón 00:20:15
de otras 00:20:16
excepciones 00:20:17
como por ejemplo 00:20:18
la reindex 00:20:19
autobound 00:20:20
exception 00:20:21
la null pointer 00:20:22
exception 00:20:23
la number 00:20:24
format 00:20:25
exception 00:20:26
y otras cosas 00:20:27
porque si yo 00:20:28
lo pongo así 00:20:29
como todas 00:20:30
las que he nombrado 00:20:31
ahora 00:20:32
son excepciones 00:20:33
pillaría una 00:20:34
cualquiera de ellas 00:20:35
cualquier excepción 00:20:36
que explote 00:20:37
en el try 00:20:38
me la va a recoger 00:20:39
y ejecutaré esto 00:20:40
independientemente 00:20:41
de si es una 00:20:42
null pointer 00:20:43
exception 00:20:44
una index 00:20:45
autobound 00:20:46
una 00:20:47
bueno 00:20:48
whatever 00:20:49
exception 00:20:50
entonces 00:20:51
la idea es 00:20:52
que nos creemos 00:20:53
nuestras propias 00:20:54
excepciones 00:20:55
y las 00:20:56
sobre esta base 00:20:58
de tener este 00:20:59
mecanismo 00:21:00
ahora veremos 00:21:01
que hay 00:21:02
métodos que tú 00:21:03
puedes utilizar 00:21:04
que lanzan 00:21:05
excepciones 00:21:06
habrá métodos 00:21:07
que pueden lanzar 00:21:08
excepciones 00:21:09
pero no necesariamente 00:21:10
la tienes que controlar 00:21:11
y habrá la posibilidad 00:21:12
de crearte tus 00:21:13
propios mensajes 00:21:14
de errores 00:21:15
y tus propios 00:21:16
excepciones 00:21:17
para que si en un 00:21:18
determinado momento 00:21:19
de tu programa 00:21:20
no puedes seguir 00:21:21
adelante 00:21:22
porque tú has hecho 00:21:23
un programa 00:21:24
que accede a ficheros 00:21:25
la carpeta 00:21:26
donde ir a buscar 00:21:27
estos ficheros 00:21:28
y no puedes seguir 00:21:29
adelante 00:21:30
lanzas una excepción 00:21:31
mi excepción 00:21:33
de no tengo 00:21:34
ficheros 00:21:35
the 00:23:31
the 00:23:33
the 00:23:34
the 00:23:35
... 00:25:01
Autor/es:
Stefano chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
10
Fecha:
21 de febrero de 2023 - 12:07
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
46′ 17″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
387.12 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid