Saltar navegación

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

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, a ver, un poco de alegría, por Dios 00:00:00
Vale 00:00:02
Bueno, pues este código parece que nos ha gustado 00:00:04
Vamos a hacerle pruebas 00:00:07
Pero en lugar de 30 vamos a poner 00:00:08
Ah, no, 10 votaciones las que están 00:00:12
Vale, 10 00:00:13
Pues venga, vamos a ejecutarlo 00:00:14
Primero vamos a ejecutarlo 00:00:17
A ver si funciona, no vaya a ser que 00:00:21
Que el código esté mal ya de partida 00:00:23
Venga, tenemos 00:00:27
Tres se van a presentar 00:00:30
tres votantes, nombre 00:00:31
el A, el B 00:00:32
y el C, vale, y ahora empezamos 00:00:35
a votar, pues venga, voto 00:00:37
a este, voto a este 00:00:39
voto a este 00:00:40
voto a este, a este 00:00:42
a este 00:00:45
a este, a este 00:00:46
y a este, y a este, vale 00:00:48
¿veis? 00:00:51
cuando yo he mostrado 00:00:53
mi map 00:00:55
que lo he mostrado directamente así 00:00:57
lógicamente 00:00:59
la máquina virtual de Java ha tenido que llamar 00:01:05
al toString de map 00:01:07
y el toString de map es bonito 00:01:08
el toString de map es bonito 00:01:10
porque nos lo muestra entre llaves, así todo chulo 00:01:13
¿vale? el toString de map 00:01:15
y no solo eso, nos lo ha mostrado 00:01:17
en orden alfabético 00:01:19
de claves 00:01:21
¿vale? ¿por qué nos lo ha mostrado 00:01:23
en orden alfabético de claves? 00:01:26
porque era un trimap, si hubiera sido un 00:01:28
hashMap no tendría por qué haberlo 00:01:30
mostrado en orden alfabético de claves 00:01:32
¿vale? 00:01:34
Bueno, y aquí como no hay mayoría absoluta 00:01:36
Bueno, hay mayoría absoluta, vale 00:01:38
Entonces uno podría decir 00:01:40
Ay, que bien, he pasado las pruebas 00:01:42
Entonces 00:01:44
Hemos hecho 00:01:52
Ups, ya está 00:01:54
Una primera prueba 00:01:55
Y vale, bien, parece que funciona 00:01:57
Hemos metido nombres, los ha mostrado 00:02:01
En orden alfabético porque es un trimap 00:02:02
Vale, funciona 00:02:04
Pero claro, uno pues no puede 00:02:07
Cometer el error de 00:02:09
Darlo por válido a la primera prueba 00:02:10
Para eso hay 00:02:13
Todo un protocolo 00:02:15
De creación de casos 00:02:17
De prueba, pruebas unitarias 00:02:19
Pruebas de 00:02:22
De proyecto 00:02:23
De todo, de las cuales 00:02:25
Algo pues más o menos ya sabéis 00:02:27
De entornos de desarrollo 00:02:29
Entonces por ejemplo 00:02:31
Si yo sigo haciendo pruebas porque no caigo 00:02:33
En el error 00:02:35
De a la primera prueba que me sale bien 00:02:37
Darlo por válido 00:02:39
Pues aquí podríamos 00:02:40
Hacer esta prueba 00:02:41
¿Cuántos se presentan? 00:02:44
Se presentan JJ 00:02:46
Pues este programa lógicamente 00:02:47
No ha pasado la fase de pruebas 00:02:51
Porque cuando yo pongo 00:02:52
Se presentan JJ 00:02:55
Me sale 00:02:56
Una excepción, ¿vale? 00:02:58
Que es lo que digo, que siempre hemos pasado 00:03:00
Un poco así por alto 00:03:03
Porque no 00:03:04
teníamos todavía tiempo para meternos en ello 00:03:05
vale, pues ahora vamos a meternos ya un pelín 00:03:09
vamos a meternos ya un pelín 00:03:11
en el tema de las excepciones 00:03:12
vale, pues vamos a meternos 00:03:14
ya un pelinín en este tema 00:03:20
un pelinín, tampoco que nos vayamos a 00:03:21
volver locos porque tampoco hace 00:03:24
falta 00:03:26
tampoco hace falta volverse locos 00:03:26
bueno, pues 00:03:30
muy rápidamente 00:03:34
No, no, no 00:03:38
Gracias 00:03:51
No os creen 00:03:53
No os creen 00:04:01
¿Quién es? 00:04:02
No, alguien nos creó 00:04:04
¿Qué? 00:04:06
a ver, entonces 00:04:13
¿qué es una excepción? 00:04:18
pues una excepción 00:04:23
en realidad es 00:04:28
un objeto 00:04:29
eso es una excepción 00:04:31
es un objeto 00:04:33
que se crea 00:04:34
que se instancia 00:04:38
que aparece ese objeto, se crea esa instancia 00:04:39
cuando el programa 00:04:41
decide que ha pasado 00:04:43
algo raro que no le gusta 00:04:46
Entonces, todo es código 00:04:47
Una excepción no es que haya pasado algo raro 00:04:49
Que se haya roto la RAM 00:04:52
Que se haya roto el teclado 00:04:54
Y pum, aparezca algo de eso 00:04:56
No, es todo código también 00:04:58
Todo código 00:05:01
Entonces, cuando uno tiene un programa Java 00:05:02
Pues nosotros ya sabemos que nuestros programas Java 00:05:04
Aparte de hacer nuestras propias sentencias 00:05:08
Lógicamente también llaman a métodos que hacen cosas 00:05:11
Por ejemplo, aquí hemos llamado al método nextIn que hace cosas. A veces también llamamos al método systemOut que hace cosas. Nosotros, aparte de nuestras propias sentencias, llamamos a métodos que hacen cosas. 00:05:15
Y estos son métodos que hacen código, que a su vez pueden llamar a métodos que hacen código, ¿vale? Pues puede ocurrir que en alguno de estos puntos se verifique una condición con un if y esa condición lleve a que se genere, aparezca un objeto excepción, ¿vale? Aparezca. 00:05:33
Por ejemplo, en nuestro ejemplo que estamos viendo aquí, 00:05:57
el next in se ha metido a hacer cosas. 00:05:59
Entonces, el next in aquí ha validado, 00:06:03
a ver, si esa cadena de texto que se ha leído por el teclado 00:06:06
se ha puesto aquí a validar por dentro, 00:06:11
si es una sucesión de cifras que componen un entero o no lo es. 00:06:14
Se ha puesto a validarlo. 00:06:17
Nosotros no lo vemos, pero lo hace aquí dentro. 00:06:19
Entonces, cuando ha comprobado que no, 00:06:21
Que lo que le hemos metido 00:06:23
No es una sucesión de cifras 00:06:25
Que forman un entero 00:06:27
Cuando ha comprobado eso 00:06:28
Ha creado un objeto 00:06:30
Excepción, lo ha creado 00:06:33
Y lo ha mandado de vuelta 00:06:35
De vuelta 00:06:39
Al punto 00:06:41
En el que se llamó a este método 00:06:42
Es como si lo pasara por parámetro 00:06:44
Como si fuera un paso por parámetro 00:06:47
Es decir 00:06:50
Next in 00:06:51
ha hecho lo que tenga que hacer 00:06:52
ya sabemos que si next in 00:06:54
hubiera terminado con éxito 00:06:57
si hubiera terminado con éxito 00:06:58
ya sabríamos que lo que se habría devuelto 00:07:00
es el valor 00:07:03
entero leído, ya lo sabemos 00:07:05
pero next in no ha acabado con éxito 00:07:06
next in en algún momento 00:07:09
ha hecho un if y ha visto que 00:07:11
esa secuencia leída no es 00:07:13
un número, con lo cual 00:07:15
el next in no ha llegado a terminar 00:07:16
y a devolver el número 00:07:18
entero leído, sino que mucho 00:07:21
antes de eso, ha creado 00:07:23
un objeto excepción 00:07:25
y ese es el que le ha 00:07:26
entregado al punto de llamada. 00:07:28
Ese es el que le ha entregado. 00:07:31
En realidad es como si le estuviera 00:07:33
pasando un parámetro también. 00:07:35
Le pasa un objeto excepción. 00:07:37
Pues ahora mi programa, este que 00:07:39
está aquí, 00:07:41
habiendo llamado al nextIn, 00:07:43
tiene dos opciones, 00:07:46
tiene dos posibilidades, por tanto, 00:07:47
repito que el nextIn haya terminado 00:07:48
correctamente 00:07:51
le haya devuelto el número entero 00:07:52
y mi programa sigue 00:07:54
o que el nextIn no haya terminado correctamente 00:07:55
y la forma de saber que no ha terminado 00:07:59
correctamente es porque le ha llegado 00:08:01
este objeto de excepción 00:08:02
pues aquí que ocurre 00:08:03
pues si estamos en un punto 00:08:07
del programa en el cual 00:08:09
de ese método que hemos llamado 00:08:10
hemos recibido ese objeto de excepción 00:08:12
que indica no he podido terminar correctamente 00:08:14
lo siento no he podido terminar 00:08:17
y te mando un objeto de excepción para avisarte. 00:08:18
Pues si ha ocurrido eso, ¿qué pasa? 00:08:21
Que si yo no hago nada y me quedo tan tranquila 00:08:23
como hemos hecho siempre, no hacer nada al respecto, 00:08:26
si no hacemos nada al respecto, ¿qué es lo que ocurre? 00:08:29
Que el programa automáticamente terminó, se para 00:08:31
y aquí se han acabado las cosas, programa terminado. 00:08:37
Eso es lo que pasa, ¿vale? 00:08:41
Cuando llamamos a un método que en algún momento 00:08:44
verifica que una condición no le gusta 00:08:47
lo que obtiene 00:08:51
y me entrega una excepción 00:08:52
en lugar de completarse y darme el valor 00:08:54
pues el punto 00:08:57
en el que llamé recibe 00:08:58
esa excepción y pum 00:09:00
el programa se paró 00:09:02
ya no hay más programa que ejecutar 00:09:04
¿vale? 00:09:07
repito, no es que de repente 00:09:09
cuando salen esas letras rojas 00:09:10
de aquí, o las letras rojas 00:09:12
que nos han salido, no es 00:09:15
que haya pasado algo extraño 00:09:16
no controlado, no ha pasado nada extraño 00:09:18
forma parte de nuestro programa 00:09:21
el next in 00:09:22
hacía cosas, no le ha gustado 00:09:24
algo, en este caso 00:09:27
no le ha gustado que lo que ha leído del buffer 00:09:28
del teclado era JJ 00:09:30
en lugar de ser un número, no le ha gustado 00:09:32
y te dice, uy, no me gusta 00:09:34
pues construye instancia 00:09:35
ese objeto excepción 00:09:40
y te lo devuelve 00:09:42
en lugar de devolverte el número entero 00:09:43
que hay en ese buffer 00:09:46
Entonces, es todo programa, no es que pase nada raro, no es que aparezca un evento y de repente, porque otra cosa es la programación entra de evento, es otra cosa. 00:09:48
Pero lo que sí que ocurre es que la máquina virtual, en cuanto ve que en este punto, en esta sentencia, la vuelta ha llegado vía objeto excepción, 00:09:56
cuando ve que la vuelta ha llegado vía objeto excepción y no ha llegado vía valor de retorno normal, el valor de retorno del método, 00:10:08
sino que ha llegado vía objeto de excepción 00:10:14
lo que sí que ocurre es que la máquina virtual 00:10:16
te hace un siso en la consola 00:10:18
con los detalles de ese objeto 00:10:22
y luego para 00:10:24
se acabó 00:10:25
entonces todas esas letras rojas que vemos 00:10:26
son los detalles 00:10:29
que hay dentro del objeto 00:10:31
que ha recibido el programa 00:10:33
principal cuando se ha llamado 00:10:35
a ese método que ha hecho cosas raras 00:10:37
eso es lo que vemos 00:10:39
que es lo que hemos visto 00:10:40
aquí 00:10:43
vale 00:10:46
es lo que hemos visto aquí 00:11:02
estos son los detalles 00:11:11
que están dentro 00:11:13
de ese objeto 00:11:14
y los detalles son 00:11:16
oye, la clase a la que pertenece 00:11:18
el objeto excepción 00:11:21
que yo te mando 00:11:23
es esta clase 00:11:24
inputMisMatchException 00:11:26
es que este objeto excepción particular 00:11:28
es muy 00:11:31
sencillito, hay algunos que tienen dentro 00:11:32
más información y más cosas 00:11:35
oye, que me pasó eso 00:11:36
cuando tú llamaste a votaciones 00:11:38
y yo de votaciones me fui a votaciones 00:11:41
y de votaciones me fui a escáner y de escáner 00:11:43
me fui a escáner a esta línea y de escáner me fui a esta 00:11:45
y de escáner me fui a esta 00:11:47
fue aquí, en la línea 00:11:48
947 de la clase escáner 00:11:50
fue en esta línea 00:11:53
donde me encontré yo 00:11:54
haciendo mi código que no me gustaba 00:11:56
lo que estaba viendo ahí, que no me gustaba 00:11:59
pues fue aquí 00:12:01
donde yo decidí crear mi objeto 00:12:02
de la clase InputMismatchException 00:12:05
y te lo envié. 00:12:07
Es lo que nos está contando. 00:12:09
Entonces, 00:12:12
una vez que la máquina virtual ya ha sacado 00:12:13
la información de dentro de ese objeto, 00:12:15
paz, para el programa. 00:12:18
Y ya está. 00:12:21
Y por eso no ha seguido. 00:12:21
¿Vale? 00:12:25
Bueno, pues hasta ahí está claro lo que es una excepción. 00:12:26
Una excepción es un objeto 00:12:28
que se crea con información dentro 00:12:30
que detalla que algo raro ha pasado 00:12:32
y es un objeto 00:12:35
que como todos los objetos de Java 00:12:36
pertenece a una clase 00:12:37
clases de posibles excepciones 00:12:38
hay 3.598 millones 00:12:42
esta es una de ellas 00:12:44
¿vale? 00:12:46
esta es una 00:12:49
JavaUtilInputMidMatchExcept 00:12:49
¿vale? 00:12:51
entonces ¿cuál es el problema de las excepciones? 00:12:52
que cuando le llegan a un punto 00:12:55
que en este caso aquí han llegado aquí 00:12:57
el next in 00:12:59
se ha ido a un sitio 00:13:00
no ha podido completarlo 00:13:03
si hubiera podido completarlo, genial 00:13:06
nos habría devuerto el entero para guardarlo aquí 00:13:08
no ha podido completarlo 00:13:11
con lo cual nos ha mandado el objeto excepción 00:13:13
la máquina virtual en este punto 00:13:15
lo ha mostrado por consola 00:13:17
y ahora ya sí que sí 00:13:19
lo grave es que 00:13:20
lo grave es 00:13:23
que aquí el programa 00:13:26
se acabó 00:13:28
Esto. No hay forma de continuar. Bueno, pues eso es un rollo realmente. ¿Por qué? Porque es imposible controlar todos los errores. Es imposible todos los posibles fallos. 00:13:30
entonces entregar una aplicación 00:13:48
que en algún momento 00:13:51
pues puede de repente 00:13:53
pasarle esto 00:13:55
que está el usuario que de repente 00:13:56
ve ahí un chorizo extraño 00:13:59
y se le ha parado la aplicación 00:14:00
pues hombre no es la idea 00:14:03
entonces tenemos que entregar 00:14:04
aplicaciones no con la garantía 00:14:07
de que nunca jamás van a petar porque eso es 00:14:09
imposible seguro que hay cosas que no contemplamos 00:14:11
pero al menos tenemos 00:14:13
que intentar entregarlas 00:14:15
con caminos alternativos 00:14:17
en el caso de que peten 00:14:19
para que no se paren y puedan seguir 00:14:20
para que no se paren 00:14:23
esta, desde luego no le hemos implementado 00:14:24
ningún camino alternativo 00:14:27
esta es muy mona, te lo prometo 00:14:28
esta no le hemos implementado ningún camino alternativo 00:14:31
¿vale? entonces en cuanto 00:14:35
se ha encontrado el error de que el usuario 00:14:37
ha puesto JJ, pues ha petado 00:14:39
pues muy mal hecho 00:14:41
bueno, pues ¿qué podemos hacer? 00:14:42
lo que podemos es decir, oye 00:14:45
Esta excepción, esta sentencia 00:14:47
Si el usuario es un poco malintencionado 00:14:51
Y el usuario se empeña en meter aquí 00:14:56
Aunque yo le diga, dame número entero positivo 00:14:59
Aunque yo me empeñe en decirle al usuario 00:15:07
Dame número entero positivo 00:15:16
Si el usuario se empeña en meterme aquí JJ 00:15:18
bueno, voy a dar un camino alternativo 00:15:23
para que no se pare la aplicación ahí 00:15:27
porque tal y como lo tenemos 00:15:29
si el usuario mete aquí hola, ¿qué tal? 00:15:31
pum, se va a parar 00:15:33
no tenemos por qué resignarnos a que eso te va a ocurrir 00:15:34
¿cómo podemos darle un camino alternativo? 00:15:38
bueno, podemos hacerlo pasando de las excepciones 00:15:43
en realidad también 00:15:45
por ejemplo, aquí ¿qué podríamos hacer 00:15:46
para que no se parara la aplicación? 00:15:49
olvidándose de las excepciones 00:15:51
que eso os ocurriría 00:15:52
y como lo validaríais 00:15:53
pero como 00:15:56
por lo pronto el next scene habría que quitarlo 00:16:00
habría que poner un next line para 00:16:03
que leyera lo que fuera 00:16:04
y ahora ya esta cadena 00:16:06
pasarla a una función que hagamos 00:16:08
para ver si realmente es una sucesión 00:16:10
de dígitos 00:16:13
si lo es entonces ya 00:16:13
permito que el programa sigue 00:16:17
si no bucle otra vez 00:16:19
es un rollo esa validación 00:16:20
en realidad ¿no? porque tenemos 00:16:23
nosotros que leerlo con 00:16:24
next line, eso, hacer el 00:16:26
código para ver si es una sucesión 00:16:28
de dígitos, si lo 00:16:30
es, sigo, si no 00:16:32
bucle para arriba, vale 00:16:34
bueno, podríamos hacerlo así 00:16:36
sin excepciones, pero bueno 00:16:38
hay una forma más cómoda 00:16:40
que es, hombre, el next in 00:16:42
el next in está para algo 00:16:44
el next in está para leer un número 00:16:46
entero, porque voy a 00:16:48
coger yo aquí un next line 00:16:50
luego obligarme a la validación 00:16:52
No, dejo aquí mi next in 00:16:54
Y lo que hago es hacer una cosa que es 00:16:55
Voy a capturar la excepción 00:16:58
Es decir, aquí 00:17:01
Yo veo, porque soy muy listo 00:17:03
Y sé de qué va esto 00:17:06
Veo que puede haber una excepción 00:17:07
Puede haberla 00:17:10
Pues voy a decir, oye 00:17:11
En caso de que haya excepción 00:17:13
Haz esta otra cosa 00:17:15
Y ahí el programa no se para 00:17:16
¿Vale? Eso es lo que se llama 00:17:18
Capturar la excepción 00:17:21
Vale, ¿cómo se captura una excepción? 00:17:22
Pues el famoso bloque try-catch 00:17:25
Entonces, esto es una posible excepción sin capturar 00:17:27
Posible excepción sin capturar está así 00:17:31
Que ya sabemos el efecto que tiene 00:17:34
Si esa excepción llega, programa parado 00:17:36
Vale, pues ahora vamos a capturar la excepción 00:17:40
Variante excepción capturada 00:17:43
¿Cómo capturamos una excepción? 00:17:46
Bueno, pues el bloque básico, ya sabéis cuál es 00:17:56
try 00:17:59
entre llaves 00:18:00
pongo la o las 00:18:05
sentencias, pueden ser una 00:18:07
pueden ser muchas, la o las sentencias 00:18:09
que pueden 00:18:11
generar esa excepción 00:18:14
que pueden generarla 00:18:15
y ahora aquí catch 00:18:16
y aquí pongo 00:18:19
la clase de excepción 00:18:21
que podría generar 00:18:24
esta sentencia, en este caso 00:18:25
es esta 00:18:27
input mismatch 00:18:28
exception, vale 00:18:31
este error es cuando 00:18:33
se espera un tipo de dato 00:18:40
y en un escáner 00:18:42
y es otro, pero vamos, que eso es lo de menos 00:18:43
vale, pues entonces este sería un bloque 00:18:45
básico, que haría 00:18:52
oye tú, intenta hacer 00:18:54
esta excepción 00:18:56
que todo, perdón, esta sentencia 00:18:57
que todo funciona 00:19:01
sin ningún problema, genial 00:19:02
el programa 00:19:05
Continúa por aquí, y todo estupendo 00:19:06
Como si nada hubiera pasado 00:19:08
Vale 00:19:09
¿Qué ocurre si esto 00:19:12
Saca excepción? 00:19:14
Si esto saca excepción 00:19:16
Entonces se hace lo que haya en el catch 00:19:18
Y el programa 00:19:20
Continúa igualmente, o sea, no se para 00:19:22
En ningún caso, vale 00:19:24
Esa es la gracia 00:19:26
De capturar la excepción 00:19:30
Esa es la gracia 00:19:31
de capturarla, que el programa 00:19:34
no para en ningún 00:19:36
caso, salga excepción o no salga 00:19:38
a ver, la excepción 00:19:40
sale, porque es que la excepción 00:19:50
si next int tú le pasas un 00:19:52
jj, la excepción 00:19:54
el objeto se instancia 00:19:56
vale, pero ahora ya el comportamiento 00:19:57
no va a ser el comportamiento por defecto 00:20:00
que es, la máquina virtual te hace 00:20:02
un siso con los datos 00:20:04
y luego lo para 00:20:05
ahora ya, si la excepción sale 00:20:06
lo que se va a hacer es lo que 00:20:10
haya aquí dentro, si no hay nada no se hace nada 00:20:12
esto es lo que se 00:20:14
ejecuta 00:20:19
si salta excepción 00:20:20
ahora mismo con mi catch 00:20:25
no se haría nada y el programa 00:20:29
seguiría, vale 00:20:31
ese es el try catch 00:20:33
básico, vale, el try catch 00:20:37
básico, aquí 00:20:39
lo que pasa es que al hacer un try catch nos hemos 00:20:42
encontrado un primer problema, un try catch 00:20:44
abre un bloque 00:20:46
¿vale? un try catch abre un bloque 00:20:47
entonces al abrir un bloque 00:20:49
cuidado de nuevo con el ámbito de las variables 00:20:52
al abrir un bloque 00:20:54
si yo dejo la n 00:20:56
declarada aquí dentro 00:20:58
ya no va a ser accesible desde aquí 00:20:59
entonces cuidado cuando 00:21:02
abrimos los bloques 00:21:04
porque entonces ahora esto tendría que estar 00:21:05
declarado aquí 00:21:08
y aquí 00:21:09
simplemente dado su valor 00:21:12
¿vale? 00:21:14
Ya, ya, pero ¿por qué? 00:21:16
Claro. 00:21:19
Claro, pero ahora es por otra cosa. 00:21:20
¿Por qué cosa es ahora? 00:21:23
Claro, porque el try-catch 00:21:25
en realidad es como, 00:21:27
en cuanto a flujo, 00:21:29
es como si fuera un if. 00:21:30
Que es, oye tú, 00:21:32
intenta hacer esto. 00:21:34
Si tienes éxito, magnífico, 00:21:36
n se quedará con ese valor. 00:21:39
Pero si no tienes éxito, 00:21:40
te vas al catch, 00:21:43
que sería como el else. 00:21:44
Con lo cual, el compilador que te verifica que todos los flujos estén cubiertos, que ninguna variable se quede abandonada sin inicializar cuando tú la usas después, el compilador te dice, uy, perdón, aquí hay un flujo, aquí hay un camino en el cual la n podría no estar inicializada. 00:21:46
que es lo que hace el compilador, explorar todos los caminos 00:22:04
sean posibles, no lo sean 00:22:06
tengan sentido o no, el compilador 00:22:08
se hace ahí su grafo de caminos 00:22:10
y si en algún camino 00:22:12
alguna variable usada 00:22:14
está sin inicializar, la lía 00:22:16
bueno, pues con este try-catch acabamos de abrir 00:22:18
un camino en el cual n se quedaría 00:22:20
sin inicializar, que es el 00:22:22
camino n declarada 00:22:24
esto no se llega a 00:22:26
completar, porque ha saltado la 00:22:28
excepción en la mitad, no se llega a 00:22:30
completar, luego vamos por 00:22:32
aquí y aquí a la n 00:22:34
no se le hace nada, aquí a la n 00:22:36
no se le hace nada, con lo cual 00:22:38
me dice aquí, cuidado que 00:22:40
he detectado un camino en el cual n 00:22:42
podría no estar inicializada 00:22:44
¿vale? 00:22:45
vale, entonces bueno, ahora ya 00:22:48
entramos en el juego de que queremos hacer 00:22:50
que no queremos, depende de los requisitos de mi aplicación 00:22:52
¿vale? vamos a imaginarnos 00:22:54
que me dicen por 00:22:56
defecto, si tú no te das número 00:22:58
de candidatos, por defecto 5 00:23:00
candidatos, por ejemplo 00:23:02
Aquí ya entramos en todas las posibilidades 00:23:04
Que podríamos hacer con estas reglas del juego 00:23:07
Vale, pues por ejemplo 00:23:09
Por ejemplo 00:23:11
Si yo lo dejo así 00:23:12
N por defecto 00:23:14
Tendría 5 candidatos 00:23:17
Yo la leo 00:23:19
Si la lectura es correcta 00:23:20
Pues ya está 00:23:23
Serán los candidatos que me hayan dado 00:23:24
Y si no es correcta 00:23:26
Va a hacer esto de aquí 00:23:28
Que es nada 00:23:30
Y luego va a seguir 00:23:31
Con lo cual este programa no va a parar nunca 00:23:33
Por mucho que yo meta JJHH 00:23:35
Va a seguir, luego es mucho más robusto 00:23:37
Es mucho más robusto 00:23:39
Aquí por ejemplo, para que el usuario supiera 00:23:41
Podríamos avisarle 00:23:44
Se establecen 00:23:45
Los candidatos 00:23:48
A 5 00:23:50
Por defecto, por ejemplo 00:23:53
Vale, pues esto es mucho más robusto 00:23:55
Esto no se va a parar 00:23:58
Que tú no me das un número válido 00:23:59
No pasa nada 00:24:01
Yo lo dejo en 5 00:24:03
O en el que sea 00:24:05
Vale, ya ejecutamos este programa 00:24:07
¿Cuántos se presentan? 00:24:13
Bla, bla, bla 00:24:17
Vale, no me ha gustado 00:24:18
Pero yo no me paro ahí 00:24:20
No me ha gustado lo que me has dicho 00:24:21
Pero yo sigo 00:24:23
¿Veis? 00:24:25
La excepción se ha generado igualmente 00:24:30
Se ha instanciado el objeto 00:24:32
Pero esas letras rojas no me han aparecido 00:24:33
¿Vale? ¿Hasta aquí está claro? 00:24:36
Entonces ese es el bloque 00:24:48
try-catch básico, luego tiene 00:24:48
pequeñas variantes que podemos incorporar 00:24:51
¿vale? pero lo que importa es que el bloque 00:24:53
try-catch básico 00:24:55
lo que permite es que el 00:24:56
programa no se detenga aunque 00:24:59
salga una excepción, porque el 00:25:01
bloque try-catch es así 00:25:07
el catch es el que recibe 00:25:09
la excepción, recordáis 00:25:11
que he dicho antes que cuando este 00:25:13
se ejecuta erróneamente 00:25:15
genera el objeto 00:25:18
y lo entrega al programa 00:25:20
Pues ese va a parar ahí 00:25:22
¿El tipo de objeto de excepción tiene que ser igual a la excepción que es? 00:25:25
Igual o de una subclase 00:25:28
¿Vale? 00:25:31
Entonces si tú lo sabes 00:25:33
Si tú lo sabes lo pones tal cual 00:25:34
Si tú quieres capturar cualquier excepción que se genere 00:25:36
Pero que no te sabes los nombres 00:25:40
Puedes hacer esto 00:25:42
Porque excepción es la superclase de todas 00:25:44
Es la superclase de todas 00:25:48
Pero esto tendría un pequeño inconveniente 00:25:51
Ahora lo incorporamos 00:25:54
¿Vale? 00:25:56
A ver 00:26:04
¿Por qué se me ha vuelto a poner rojo? 00:26:05
¿Mis match? 00:26:07
No, no, es porque en el AH 00:26:09
No lo había puesto 00:26:11
Vale 00:26:12
Vale 00:26:13
Bueno, hasta aquí está claro 00:26:15
¿Vale? 00:26:20
Aquí lo único es que 00:26:24
Aquí vais a ver que en los cats 00:26:25
siempre se pone una cosa por defecto 00:26:27
porque cuando yo estoy haciendo un código 00:26:29
estoy en la fase de creación de mi código 00:26:31
lo estoy haciendo todavía 00:26:33
yo necesito toda la información posible 00:26:34
de por qué me pasan las cosas 00:26:37
entonces yo estoy probando este código 00:26:39
y en la prueba 00:26:41
he visto que algo raro ha pasado 00:26:44
porque se han establecido a 5 00:26:48
pero no sé exactamente 00:26:50
cuál ha sido el fallo, no lo sé 00:26:52
entonces en los cats 00:26:53
se suele poner 00:26:55
se suele poner esto normalmente 00:26:57
esta sentencia de aquí 00:26:59
¿vale? 00:27:03
esta sentencia de aquí 00:27:15
¿qué es lo que hace? 00:27:17
pues precisamente hacer un system out 00:27:19
con las famosas letritas rojas 00:27:21
es lo que hace 00:27:23
entonces viene muy bien 00:27:25
porque cuando tú estás probando tu código 00:27:26
vas a ver todos los detalles 00:27:29
de por qué te ha fallado, vas a verlo 00:27:32
entonces en tiempo 00:27:33
de escritura de código, estamos 00:27:35
analizando la aplicación, esto 00:27:37
conviene mantenerlo en todas las excepciones. 00:27:39
En todas. 00:27:42
Porque te permite sacar por consola 00:27:43
la información de qué ha pasado. 00:27:45
De qué ha pasado. 00:27:48
Si yo no lo tengo, que es como 00:27:50
teníamos antes, la excepción 00:27:51
ha saltado, pero 00:27:53
yo no he visto nada ahí, no he visto detalles 00:27:55
de esa excepción. Si ponemos esto, 00:27:57
¿qué es lo que hace esta 00:28:00
sentencia? Pues el objeto excepción 00:28:01
que es este, el objeto excepción 00:28:04
que me ha llegado del next in 00:28:06
el objeto excepción que me ha llegado 00:28:07
pues llama 00:28:09
a esto y que es lo que hace el print 00:28:11
de stack 3, muestra su contenido 00:28:13
interno 00:28:16
esto es lo que hace el print de stack 3, mostrar 00:28:16
el contenido interno de este objeto 00:28:19
entonces si 00:28:21
¿se inicializa eso con el error? 00:28:26
¿con el tipo de error? 00:28:31
¿se inicializa el qué? 00:28:33
el input mismas 00:28:34
Pero no he inicializado el qué 00:28:35
Pero es que este es el parámetro 00:28:41
Es una declaración del parámetro que recibe el catch 00:28:45
Es como una declaración del parámetro de un método 00:28:48
Vale 00:28:50
Entonces esto lo que significa es 00:28:51
Oye tú al catch 00:28:54
Tú vas a recibir 00:28:55
El objeto excepción 00:28:57
Que es de esta clase 00:29:00
Que es el que te habrá mandado este 00:29:02
vale, es como una declaración de parámetros 00:29:04
de un método, vale 00:29:07
entonces si ejecutamos ahora este código con el 00:29:08
print extract trace 00:29:11
pues ahora ya 00:29:12
veis, me sale esto 00:29:14
este es el print extract trace 00:29:18
el programa no para, el programa sigue, se establecen 00:29:19
a 5, dime nombre 00:29:22
pero me está mostrando 00:29:23
datos sobre la excepción 00:29:26
pues en qué momento del código fue 00:29:27
qué excepción fue 00:29:30
etcétera 00:29:32
luego esta sentencia 00:29:33
conviene ponerla dentro de los 00:29:35
catch de cualquier try catch 00:29:37
porque me va a dar información 00:29:39
por consola, no es que 00:29:41
pase, pero bueno 00:29:44
te va a facilitar el desarrollo del código 00:29:45
lógicamente, vas a saber cuando fallen las cosas 00:29:52
una cosa es que tengas una excepción 00:29:54
y otra cosa es que en un código normal 00:29:56
lo normal es que tú tengas 00:29:58
27.000 00:30:00
excepciones distintas 00:30:02
entonces si no 00:30:05
vas dando los detalles de cada una 00:30:06
pues depurar ese código es una 00:30:08
barbaridad 00:30:10
luego lógicamente 00:30:11
cuando ya este código está estupendo 00:30:14
perfecto, yo ya he pasado todas las fases 00:30:16
de prueba, me encanta como está 00:30:18
que bonito, y ya lo entrego 00:30:20
para que se suba a producción 00:30:22
y ya 00:30:24
lo empiece a usar la gente 00:30:26
entonces esto lo quito, lógicamente 00:30:28
porque si no lo quito 00:30:30
cada vez que el usuario meta mal el dato 00:30:32
Le sale esto 00:30:34
Que es muy feo 00:30:36
¿Vale? 00:30:37
Nosotros queremos que el usuario vea solamente esto 00:30:39
Se establecen a 5, dime nombre 00:30:42
No queremos que vea esto 00:30:44
¿Vale? Esto no lo queremos 00:30:45
Esta información nos viene muy bien a nosotros 00:30:47
Mientras estamos desarrollando y probando el código 00:30:50
Una vez que lo mandamos 00:30:52
Ya a producción para que 00:30:54
Los usuarios disfruten de él 00:30:56
Pues quitamos esas cosas 00:30:58
Claro, estas cosas las quitamos 00:31:00
¿Vale? 00:31:02
Las sustituiríamos por enviar a un fichero de log. 00:31:04
Pero bueno, eso ya lo dejamos para el año que viene. 00:31:10
¿Vale? 00:31:13
Vale, pues este es el try catch. 00:31:16
Entonces, en relación a la pregunta que hacía Nacho. 00:31:19
A ver, lo normal es que tú pongas aquí la excepción que te va a generar. 00:31:25
pero claro, las excepciones que hay muchísimas 00:31:34
son todas herederas de exception 00:31:38
hay tropecientas mil posibles excepciones 00:31:40
y heredan todas de la superclase de exception 00:31:44
entonces como ya sabéis 00:31:47
una variable cae en su clase 00:31:49
y en todas las superclases 00:31:54
entonces yo podría también ponerlo así 00:31:55
y ya está, y no pasa nada 00:31:58
podría dejar aquí exception 00:32:01
Podría dejar exception y vale 00:32:03
Y ya está 00:32:08
Porque tengo la seguridad de que el objeto 00:32:09
Que va a lanzar este 00:32:12
El objeto que va a lanzar es exception 00:32:13
¿Vale? 00:32:16
Claro, lo que no puedo es poner una excepción 00:32:18
Que este código no va a poder lanzar nunca 00:32:20
Por ejemplo 00:32:22
Array index out of bound 00:32:23
Era una excepción que es 00:32:26
Array index 00:32:27
Out of bound 00:32:29
Exception 00:32:33
Ah bueno, es que esta es 00:32:35
Pero por ejemplo 00:32:40
No, la voy a poner 00:32:42
Por ejemplo, esta es otra excepción 00:32:43
Otra excepción que está por ahí contemplada 00:33:00
Y o exception 00:33:02
Esta excepción es una excepción que sale 00:33:03
Cuando uno trata de leer de un fichero 00:33:05
Y no puede 00:33:07
Entonces yo aquí no puedo plantar 00:33:09
Captúramela y o exception 00:33:11
Me va a decir, perdona 00:33:12
Es que este bloque 00:33:15
Nunca te va a dar esta 00:33:18
Nunca te va a dar 00:33:20
entonces no me captures esa 00:33:21
¿vale? no me captures esa porque esa excepción 00:33:22
nunca te la va a provocar ese bloque 00:33:25
pero si yo pongo 00:33:27
exception aquí no hay ningún problema 00:33:29
porque exception es la super clase 00:33:31
y por tanto input type mismatch 00:33:33
exception 00:33:35
hereda de esta, entonces esto encaja perfectamente 00:33:36
¿vale? 00:33:39
claro, cuando tú hayas hecho pruebas 00:33:48
pues habrás visto cuál es 00:33:50
¿vale? 00:33:52
entonces cuál es el problema de poner 00:33:53
exception, tiene un pequeño 00:33:55
problema y es 00:33:57
que este bloque puede tener un montón de 00:33:59
cosas, yo puedo haber capturado 00:34:01
un bloque de golpe para no ir tricat 00:34:03
tricat por línea, entonces a lo mejor 00:34:05
este bloque me genera 00:34:07
un montón de cosas, por ejemplo 00:34:09
yo que sé, para poner aquí algo 00:34:11
luego lo, vamos a imaginarnos que 00:34:13
tenemos aquí un 00:34:15
un array 00:34:16
por poner algo, y ahora yo me voy a hacer aquí 00:34:18
Pues n de 0 00:34:36
Perdón, números 00:34:40
Números de 0 00:34:43
Igual a 0 00:34:46
A n 00:34:48
Vale, a ver, por ejemplo 00:34:49
Imaginaos capturar excepciones 00:34:53
De que yo me salga un array 00:34:56
Eso ya es demasiado 00:34:57
Normalmente 1 00:34:58
Es lo suficientemente cuidadoso 00:35:01
Cuando hace su código, asegurarse de que sus for 00:35:03
Y sus cosas no se salen del array 00:35:05
Pero bueno, por poner aquí el ejemplo 00:35:07
Aquí yo tengo dos sentencias 00:35:10
Aquí en principio habría dos posibles excepciones 00:35:12
Esta porque el tipo no case 00:35:16
Y esta porque yo me salga del array 00:35:21
Que de hecho me saldría 00:35:24
Si la hago aquí 00:35:26
Voy a poner la que estaba 00:35:28
Esta de aquí 00:35:31
Se llama así, ¿no? 00:35:32
Input type 00:35:40
O input mismatch 00:35:42
Exception 00:35:45
La he puesto bien, ¿no? 00:35:46
Vale 00:35:50
Vale, porque la había quitado del 00:35:50
Vale 00:35:57
Bueno, pues por ejemplo, yo ejecuto este código 00:35:59
Ejecuto este código 00:36:02
¿Cuánto se presenta? Le voy a poner el número 00:36:03
Bueno, vale, 6 00:36:07
Pues también 00:36:08
En este caso, ¿qué excepción me ha salido de aquí? 00:36:11
Esta no me ha salido 00:36:14
Porque esta lo he hecho bien, he puesto 6 00:36:15
Pero sin embargo aquí 00:36:17
Aquí sí que me ha salido excepción 00:36:18
Pero el catch no la ha capturado 00:36:20
No la ha capturado 00:36:22
Porque el catch sólo captura 00:36:24
La excepción que yo le ponga aquí 00:36:27
Sólo captura esta 00:36:29
Entonces el programa ha parado 00:36:30
Este programa mío terminó 00:36:32
Porque aquí hay dos posibles excepciones 00:36:33
Pero sólo está capturada la primera 00:36:36
¿Vale? 00:36:38
Entonces 00:36:41
¿Qué pasa si yo 00:36:42
Cambio y pongo esta 00:36:45
ahora ya este catch 00:36:48
me vale para las dos 00:36:54
porque las dos 00:36:55
la rain desbound exception 00:36:58
esta de aquí, la rain desoutbound exception 00:37:00
esta 00:37:02
y la 00:37:03
input miss match exception, las dos 00:37:06
heredan de exception, con lo cual 00:37:08
ahora este catch me vale para las dos 00:37:10
entonces si yo pongo exception 00:37:11
me da igual que la cague por aquí 00:37:13
que la cague por aquí, se va a hacer 00:37:15
esto 00:37:18
Y voy a seguir 00:37:18
Con el programa sin parar 00:37:20
¿Vale? 00:37:22
Es decir, yo ahora meto 00:37:24
Efectivamente 00:37:27
Aquí la he cagado 00:37:30
Aquí la he cagado 00:37:31
Pero el programa no ha parado 00:37:33
Me ha hecho el catch, lo ha capturado 00:37:35
Y ha seguido, dime nombre patatín 00:37:37
Luego en principio no podría pensar 00:37:39
Ah vale, pues mira, pongo aquí exception 00:37:42
Y genial, pase lo que pase 00:37:44
En el código que hay aquí dentro 00:37:46
pase lo que pase 00:37:48
voy a ir al catch 00:37:49
y el programa va a seguir 00:37:51
pero aquí es donde viene el pequeño problema 00:37:52
que es feo, claro, es que yo no 00:37:56
quiero tratar todas las excepciones 00:37:58
por igual, si pasa esto 00:37:59
quiero hacer una cosa 00:38:01
¿vale? pero es que fijaos lo que ha pasado 00:38:02
aquí me ha metido el número estupendamente 00:38:05
¿vale? imaginaos que este 00:38:07
catch fuera, se establecen 00:38:09
los candidatos por defecto 00:38:12
y yo pongo aquí 00:38:13
n igual a 10 que son los candidatos por defecto 00:38:14
por ejemplo, con lo cual ya no me hace falta 00:38:21
inicializarla 00:38:23
porque en cualquiera de los caminos 00:38:24
ahora ya el compilador ya le parece que tiene 00:38:26
valor, imaginaos que mi código es este 00:38:29
si salta 00:38:31
excepción se establecen por defecto 00:38:33
n igual a 10 00:38:34
vale, que he ganado poniendo excepción 00:38:35
una cosa buena he ganado 00:38:38
y es que si esta 00:38:40
funciona bien, pero esta casca 00:38:42
el programa no para 00:38:45
se va al catch y no para 00:38:46
luego en ese sentido es robusto 00:38:49
vale, pero jolín 00:38:50
¿a costa de qué? 00:38:52
de haber ignorado completamente el n 00:38:54
del usuario 00:38:56
porque la excepción me ha salido aquí 00:38:58
y yo lo he puesto aquí a 10 00:39:00
entonces esto tampoco está muy bonito 00:39:02
¿entendéis por qué 00:39:04
la solución de meter todas las excepciones 00:39:06
en el mismo saco 00:39:09
tampoco es buena? porque no las quiero tratar todas por igual 00:39:09
si la que me sale es esta 00:39:12
quiero hacer una cosa que es n igual a 10 00:39:14
pero si la que me sale es esta 00:39:16
entonces quiero hacer otra distinta 00:39:18
no quiero hacer el n igual a 10, la que me sale es esta 00:39:20
entonces 00:39:22
no las meto todas dentro del mismo paraguas 00:39:24
exception, ¿qué es lo que puedo hacer en este 00:39:26
caso? me hago tantos 00:39:28
cats como excepciones tenga 00:39:30
que ese es el try multi 00:39:32
cats, entonces 00:39:34
yo aquí me haría 00:39:36
primero mi cats para la 00:39:38
mismas exception 00:39:40
esta, que 00:39:42
Vale 00:39:50
Entonces, si la que me sale 00:39:53
Es esta, genial 00:39:56
Entra aquí 00:39:57
Y me hace el n igual a 10 00:39:58
Pero, ¿qué pasa si la que me sale es esta? 00:40:01
Si la que me sale es esta, también quiero 00:40:04
Capturarla, no quiero que se pare 00:40:06
Pues otro catch 00:40:08
¿Qué excepción era esta? 00:40:09
Esa era la de 00:40:12
La he quitado, array index out of bound 00:40:13
¿No? 00:40:16
Array 00:40:17
Index out of 00:40:18
bounce 00:40:21
excepción 00:40:24
y por ejemplo ponemos 00:40:26
no he podido 00:40:37
rellenar el array 00:40:38
ahora ya, bien, ahora ya esto está mejor 00:40:40
vale, las estoy tratando 00:40:45
por separado 00:40:47
vale, las estoy tratando 00:40:48
por separado 00:40:53
si este código me falla por la de arriba 00:40:54
me pone n igual a 10 00:40:57
si este código 00:40:59
me falla por la de abajo 00:41:01
no por esta 00:41:03
no me pone n igual a 10 00:41:04
luego el n será el que se haya recibido 00:41:06
aquí 00:41:09
y me hace lo que sea, en este caso 00:41:09
pues no he podido rellenar el array 00:41:12
¿vale? ya está 00:41:14
entonces la idea es 00:41:16
tratar a las excepciones por separado 00:41:21
¿vale? 00:41:23
entonces es un rollo porque hay que 00:41:27
saber de alguna manera que excepciones 00:41:29
generan nuestros códigos 00:41:32
pero no se capturan tampoco 00:41:33
lo que pasa es que 00:41:35
hay dos tipos de excepciones 00:41:37
Que eso bueno 00:41:39
Ya lo tenemos que ver el próximo día 00:41:41
Y las que no son obligatorias 00:41:42
De capturar como estas 00:41:47
Pues bueno 00:41:48
No se suelen capturar tanto 00:41:49
Capturar esta excepción repito 00:41:52
Por ejemplo es absurdo 00:41:56
Se supone que partimos 00:41:58
De que uno cuando está programando 00:42:00
Sabe hacer sus for y sus cosas 00:42:01
Para no salirse del array 00:42:02
Y sabe que hay un parámetro length 00:42:03
Con el que validar si te has salido del length o no 00:42:05
Entonces capturar esa excepción 00:42:08
es un poco raro 00:42:12
para muchas cosas 00:42:13
son 00:42:21
sobre todo 00:42:22
para 00:42:23
hacer el programa 00:42:24
robusto 00:42:25
en el sentido 00:42:26
de que no va a parar 00:42:26
porque pase algo raro 00:42:28
porque tú le estás dando 00:42:30
una vía alternativa 00:42:31
¿vale? 00:42:32
eso es lo fundamental 00:42:33
tú le das una vía alternativa 00:42:34
y en esa vía alternativa 00:42:35
en el catch 00:42:36
se lo vuelves a pedir 00:42:37
lo que tú quieras 00:42:38
¿vale? 00:42:39
eso por un lado 00:42:40
y luego por otro lado 00:42:41
intercambiarse información 00:42:41
entre clases 00:42:43
¿vale? 00:42:43
que 00:42:45
es que no 00:42:45
Vamos, que tenemos que continuar viendo 00:42:46
Lo que nos faltan cosas aquí 00:42:50
Lo que hemos visto hasta ahora es 00:42:51
La primera de las prestaciones 00:42:54
Que es evitar que el programa pare 00:42:55
Porque tú le das una vía alternativa 00:42:57
Y en esa vía ya lo que tú quieras 00:42:59
Meterte en el bucle para que te lo vuelva a pedir 00:43:01
Lo que tú quieras 00:43:04
Fijaros un valor por defecto, lo que sea 00:43:05
Tú ya juegas con eso como quieras 00:43:07
Aquí como veis, el compilador 00:43:08
Que es un pesado 00:43:12
El compilador solamente se hace 00:43:13
su grafo de caminos 00:43:15
y es que el compilador es 00:43:17
muy tonto porque 00:43:19
su grafo de caminos, aunque tú le pongas un if 00:43:20
con una condición que va a ser falso siempre 00:43:24
porque tú lo sabes, lo estás haciendo 00:43:26
va a ser falso siempre 00:43:27
el grafo de caminos considera que entras en ese if 00:43:28
pues aquí igual 00:43:32
al añadir yo este catch 00:43:34
el compilador 00:43:35
automáticamente ve 00:43:38
que se ha abierto otro camino 00:43:39
nuevo, tenemos este camino 00:43:42
este y este 00:43:43
su grafo de camino se ha ampliado con este 00:43:45
y en este n no tiene nada 00:43:47
con lo cual 00:43:50
el compilador aquí se nos ha vuelto a quejar 00:43:52
por este n 00:43:53
porque repito, el compilador no mira 00:43:54
significados 00:43:57
mira posibles caminos 00:43:59
aunque no sean 00:44:01
alcanzables, o sea, el camino de llegar aquí 00:44:03
sin tener n un valor 00:44:05
no es posible 00:44:07
porque llegamos aquí, se ha saltado esta excepción 00:44:08
y para haber saltado 00:44:12
esta excepción 00:44:13
esto tenemos que haberlo completado entero 00:44:14
con lo cual n tendría algo 00:44:17
entonces nosotros sabemos que 00:44:19
n siempre va a tener un valor para el compilador 00:44:21
¿no? pues entonces pues yo que sé 00:44:23
ponemos aquí 00:44:25
lo que sea, esto ya 00:44:27
lo que decidamos 00:44:28
en función de requisitos de la aplicación 00:44:31
¿vale? ¿hasta aquí está claro? 00:44:33
vale 00:44:39
bueno, pues mañana entonces seguimos 00:44:40
con esto de excepciones, que nos queda un poquito todavía 00:44:42
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 - 13:59
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
44′ 47″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
499.74 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid