Saltar navegación

Clase 08-04-24 - 1 - 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 8 de abril de 2024 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Que aunque se vea al revés, lo que importa es hacerse una idea de lo que se ha contado 00:00:00
y volver a oírlo por si algo no ha quedado claro, simplemente. 00:00:04
Bueno, vamos a completar con lo de excepciones. 00:00:09
Lo que contamos el otro día era simplemente que las excepciones son una forma 00:00:13
que tiene el código de avisar de que ha pasado algo raro. 00:00:21
entonces un código 00:00:25
siempre puede avisar 00:00:27
si nosotros lo programamos así, claro 00:00:29
de que han pasado cosas de mil maneras 00:00:31
pues puede avisar 00:00:34
mostrando un mensaje por consola 00:00:36
puede avisar 00:00:38
en el caso de que estemos haciendo un método 00:00:40
puede avisar 00:00:42
mediante el valor de retorno 00:00:46
y lo ponemos aquí 00:00:48
si el valor de retorno es cero 00:00:50
es que ha pasado no sé qué 00:00:52
eso lo estuvimos viendo el otro día 00:00:53
puede avisar de muchas formas 00:00:55
pero cada una de ellas tiene sus 00:00:57
inconvenientes, esta 00:01:00
que este aviso para qué sirve 00:01:01
pues solo porque si hay alguien sentado delante en la consola 00:01:03
lo lea 00:01:06
lo lea y decida parar 00:01:07
en el programa y decida hacer algo 00:01:09
vale 00:01:11
bajo esas circunstancias que son un poco raras 00:01:12
que haya alguien sentado para leerlo y entonces 00:01:16
decidir cómo actúa 00:01:18
y esto de aquí lo mismo, vale 00:01:19
si es que este valor de retorno no tiene ya 00:01:21
un uso concreto 00:01:23
si este valor de retorno tiene un uso concreto 00:01:24
que es devolver el resultado 00:01:27
de este método 00:01:29
pues si tiene ese uso concreto 00:01:30
no podemos usarlo como código 00:01:33
de error o como código de lo que ha pasado 00:01:35
¿vale? no podemos 00:01:37
porque ya tiene un uso concreto que es 00:01:39
devolver la suma, la multiplicación, lo que sea 00:01:41
que sea de aquí 00:01:43
entonces hay un mecanismo para avisar de que algo 00:01:44
raro ha pasado, que es el de excepciones 00:01:47
que 00:01:49
se puede hacer 00:01:51
en cualquier momento del código 00:01:54
escribiendo esto 00:01:56
como vimos el otro día 00:01:58
esto y aquí un objeto excepción 00:01:59
un objeto excepción 00:02:04
el que sea 00:02:07
¿vale? 00:02:07
esta es una sentencia más de código en Java 00:02:12
el throw 00:02:14
entonces 00:02:14
cuando la máquina virtual 00:02:16
se encuentra esta sentencia escrita 00:02:19
lo que hace es 00:02:21
crear un objeto 00:02:23
de este tipo 00:02:25
instanciar un objeto como este 00:02:27
instanciarlo 00:02:29
y si 00:02:31
no hay nada más, si no hay más indicaciones 00:02:33
que esto, no hay nada más puesto en el código 00:02:35
lo que hace es 00:02:37
mostrar un aviso 00:02:38
mediante letras rojas en la consola que estamos 00:02:41
acostumbrados a verlo, un aviso con letras rojas 00:02:43
en la consola que estamos acostumbrados 00:02:45
y además 00:02:47
parar el programa, eso es lo que hace 00:02:48
muestra 00:02:51
una traza roja 00:02:52
con información sobre lo que ha pasado 00:02:54
y para el programa. 00:02:56
Eso es lo que hace la máquina virtual 00:02:58
cuando se encuentra esta sentencia. 00:02:59
¿Vale? 00:03:03
Y eso nos ha pasado un montón de veces. 00:03:04
El ver que salían letras rojas 00:03:06
y que el programa paraba. 00:03:08
Nos ha pasado un montón de veces. 00:03:09
¿Por qué? 00:03:11
Porque hemos llamado a métodos, 00:03:12
hemos hecho cosas 00:03:14
que cuando se ha entrado en ese método 00:03:14
la máquina virtual se ha encontrado esto. 00:03:17
¿Vale? 00:03:21
pues cuando hemos tratado de acceder a objetos que eran nulos 00:03:21
cuando hemos llamado a métodos de leer por teclado 00:03:25
por ejemplo next in 00:03:28
y lo que le hemos pasado era una cadena con caracteres 00:03:30
entonces ese next in ha entrado dentro y ha visto 00:03:34
uy es un carácter, pues ese next in tiene dentro el throw 00:03:36
entonces cuando una excepción aparece 00:03:39
no es que se haya roto algo 00:03:43
es simplemente que se ha ejecutado una línea de código como esta 00:03:44
ya está, se ha ejecutado una línea de código como esa 00:03:49
esa línea de código 00:03:51
lo normal es que vaya lógicamente 00:03:53
dentro de un if, claro 00:03:55
un if 00:03:57
de verificación, ¿qué ha pasado esa cosa 00:03:59
rara? que yo me esperaba 00:04:01
un número y tengo un carácter 00:04:03
que este objeto es nulo 00:04:05
lo que sea, ¿qué ha pasado una cosa 00:04:07
rara? pues throw 00:04:09
lo normal es que esos throw por tanto estén dentro de if 00:04:10
y si ha pasado algo 00:04:13
uno decida que se lance excepción 00:04:15
Entonces, es la mejor manera de avisar de que algo ha pasado, ¿vale? Y repito, la respuesta de la máquina virtual a esta sentencia cuando se la encuentra, si no hay nada más que esto, si no hay nada más, es mostrar la traza roja con información y detener la ejecución, ¿vale? Detenerla y ya está, detenerla. 00:04:17
vale, entonces 00:04:41
¿qué vimos el otro día? bueno, pues cuando 00:04:42
pasa esto, cuando 00:04:44
la máquina virtual encuentra 00:04:46
este throw y lanza la excepción 00:04:48
y se para 00:04:51
la máquina virtual, sabemos que 00:04:53
tenemos una manera de alterar este 00:04:54
funcionamiento, de alterarlo 00:04:56
tenemos una manera de alterarlo, y es 00:04:58
oye, en este código 00:05:00
que me puede lanzar 00:05:02
por ejemplo, nosotros tenemos 00:05:05
un objeto scanner 00:05:06
que va a leer 00:05:08
tenemos esta sentencia 00:05:10
¿vale? tenemos esta sentencia de aquí 00:05:14
nextIn 00:05:17
entonces este es un método 00:05:17
este es un método al que la máquina virtual salta 00:05:19
la máquina virtual salta 00:05:22
y se pone a leer 00:05:25
del teclado, a hacer cositas 00:05:27
entonces si detecta 00:05:29
que lo que ha leído son caracteres 00:05:30
si detecta que lo que ha leído son caracteres 00:05:33
pues hace el throw 00:05:35
el throw este 00:05:36
y este throw en particular 00:05:38
que hace el next in dentro 00:05:41
será un throw del tipo 00:05:42
algo así 00:05:45
creo que se llamaba así 00:05:47
la excepción que nos salía cuando intentábamos 00:06:09
leer un número 00:06:11
y resulta que no era número 00:06:12
sino que era carácter 00:06:15
ah, no era number format exceptio 00:06:16
una de las dos, o input type o number format 00:06:21
da igual 00:06:23
vale 00:06:25
Bueno, pues esto de aquí estará dentro del método NextIn, ¿verdad? Estará dentro. 00:06:47
El método NextIn se pone a coger del buffer, del teclado, se pone a verificar cosas, 00:06:53
si verifica que la cadena no son números, hace el throw, ¿vale? 00:06:58
Todo esto estará dentro de ese método NextIn. 00:07:03
Nosotros cuando hemos llamado a NextIn, pues esperábamos que pasara todo lo necesario para leer del teclado, 00:07:06
lo que fuera, bueno, pues todo eso está dentro de NextIn, ¿vale? 00:07:12
Entonces dentro de next in habrá todo el código para leer y dentro de ese código habrá algo de este estilo, habrá algo de este estilo que será, oye, si esta cadena que yo me he encontrado en el buffer del teclado no son números, lanza esta excepción, ¿vale? 00:07:15
Por eso cuando nosotros hemos ejecutado esta sentencia y le hemos pasado una cadena que no eran números, nos hemos encontrado las letras rojas que nos decían number for my exception y se ha detenido la ejecución. 00:07:31
bueno, nos hemos encontrado eso 00:07:44
porque al entrar dentro de NextInt 00:07:46
la máquina virtual ha ejecutado esta sentencia 00:07:48
por eso nos hemos encontrado eso 00:07:50
pues las letritas rojas 00:07:52
y además que la ejecución se para 00:07:54
eso es lo que nos hemos encontrado 00:07:56
vale, bueno, pues también 00:08:00
sabemos que, oye 00:08:02
quiero alterar este funcionamiento 00:08:04
no quiero que aunque 00:08:05
NextInt se encuentre 00:08:08
números, perdón, caracteres 00:08:10
en vez de números, no quiero 00:08:12
que se pare el programa, porque 00:08:14
es muy radical, que por cualquier cosita que pase 00:08:16
se tenga que parar el programa, es muy 00:08:18
radical, uno 00:08:20
en su ejecución de su código, en su 00:08:21
diseño puede decir, oye, si no 00:08:24
es un número, sino que 00:08:26
son caracteres, pues mala suerte 00:08:28
ya sobreviviré de otra manera, pero 00:08:30
no detengas el programa por eso 00:08:32
entonces uno puede alterar este funcionamiento básico 00:08:34
puede alterarlo 00:08:36
¿vale? ¿y cómo lo altera? pues como dijimos 00:08:38
también el otro día y como hemos hecho otras veces 00:08:40
esta sentencia que es la peligrosa 00:08:42
porque es la que cuando saltamos 00:08:45
dentro tiene el throw 00:08:46
tiene el throw si pasa algo raro 00:08:48
y ya sabemos que el throw es el que 00:08:50
provoca esto 00:08:52
pues esta sentencia la capturamos 00:08:53
¿no? 00:08:56
y la capturamos de esta manera 00:08:58
ahora ya simplemente metiendo esta 00:09:20
sentencia en try catch, aquí 00:09:22
la excepción que queremos capturar 00:09:24
y aquí 00:09:27
lo que queramos en el catch 00:09:28
simplemente así alteramos 00:09:31
el funcionamiento, la sentencia se va a ejecutar 00:09:33
igualmente 00:09:35
que no hay problema 00:09:36
se ha ejecutado sin ningún error 00:09:38
y no hemos llegado al throw 00:09:41
porque este 00:09:43
if era falso 00:09:45
pues el programa sigue por aquí tan feliz 00:09:46
que si ha habido un problema 00:09:49
porque al saltar a next in 00:09:51
esto ha sido true 00:09:53
la máquina virtual ha hecho el throw 00:09:55
vale, pues si, la máquina virtual ha hecho el throw 00:09:57
pero ya no saltamos a mostrar líneas rojas 00:09:59
y stop, ha hecho el throw 00:10:01
pero la máquina virtual lo que hace ahora 00:10:03
es saltar al catch 00:10:05
luego la máquina virtual 00:10:06
a resultas de ejecutar un throw 00:10:09
tiene dos caminos, que la excepción 00:10:11
no esté capturada, no haya un try catch 00:10:13
letras rojas 00:10:15
y parada de ejecución 00:10:17
que la sentencia si esté 00:10:18
capturada, la excepción si esté capturada 00:10:21
pues entonces va al otro camino 00:10:23
que es ejecutar lo que hay en el catch 00:10:25
lo que uno haya escrito, lo que le dé la gana 00:10:27
como si es nada, en blanco 00:10:29
ejecuta eso 00:10:30
y luego continúa el programa sin pararlo 00:10:32
continúa el programa sin pararlo 00:10:35
son las dos posibilidades 00:10:37
que tiene la máquina virtual cuando se encuentra 00:10:39
un flow 00:10:41
y va a depender de si está capturada 00:10:42
o no está capturada esta excepción 00:10:45
¿vale? 00:10:47
porque podría estar capturada la otra 00:10:50
imaginaos que yo aquí 00:10:51
tengo este mismo 00:10:53
try-catch 00:10:55
pero en lugar de 00:10:56
tener ahí number for my exception 00:10:58
tengo por ejemplo null pointer exception 00:11:00
tengo esta, tengo un try catch 00:11:03
que pone null pointer exception 00:11:06
vale, pues entonces, la máquina virtual 00:11:07
entra al next thing 00:11:10
se encuentra 00:11:12
la cadena del buffer que estoy leyendo 00:11:13
no son números, throw 00:11:16
pero la que lanza es esta 00:11:18
esta está capturada, no 00:11:19
la que está capturada es esta otra 00:11:21
y no es la que hemos lanzado 00:11:24
es esta, con lo cual 00:11:25
a resultas de este throw nos iríamos 00:11:28
a este camino, nos iríamos a letras rojas 00:11:30
y esto, porque a mí me has dado 00:11:32
indicaciones solo para esta 00:11:34
me has dado indicaciones para esta, para esta no me has dado 00:11:36
con lo cual 00:11:38
aunque esto esté en un try-catch 00:11:40
como la que está capturada no es la que se ha lanzado 00:11:42
pues 00:11:45
procederíamos a letras rojas y esto 00:11:46
sin embargo 00:11:48
imaginaos que aquí lo que ha ocurrido 00:11:50
que scan yo no lo he instanciado 00:11:52
y scan es null 00:11:53
porque no lo he instanciado 00:11:55
si me he olvidado 00:11:57
hacer el new scanner 00:11:58
vale 00:11:59
pues entonces 00:12:00
este try catch entramos 00:12:00
y la excepción 00:12:02
que saldría aquí 00:12:03
si sería 00:12:03
null pointer exception 00:12:05
porque scan es null 00:12:06
null 00:12:07
intenta llamar a algo 00:12:08
y ya le sale 00:12:09
el null pointer exception 00:12:10
entonces 00:12:11
esta si estaría capturada 00:12:12
con lo cual 00:12:14
la de null pointer exception 00:12:16
no detendría el programa 00:12:18
aunque scan fuera null 00:12:19
no lo detendría 00:12:20
se iría 00:12:21
a lo que hay aquí 00:12:23
Y luego continuaríamos. 00:12:24
¿Vale? 00:12:27
Bueno, pues lo importante, 00:12:29
sobre todo lo que aportamos ahora, 00:12:31
porque más o menos cómo funcionaba el try-catch, 00:12:32
más o menos podíamos tenerlo 00:12:35
de alguna vez que lo hemos tenido que usar, 00:12:36
es por qué aparecen las excepciones. 00:12:38
Son una sentencia más de código 00:12:40
que aparecen a resultas 00:12:42
de que la máquina virtual ejecuta un throw. 00:12:43
¿Y qué implica la ejecución de un throw? 00:12:47
Pues implica o esto o esto. 00:12:49
Depende de si hay captura 00:12:52
o no hay captura, ya está 00:12:53
¿vale? 00:12:55
entonces también dijimos 00:12:59
el otro día, oye y objetos excepción 00:13:00
¿cuántos tipos distintos hay? 00:13:02
pues tropecientos mil 00:13:04
conocemos muchos 00:13:05
null pointer exception, string line desbound exception 00:13:07
number formal exception 00:13:10
divide by zero exception 00:13:12
conocemos muchos ya porque nos han 00:13:14
aparecido, pero hay muchísimos 00:13:16
más, cada uno 00:13:18
de ellos asociado a una 00:13:20
causa de error específica 00:13:22
¿vale? 00:13:24
entonces el throw 00:13:26
instancia el objeto 00:13:27
asociado que él cree 00:13:29
que está asociado a esa causa de error 00:13:32
ya hicimos el otro día un ejemplo 00:13:34
en el cual 00:13:36
lanzábamos nosotros 00:13:37
nuestra propia excepción 00:13:39
lanzábamos nosotros un null pointer exception 00:13:41
asociado a otra cosa 00:13:44
entonces bueno, no pegaba mucho pero podíamos lanzarlo 00:13:45
¿vale? 00:13:48
vale, entonces 00:13:50
ahora que estamos aquí 00:13:53
antes de ver ya el ejemplo y todo eso 00:13:56
vamos a terminar un poco con los try-catch 00:13:58
entonces esta es la 00:14:00
la estructura básica de un try-catch 00:14:05
es esta que ya hemos visto 00:14:07
la que hemos mencionado 00:14:09
pues dentro del try-catch 00:14:12
se ponen la 00:14:16
o las sentencias que uno quiera 00:14:18
se puede poner aquí muchas sentencias 00:14:19
da igual, cállate 00:14:22
¿vale? 00:14:26
y aquí se pone un tipo de excepción 00:14:29
un tipo de excepción 00:14:33
imaginaos que pongo esta 00:14:34
un tipo de excepción y aquí un nombre de variable 00:14:36
esto es como si fuera 00:14:41
la lista de parámetros 00:14:43
que recibe un método 00:14:45
la lista de parámetros que recibe un método 00:14:46
¿vale? 00:14:49
Andrés 00:14:52
¿vale? 00:14:52
esta es la estructura del try-catch básica 00:14:55
entonces, ¿esto qué significa? 00:14:57
la sentencia o las sentencias 00:15:02
se intentan ejecutar 00:15:04
si una de ellas 00:15:05
tiene como consecuencia 00:15:07
una excepción de este tipo 00:15:10
de este tipo 00:15:12
de este tipo 00:15:13
pues entonces saltamos al catch 00:15:15
y esto es como si fuera un método en realidad 00:15:17
y a este método 00:15:20
se le pasa como parámetro 00:15:22
un objeto excepción de este tipo 00:15:24
entonces el objeto excepción 00:15:26
lo instancia la máquina virtual 00:15:28
o sea el propio throw de hecho lo tenía 00:15:30
el throw decía 00:15:32
throw new la excepción que sea 00:15:34
¿veis? el propio throw 00:15:37
ya instancia 00:15:44
un objeto excepción 00:15:45
y ese objeto excepción es el que recibe 00:15:47
el catch como parámetro, lo recibe aquí 00:15:49
¿vale? 00:15:51
el catch recibe como parámetro un objeto 00:15:53
excepción que es el que se ha instanciado 00:15:55
como consecuencia de hacer el throw 00:15:58
entonces yo aquí le puedo llamar 00:16:00
le podéis llamar como os dé la gana 00:16:02
a este objeto excepción 00:16:03
esto vedlo como si fuera 00:16:05
la cabecera de un método 00:16:07
este es el objeto parámetro 00:16:09
que recibe 00:16:12
este método 00:16:12
y el objeto parámetro que recibe es el objeto 00:16:14
excepción que se ha instanciado 00:16:18
cuando se hizo el throw 00:16:20
entonces 00:16:21
recopilamos 00:16:23
esto, hemos saltado al código 00:16:25
de nextIn 00:16:28
ha hecho un throw 00:16:28
bueno, la que sea 00:16:31
ha hecho un throw 00:16:33
la máquina virtual al ver el throw 00:16:34
ha generado este objeto, lo ha instanciado 00:16:36
y ahora se pone a mirar 00:16:40
¿la sentencia que ha generado este throw 00:16:43
está dentro de un try-catch? 00:16:48
no, letra roja, sí, stop 00:16:51
sí, vale, ¿ese catch se corresponde 00:16:54
con la excepción que yo he instanciado? 00:16:58
no se corresponde, letra roja, sí, stop 00:17:01
si se corresponde, pues ahora ya 00:17:04
entramos en el catch 00:17:07
pasándole como parámetro 00:17:09
este objeto que acabamos de instanciar 00:17:10
¿vale? 00:17:13
ya está, ese es el funcionamiento 00:17:15
y ahora con este objeto que acabamos de instanciar 00:17:17
uno puede hacer aquí lo que le dé la gana 00:17:19
lo que normalmente 00:17:21
queremos hacer con este objeto 00:17:23
es simplemente sacar 00:17:25
información sobre la excepción, nada más 00:17:27
entonces este objeto x 00:17:29
o e, como lo queráis haber llamado 00:17:30
es un objeto excepción 00:17:33
que tiene dentro información 00:17:34
varia sobre la excepción 00:17:36
y podemos sacarla mediante sus métodos 00:17:37
si nosotros hacemos aquí a ver que métodos tiene 00:17:40
pues tienen métodos relacionados con 00:17:42
pues dame el objeto que generó el método 00:17:44
que llamó la excepción, información varia 00:17:46
entre ellas el método 00:17:48
más importante, más usado 00:17:50
es este, este método 00:17:52
es un método 00:18:01
de los objetos exception 00:18:03
de las clases excepción que lo único 00:18:05
que hace es hacer unos system 00:18:07
OutprintDLN con un montón 00:18:09
de información sobre la excepción. 00:18:11
En qué línea se produjo de código, 00:18:13
quién le había llamado, es decir, 00:18:15
esto muestra 00:18:17
y además las muestra en colorcito 00:18:19
rojo. Esto muestra 00:18:21
los mismos 00:18:23
mensajes que vemos nosotros 00:18:25
cuando la excepción no es capturada. 00:18:27
Los mismos, coinciden, son los mismos. 00:18:30
Entonces, si la excepción 00:18:32
no es capturada, ya hemos visto que la máquina virtual 00:18:33
muestra unos mensajes 00:18:35
y además para, pues los mensajes 00:18:36
que muestra, los saca 00:18:39
de aquí también, los genera 00:18:41
también la máquina virtual con este método 00:18:43
¿vale? pero bueno, eso es lo de menos 00:18:45
entonces, este objeto 00:18:47
repito, lo podemos usar aquí dentro 00:18:51
para ver cosas 00:18:53
de la excepción si queremos 00:18:55
o podemos pasar de él y limitarnos a 00:18:56
poner aquí, pues ha habido un error 00:18:59
lo que yo quiera, o un retun 00:19:01
para que el método salga 00:19:04
lo que a mí me dé la gana, puedo poner 00:19:05
entonces cuando estoy todavía 00:19:07
en fase de desarrollo de pruebas 00:19:12
de mi código, no lo he entregado 00:19:14
al cliente, estoy todavía haciendo 00:19:16
pruebas, siempre tendremos 00:19:18
esto puesto, siempre 00:19:20
porque lo que yo quiero es 00:19:22
si hay un error 00:19:24
ver toda la explicación, quiero verla 00:19:25
entonces cuando estamos en esa fase en la que yo 00:19:28
como programador estoy haciendo pruebas 00:19:32
yo si ha habido un problema y me he ido 00:19:33
al catch, quiero ver todos los detalles de lo que 00:19:36
ha pasado, pues entonces llamo a esto 00:19:38
pondré esto dentro 00:19:40
pero claro, cuando ya 00:19:41
he entregado el software y ya se lo he 00:19:44
dado al cliente, esto 00:19:46
lo comentaremos y lo quitaremos 00:19:48
porque 00:19:50
en el caso de que haya una excepción 00:19:52
yo ya en el tiempo de explotación 00:19:54
de la aplicación, no quiero que le salgan 00:19:56
letras rojas que no va a entender 00:19:58
al que la está ejecutando 00:20:00
lo más que puedo querer es 00:20:02
que le salga un mensajito de disculpe 00:20:04
ha habido un error, contáctenos el sitio técnico 00:20:06
a lo mejor si puedo querer que le aparezca eso 00:20:08
pues pondría aquí un mensaje 00:20:10
con eso, o una escritura 00:20:12
en el archivo de logs 00:20:14
lo habitual, vale, entonces 00:20:15
en tiempo de desarrollo 00:20:20
esto 00:20:22
es fundamental que esté, porque me va a ayudar 00:20:23
si mi aplicación está dando errores 00:20:26
me va a ayudar a explicarme 00:20:28
a entenderlo, cuando ya entrego 00:20:29
la aplicación, todo esto lo voy comentando, lo quito 00:20:32
porque en ese caso 00:20:34
cuando hay error, la información 00:20:36
es al cliente, no es al desarrollador 00:20:38
y la información para el cliente 00:20:40
para el usuario del software no es 00:20:42
main, la línea, no sé qué 00:20:44
no es esa, la información para el cliente 00:20:46
para el usuario de la aplicación es 00:20:49
ha habido un error, no se pudo ejecutar 00:20:50
o la que uno decida 00:20:53
¿vale? 00:20:54
bueno, por eso por un lado 00:20:58
vale, luego los cats admiten 00:21:00
diferentes 00:21:02
variantes 00:21:03
para dejar a lo mejor más completo 00:21:06
más bonito, variantes que se han ido incorporando 00:21:08
según las versiones, por ejemplo 00:21:10
está el try, el multicatch 00:21:12
si yo quiero capturar 00:21:14
varias excepciones, por ejemplo 00:21:17
uno podría decir, el scan next in 00:21:19
me puede generar la number 00:21:21
formal exception, que ya lo sabemos, vale 00:21:23
pues yo capturaría la number formal exception 00:21:25
y aquí pongo 00:21:27
pues lo que quiera yo, que se ejecute 00:21:42
cuando se da la number formal exception 00:21:44
pero puede decir, ya, pero aquí también 00:21:45
en estas sentencias, también puede 00:21:48
ser que ocurra otra, puede ser que ocurra 00:21:50
por ejemplo la null pointer exception 00:21:52
vale, pues entonces ponemos 00:21:53
otro catch, este es el 00:21:56
multicatch, asociado a un mismo 00:21:58
try, podemos poner un montón de catch 00:22:00
distintos, cada una de ellas con 00:22:02
diferentes excepciones 00:22:04
y así podríamos poner tropecientos 00:22:05
catch, si es que el código 00:22:18
que yo tengo aquí, puede que 00:22:19
genere muchos diferentes tipos de 00:22:21
excepciones y yo quiero capturarlas todas 00:22:23
pues podría hacer un multicatch 00:22:25
y ahora ya pues esto funciona 00:22:28
esto se intenta ejecutar 00:22:31
que no hay ningún problema, fenomenal 00:22:33
saltamos por aquí y pasamos de los 00:22:35
cats y seguimos 00:22:37
que sale esta excepción 00:22:38
se salta el cats, se ejecuta esto 00:22:40
y continuamos 00:22:43
el programa no se para, el resto de los cats 00:22:45
se ignoran, que la excepción 00:22:47
que salta es esta 00:22:49
pues entonces se ejecuta este cats 00:22:50
y ya seguimos por el final 00:22:53
entonces si sale una excepción 00:22:54
la máquina virtual va a ir catch por catch 00:22:56
desde arriba hasta que encuentre 00:22:59
el primero en el cual se 00:23:01
corresponde la excepción generada con esta 00:23:03
en cuanto lo encuentra 00:23:05
entra adentro, hace lo que tenga que hacer 00:23:06
y ya está, y sale 00:23:09
entonces es el multicatch 00:23:10
y así yo puedo tratar de forma diferente 00:23:13
diferentes excepciones 00:23:15
No, a ver, el throw 00:23:17
genera una excepción 00:23:27
o sea, si hay un método que tú 00:23:29
generas varias, pues dependerá 00:23:31
que no hay números en la cadena 00:23:32
throw new exception 00:23:35
que el scan es nulo 00:23:36
pues throw new number formal exception 00:23:39
throw null pointer exception 00:23:41
o sea, el throw, cada throw 00:23:43
te lanza una única excepción 00:23:45
te lanza la que corresponda 00:23:47
a eso que tú has verificado 00:23:50
pero un solo método, pues puede tener 00:23:51
diferentes throw, si pasa 00:23:54
esto, throw esta, ahora sigues 00:23:56
haciendo cosas, que pase esto, throw 00:23:58
esa otra cosa, o sea el throw 00:23:59
te lanza un objeto de excepción 00:24:02
pero claro, un mismo método en función 00:24:04
de lo que ha pasado, pues puede ejecutar un throw 00:24:06
o puede ejecutar otro, el que sea 00:24:08
en cada momento dado 00:24:09
este next in puede haber 00:24:11
ocurrido que te genere la number 00:24:13
formar exceptio, porque el throw 00:24:16
que se ha lanzado es este 00:24:17
porque la condición que fue true es esta 00:24:19
pero en otro momento dado, esta misma 00:24:21
sentencia puede que te lance otro throw 00:24:24
porque no entró por este if 00:24:26
sino que entró por otro, y tenía otro throw 00:24:27
a eso me refiero 00:24:29
que a todos casi tienen 00:24:31
tanto, pero tienen 00:24:33
sí, pero 00:24:34
piensa que aquí no tienes por qué tener solo una sentencia 00:24:40
puedes tener muchas 00:24:42
puedes tener muchas 00:24:43
lo que tú puedes es 00:24:45
¿Cuál ha sido? ¿Cuál de ellos posibles ha sido? 00:24:46
Entonces, claro, tú aquí 00:24:50
los cats que pongas 00:24:52
en este código de una o más 00:24:54
sentencias, se supone que en algún sitio 00:24:56
habrá un throw al menos 00:24:58
correspondiente a esto 00:25:00
si es tu pregunta, de hecho es que si no lo hay 00:25:01
el compilador te va a decir 00:25:04
esta excepción no es posible 00:25:07
que se lance, o sea, como 00:25:10
en la máquina virtual, el compilador 00:25:11
tiene acceso al código 00:25:14
si tú pones aquí una sentencia 00:25:15
que ese throw no lo tiene en ningún sitio 00:25:17
te va a decir 00:25:20
esta excepción es imposible 00:25:21
que la puedas lanzar, es imposible 00:25:24
¿vale? entonces en alguna 00:25:26
de las ramas del next in 00:25:28
tendrá que haber un throw 00:25:29
correspondiente a esta y a esta 00:25:32
y a esta, todas las que tú pongas ahí 00:25:34
¿vale? pero cada throw te lanza una sola 00:25:35
otra cosa es que dentro de este código 00:25:38
que puede ser de una o muchas 00:25:40
pues hay un montón de throws en diferentes sitios 00:25:42
en función de los if 00:25:44
en función de los if 00:25:45
¿vale? 00:25:47
pues sería el multicatch 00:25:49
que se puede poner también 00:25:50
desde cierta versión 00:25:52
pues como or 00:25:54
pero bueno 00:25:55
eso cuando hagamos un ejemplo 00:25:55
lo podemos ver 00:25:56
pues numbers for exception 00:25:57
o null pointer exception 00:25:58
y así se pone un único catch 00:26:00
tan largo 00:26:01
también se puede poner 00:26:02
y ya por último 00:26:03
porque debe estar a 00:26:05
a no 00:26:06
son las 11 todavía 00:26:07
vale 00:26:08
para cerrar un poco 00:26:10
esto de 00:26:11
la sintaxis del try catch 00:26:12
el try-catch puede finalizar 00:26:14
opcionalmente 00:26:16
si uno quiere, no es obligatorio 00:26:17
con una cláusula 00:26:20
que se llama la final 00:26:22
después de los try-catch 00:26:23
si uno quiere puede poner el 00:26:28
final y ya ves 00:26:30
otra vez que es 00:26:32
una especie de epilo 00:26:34
lo que tú quieres que se haga 00:26:36
tanto si 00:26:38
ejecutó el try 00:26:40
porque no hubo excepciones, como si 00:26:41
ejecutó cualquiera de los catch. 00:26:44
Es una especie de epílogo, que sería, 00:26:46
intenta hacer esto, que funciona, fenomenal, 00:26:48
que no funciona, ejecuta el catch que toque. 00:26:52
Y ahora, en cualquiera de esas opciones, 00:26:55
para terminar, ejecuta el final. 00:26:57
Entonces es, por ejemplo, 00:27:03
cuando se abre un recurso, un fichero, 00:27:05
se abre una tubería, se abre un hilo, cualquier cosa, 00:27:08
que son recursos que luego hay que cerrar 00:27:11
esos recursos hay que cerrarlos siempre 00:27:14
haya funcionado la lectura 00:27:16
sobre ellos o no haya funcionado 00:27:18
entonces a la estructura típica 00:27:20
pues en el finally poner sentencias de cierre 00:27:21
de recursos, porque esos recursos 00:27:24
a los que has querido acceder 00:27:26
los vas a cerrar 00:27:28
bien si los has usado con éxito 00:27:29
o aunque no los hayas usado con éxito porque han cascado 00:27:32
en cualquier caso los quieres cerrar 00:27:34
pues las sentencias de cerrado 00:27:36
se podrían poner aquí, es el ejemplo más habitual 00:27:38
en el cual un finally viene bien 00:27:40
pero no es obligatorio ponerlo 00:27:42
uno podría poner esos cerrados tanto aquí como aquí 00:27:44
los tendría que duplicar en todas partes 00:27:46
pues para evitar duplicarlos en todas partes 00:27:48
te haces un finally y lo pones solo aquí 00:27:51
¿vale? 00:27:52
entonces uno usa esta cláusula 00:27:55
final si quiere y si no, no 00:27:56
vale, ya por último, antes de irnos 00:27:58
aquí como en 00:28:03
cualquier 00:28:05
conjunto de clases 00:28:06
que ya están hechas en Java 00:28:09
existe una estructura 00:28:10
jerárquica por detrás 00:28:13
en las colecciones ya la hemos visto 00:28:14
clases de colección hay un montón 00:28:16
los tricet, los linked list 00:28:19
los hash map 00:28:21
hay un montón 00:28:23
y todas están en una jerarquía 00:28:25
de clases, las de colecciones 00:28:27
heredan todas de iterable 00:28:29
de colección, luego las de list 00:28:30
hay una jerarquía 00:28:33
perdón 00:28:34
No te entiendo 00:28:37
A ver, todas heredan de object en cualquier caso 00:28:42
Entonces 00:28:44
Las clases excepción 00:28:46
IOSception, FileNotFoundException 00:28:48
NumberFormatException, son clases excepción que ya están hechas 00:28:50
Y todas 00:28:53
Heredan de 00:28:54
De object por supuesto, porque todas heredan de object 00:28:56
Pero luego de object a su vez 00:28:58
Hay una que se llama 00:29:00
Probable, que es una 00:29:02
Clase abstracta, una interfaz 00:29:03
throwable, que significa 00:29:05
pues lanzable, porque las excepciones 00:29:07
son lanzables 00:29:09
bueno, pues de throwable hereda ya 00:29:10
exception 00:29:13
y error 00:29:16
que luego mencionamos que es error 00:29:19
pero es muy parecido 00:29:22
exception es la superclase de todas 00:29:23
las excepciones, es la superclase de todas 00:29:27
es como 00:29:29
collection, que es la superclase de todas 00:29:30
las colecciones, pues exception 00:29:33
es la superclase de todas 00:29:35
exception a su vez 00:29:36
tiene una heredera 00:29:38
que es runtime exception 00:29:40
y otra 00:29:41
que, ah no, perdón, bueno, tenemos que ver 00:29:46
el cuadro, ¿vale? porque exactamente 00:29:49
yo creo que runtime exception hereda 00:29:51
de throwable directamente 00:29:53
pero vamos, lo que quiero decir 00:29:54
¿vale? 00:29:57
lo que quiero decir es que todas las excepciones 00:29:59
que ya están hechas 00:30:01
están en una jerarquía de clases 00:30:02
y en última instancia 00:30:05
heredan todas 00:30:07
de throwable 00:30:08
en última instancia eran todas de throwable 00:30:10
y luego algunas heredan de exception 00:30:11
otras heredan de runtime exception 00:30:13
que ahora veremos la diferencia 00:30:15
¿vale? entonces 00:30:17
¿qué quiero decir? 00:30:19
que este tricats tiene en cuenta 00:30:22
esa estructura jerárquica 00:30:23
y por ejemplo 00:30:25
imaginaos que yo aquí pongo 00:30:27
esto 00:30:29
exception, que es una clase más 00:30:31
es una clase más de la jerarquía 00:30:35
aunque sea una superclase 00:30:37
abstracta, es una clase más 00:30:39
pues como ya conocemos cómo funciona la herencia 00:30:40
si yo pongo aquí 00:30:43
exception, aquí se lanza 00:30:45
la excepción 00:30:47
imaginemos, number format exception 00:30:48
la máquina virtual 00:30:51
iría uno por una, diría number format exception 00:30:53
es esta 00:30:55
pues sí, porque como ya 00:30:57
sabéis, un objeto 00:30:59
pertenece tanto a su clase 00:31:01
como a cualquiera de las superclases 00:31:03
que están por encima de su clase 00:31:05
con lo cual un number 00:31:07
formal exception es number 00:31:09
formal exception pero también es exception 00:31:11
porque es super clase 00:31:13
de ella y todas las clases de exception 00:31:15
heredan de esta en última instancia 00:31:17
entonces este try-catch 00:31:18
los catch a partir de aquí 00:31:25
ya estarían de más 00:31:27
porque sea cual sea la excepción 00:31:29
que se genere, todas van a caer en este 00:31:31
me da igual que sea null 00:31:33
pointer exception, que sea todas porque como son herederas 00:31:35
de estas, de hecho si 00:31:37
escribimos esto, luego 00:31:39
lo escribimos, el compilador me dirá, oye, nunca 00:31:41
vas a llegar a este catch, claro 00:31:43
que nunca vas a llegar, porque es que, aunque 00:31:45
sea null point de excepción la que te 00:31:47
genere, esa ya va a 00:31:49
casar aquí, ya va a casar aquí, porque 00:31:51
aquí van a casar todas las que den de 00:31:53
excepción, todas. 00:31:55
Entonces, esto, cuando 00:31:57
uno quiere capturar, quiere hacer un 00:31:59
código súper mega potente 00:32:01
que no se pare nunca, 00:32:03
se hace un try-catch de excepción 00:32:05
y sea cual sea la excepción que se genere, 00:32:06
cualquiera, incluso la que él ni sabía 00:32:08
que existía y que se puede generar 00:32:11
porque no podemos, hay métodos 00:32:13
que hombre, meternos en ellos 00:32:15
para ver todas las posibilidades que pueda generar 00:32:17
es muy complejo, entonces nosotros podemos 00:32:19
de este, pues yo 00:32:21
puedo recordar que me puede generar 00:32:23
la number former exception 00:32:25
pero a lo mejor también hay otra que me pueda generar 00:32:26
que yo la desconozco, que me la genera 00:32:29
cuando pasa algo muy raro, cuando llueve 00:32:31
pues cuando llueve me la genera, no puedo 00:32:33
saberlas todas, entonces 00:32:35
si me hago un catch exception 00:32:37
en ese sentido es el código más robusto 00:32:38
del mundo, porque pase 00:32:41
lo que pase, vayamos al 00:32:43
throw que vayamos, sea el throw 00:32:45
porque llueve exception, sea el throw 00:32:47
porque no me apetece exception, sea el throw 00:32:49
que sea, da igual 00:32:51
va a caer en este catch, va a caer 00:32:53
luego el programa nunca 00:32:55
se va a parar jamás, porque va a estar 00:32:57
capturada cualquier excepción, porque cualquiera 00:32:59
es heredera de exception, cualquiera 00:33:01
entonces, esta sería 00:33:03
la forma más cómoda 00:33:05
de hacer un programa que no se va a parar nunca. 00:33:07
Nunca se va a detener. 00:33:10
Nunca se va a dejar al usuario ahí parado. 00:33:11
En ese sentido, muy robusto. 00:33:14
Pero, hombre, muy poco amigable. 00:33:16
Porque yo aquí en el cache no puedo dar ninguna explicación 00:33:20
porque no tengo ni idea de qué ha pasado. 00:33:23
Si yo voy separando excepción por excepción, 00:33:25
puedo decirle al usuario, 00:33:27
lo siento, pero has metido una cadena mala aquí. 00:33:29
Lo siento, pero no has instanciado el objeto escáner o lo que sea. 00:33:31
Lo siento, pero no sé qué. 00:33:34
puedo distinguir en cada catch 00:33:35
lo que ha pasado y darle explicaciones 00:33:37
pero 00:33:39
si yo lo capturo todo en un único catch 00:33:41
el programa no se va a parar 00:33:43
pero no tengo manera de programar aquí 00:33:44
decirle oye lo que ha pasado, porque yo aquí 00:33:47
no sé qué habrá pasado 00:33:49
sé que voy a saltar cuando se haga una excepción 00:33:51
pero a saber cuál habrá saltado 00:33:53
no tengo ni idea 00:33:55
entonces es un programa que no se para nunca 00:33:56
pero 00:33:59
poco útil 00:34:00
en ese sentido 00:34:03
poco útil porque 00:34:04
puede seguir, va a seguir 00:34:05
pero puede seguir funcionando mal 00:34:08
porque yo no sé qué ha pasado 00:34:11
no sé qué ha pasado para que fuéramos al catch 00:34:12
y por tanto no he podido arreglarlo de forma 00:34:15
personalizada, no he podido arreglarlo de forma personalizada 00:34:17
¿vale? 00:34:19
pero bueno, lo que nos importa 00:34:23
ahora mismo de todo esto que estoy diciendo es 00:34:24
que las clases que ya están hechas en 00:34:27
Javel y las que nos aprovechamos nosotros 00:34:29
todas están diseñadas 00:34:31
en una estructura de superclases 00:34:33
y subclases, porque eso facilita 00:34:35
su uso, y lo estamos 00:34:37
viendo continuamente, lo hemos visto en las colecciones 00:34:39
y aquí también lo vemos 00:34:41
si yo quiero capturar un montón de clases de golpe 00:34:42
pues pongo la superclase y ya está 00:34:45
¿vale? gracias 00:34:47
a esa ventaja de la herencia 00:34:49
que si hay una estructura de superclase 00:34:50
y subclase, todos los 00:34:53
objetos de las subclases caen 00:34:55
en las referencias suyas 00:34:57
propias, pero también encajan 00:34:59
en las de las superclases 00:35:01
y esa tontería 00:35:02
que un objeto encaje 00:35:04
en su clase y encaje 00:35:06
en cualquiera de sus superclases 00:35:08
esa tontería 00:35:10
es lo que permite que la aprobación de todos los objetos 00:35:11
sea potente 00:35:14
porque es mucho más fácil el desarrollo de código 00:35:15
solamente ese detalle 00:35:18
esa es en realidad 00:35:20
el invento de la aprobación de todos los objetos 00:35:21
la herencia, es el verdadero invento 00:35:24
¿vale? y como a través 00:35:27
de esa herencia podemos reutilizar 00:35:28
y podemos hacer códigos mucho más sencillos 00:35:30
bueno, pues en cuanto a try-catch 00:35:33
lo podemos dejar aquí y nada más 00:35:35
y ya a la vuelta del recreo 00:35:37
pues ya vemos cómo hacer nuestras propias excepciones 00:35:41
y damos algún ejemplo 00:35:43
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
8 de abril de 2024 - 19:31
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
35′ 51″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.11

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid