Saltar navegación

20250225 Excepciones - 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 26 de febrero de 2025 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Nos ha ocurrido hasta ahora 00:00:00
Que a veces nos han 00:00:05
Ocurrido dos cosas 00:00:07
Primera, que hemos ejecutado un programa 00:00:09
Y nos han salido letras rojas 00:00:11
¿Verdad? 00:00:13
Entonces, eso es 00:00:14
Las letras rojas 00:00:17
También están programadas 00:00:19
Alguien ha programado 00:00:20
¿Cómo? 00:00:22
No es que el ordenador haya explotado 00:00:24
Y nos diga eso 00:00:26
No, no, no. Eso no nos lo dice el ordenador. Alguien ha programado que cuando detecta que ocurre cierta cosa, pues, por ejemplo, que tú has dado un índice dentro de unos corchetitos de un array y resulta que ese índice que tú has dado es mayor que el tamaño que tiene ese objeto array. 00:00:28
pues alguien ha programado en esas clases 00:00:47
de la máquina virtual, entonces hacer un 00:00:50
system out con las líneas rojas 00:00:52
¿vale? ya nos ha pasado eso 00:00:54
que hay veces que hemos ejecutado código 00:00:56
y como consecuencia de ejecutarlo 00:00:58
nos han salido líneas rojas 00:01:00
¿vale? pues eso significa 00:01:02
que alguien 00:01:04
y ese alguien es un código 00:01:06
un código de las clases 00:01:08
que nosotros usamos 00:01:10
siempre 00:01:12
sin saber que son las de la JR 00:01:13
alguien ha decidido que ahí has hecho algo 00:01:16
que no mola 00:01:19
y ese algo que no mola 00:01:19
te informa sacándote un montón 00:01:22
de líneas rojas de system out 00:01:24
y además te para el programa con un system exit 00:01:26
el programa también se para 00:01:28
por código 00:01:31
entonces no es que haya explotado el ordenador 00:01:31
y se haya parado la aplicación 00:01:34
no, es que todo de forma muy controlada 00:01:36
en algún momento 00:01:39
el código, no el que has hecho tú 00:01:41
sino el código que ya está en la JR 00:01:42
al que llamamos todo el rato 00:01:44
cada vez que hacemos un forEach 00:01:45
llamamos a ese código de la JRE 00:01:48
cada vez que hacemos un system out 00:01:49
llamamos a ese código 00:01:51
cada vez que usamos una clase stream 00:01:52
llamamos a ese código 00:01:53
cada vez que hacemos un montón de cosas 00:01:54
la máquina virtual tiene que ir a ese código 00:01:56
bueno, pues dentro de ese código 00:01:59
en ese punto 00:02:00
se ha verificado que algo de lo que has hecho 00:02:02
está muy mal hecho 00:02:05
no deberías hacerlo 00:02:07
y entonces él te hace un system out 00:02:08
en el que te avisa 00:02:11
y además para el programa consiste en el sí 00:02:11
¿vale? eso es lo primero 00:02:14
eso es lo que pasa cuando se hacen líneas rojas 00:02:15
vale, entonces 00:02:17
puede ocurrir que nosotros 00:02:19
no queramos que sea eso lo que pase 00:02:21
oye, sí, puede que yo 00:02:23
esté haciendo esto mal cuando yo lo estoy escribiendo 00:02:25
en mi código, puede que sí 00:02:27
o puede que no, porque depende 00:02:29
a lo mejor de datos externos 00:02:31
entonces, tenemos que nosotros 00:02:33
poder decidir si aún 00:02:35
detectando el código que hemos 00:02:37
hecho al cofeo, aún detectándolo 00:02:39
queremos que el programa siga o 00:02:41
se pare, tenemos que tener esa opción 00:02:43
¿vale? 00:02:45
eso es una de las cosas que tenemos que incorporar 00:02:47
tenemos que incorporar dos pequeñas cositas, primero 00:02:49
tener al menos la opción 00:02:51
de, vale, muy bien, código de la 00:02:53
JRE, has detectado que 00:02:55
he hecho algo feo, pero no me pares 00:02:57
no me pares 00:02:59
que la aplicación siga, eso es lo primero 00:03:00
que tenemos que incorporar, la opción de que el programa 00:03:03
no pare, porque es que es imposible 00:03:05
controlar todo lo que 00:03:08
hacemos mal, es imposible 00:03:09
entonces si subimos una aplicación enorme 00:03:10
a producción y ya está funcionando 00:03:13
y de repente llega un dato 00:03:15
de entrada que hace 00:03:17
que algo esté 00:03:19
funcionando mal y que mi código de la 00:03:21
JR verifica que está funcionando mal 00:03:23
y el programa se para, pues el usuario 00:03:24
se queda ahí con el programa parado, ya está 00:03:27
no, eso no debería ocurrir, el programa debería 00:03:29
poder seguir por otro camino 00:03:31
que le permite arreglar eso, lo que 00:03:33
fuera, pero nunca jamás pararse 00:03:35
nunca jamás pararse, que es lo que está ocurriendo 00:03:36
luego vamos a incorporar eso 00:03:38
Y luego también vamos a incorporar la opción de hacer nosotros nuestros propios programas de tal manera que también lancen esas excepciones, porque eso nos da una flexibilidad de diseño que está muy bien, ¿vale? De hacer unos diseños mejores. 00:03:40
No avisar siempre con el system out, que es muy feo, sino avisar de una manera más sofisticada, que es lanzando una propia excepción, en rojo o como sea, ¿vale? 00:03:56
vamos a hacer 00:04:06
la primera de las partes 00:04:09
pues venga 00:04:10
vamos a hacer un proyectillo 00:04:22
a ver 00:04:39
sí, sí, sí 00:04:42
Sois muy poco finos y refinados 00:04:45
Como digas en tu puesto de trabajo 00:04:47
Estoy hasta la polla 00:04:54
En un entorno controlado 00:04:55
Depende 00:05:04
Imagínate que tienes al CEO detrás 00:05:07
Eso, cuidado 00:05:09
En los entornos laborales no hay amigos 00:05:15
Otra enseñanza que 00:05:16
de verdad, no os dejéis engañar 00:05:18
porque luego te pueden 00:05:21
claro 00:05:22
a ver 00:05:23
ya, pero aún así hay que ser siempre 00:05:27
muy cuidadoso en el entorno laboral 00:05:33
no hay amigos 00:05:35
ni amantes, nada 00:05:37
en el entorno laboral no hay nada de eso 00:05:38
y si los hay 00:05:40
solo en el cuarto de baño 00:05:43
Pues eso 00:05:48
Aplicarlo al dedillo 00:05:51
Otro refrán machista 00:05:54
Vamos 00:06:01
El que acaba de decir 00:06:01
Claro, como si fuera primero 00:06:05
Exclusivamente decisión de esa parte 00:06:08
Pero bueno, en fin 00:06:10
El que ha dicho él 00:06:12
No me hagas repetirlo 00:06:15
Cuando tengas la olla, no metas la... 00:06:16
Vale, venga, a ver. 00:06:19
Claro, es que ya tengo el de... 00:06:31
Le voy a llamar con barra baja y ya está. 00:06:36
Ejemplo, excepciones. 00:06:43
Tonterina y nos vamos. 00:06:46
Vale, pues por ejemplo, situación que se nos da típica, por ejemplo, 00:06:47
ay, ya estamos con el mail, que ya sé que hay un truco, que no sé qué, que te lo hace. 00:07:12
Es que me cuesta incorporar nuevos aprendizajes. 00:07:21
Porque es muy cómodo. 00:07:26
No tengo que buscar el corchete 00:07:32
que con lo mal que veo me cuesta encontrarlo. 00:07:34
A ver, esto es una manera, por si lo veis por ahí 00:07:35
escrito. 00:07:38
Ya, ya, ya. 00:07:40
Esto no lo hemos visto ni lo hemos mirado, pero bueno, son los 00:07:41
típicos detalles que se van incorporando en versiones de Java. 00:07:43
Esto es una forma 00:07:47
cuando tú quieres decir, 00:07:48
hay una cosa que se llama 00:07:49
parámetros variables de los métodos. 00:07:50
Nosotros hemos visto hasta ahora 00:07:54
que a los métodos hay que pasarle 00:07:55
exactamente los parámetros que necesitas. 00:07:58
Este y este y este. 00:08:00
Pero es esta la posibilidad de dejar abierto. 00:08:01
¿Como los tipos canálicos? 00:08:03
Sí. 00:08:05
En este caso en cantidad. 00:08:07
No en tipo de dato, sino en cantidad. 00:08:10
Claro. 00:08:12
Entonces, yo aquí estoy diciendo 00:08:13
pásame un número variable 00:08:16
de parámetros de tipo string. 00:08:19
No sé si 2, 3, 4, 5. 00:08:21
con lo cual es lo mismo 00:08:23
que esto en realidad 00:08:25
es lo mismo que esto 00:08:26
con esto pásame una cantidad de parámetros 00:08:28
¿vale? entonces 00:08:31
como es lo mismo pero se 00:08:33
aplica también en otras 00:08:35
cosas, o sea que tiene sus detalles 00:08:37
no lo hemos visto 00:08:40
pero bueno es una cosa que se incorporó después 00:08:41
son esos pequeños detalles que podéis estudiar 00:08:43
por vuestra cuenta, pero a veces por vaguería 00:08:45
y porque no viven el corchete yo lo pongo 00:08:47
pero da igual, olvidarlo 00:08:49
vale, pues entonces, situación típica 00:08:51
en la que se nos puede dar una excepción 00:08:54
con la que no contábamos 00:08:56
pues le vamos a decir al tío 00:08:57
John 00:08:59
o quien sea el que habla 00:09:01
oye John 00:09:02
vale, imaginaos un 00:09:06
programa que tiene que 00:09:22
introducir un número y mostrar 00:09:24
pues 00:09:26
no, hombre, no, te has quedado más adelante 00:09:27
imagina un programa 00:09:32
oye, ni que 00:09:34
fuera el único, en caso de serlo 00:09:40
eso jamás 00:09:42
jamás lo diría 00:09:48
Eso sí, lo que hay en el cerebro de cada persona 00:09:50
Nunca lo indaguéis 00:09:53
Porque puede haber de todo 00:09:54
Pero lo importante no es lo que se piensa 00:09:56
Es lo que se dice 00:09:59
La imagen que des a los demás es lo que quieras 00:10:00
Por supuesto 00:10:03
Lo importante no es lo que eres 00:10:04
Eso no existe, es lo que haces 00:10:07
Es lo que hay en las acciones 00:10:08
Justo 00:10:10
Tú puedes ser un cabronazo, pero si no lo manifiestas 00:10:11
Eres maravilloso 00:10:14
Tú puedes estar pensando todo el día 00:10:15
Odio a los negros, odio a los negros 00:10:16
de todas formas 00:10:18
me pregunto que tienes tú de negro 00:10:25
ha dicho que podría pensar eso 00:10:28
pero lo que importa es lo que haga 00:10:43
y tiene razón 00:10:45
lo que importa es lo que tú hagas 00:10:46
porque del pensamiento a veces no eres libre 00:10:47
Estás demasiado acondicionado 00:10:49
Pero sí que eres libre sobre lo que tú vas a hacer 00:10:50
Con eso 00:10:53
Tus acciones son las que te definen 00:10:53
No tu 00:10:56
Eso 00:10:57
Vale, a ver 00:11:00
Introduzca número 00:11:02
Pues venga, ahora introducimos un número 00:11:04
Bueno, aquí en este programa sí que hemos llegado todos 00:11:06
Estamos todos, ¿verdad? 00:11:46
aquí no se ha perdido 00:11:47
el doble igual 00:11:48
aquí nadie se ha perdido 00:11:52
¿qué significa el cero? 00:11:53
uff 00:11:56
una pregunta interesante 00:11:57
para los chinos no existía el cero 00:11:58
era todo 00:12:02
el uno y el menos uno, la lucha de contrarios 00:12:03
no existía el cero 00:12:05
por ejemplo 00:12:06
claro, entonces interesante 00:12:10
¿qué significa el cero? en nuestro caso 00:12:11
pues significa que no tiene resto 00:12:13
vale, a ver, entonces 00:12:16
uno ejecuta esto y ya está, y estupendo 00:12:19
y tiene un programa maravilloso y le dan en el trabajo 00:12:21
pues 00:12:23
un bonus, porque ha hecho su trabajo 00:12:25
y ya está, vale, pero claro 00:12:27
el equipo de pruebas no es 00:12:29
tonto, no es tan tonto como el jefe 00:12:31
el jefe normalmente sí es bastante 00:12:33
lerdillo, porque si no no sería jefe 00:12:35
habría seguido de técnico, porque el listo 00:12:37
sigue de técnico que es el que saca el curro 00:12:39
entonces si es medio tonto, pues se va para arriba 00:12:41
y así no molestas 00:12:42
pero el equipo de testing no es tonto 00:12:44
y el equipo de testing 00:12:48
se pone a pasar sus pruebas 00:12:50
hace sus pruebas de caja negra, de caja blanca 00:12:52
después de todas las pruebas tiene un conjunto de casos 00:12:54
de pruebas que te cagas 00:12:56
y hace esto 00:12:57
y dice, ah, pues no has pasado las pruebas 00:12:59
en este programa estupendo 00:13:01
vale, entonces efectivamente, ¿qué ha ocurrido? 00:13:02
el programa está mal 00:13:06
no, el programa no está mal 00:13:08
yo trato de leer un número entero 00:13:10
lo guardo en un número entero 00:13:12
el programa está estupendo, es que no puedo hacer nada más 00:13:13
de lo que he hecho, no puedo cambiar el código, está bien 00:13:15
pero claro, dependo de 00:13:17
factores externos, dependo de lo que 00:13:19
haga la gente de fuera 00:13:21
me tengo que resignar a que 00:13:22
si el de fuera le da por meter un decimal 00:13:25
mi programa se ha parado 00:13:28
y el pobre usuario 00:13:29
se ha quedado diciendo y aquí que pasa 00:13:30
no me tengo que resignar a eso, tengo que poder hacer algo 00:13:33
entonces 00:13:35
del desarrollador siempre 00:13:37
porque una premisa fundamental es que el usuario 00:13:50
es tonto y lo va a hacer 00:13:53
todo mal 00:13:55
pues tu programa 00:13:55
el desarrollador tendrá que ponerte un amable mensaje 00:14:02
en el que te diga 00:14:05
Por favor, introduzca la fecha en este formato. 00:14:06
Y si tú insistes, otra vez el amable mensaje. 00:14:09
Y si no, pues el desarrollador está haciendo mal. 00:14:13
Claro, pues el tema es que aquí no hay salida. 00:14:17
Yo no puedo cambiar mi programa. 00:14:19
Pero sí que podemos decir, oye, ¿qué pasa? 00:14:21
Yo sé, porque ya tengo experiencia, 00:14:24
porque he hecho en mi caso de pruebas, 00:14:26
pues he visto que esto que ha ocurrido 00:14:28
es que se ha lanzado una excepción. 00:14:30
Esto no lo quería. 00:14:32
¿Qué es una excepción? 00:14:34
Una excepción en realidad es un objeto que se instancia y aparece en el programa cuando se detecta, el código detecta que ha ocurrido algo raro. 00:14:36
Entonces, ¿aquí quién lo detecta aunque nosotros no lo veamos? 00:14:47
Aquí lo detecta el next in. 00:14:49
El next in no lo hemos hecho nosotros, lógicamente. 00:14:51
El next in, pues, tiene su código aquí dentro que hace un montón de historietas, ¿vale? 00:14:54
Y cuando ese código detecta, lo siento, aquí el match me ha fallado, ¿qué hace? Te lanza, y como veis está muy controlado por código, te lanza un objeto, por eso es un new, un objeto excepción de este tipo. 00:15:00
Luego, las excepciones son objetos que se crean en el programa, 00:15:21
alguien los crea cuando detecta que algo ha fallado. 00:15:25
Bueno, esta clase está declarada en algún sitio, le mete información, 00:15:32
en este caso le mete un mensajito, que es el mensajito que a su vez 00:15:35
está aquí en esta clase, que lo podemos, sí, bueno. 00:15:41
¿Dónde está este getMessage? 00:15:52
En F, pues aquí tendrá su mensaje en algún sitio puesto. 00:15:55
Ese mensajito que sale en algún sitio de este objeto está... 00:16:00
¡Ay, ya lo he perdido! 00:16:05
Sí, pero bueno, que luego cuando hagamos nuestras propias excepciones 00:16:16
veremos que el que ha hecho esa clase excepción 00:16:20
ha puesto el mensajito que quiere que aparezca 00:16:22
que se va recuperando con los métodos 00:16:24
que es exactamente esto que vemos ahí, 00:16:27
de alguna manera, ¿vale? 00:16:30
Entonces, pero lo que me importa ahora, 00:16:31
sobre todo, es que la excepción es un objeto 00:16:32
que crea mi programa. 00:16:36
En este caso, el método este de escáner, 00:16:39
el next in, este de aquí, 00:16:42
el método next in, este, 00:16:44
ha visto que esto ha fallado, 00:16:49
ha hecho este matcher de aquí, lo que sea, 00:16:50
ha visto que, oye, eso está mal, 00:16:53
y ha lanzado 00:16:55
ha creado un objeto 00:16:57
de tipo excepción 00:16:58
entonces excepciones solo se pueden lanzar 00:17:00
las que tengan clases 00:17:03
que ya existen 00:17:05
las que tengan clases 00:17:06
y hay 200.000, 300.000 millones 00:17:08
bueno, exagero, no tantas, pero hay muchas 00:17:11
hay muchas 00:17:13
y una de ellas es esta, por ejemplo 00:17:14
input mismatch exception 00:17:16
que esta se crea cuando tú esperas 00:17:17
un tipo de dato que no casa 00:17:20
en formato con el que 00:17:23
necesitas, ¿vale? 00:17:24
Cuando tú recibes un tipo de dato que no casa. 00:17:26
Vale, pues la excepción es un objeto que la 00:17:29
máquina virtual hace 00:17:30
aparecer, la máquina virtual, no, el 00:17:32
código, el código que se está ejecutando 00:17:34
hace aparecer cuando ve que 00:17:36
algo falla, ¿vale? ¿Y qué 00:17:38
hace? Te lo lanza mediante 00:17:40
esta sentencia throw, hace throw, 00:17:42
te lo lanza, pa. 00:17:45
Y ese lanzamiento 00:17:47
nos llega a nosotros 00:17:48
aquí, nos llega aquí. 00:17:50
Entonces, 00:17:54
Si nosotros nos callamos y no decimos nada, cuando la máquina virtual, después de haber hecho el next in, le llega a ese objeto lanzado con el throw, la máquina virtual dice, uh, me han hecho un throw de una excepción que se ha creado ahí. 00:17:54
¿Qué hago yo? Pues lo siento. ¿Qué es lo que hago yo? La máquina virtual para el programa y te pone estas letritas. Ya las ha sacado del mensaje de la excepción, etc. 00:18:11
Vale, pero nosotros podemos alterar ese funcionamiento y podemos decirle, oye máquina virtual, cuidado, escucha máquina, si en algún momento te llega a ti una excepción de esta clase, de este tipo, por Dios no pares, haz esto otro y continúa el programa. 00:18:24
Vale, pues ¿cómo hacemos eso? Hacemos eso capturando la excepción. Luego tenemos dos opciones cuando me aparece una excepción, cuando me aparece ese objeto excepción, que en este caso nos está apareciendo aquí. 00:18:43
callarnos 00:18:55
callarnos significa 00:18:57
dejar que esa excepción 00:18:59
se lance 00:19:02
y la máquina virtual entonces la recoja 00:19:03
y para el programa y se acabó 00:19:06
callarnos o 00:19:07
capturarla 00:19:09
capturarla 00:19:10
pues vamos a capturarla 00:19:12
y ya la capturamos 00:19:20
y nos vamos 00:19:21
Pues aquí hasta que no la capturemos 00:19:23
Aquí no se va nadie 00:19:29
Hasta que no se capture la excepción 00:19:30
Así que ya podéis correr rápido 00:19:33
Vale 00:19:35
¿Cómo se captura una excepción? 00:19:36
Poniendo un bloque 00:19:40
Como ya habéis visto muchas veces 00:19:41
Try, catch 00:19:43
A ver, se pone este bloque 00:19:44
Dentro del try 00:19:50
Entre las llaves 00:19:52
se pone la sentencia que tú 00:19:54
prevés que puede que te haga parecer una excepción 00:19:56
que tú por tu experiencia 00:19:58
porque el equipo de testing te lo ha dicho 00:20:00
por lo que sea prevés que puede 00:20:02
que eso lance una excepción 00:20:04
entonces 00:20:05
la metes en el try y le dices, oye, inténtalo 00:20:07
no te obligo a que la 00:20:10
hagas porque pueda, inténtalo 00:20:12
tú inténtalo 00:20:14
que lo consigues 00:20:14
porque el usuario te ha metido el dato bien 00:20:17
maravilloso, lo que haya en el catcha 00:20:20
como si no existiera, sigues con el programa 00:20:22
que no lo consigues 00:20:23
mira a ver si la excepción 00:20:26
que ha salido es esta 00:20:28
sí 00:20:29
y no 00:20:36
porque gracias a Dios tenemos la herencia 00:20:38
ahora lo 00:20:40
es que hacéis tantas preguntas interesantes 00:20:42
que es imposible acabar pronto 00:20:45
no, pero es que a ver 00:20:47
que de todas estas cosas 00:20:54
salen cosas 00:20:56
sale la clave de 00:20:58
no, pero de responder eso 00:21:00
y de entender eso 00:21:03
está la diferencia 00:21:04
entre ser un programador que vas a poder avanzar 00:21:05
y adaptarte a tu mundo 00:21:09
que seguramente no sea Java 00:21:10
sea bla bla bla, vete a saber qué 00:21:12
o a solamente saber 00:21:15
lo que te han enseñado 00:21:17
¿a dónde están vendiendo que pruebe Cobol? 00:21:17
que hay trabajo 00:21:20
y que no están coñando 00:21:21
Cobol es viejo, no está para mí 00:21:22
Ya, pero 00:21:27
por la vaguería de migrar 00:21:30
pero en cuanto una IA 00:21:32
se lo migre en un PIS-PAS, pues ya está 00:21:34
Claro 00:21:36
Entonces 00:21:38
Un nombre, sí, a ver 00:21:39
Entonces, no, no, dejadme terminar, paciencia, a ver, sintaxis y estructura del try-catch, tú le dices, try y un bloque entre llaves, dentro de ese bloque pones todas las sentencias que tú quieras, en esas sentencias estarán las que tú preves que puedan generar la excepción, vale, 00:21:58
y el cat significa 00:22:26
si la excepción 00:22:28
que se ha lanzado es de esta clase 00:22:31
entonces 00:22:33
haz lo que yo te meta aquí 00:22:35
haz esto 00:22:37
esto es como si fuera un if 00:22:38
haz esto que está aquí 00:22:39
que te funciona, genial, olvídate de lo demás 00:22:42
y continúe por abajo 00:22:45
que no te funciona 00:22:46
porque te sale una excepción 00:22:48
de esta clase 00:22:50
ahora miramos lo del ex 00:22:52
etcétera 00:22:53
pues entonces entra aquí 00:22:55
y hace esto 00:22:56
pero no paras el programa 00:22:58
sigues por abajo otra vez 00:23:00
luego con un try catch 00:23:01
en ningún caso se para el programa 00:23:04
haya excepción o no, en ningún caso 00:23:06
lo que puede ocurrir es que bien 00:23:08
haces lo del try o bien haces lo del catch 00:23:10
una de dos 00:23:12
si todo te ha funcionado haces lo del try 00:23:13
y continúas por abajo 00:23:16
si no te ha funcionado 00:23:17
haces lo del catch y continúas por abajo 00:23:19
en este caso no queremos continuar por abajo 00:23:22
Con lo cual, en este caso, tendría sentido meter esto aquí dentro, porque solamente quieres hacer esto si esto te ha funcionado, ¿vale? Entonces, este programa lo podríamos cambiar de esta manera. Intenta leer el número. Si no te ha salido excepción, sigue haciendo esto, ¿vale? 00:23:24
Pero si como consecuencia de hacer el next in apareció la excepción, aquí se detiene, aquí se detiene automáticamente, esto ya no se continúa, se detiene y automáticamente saltas al catch y haces lo de dentro y el programa sigue. 00:23:44
entonces funciona o no funciona 00:24:00
el programa sigue 00:24:02
ponemos el adiós para ver que realmente sigue 00:24:02
vale 00:24:06
entonces el catch además 00:24:06
el catch además recibe 00:24:09
el objeto 00:24:12
que ha generado aquí 00:24:13
este código 00:24:15
este código next in cuando vio ese error 00:24:16
generó con el throw un objeto 00:24:19
¿verdad? vimos aquí un throw new 00:24:21
pues este objeto throw new 00:24:23
que se ha generado este objeto 00:24:25
es el que atrapa este catch 00:24:27
bajo este nombre ex 00:24:29
esto es como si declaramos un método 00:24:31
y este ex se rellena 00:24:34
con el objeto que lanzó 00:24:36
este método, que tiene dentro 00:24:38
toda la información 00:24:40
luego este objeto ex, si uno ve 00:24:41
con el punto todo lo que nos ofrece, nos ofrece 00:24:44
mucha información sobre esa excepción 00:24:46
pues por qué vino, cómo vino, su mensaje 00:24:48
de error, etcétera 00:24:50
y ese objeto pertenece a una clase, ¿a qué clase 00:24:51
pertenece? a esta clase 00:24:54
que tengo que importar, como todas 00:24:56
como todas menos las de 00:24:57
Havala 00:25:01
lo sé 00:25:02
pero la idea 00:25:03
general está entendida 00:25:07
entonces 00:25:09
si yo hago un try-catch 00:25:10
claro porque es una 00:25:12
clase, tengo que importarla 00:25:15
creo que es súper fácil 00:25:17
puedo poner dos en el catch 00:25:19
dos tipos de gestiones distintas 00:25:21
puedes poner 00:25:22
muchas 00:25:23
un multi-catch aquí 00:25:25
porque claro 00:25:27
sí, sí lo vamos a completar 00:25:29
el próximo día, pero sí, puedes poner 00:25:32
catch, catch, catch, porque este código podría 00:25:34
generar varias, claro 00:25:36
entonces 00:25:38
sí 00:25:39
claro 00:25:41
este código imagínate que lanza una excepción 00:25:43
porque el momento en que lanza una, ya como 00:25:46
no sigue, solo puede lanzar una 00:25:48
que es la primera, y ahora ya se pone 00:25:50
a comprobar en todos los catch 00:25:52
y el primero que encuentre que coincide se mete dentro 00:25:53
lo hace y luego ya sigue 00:25:56
¿vale? entonces 00:25:57
si ejecutamos ahora esto 00:25:59
ahora sí 00:26:01
si el tío mete el numerito bien, estupendo, es par y adiós 00:26:03
pero si el tío 00:26:06
mete el numerito mal, pues has metido 00:26:08
mal el número y en este caso termina 00:26:10
pero podría seguir 00:26:12
entonces es un programa más robusto 00:26:13
¿vale? 00:26:16
venga, anda, sí, vámonos ya 00:26:24
Pero no hemos terminado 00:26:26
Que no hables así 00:26:28
Habla en bajo 00:26:29
O sea, di esas cosas en bajo 00:26:32
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
26 de febrero de 2025 - 12:58
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
26′ 35″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
120.27 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid