Saltar navegación

20260318 SerializaciónObjetos_2 - 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 20 de marzo de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

vale 00:00:00
pues ahora 00:00:04
para que nos sirve 00:00:06
este object output string 00:00:08
pues nos sirve para usar tan 00:00:10
cómodamente como este método 00:00:12
el write object 00:00:14
y ya está 00:00:16
y este método write object 00:00:17
nos permite guardar 00:00:20
un objeto de 00:00:22
cualquier tipo en el 00:00:24
fichero, vale, nosotros que queremos 00:00:26
guardar, queremos guardar los 00:00:28
alumnos, vale 00:00:30
podríamos guardar el set 00:00:31
y es un objeto 00:00:34
con lo cual podríamos guardar directamente 00:00:35
el set entero, write object alumnos 00:00:38
vale 00:00:40
pero bueno, vamos a hacer otra cosa 00:00:40
vamos a guardar los alumnos 00:00:43
cada uno, uno por uno, pues venga 00:00:46
write object, vamos a hacernos aquí nosotros 00:00:48
nuestro bucle 00:00:50
para cada alumno 00:00:52
A en alumnos 00:00:56
ala, guárdate alumno 00:00:57
Y ya está 00:01:02
Y ahora ya aquí sí que queremos cerrar 00:01:03
Este y este 00:01:07
¡Hala! Ya están los objetos guardados 00:01:10
Aquí realmente 00:01:17
No nos haría falta 00:01:25
Haber hecho una referencia específica 00:01:27
Podríamos haber metido esto 00:01:30
Que es lo normal 00:01:31
Meter esto directamente aquí 00:01:33
¿Vale? No hace falta que lo hagamos 00:01:35
Con una referencia aparte 00:01:37
Metemos esto directamente aquí 00:01:38
Y ya está 00:01:40
Vale, pero bueno 00:01:42
Esto era para que quedara más claro 00:01:44
Vale, explotete salpica 00:01:46
Vale, entonces ya está 00:01:58
Guardar datos, ya está, nos ha aparecido el error 00:02:05
De oye, cuidado que puede salir una excepción 00:02:07
¿Qué haces? 00:02:09
Venga, vamos a capturarla, no vamos a hacer un 00:02:11
Throws, venga, vamos a hacer un try catch 00:02:13
Y vamos a decir 00:02:15
Aquí, pues 00:02:17
No se guardaron los datos 00:02:19
No se guardaron 00:02:25
Los datos 00:02:28
¡Hala! Pues antes de seguir 00:02:33
Vamos a probar 00:02:38
Esta aplicación 00:02:40
A ver si nos guarda los objetos en algún lado 00:02:40
He escrito cada objeto 00:02:43
Y ya está 00:02:51
Vale, pues volvemos a ejecutar esto 00:02:51
1, 2, 3, 4 00:02:57
Esta de aquí 00:03:02
5, 6, 7, 8 00:03:06
Este de aquí 00:03:08
Se va a matricular de programación 00:03:10
El primero de ellos 00:03:13
Y de nada más 00:03:15
Y el segundo se va a matricular 00:03:18
De bases de datos 00:03:20
Y de nada más 00:03:21
No se guardaron los datos 00:03:23
No se guardaron 00:03:26
No se ha salido una excepción 00:03:29
¿Vale? 00:03:31
Que dice 00:03:33
error de no serializable 00:03:35
oye, alumno 00:03:38
no es serializable 00:03:40
ay, que mal rollo nos da 00:03:41
no pasa nada, claro, alumno no es 00:03:44
serializable 00:03:46
porque yo no le he dado el rol de ser 00:03:47
serializable 00:03:50
ser serializable es que tú puedas 00:03:51
ser cogido por alguien 00:03:57
en este caso el object output stream 00:03:59
que es capaz de cogerte 00:04:02
y ponerte 00:04:04
en filita todos tus 00:04:06
bits, que en este caso serán los de 00:04:07
name, nombre y matrícula, ponértelos 00:04:10
en texto, no, aquí el texto 00:04:12
no existe, ponértelos todos 00:04:14
los bits que codifican este string 00:04:16
este nombre y esta matrícula 00:04:18
pues ponerlos todos en filita y sacarlos todos en filita 00:04:20
en fichero, entonces 00:04:22
para que object output stream 00:04:24
pueda hacer eso 00:04:26
tú tienes que 00:04:28
darle a este 00:04:30
el role, o tienes 00:04:31
que marcarlo como sujeto 00:04:34
poder ser serializado. Marcarlo de alguna 00:04:37
manera, darle ese rol. Porque 00:04:39
Object to Put String lo primero que hace es, lo que tú me has 00:04:40
dado, ¿tengo 00:04:43
yo permiso de serializarlo? ¿Tengo 00:04:45
yo permiso de hacerle ese pastiche 00:04:47
extraño? 00:04:48
¿Qué significa tener permiso 00:04:51
en Java? Pues tener ese rol. 00:04:52
¿Cómo se le da un rol en Java 00:04:55
a alguien? Implementando la 00:04:57
interfaz correspondiente. 00:04:58
Todo esto es diseño, porque está diseñado 00:05:01
así. Las interfaces significan 00:05:02
papeles que tú puedes 00:05:05
adoptar, cuando tú puedes adoptar 00:05:06
un papel se pueden hacer cosas contigo 00:05:08
te pueden hacer cosas, oye pues yo quiero 00:05:10
resulta que alumno 00:05:12
yo quiero que ahora vaya todo en filita 00:05:14
con todos sus bits hechos ahí 00:05:16
un desastre, quiero que vaya un fichero 00:05:18
pues si quiero que con los objetos 00:05:20
alumnos se pueda hacer eso 00:05:22
tengo que darle a este, ese papel 00:05:24
y como le doy a ese 00:05:26
esa capacidad o ese papel 00:05:28
implementando una interfaz 00:05:30
y como se llama esa interfaz 00:05:32
pues si no lo sé, casi que este me lo 00:05:34
acaba de decir y si no lo busco. Serializable. Implementar serializable es una interfaz sin 00:05:36
métodos en realidad. Por eso implementando serializable no me dice lo que me dice siempre 00:05:53
cuando implemento una interfaz que es pues tienes que implementar los métodos. No me lo dice porque 00:05:58
serializable no tiene métodos. Y diréis ¿y para qué vale? Es una marca. Es una marca para que el 00:06:03
Oye, da un put string 00:06:09
Diga, ah, vale, puedo actuar con este 00:06:12
Me han dado permiso 00:06:14
Es todo diseño, en realidad 00:06:15
Bueno, pues ya lo he marcado como serializable 00:06:17
Vamos a ver si ya no se queja 00:06:21
Se queja 00:06:23
¿Y qué dice ahora? 00:06:26
¿Seguro que dice lo mismo? Vamos a ver si dice lo mismo 00:06:29
A ver, la gestión es la misma 00:06:31
Vale, 5, 6, 7, 8 00:06:32
Nombre Luis 00:06:41
Le matriculamos 00:06:44
De prog 00:06:46
y le matriculamos de bases de datos. 00:06:47
No se pudieran guardar datos. 00:06:51
No es lo mismo porque antes me decía objetos alumno 00:06:53
y ahora me dice objetos matrícula. 00:06:56
Claro, porque alumno tiene dentro matrícula. 00:07:00
Entonces, serializar alumno implica serializar lo que tiene dentro. 00:07:03
Tiene dentro string, pero es que string ya es serializable. 00:07:08
String no es una clase que hemos hecho nosotros. 00:07:11
Si nosotros abrimos la clase string, 00:07:14
fijaos, ya implementa serializable 00:07:16
ya, ya 00:07:18
si implementa serializable, implementa 00:07:19
comparable, etc 00:07:22
pero matricular la acabo de hacer yo 00:07:23
entonces pues a matricular también 00:07:26
es que 00:07:28
la secretaria vaya tan por delante me pone 00:07:31
nerviosa 00:07:34
pues ya me va diciendo, pues si funciona 00:07:34
pues no funciona, pues no se que, pues me estreso mucho 00:07:38
serializable 00:07:44
Vale, entonces 00:07:45
Serializable 00:07:48
Que es de Havai 00:07:51
Vale, siguiente intento 00:07:51
Vamos a hacerlo cortito 00:08:01
NIF1, nombre 1 00:08:02
NIF2, nombre 2 00:08:04
Módulo P1 00:08:07
Se acabó 00:08:10
Módulo P2 00:08:12
Se acabó 00:08:13
Vale 00:08:15
¿Ha creado el archivo de objetos? 00:08:17
Pues vamos a refrescar 00:08:20
Refresh 00:08:22
Pues sí 00:08:24
En datos está alumnos.dat 00:08:25
Lógicamente uno no va y lo abre 00:08:28
Lógicamente, ¿por qué? 00:08:30
Porque 00:08:33
Esto es un editor de texto 00:08:34
Con lo cual solo es capaz de visualizar 00:08:36
Archivos de texto, ¿qué hace un editor de texto? 00:08:38
Uy, que se ha abierto ahí 00:08:41
¿Qué hace un editor de texto? 00:08:42
Pues te coge tu fichero, que son un montón de bits 00:08:46
Los va cogiendo de 8 en 8 00:08:48
Se va a la tabla ASCII 00:08:50
mira a ver esos 8 bits que codifican 00:08:52
y te planta el carácter 00:08:54
si el fichero es de texto, eso tendrá algún sentido 00:08:55
pero si el fichero no es de texto 00:08:58
eso no tiene ningún sentido 00:09:00
que es como ocurre aquí 00:09:01
el archivo es una serialización en bits 00:09:03
de ese int, de ese string 00:09:06
de todas esas cosas 00:09:07
y eso no codifica caracteres ASCII 00:09:08
con lo cual el editor de texto los ha cogido 00:09:11
de 8 en 8, los ha plantado 00:09:13
y esto no tiene ningún sentido 00:09:15
algunas cosas si son caracteres ASCII 00:09:18
pero otras no 00:09:20
entonces bueno, el archivo lo ha creado 00:09:21
los objetos están 00:09:26
pero ¿para qué sirven? 00:09:27
sirven para que otra aplicación 00:09:29
ahora ya los lea 00:09:32
o mi propia aplicación al principio 00:09:34
al arrancar, los lea 00:09:36
entonces 00:09:37
¿esta aplicación ahora cómo la 00:09:39
podríamos modificar para que tenga algún 00:09:42
sentido? pues que cuando la 00:09:44
aplicación arranca y el de 00:09:46
secretaría viene por 00:09:48
la mañana y va a matricular alumnos 00:09:50
nuevos o hacer lo que sea, pues si arranca su ordenador 00:09:52
y su aplicación, lógicamente quiere que la aplicación tenga 00:09:56
los alumnos del día anterior, que está en el fichero. Pues entonces 00:10:00
lo primero que tendrá que hacer este main es un 00:10:04
recuperar alumnos para leer del archivo 00:10:07
si existiera los alumnos que haya y ya 00:10:13
a partir de ahí, pues añadir alumnos o lo que toque hacer. 00:10:17
vale, pues vamos a hacer el recuperar 00:10:20
alumnos 00:10:27
bueno, recuperar alumnos 00:10:27
tiene sentido si el fichero existe 00:10:35
entonces vamos a hacerle el file 00:10:37
primero, se llama 00:10:39
fichero, ¿no? y ahora 00:10:46
ya sí, si el fichero no existe no hagas 00:10:52
nada más, si el fichero no existe 00:10:54
fuera, no hay nada que recuperar 00:11:03
pero si el fichero existe 00:11:04
pues ahora ya 00:11:07
sí, tendremos que abrirlo para 00:11:09
leer, pero para leer objetos 00:11:11
con lo cual será el object 00:11:12
input string, si el object output string era para escribir 00:11:15
el object input string es para leer 00:11:19
de nuevo el object input string no se asocia 00:11:23
directamente al nombre del archivo o al objeto file, se tiene que 00:11:37
asociar a un flujo de bytes básico de entrada 00:11:41
si el object output se asociaba a un file output string 00:11:44
que es el flujo básico de salida de bytes 00:11:49
Pues el object input se asocia 00:11:52
Al file input string 00:11:54
Pues vamos a ponérselo aquí directamente 00:11:56
Y así ni le creamos 00:11:58
Variable aparte 00:12:00
File input string 00:12:03
A ver que lo paso aquí abajo 00:12:05
Fichero 00:12:07
Vale, el object input string se asocia 00:12:13
A un flujo de bytes básico 00:12:20
Y excepción 00:12:22
Pues lo mismo, la propago 00:12:25
Y que ya el main 00:12:26
Decida que hace si no se pudieron 00:12:28
recuperar. Ahí se queda 00:12:30
propagada. Y ahora, 00:12:35
bucle de lectura. No sé cuántos 00:12:40
objetos alumno hay. 00:12:42
No lo sé. Bucle de lectura. 00:12:44
Pues 00:12:48
aquí hay alguna marca 00:12:48
cómo se hará la lectura. La lectura está claro 00:12:50
que se hará con algún read. Pues 00:12:52
justo, fíjate que tenemos 00:12:54
un read object. Va a ser que es ese. 00:12:56
Entonces, nosotros 00:13:02
queremos hacer varias veces lo de 00:13:03
amiset de alumnos 00:13:05
alumnos.add 00:13:07
el objeto este que estamos leyendo 00:13:11
o sea 00:13:16
esto 00:13:20
ahora corregimos este error de compilación 00:13:20
es leer objeto 00:13:23
añadir al set de mi aplicación 00:13:26
leer objeto, añadir al set 00:13:28
esto lo querré hacer yo 00:13:30
varias, un montón de veces 00:13:32
lógicamente 00:13:34
lo querré yo hacer un montón de veces 00:13:35
Sí, sí, sí, sí, no ves que está aquí en rojito 00:13:38
Sí, pero lo he dejado aparcado ahora 00:13:48
Lo he dejado eso aparcado por ahora 00:13:50
Lo que me interesa es la estructura del guay 00:13:51
Ahora arreglamos este error 00:13:54
Vale, entonces lo que yo querría hacer 00:13:55
Un montón de veces es 00:13:57
Leer objeto, añadir alumnos 00:14:00
Leer objeto, añadir alumnos 00:14:02
Leer objeto, añadir alumnos 00:14:03
Mientras que 00:14:06
Mientras no haya llegado al final 00:14:07
Aquí hay alguna marca de final en el read object 00:14:09
en realidad no hay ninguna marca 00:14:12
pero sí que va a ocurrir 00:14:13
que si el read object se intenta hacer 00:14:15
y yo ya estoy fuera, porque ya me he salido 00:14:18
me va a salir un 00:14:20
en odd file exception 00:14:21
entonces vía excepción podemos decidir 00:14:23
cuando hemos acabado y cuando no 00:14:26
por ejemplo así 00:14:28
boolean fin 00:14:29
inicialmente es falso, yo no he acabado 00:14:32
y ahora ya 00:14:34
mientras yo no haya 00:14:36
acabado 00:14:38
mientras yo no haya acabado 00:14:39
Intenta hacer esto 00:14:41
Intenta hacer esto 00:14:44
Pero si te sale 00:14:48
La excepción 00:14:50
En odd file 00:14:52
Exception 00:14:53
Si te sale esta excepción 00:14:54
Entonces 00:14:57
Yo aviso de que hemos llegado al final 00:14:58
¿Vale? 00:15:04
Esta es la maquinaria más bonita 00:15:08
¿Qué pasa? ¿No te gusta o qué? 00:15:09
Vamos a ver 00:15:12
Vale, entonces 00:15:13
este bucle es el más general que hay 00:15:21
lo podríamos usar 00:15:24
en más clases de lectura 00:15:26
y todo 00:15:28
entonces está todo el rato, ahora arreglamos este rojo 00:15:29
lee 00:15:32
y añade a la colección 00:15:34
lee y añade a la colección 00:15:36
si cuando 00:15:37
hagamos una lectura resulta 00:15:38
que esa lectura es imposible 00:15:42
porque estamos al final 00:15:43
irá aquí 00:15:44
pondrá fin igual a true 00:15:46
cuando el while vuelva ya está, ya no la más 00:15:49
Entonces nos quedará cerrar el flujo 00:15:51
Y fuera 00:15:54
End of file 00:15:54
Ahora, este rojo de aquí 00:16:02
¿Por qué es? 00:16:06
Porque el read object está declarado 00:16:07
Está declarado para que te devuelva 00:16:10
Un object genérico 00:16:12
Porque claro, el método read object 00:16:13
No se puede declarar 00:16:15
Un read object para cada clase 00:16:17
entonces si nos metemos en el método readObject 00:16:19
dentro de object.putString vemos que en su declaración 00:16:22
pone object 00:16:24
lógicamente, porque es un método que lee un objeto 00:16:25
no sabemos cuál, cada vez el que toque 00:16:28
entonces el compilador 00:16:30
te dice, perdona 00:16:32
esto es un set de alumnos, yo no puedo hacer 00:16:34
un add de algo que esté 00:16:36
declarado como object 00:16:38
yo solamente puedo hacer un add de algo 00:16:40
que esté como alumno 00:16:42
bueno, pues le hagamos un casting 00:16:44
un casting siempre es una cosa muy bestia 00:16:45
Pero en este caso se supone que 00:16:48
Controlamos que este fichero 00:16:50
Se ha hecho creando alumnos 00:16:52
O sea, insertando alumnos 00:16:55
Con lo cual ese casting va a funcionar 00:16:56
Entonces es que no hay tu tía 00:16:58
Tengo que hacer el casting, es que aquí no hay otra solución 00:17:01
Y esto ya se queda arreglado 00:17:03
Y el cierre este de aquí 00:17:10
Es que sois, perdón 00:17:12
Hoy sois 00:17:17
Vale 00:17:18
Y ahora el read object ya sí que me dice 00:17:22
Cuidado, te puedo dar una excepción 00:17:25
Pues venga, a propagarla 00:17:26
Ya tenemos ahí 00:17:28
200.000 excepciones 00:17:31
Vale, pues el método 00:17:32
De lectura de objetos del fichero 00:17:44
Estaría 00:17:45
Y sigo teniendo una cosa roja 00:17:46
Ah, claro, aquí, que al hacer el throws 00:17:51
Me dice, oye tú, recuperar alumnos 00:17:53
Pues venga, vamos a hacerle un try 00:17:55
Entonces, este es el try 00:17:58
Que me permite 00:18:01
Capturar cada excepción 00:18:03
por separado y para excepción dar un mensaje 00:18:05
distinto 00:18:07
pero a ver si soy vago 00:18:08
puedo hacer este sintaxis 00:18:11
que esta sintaxis en el mismo 00:18:14
catch me captura 00:18:18
todas 00:18:20
entonces aquí no podría yo distinguir 00:18:21
mensajitos, si es esta un mensaje 00:18:24
si es esta otra 00:18:26
pero bueno, en mi caso no lo voy a distinguir 00:18:27
voy a poner pues 00:18:30
error al recuperar 00:18:32
el alumnos 00:18:34
¿por qué ha sido? me da igual 00:18:37
ha habido un error al recuperar alumnos 00:18:38
ya está, vale 00:18:41
pues yo tengo un fichero ya de antes previo 00:18:47
el alumnos.dat 00:18:50
voy a ver si ahora esta aplicación 00:18:51
me los recupera correctamente 00:18:54
y los dos que me añada después 00:18:55
me los añade sobre el otro 00:18:57
vamos a ejecutarlo 00:18:59
venga, vamos a añadir otro 00:19:06
este que se llama 00:19:09
carlos 00:19:14
y ahora vamos a añadir al otro 00:19:16
esta 00:19:18
que se llama Luisa 00:19:20
vamos a matricular al primero 00:19:21
de sistemas 00:19:24
que será el tercero, porque hemos leído 00:19:25
dos previamente 00:19:28
y al segundo nuevo que he metido 00:19:28
lo vamos a matricular 00:19:32
de entornos 00:19:33
entornis me ha salido 00:19:36
da igual, fin 00:19:38
módulo 1, módulo 2, fin 00:19:39
porque me sigue 00:19:48
pidiendo más, ya tendría que haber acabado 00:19:50
Pues fin 00:19:52
Ah, porque me está pidiendo matrícula 00:19:54
Para los otros dos que había, claro 00:19:58
O sea, ya puedo 00:20:00
¿Vale? Es decir, está claro que me ha funcionado 00:20:01
Bien 00:20:04
Porque 00:20:05
Me lo está pidiendo para los cuatro 00:20:06
Vale, pues venga 00:20:10
A este le voy a matricular de cualquier cosa 00:20:12
De sistemas también, fin 00:20:14
Y al cuarto alumno 00:20:16
Le voy a matricular de cualquier cosa 00:20:17
Fin 00:20:21
y aquí están mis cuatro alumnos 00:20:21
los dos que estaban en el archivo 00:20:23
que los ha recuperado 00:20:26
correctamente 00:20:28
les ha cambiado la matrícula porque es que 00:20:29
como me piden matricular 00:20:31
a todos, pues otra vez 00:20:34
me han pedido matricular a los dos primeros 00:20:35
pero bueno, los ha leído del fichero 00:20:37
perfectamente 00:20:39
y estos son los dos nuevos que ha añadido 00:20:40
luego esto de leer 00:20:42
los objetos que había, los ha leído 00:20:47
¿vale? vamos a hacer 00:20:49
una última prueba 00:21:02
porque a veces una prueba puede ser de casualidad 00:21:03
nombre 00:21:09
nif 00:21:10
nombre 00:21:12
lo que se hace es que debe tener que matricular a 6 alumnos 00:21:15
pero bueno 00:21:19
el módulo 1, 1, fin 00:21:19
módulo 1 00:21:22
1, fin 00:21:24
1, fin 00:21:26
1, fin 00:21:29
a este no le matriculo de nada 00:21:32
y a este no le matriculo de nada 00:21:34
y aquí tengo mis seis alumnos 00:21:36
¿vale? 00:21:38
los cuatro que tenía 00:21:39
de las dos ejecuciones anteriores 00:21:41
con las cosas que les he 00:21:44
matriculado a lo tonto 00:21:46
y los dos nuevos 00:21:47
¿vale? aquí lo único 00:21:49
es que estoy trabajando 00:22:00
todo el rato con todos los alumnos en memoria 00:22:01
lo primero que hago es 00:22:04
vuelco la base de datos 00:22:05
digo base de datos entre comillas porque es un archivo 00:22:07
no es una base de datos 00:22:09
pero para mí está siendo como una especie de simulación 00:22:10
de base de datos, mi archivo 00:22:13
entonces vuelco toda mi 00:22:15
pseudo base de datos 00:22:17
la vuelco toda en un set 00:22:19
con el set ya hago lo que yo quiera 00:22:21
eso ya es Java, matriculo 00:22:23
desmatriculo, añado, quito, lo que yo quiera 00:22:25
y antes de irme cojo 00:22:27
todo mi set entero y se va para allá 00:22:29
eso es lo más cómodo 00:22:31
lo más rápido 00:22:33
porque todas mis operaciones con los alumnos 00:22:34
se hacen en memoria con los alumnos 00:22:37
es lo más rápido 00:22:39
pero tengo todos los alumnos en memoria 00:22:39
hasta 100.000 00:22:43
vale 00:22:45
de 100.000 para arriba 00:22:46
20.000 para arriba 00:22:49
depende de mi máquina 00:22:51
pues hombre, no es la idea 00:22:53
entonces en un instituto que no tenemos 00:22:55
100.000 alumnos 00:22:57
pues quizá esta sería la mejor opción 00:22:58
que la aplicación los vuelque todos 00:23:01
y luego ya pipipi, trabajamos con el set 00:23:03
a toda velocidad 00:23:05
en una aplicación que maneje 00:23:06
100.000 entradas de usuarios 00:23:09
de lo que sea, no los volcaría 00:23:11
a todos en un set 00:23:14
y trabajaría con ellos. 00:23:15
Directamente trabajaría con el fichero. 00:23:18
Como hacíamos con las líneas. 00:23:20
Voy leyendo objeto por objeto. 00:23:22
El que me interese, con ese hago los cambios 00:23:23
y lo vuelvo a guardar. 00:23:26
Etcétera. Trabajaría con el archivo. 00:23:27
No los volcaría a todos. 00:23:29
Con lo cual podría encontrar 00:23:32
algún problemilla, pero bueno. 00:23:33
Ya mañana o el viernes. 00:23:35
Venga, pues 00:23:39
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:
20 de marzo de 2026 - 13:42
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
23′ 40″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
99.15 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid