Saltar navegación

20260309 Exception_4 - 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 10 de marzo de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, vamos a terminarlo. 00:00:04
Vale, estábamos, ¿verdad? 00:00:07
Este método getVoto 00:00:09
versión 2 puede 00:00:11
lanzar una excepción, por eso tiene el throw. 00:00:13
Puede lanzar una excepción. 00:00:15
Entonces, como puede lanzarla, 00:00:17
el programa que lo 00:00:20
llama me dice, uy, 00:00:21
este lo siento, pero puede 00:00:24
que lance una excepción. No te dejo seguir. 00:00:25
El compilador se planta ahí 00:00:27
y dice, no te dejo seguir, 00:00:29
con lo cual no podemos ejecutar ni hacer nada, lógicamente, 00:00:31
si no compila. 00:00:33
Vale, no te dejo seguir. 00:00:34
Entonces, ¿qué hemos hecho nosotros? 00:00:36
Pues hemos dicho, pues entonces no nos queda más remedio, 00:00:39
ahí la semimentira, 00:00:41
no nos queda más remedio que hacer un try-catch para decir, 00:00:43
oye, intenta hacerlo y si lanza la excepción, 00:00:46
voto no válido excepción, que es la que puede lanzar, 00:00:51
pues ya lo que quieras. 00:00:54
Lo que quieras, como si es nada. 00:00:56
Lo que quiera, lo que el programador quiera y decida. 00:00:59
Pero el try-catch hay que ponerlo, ¿vale? 00:01:01
Es decir, yo podría 00:01:04
Quiero no haber puesto nada, en realidad 00:01:06
¿Vale? 00:01:08
Y ya está, y el compilador se queda 00:01:11
Tranquilo, porque la he 00:01:14
Capturado, la he capturado 00:01:15
Pero en el caso de que salga, no hago 00:01:17
Absolutamente nada 00:01:19
¿Vale? Esto es una regla de 00:01:20
Compilación, simplemente, pero por lo menos lo has 00:01:23
Capturado, este rojo es porque podría 00:01:25
Estar sin inicializar, pero no es por 00:01:28
La excepción, ¿vale? 00:01:29
Pero bueno, es la idea, si tú capturas 00:01:31
Es para 00:01:33
si tú capturas 00:01:35
es para dar una alternativa 00:01:39
claro, vale 00:01:41
bueno, pues la semi mentira 00:01:43
no es obligatorio capturar 00:01:45
es decir, si yo quito esto 00:01:49
el compilador 00:01:51
efectivamente me dice, uy lo siento 00:01:58
vale, pero yo no quiero 00:02:00
capturar, no quiero 00:02:02
pues tengo una opción que es 00:02:03
propagar, vale 00:02:05
capturamos 00:02:07
es lo que hemos hecho antes o 00:02:12
propagamos 00:02:14
son las dos cosas que podemos hacer 00:02:16
llegados a este punto 00:02:18
para solucionar este error 00:02:20
de compilación, o capturamos 00:02:22
que es lo que hemos hecho antes y solucionado 00:02:24
o propagamos, que significa 00:02:26
propagar, me desentiendo 00:02:29
y esa excepción que me ha llegado 00:02:31
a mí 00:02:33
el método en el que estoy que la propague 00:02:33
al de arriba y ya está, eso significa 00:02:37
propagar, entonces 00:02:38
que es la otra 00:02:41
opción que me da aquí el compilador, ¿vale? Cuando yo pincho me da 00:02:43
dos, o capturas, que se le envuelve 00:02:47
con try-catch, o propaga, la de arriba es propaga 00:02:50
¿y qué significa propagar? Propagar significa 00:02:54
que el método, el método en el que 00:02:59
se lanza esta excepción, que en este caso es el main ya 00:03:03
directamente, podría ser otro, pero es el main, el método avise 00:03:06
Y diga, oye, puede ser que yo lance 00:03:10
Voto no válido, puede ser que yo lo lance 00:03:13
Porque aquí este 00:03:16
No ha capturado 00:03:17
Entonces como aquí este no ha capturado 00:03:18
Lo siento, pero puede ser que lo tenga que lanzar 00:03:20
Entonces son las dos opciones 00:03:24
Para quitarse ese error de compilación 00:03:27
¿Cuál cogemos? 00:03:29
Pues depende del contexto 00:03:32
Aquí en el main sería muy mala idea 00:03:34
Coger esta de propagar 00:03:37
porque que significa un throws en el main 00:03:39
que cuando la excepción llega 00:03:42
el main ya no tiene nadie más a quien pasársela 00:03:43
se para todo 00:03:46
vale 00:03:47
pero este getBoto podría estar en otro método 00:03:48
no en el main directamente 00:03:52
entonces el throws pasa al método de arriba 00:03:53
y ahora el que llama al método 00:03:56
le queda la oportunidad de capturar 00:03:58
si quiere, a él si le queda 00:04:00
vale, pero en este caso 00:04:01
el getBoto2, el método 00:04:07
que lo envuelve es el main 00:04:09
Entonces, ¿qué implica poner un throws en el main? 00:04:10
Que si esta excepción llega 00:04:14
El main en ese momento se para 00:04:15
¿Vale? 00:04:18
Entonces 00:04:21
El catch lo he quitado para dar la otra opción 00:04:22
Claro, es que estabas durmiendo, creo 00:04:34
¿Vale? 00:04:37
Entonces 00:04:44
Capturamos o propagamos 00:04:45
Y aquí tenía yo el throws 00:04:48
entonces 00:04:49
si no lo meto en un try-catch 00:04:55
si no lo meto en un try-catch 00:04:57
ese método 00:04:59
tiene que avisar de que entonces 00:05:01
ahora soy yo, entonces ahora soy yo 00:05:03
el que la puedo lanzar, pero claro 00:05:05
que el main la lance es 00:05:07
feo 00:05:09
porque vamos a ejecutar ahora este programa 00:05:11
pasándole un botón no válido 00:05:13
ejecutamos esto 00:05:15
venga, se presentan dos 00:05:17
que son aa y bb 00:05:19
Dime nombre 00:05:21
Este 00:05:22
Pum 00:05:23
Excepción lanzada 00:05:26
La excepción no la he capturado 00:05:27
La he mandado al main 00:05:30
El main para el programa 00:05:32
Y se acabó 00:05:34
Y este programa ha terminado 00:05:35
Se acabó 00:05:37
Porque ha salido la excepción 00:05:38
Voto no válido 00:05:40
Excepción 00:05:41
Y no está capturada 00:05:41
No está capturada 00:05:45
Está soplantado ahí 00:05:47
No está capturada 00:05:49
Sino que está puesto aquí en el main 00:05:52
Que puede que lance 00:05:55
Bueno, más o menos he entendido todo 00:05:56
Seguido todo 00:06:08
Sí 00:06:09
Y no hay nada que os choque con el pasado 00:06:11
Ninguna pregunta 00:06:17
Algo que os resulte chocante 00:06:21
Uy, entonces porque hasta ahora 00:06:23
¿Vale? 00:06:24
Es decir, situación 00:06:28
Imaginaos que yo aquí no tengo ningún 00:06:31
Throws puesto 00:06:33
Que es lo que hemos hecho hasta ahora 00:06:34
nuestros main hasta no tenían ningún throw 00:06:37
nunca tenían un throw 00:06:39
¿vale? 00:06:40
entonces, esta sentencia puede que lance 00:06:44
una excepción, como next int 00:06:47
next int también puede que lance una excepción 00:06:49
¿no? 00:06:51
por ejemplo, imagínate que yo aquí 00:06:53
tengo un escáner puesto, imagínate que aquí 00:06:55
me da a mí la gana poner 00:06:57
volver a poner algo 00:06:58
next int 00:07:02
estas dos situaciones son 00:07:03
conceptualmente idénticas 00:07:08
este es un método al que yo llamo 00:07:10
que puede que lance una excepción 00:07:13
la input miss match excepción 00:07:14
este es un método 00:07:17
que yo llamo que puede que lance 00:07:19
una excepción, la de voto no válido 00:07:21
pero 00:07:22
no se están comportando igual 00:07:24
en esta el compilador me está 00:07:26
diciendo, eh tú 00:07:29
que puede que esto te lance 00:07:30
voto no válido, de aquí no paso 00:07:33
a menos que me captures 00:07:34
con un try catch o que me avises 00:07:37
en el main, elige 00:07:39
captura propaga 00:07:40
Sin embargo, esta es una situación idéntica 00:07:41
Next int 00:07:45
Si nos metiéramos dentro del código 00:07:46
Vemos que en algún momento tiene su throw 00:07:47
¿Verdad? 00:07:50
Si nos metemos en el código de next int 00:07:51
Aquí 00:07:54
¿Cómo se busca aquí? 00:08:00
Control F 00:08:04
Throw 00:08:06
Tendrá un throw en algo 00:08:07
No, el mismatch input, mismatch exception 00:08:09
Ay, joder, lo estoy haciendo mal 00:08:11
No, la te va antes 00:08:20
Es que la te va antes, jolines 00:08:29
TCH 00:08:30
Ahora sí, ¿vale? 00:08:33
Vale, aquí lo tenemos 00:08:37
¿Veis? 00:08:39
Este es el método nextIn 00:08:43
Que si pasa algo raro 00:08:45
Me hace un 00:08:47
Throw new input 00:08:50
MissMatchException, que es la que yo veo arriba 00:08:51
Con lo cual estamos en la misma 00:08:53
Situación 00:08:55
Este puede que 00:08:56
me lance un input mismatch 00:08:59
exception, este 00:09:01
puede que me lance un botón 00:09:03
no válido, aquí el compilador 00:09:05
se ha plantado y me ha dicho 00:09:07
o capturas o propagas, pero no te dejo 00:09:09
seguir, y aquí el compilador 00:09:11
le da lo mismo 00:09:13
¿vale? 00:09:16
eso es lo que identificamos que nos choca 00:09:18
¿verdad? hasta ahora hemos 00:09:20
llamado a métodos que podían lanzar 00:09:22
excepciones y no hemos tenido ni que capturarlos 00:09:24
ni que propagar, no se ha podido 00:09:26
despreocupar de ellos 00:09:28
de hecho cuando llamamos 00:09:29
al método get de ArrayList 00:09:32
si le pasamos 00:09:34
una posición que no esté en el list 00:09:36
ya sabemos que nos sale 00:09:38
una excepción también 00:09:40
¿vale? o en un string 00:09:41
con charad, si le pasamos 00:09:44
una posición que no esté, ya sabemos que nos sale 00:09:46
string y no hemos tenido 00:09:48
ni que propagar ni que capturar 00:09:50
¿por qué aquí sí? 00:09:52
bueno, pues la 00:09:56
respuesta es porque hay dos tipos de 00:09:56
excepciones. Las excepciones 00:09:58
que es obligatorio capturar 00:10:02
y propagar, que en principio 00:10:04
serían todas, y luego 00:10:06
una subclase 00:10:08
que son las que se llaman de tiempo de ejecución 00:10:09
que no 00:10:12
es obligatorio a nivel de código 00:10:13
capturarlas ni propagarlas. 00:10:16
No es obligatorio. Es que si 00:10:18
todas fueran 00:10:20
obligatorias de capturar y propagar 00:10:21
nuestros códigos, serían 00:10:24
una ristra de try-cats por todos 00:10:25
lados. Sería un horror. Pues no, hay una 00:10:28
subclase de excepción 00:10:30
que es la runtime exception 00:10:31
que si mi excepción es de esa clase 00:10:34
no es obligatorio capturarla 00:10:36
ni propagarla 00:10:38
por ejemplo, en mi voto no valido 00:10:38
excepción 00:10:42
veis que aquí el compilador me obliga 00:10:42
o la capturas o la propagas, lo siento 00:10:46
me obliga 00:10:48
pero yo me vengo aquí y digo, no, espera 00:10:49
tú no seas excepción 00:10:51
sé de esta clase 00:10:53
que es una subclase 00:10:55
ser runtime exception 00:10:57
que es una subclase particular 00:11:00
que son excepciones 00:11:01
que no necesitan 00:11:03
ser tratadas en tiempo de compilación 00:11:06
por eso se llaman runtime, por tiempo de ejecución 00:11:08
son excepciones 00:11:10
solo de tiempo de ejecución, no necesitan ser 00:11:11
tratadas en tiempo de compilación 00:11:14
pues si yo decido que esta 00:11:16
no es lo suficientemente 00:11:18
válida 00:11:20
como para ya desde tiempo de compilación decir 00:11:21
oye de aquí no pasas a menos que no te pronuncies 00:11:24
pues la hago de tipo runtime 00:11:26
¿vale? y si la hago de tipo runtime 00:11:28
¿qué ha pasado en cuanto lo ha hecho de tipo runtime? 00:11:30
que el compilador ya me ha dejado 00:11:33
seguir 00:11:34
como si fuera el next scene, como si fuera cualquier otra 00:11:35
no tengo ni que capturar 00:11:38
ni que propagar 00:11:40
la puedo capturar si quiero 00:11:41
pero no es obligatorio en tiempo de 00:11:47
compilación, entonces depende 00:11:52
de la trascendencia del diseño que yo 00:11:53
quiera hacer de mil cosas 00:11:56
pues lo puedo hacer para que no 00:11:57
podamos ir a la ejecución 00:12:00
si yo no he dado un camino alternativo 00:12:01
o que no pasa nada, que avise 00:12:03
que avise con excepción, que eso es lo bueno 00:12:06
pero si yo no quiero capturar 00:12:08
pues nada, ya parará, parará el programa 00:12:10
y se acabó 00:12:12
vale, pues entonces 00:12:13
vamos a ponerlo aquí 00:12:19
como el proyecto lo estará 00:12:20
en el aula virtual 00:12:26
adiós 00:12:27
excepción 00:12:31
excepción 00:12:33
Es obligatorio, por tanto, capturarla, es decir, try-catch, o propagarla, es decir, el throw en el código. 00:12:37
Sin embargo 00:12:54
Si la excepción 00:13:00
Exception 00:13:02
RoomTime 00:13:05
Exception 00:13:07
Pues entonces 00:13:12
No es obligatorio 00:13:14
El compilador no obliga 00:13:17
No es 00:13:19
Obligatorio 00:13:20
Vale, dependerá 00:13:23
Dependerá de 00:13:32
Que reglas queramos imponer en la aplicación 00:13:33
Lo que sea 00:13:35
Bueno, pues de esto va más o menos 00:13:36
El rollo de las excepciones 00:13:53
¿Vale? Hay otra cosa que son 00:13:54
Errores 00:13:57
O sea, si vamos a mirar la jerarquía 00:13:58
De excepción 00:14:01
Mira, ya que tengo este abierto 00:14:02
Dame una imagen 00:14:06
De la 00:14:09
Jerarquía 00:14:13
Bajo 00:14:18
Fruable 00:14:20
en Java 00:14:24
bueno, casi mejor la buscamos aquí 00:14:25
jerarquía 00:14:45
excepción 00:14:48
vale, esta es la jerarquía 00:14:50
en la que algunas nos suenan, ¿verdad? 00:15:12
esta es una interfaz 00:15:16
que acá en Able nos suena 00:15:17
interfaz, ¿vale? es un row 00:15:20
entonces cualquier cosa que 00:15:21
implemente throwable 00:15:24
la puedes lanzar con un throw 00:15:25
pones un throw, cualquier cosa que implemente 00:15:27
probable, la puedes lanzar y llega 00:15:30
al punto donde se llamó el método 00:15:31
y dentro de las 00:15:34
cosas lanzables 00:15:36
están las excepciones 00:15:38
y los errores 00:15:40
que también 00:15:42
podemos crear nuestros propios errores 00:15:44
voto no válido, error 00:15:46
¿vale? 00:15:47
que están mal las flechas 00:15:50
a ver, no, en los diagramas de clases 00:15:51
van así 00:15:57
de hecho 00:15:58
los diagramas de bases de datos 00:15:59
cuando haces las relaciones, la flecha va para arriba 00:16:01
¿no? claro 00:16:04
vale, entonces, los errores 00:16:05
conceptualmente en realidad 00:16:08
o sea, más que conceptualmente 00:16:09
en código, es que es igual que es una 00:16:12
excepción, es algo que tú puedes lanzar con un 00:16:14
throw y ya está 00:16:15
lo que pasa es que para los errores 00:16:17
se suelen dejar cosas que tú 00:16:19
no quieres capturar, porque son lo suficientemente 00:16:21
graves como para 00:16:24
que no, el programa no 00:16:25
no quiera seguir, no tenga por qué seguir 00:16:27
¿vale? por eso el stack 00:16:31
overflow es un error 00:16:33
no es una excepción, porque si tú te has 00:16:34
cargado la pila, lo que quieres 00:16:37
es que el programa pare, entonces por eso 00:16:38
esto está como error 00:16:41
¿que te has quedado sin memoria? pues también 00:16:41
está como error, no como excepción 00:16:44
porque los errores 00:16:46
no están pensados para capturar, cuando tú 00:16:48
ves que algo es un error, no lo capturas 00:16:50
dices, pues ya parará el programa 00:16:53
ya parará, ¿vale? 00:16:54
Y las excepciones, pues tienen una subclase, como he dicho, la runtime, que estas no es obligatorio capturarlas. Bueno, y aquí ha puesto unas cuantas. ¿Veis? Esta nos suena. 00:16:57
index out of bound cuando nos hemos pasado de un array 00:17:11
esta nos ha salido a veces 00:17:14
y efectivamente hereda 00:17:16
de long time, no hemos necesitado 00:17:18
capturarla ni propagarla 00:17:19
esta también nos suena, nos ha salido a veces 00:17:21
cuando nos pasábamos del array 00:17:24
esta también cuando dividíamos por 0 00:17:27
esta cuando intentábamos 00:17:30
convertir con un integer parse in 00:17:32
algo que no es un entero 00:17:33
entonces todas estas en rojitas 00:17:34
no es necesario capturarlas 00:17:38
ni propagarlas 00:17:40
Porque acaban heredando de aquí 00:17:41
De alguna manera 00:17:43
Estas sí hay que capturarlas y programarlas 00:17:44
Pero vamos, estos son 00:17:48
Unos ejemplos de las 00:17:49
Entre 300 y 500 que dice que hay 00:17:51
¿Vale? 00:17:53
Las llama, las cheque 00:17:56
O sea que tienes que verificarlas 00:17:57
Y estas las que no 00:17:59
Bueno 00:18:00
Pues venga 00:18:05
Vamos a poner unos 00:18:08
Ejercicios solamente 00:18:09
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:
1
Fecha:
10 de marzo de 2026 - 14:02
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
18′ 13″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
75.50 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid