Saltar navegación

20250930-FicherosObjetos_3 - 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 30 de septiembre de 2025 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, pues ya está 00:00:00
entonces, no vamos a ponerle 00:00:02
módulos, porque a esta aplicación 00:00:05
se supone que habría que agregarle 00:00:07
que le agregaríais vosotros 00:00:09
una funcionalidad que es 00:00:11
agregar módulo a un alumno 00:00:13
agregar módulo a un alumno 00:00:15
entonces vamos a crearlo sin módulos y sin más 00:00:16
entonces su lista de módulos 00:00:19
que he puesto 00:00:21
setNif, porque he copiado y pegado 00:00:23
vale, entonces 00:00:25
Set nombre 00:00:27
Hay que ver 00:00:30
Que pendientes estamos de todo 00:00:32
Entonces este alumno 00:00:34
Se va a crear con su lista de módulos 00:00:36
Vacío 00:00:39
Esto a mi también me daba ansiedad el año pasado 00:00:39
Vale 00:00:42
Y a vosotros como 00:00:44
Contagio también 00:00:46
Una propiedad colección 00:00:47
Al menos instanciarla 00:00:50
Para no arriesgarnos 00:00:52
A los null pointer exceptions 00:00:54
Si alguien se pone a añadir así por las buenas 00:00:56
Al menos instanciarla 00:00:57
No es una mala costumbre 00:00:59
A ver 00:01:02
Es mala costumbre 00:01:04
En cuanto a que te compromete 00:01:07
Ya un tipo de estructura 00:01:09
Arraylist, linkedlist 00:01:11
Pero bueno, uno siempre podría sobreescribirla más adelante 00:01:12
Pero hombre 00:01:15
Cuanto menos 00:01:16
Nos arriesguemos 00:01:19
A un null pointer exception 00:01:20
Mejor 00:01:22
¿Vale? 00:01:23
¡Hala! Pues este es nuestro alumnito que le devolvemos aquí. 00:01:26
Ya hemos solicitado los datos. 00:01:34
Porque el null pointer exception seguramente sea la... 00:01:39
Si uno pudiera contabilizar todas las excepciones que han salido a lo largo de la historia de Java, 00:01:42
todo el mundo que ha programado en Java, 00:01:46
¿qué pena no poder hacer un histograma? 00:01:48
Seguramente null pointer exception tendría la delantera. 00:01:50
A ver 00:01:54
¿Dónde estábamos? Aquí 00:01:57
Solicitar datos 00:01:59
Y ahora ya sí que tenemos que insertar 00:02:00
Alumno 00:02:04
En el fichero 00:02:06
Ahora ya tenemos que meter 00:02:08
Al alumno en el fichero 00:02:13
Vale 00:02:15
Ah bueno 00:02:22
Perdona, perdona, perdona 00:02:28
Claro, sí, sí, sí, tienes razón 00:02:29
O sea, la aplicación está trabajando con el map 00:02:31
Perdona, claro, tienes razón 00:02:33
Entonces lo que tengo que instalar es en el map 00:02:34
En el fichero, claro, en el fichero lo mandaré 00:02:36
Claro, insertar alumno es que no me hace falta 00:02:38
Ni hacer un método aparte 00:02:41
Porque directamente pondría 00:02:42
En el map 00:02:45
Alumnos.put 00:02:46
Alumn.getNive 00:02:53
Alumn 00:02:58
Vale, ya está 00:02:59
Entonces efectivamente este método fuera 00:03:01
Ahora no pinta nada 00:03:03
Pintará cuando ya lo hagamos 00:03:06
Con un patrón de diseño un poco más decente 00:03:08
Porque os dais cuenta 00:03:10
De lo mal que estamos programando aquí 00:03:12
Estamos haciendo todos los métodos en el main 00:03:14
Según los vamos necesitando 00:03:15
No hemos hecho un diseño previo 00:03:17
Entonces esta aplicación que luego tenemos que ampliar 00:03:19
La va a ser un desmadre 00:03:22
Luego la vamos a intentar hacer con un diseño previo 00:03:23
Dime 00:03:26
Bajar hasta donde 00:03:26
Solicita datos, nada 00:03:30
Tiene el scan y devolver el alumno 00:03:33
Y ya está 00:03:35
No tiene nada 00:03:35
¿Vale? 00:03:38
Entonces efectivamente 00:03:40
Como bien has apuntado 00:03:41
Esta aplicación una vez que ha recuperado 00:03:43
A los alumnos en el map 00:03:46
Tendrá que preocuparse de cuando la aplicación 00:03:47
Termina, que es aquí 00:03:51
Guardarlos otra vez 00:03:52
¿Vale? En ese punto tendrá que guardarlos 00:03:54
Entonces 00:03:56
Aquí tendremos que 00:03:59
Guardar 00:04:04
Alumnos 00:04:06
Vale 00:04:09
Y ahora ya este método 00:04:10
Implica de nuevo 00:04:12
Que cojamos las clases de serialización 00:04:16
Guardar alumnos 00:04:18
Object output stream 00:04:23
Vale 00:04:25
Asociado a un flujo 00:04:44
New file output 00:04:45
stream 00:04:47
con el nombre del objeto 00:04:49
file, que era 00:04:51
fichero alumnos 00:04:53
y luego 00:04:55
podíamos poner opcionalmente 00:04:57
en el file output stream 00:05:00
un parámetro para 00:05:01
poner si queremos añadir 00:05:03
o sobreescribir enterores del principio 00:05:05
en este caso vamos a escribir 00:05:07
claro, pero en este caso tenemos 00:05:08
suerte, porque si no, tenemos 00:05:11
una movida, no queremos añadir 00:05:13
en este caso queremos todo el map entero 00:05:15
que tiene todos los alumnos, los nuevos 00:05:17
los que he quitado, todo el map entero, volcarlo 00:05:19
con lo cual podemos dejar 00:05:21
la variante 00:05:23
de format.string que no tiene ese parámetro 00:05:25
que es igual a tenerlo falso 00:05:28
es decir, no añadas 00:05:29
sobreescribe el fichero con todo este map entero 00:05:30
pero lo que si que tenemos que hacer es 00:05:34
los import y los 00:05:37
throws 00:05:39
y ahora ya si que si 00:05:40
Pues recorrer el map 00:05:51
De nuevo para irlos guardando 00:05:53
Pues venga, lo recorremos así a lo patatero 00:05:54
Otra vez 00:05:57
Para cada clave 00:05:58
Nuestros alumnos 00:06:03
Vamos 00:06:05
A escribir el objeto 00:06:07
Vamos a escribir 00:06:09
Alumnos.get 00:06:14
Nif 00:06:17
Lo próximo que pasa 00:06:19
sí, hace falta 00:06:20
un quesed 00:06:25
ala, los estamos escribiendo 00:06:26
uno por uno y cuando ya hemos terminado 00:06:32
fuera 00:06:34
guardar alumnos está 00:06:35
que lo haríamos 00:06:41
cuando salimos 00:06:44
si, eso 00:06:49
cuando lo hagamos con el patrón 00:06:53
lo vamos a ir haciendo añadiendo poco a poco 00:06:55
y ahí ya sí que tendremos que ver 00:06:57
que tenemos un problema con la cabecera 00:06:59
claro, y ese lo tendremos que arreglar 00:07:00
Aquí como lo sobre escribimos enterito 00:07:02
Ese problema no lo tenemos 00:07:04
Vale, entonces 00:07:05
Dime 00:07:09
Si, podríamos guardar el map entero 00:07:09
¿Vale? 00:07:16
Pero aquí lo quiero guardar uno por uno 00:07:18
Pues para que veamos 00:07:20
Que empecemos a intuir 00:07:22
Que habría una diferencia entre 00:07:24
Añadir, guardarlos todos 00:07:25
Y que esa diferencia tiene implicaciones 00:07:27
Lo veremos luego 00:07:29
Pero si, podría guardar el map 00:07:31
Un único great object 00:07:33
y luego cuando recuperara 00:07:35
haría un único read object 00:07:38
pero no habríamos tenido que hacer el buque de lectura 00:07:39
que yo si quería que hiciéramos el buque de lectura 00:07:42
para leer uno por uno 00:07:44
entonces 00:07:45
eso te vale 00:07:47
cuando tu aplicación usa un map 00:07:49
pero claro, puede ser que tu aplicación 00:07:52
guarde los alumnos 00:07:54
cada vez en una estructura 00:07:56
distinta, entonces si la aplicación 00:07:58
lo guarda cada vez en una estructura distinta 00:08:00
pues la idea es que tú los vayas añadiendo 00:08:01
Bueno, pues entonces antes de probarla para ver si esto funciona 00:08:03
Vamos a recuperar un alumno 00:08:09
Que recuperar un alumno pues no tiene nada 00:08:12
Porque aquí le pedimos el NIF del alumno 00:08:15
Leemos el NIF 00:08:20
Bueno, es que ni siquiera 00:08:23
Vamos a mostrar directamente al alumno 00:08:27
Alumnos.get 00:08:30
De scan.nextint 00:08:34
Nextline, perdón 00:08:39
Vale, pedimos el nif 00:08:41
Y con este nif 00:08:49
Indexamos en el map 00:08:51
Para sacar el alumno 00:08:53
Y con el system out 00:08:54
Pues nos lo muestra 00:08:56
Aquí no tenemos 00:08:57
Añadido nada de añadir un módulo 00:09:01
Para un módulo, pero bueno 00:09:03
Bueno, pues podríamos probar 00:09:04
Esta 00:09:07
Esta versión de la aplicación 00:09:08
A ver si funciona todo 00:09:13
Vale 00:09:14
A ver 00:09:18
Venga 00:09:21
Nombre de fichero alumnos 00:09:22
Alumnos.txt 00:09:25
Uy txt, bueno da igual 00:09:28
Venga 00:09:29
Vamos a insertar un primer alumno 00:09:32
Su nombre 00:09:34
Digo su nif 00:09:35
Su nombre 00:09:36
lo habrá insertado 00:09:38
va a un map, tampoco es que sea tan complicado 00:09:44
insertar, vamos a 00:09:46
mostrar el listado de alumnos 00:09:48
pues si, tenemos 00:09:50
este alumno 00:09:52
vamos a recuperarlo 00:09:53
por nif, 1, 2, 3, 4 00:09:56
está trabajando con el map, no tiene nada que hacer 00:09:58
vale 00:10:00
y vamos a insertar un segundo 00:10:01
para al menos tener 2 00:10:04
5, 6, 7, 8 00:10:05
nombre 00:10:08
Y ya está 00:10:10
Y aquí tenemos a los dos en el mar 00:10:12
Vale, aquí 00:10:14
Todavía no hemos guardado nada en el fichero 00:10:16
¿Cuándo vamos a guardar en el fichero? 00:10:18
Cuando demos a la opción 00:10:21
Salir 00:10:22
Aquí se supone que es la poca persistencia 00:10:23
Que tiene la aplicación 00:10:27
La hace aquí, la poca que tiene 00:10:28
Le damos a salir 00:10:30
Y esto ya lo sabíamos 00:10:31
¿Verdad? 00:10:34
Ya lo sabíamos porque se nos había olvidado 00:10:36
hacer a alumno 00:10:39
serializable 00:10:41
elements 00:10:43
serializable 00:10:45
vale, aquí 00:10:49
puede que haya llegado a hacer 00:11:02
el fichero 00:11:06
el object output string 00:11:08
puede que haya llegado a hacerlo 00:11:11
pero luego cuando ha intentado 00:11:12
hacer el great object es cuando le ha salido 00:11:15
el error, entonces ha llegado a hacerlo 00:11:17
y ya ha metido cosas 00:11:19
relacionadas con la cabecera 00:11:21
entonces este fichero ya se ha quedado 00:11:23
corrupto, porque no ha 00:11:25
entonces cuando trate de recuperarse 00:11:26
volvemos a arrancar la aplicación 00:11:29
él verá, existe y no es cero 00:11:31
pues intentará 00:11:33
leer de él y va a ser un desastre 00:11:35
claro 00:11:37
o sea, ahora si volvemos a arrancar la aplicación 00:11:39
ya al arrancarla 00:11:41
esto debería dar un error de partida 00:11:43
en cuanto le demos este 00:11:45
nombrecito, alumnos.txt 00:11:50
porque esto 00:11:52
ya es, pero que 00:11:54
basura me has 00:11:55
pasado aquí, esto que es 00:11:57
entonces, vamos 00:12:00
a eliminar este fichero 00:12:02
ok, vale 00:12:03
entonces, esto 00:12:10
funcionaría, alumnos 00:12:17
ahora, vale, insertamos 00:12:18
uno cualquiera, nif1 00:12:21
nombre1 y nos 00:12:23
vamos, vale 00:12:25
adiós 00:12:26
Vamos a recuperar ahora 00:12:27
Vamos a arrancar la aplicación 00:12:30
Otra vez 00:12:32
Arrancamos la aplicación 00:12:33
Venga, nombre del fichero 00:12:36
Alumnos 00:12:38
Vamos a ver si el alumno está 00:12:39
O sea, si esta aplicación realmente tiene 00:12:43
Esa pequeña persistencia 00:12:45
MIF 1.1 00:12:47
Pues sí 00:12:48
El alumno está 00:12:50
Vale, vamos a añadir otro nuevo 00:12:52
Alumno 2.2 00:12:57
Nombre 2-2 00:12:59
En el map está 00:13:01
Vamos a salir ya de la aplicación 00:13:04
Ahí está 00:13:08
Vale 00:13:10
La arrancamos otra vez 00:13:11
Nombre del fichero 00:13:14
Alumnos 00:13:17
A ver cuántos alumnos tengo 00:13:18
Ahí están 00:13:20
Vale 00:13:22
Con estas pruebas 00:13:23
Parece que más o menos 00:13:25
Funciona 00:13:26
¿significa eso que hayamos contemplado 00:13:28
todos los errores? seguro que no 00:13:31
si empezamos a hacer pruebas un poquito más 00:13:32
la tiramos seguro 00:13:35
aunque sea una aplicación de dos líneas 00:13:36
la tiramos fijo 00:13:38
por eso una fase de pruebas tiene que ser 00:13:40
larga y concienzuda 00:13:42
porque esto podrá tener 00:13:44
mil casos de prueba no contemplados 00:13:46
¿vale? 00:13:49
pero bueno, los arreglaríamos porque son muy listos 00:13:50
y no pasa nada 00:13:52
y esta aplicación nos ha metido 00:13:53
Que sería lo ideal que para practicar programación a vosotros y esas cosas 00:13:56
Pues hicierais por ejemplo esta funcionalidad 00:14:03
Porque seguramente luego cuando lo probéis ahí si que os vais a encontrar errores 00:14:09
Etcétera 00:14:14
Vale, pues la funcionalidad 4 00:14:16
¿Qué haría esta funcionalidad? 00:14:24
Pues esta funcionalidad tendría que solicitar un if y unos datos de módulo 00:14:28
Que los datos de módulo son nombre y nota solamente 00:14:39
Incorpora módulo a alumno 00:14:41
Y sería lo ideal que hicierais también el 5 que es listado de módulos de un alumno 00:14:50
Vale, aquí tendríamos 00:15:02
Caso 5 00:15:18
Que es dado nif 00:15:20
Listado módulos, pero vamos 00:15:26
Que esto 00:15:27
Esto no sería nada 00:15:28
Porque esto sería 00:15:33
Coger los datos y hacer 00:15:36
Al get un set 00:15:38
¿Verdad? 00:15:40
Al get por nif 00:15:42
Eh, sacar el get 00:15:43
De los módulos y hacerle el add 00:15:46
De los datos 00:15:49
Entonces esto lo podríamos hacer en una única línea, que fuera alumnos.get el nif que me han pasado y a este alumno yo le saco los módulos y le añado solicita datos. 00:15:50
Módulo 00:16:30
Método que haríais 00:16:32
Aquí fuera 00:16:38
Vale 00:16:39
Entonces 00:16:45
Se daría un NIF 00:16:47
Al alumno con ese NIF 00:16:52
Cogería su lista de módulos 00:16:54
Y le añadiría 00:16:57
El módulo 00:16:59
Que devuelve el método este 00:17:01
Solita datos de módulo 00:17:03
que no haría nada, nada más que pido los datos 00:17:04
y ya está 00:17:06
aquí claro 00:17:07
de nuevo forma de 00:17:09
aplicación 00:17:12
robustez cero 00:17:13
porque si el tío me metió un 00:17:16
if que no existe 00:17:18
aquí me sale un pedazo de null 00:17:19
entonces me sale 00:17:22
un pedazo de null 00:17:24
pointer exception cuando tenga 00:17:25
un red módulo 00:17:28
entonces aquí pues efectivamente 00:17:28
si esto no es null y si es null 00:17:31
Puede decir el NIF no existe 00:17:33
¿Vale? 00:17:35
Aplicación, acortamos código y hacemos algo 00:17:37
Lo menos robusto del mundo 00:17:39
Aquí hay un pedazo de null pointer de excepción ahí metido 00:17:40
Enorme 00:17:43
En cuanto el usuario meta un NIF 00:17:44
Que no existe 00:17:47
Bueno, pues entonces 00:17:48
Con esto 00:17:51
Tenemos una pequeña aplicación 00:17:53
Persistente que se cae por todas partes 00:17:55
Primero 00:17:58
La hemos hecho 00:18:00
Más cómoda imposible 00:18:02
todos los objetos, pum, todos al map 00:18:03
al arrancar, y si tengo un instituto 00:18:06
de 100.000 alumnos 00:18:08
pues un map de 100.000 00:18:10
pues no 00:18:12
muy mal eso, eso para empezar 00:18:13
y luego ya 00:18:16
salvando eso 00:18:18
¿qué diseño es este? 00:18:19
estamos mezclando vista 00:18:22
la vista es el menú con el switch 00:18:23
con la lógica 00:18:26
tenemos ahí los métodos 00:18:28
que por lo menos nos hemos dignado 00:18:30
a sacarlos fuera del main 00:18:32
pero es lo más a lo que hemos llegado 00:18:34
a sacarlos fuera del main, pero es que están aquí mismo 00:18:36
que es un desastre 00:18:38
es que de hecho 00:18:40
algunos ni los hemos sacado, o sea, aquí estamos 00:18:42
con la lógica de la aplicación 00:18:44
no la lógica de negocio, la lógica de la aplicación 00:18:46
aquí metida, y menos mal 00:18:48
que al menos hemos sacado una entidad fuera 00:18:50
pero vamos, que esta es una aplicación 00:18:52
que se cae por todos lados 00:18:54
entonces 00:18:55
aún así 00:18:57
podría ser una aplicación que tú se la das 00:18:59
un usuario y el usuario la usa 00:19:02
durante los 25 años restantes 00:19:04
de su vida sin tener ningún 00:19:06
problema y sin que le pase nada 00:19:08
pero ¿qué pasa? 00:19:09
si en algún momento de esos 25 años 00:19:11
ese cliente 00:19:13
necesita añadirle una funcionalidad 00:19:15
a esa aplicación 00:19:18
y te la devuelve 00:19:19
a los 10 años, oye añádenme esta pequeña 00:19:22
funcionalidad, ah sí, sí, sí 00:19:24
tú la abres 10 años después 00:19:25
no entiendes nada, eso es un desastre 00:19:28
el trabajador que te la hizo 00:19:32
ya lo has echado, lógicamente 00:19:34
porque si no hubieras tenido que subir 00:19:36
el sueldo demasiado en 10 años, lo has echado 00:19:38
y has cogido a uno de prácticas 00:19:40
que le estás pagando 00:19:42
una mierda y le sueltas esto 00:19:44
que está fatal hecho 10 años después 00:19:46
se vuelve loco 00:19:48
y dice, pero cómo voy a añadir yo una funcionalidad 00:19:50
nueva en esto que está hecho un desastre 00:19:52
la tiro a la basura y la hago de nuevas 00:19:54
con lo cual va a tardar 00:19:56
mucho tiempo, al jefe 00:19:58
tampoco le va a gustar que tarde tanto 00:20:00
y también le va a echar. 00:20:01
Entonces, ¿cómo? 00:20:04
Sí, ahora las cosas han cambiado 00:20:07
porque ahora tienes al esclavo. 00:20:09
Pero claro, el jefe sabe que tienes al char GPT 00:20:11
con lo cual va a esperar que lo hagas todo 00:20:14
muchísimo más rápido. 00:20:17
En cualquier caso, si partes de una aplicación de partida 00:20:19
bien diseñada y estructurada 00:20:21
lo vas a tener más fácil 00:20:23
para incorporar cualquier cosa nueva. 00:20:25
Bueno, pues en una aplicación que usa persistencia de datos, lo natural es que usemos un patrón de diseño de datos, perdón, un patrón de diseño, que es este patrón de aquí, ¿vale? 00:20:27
sería lo natural 00:20:45
que ya de partida incorporáramos esto 00:20:48
que es el patrón 00:20:51
de data 00:20:53
access 00:20:54
llegamos al object 00:21:03
que lo juro 00:21:05
menos que la O sea 00:21:07
sí, no, es que de repente 00:21:09
como que me ha venido un vacío a la mente 00:21:13
y me sonaba fatal 00:21:15
me sonaba fatal 00:21:17
pero no, es eso 00:21:20
Pero me ha venido como una laguna 00:21:21
Y yo, mal me suena 00:21:22
Pero no, no, es así 00:21:24
Vale, como nunca jamás 00:21:25
Uno lo deletrea, siempre dice 00:21:28
Sin más 00:21:29
Vale, entonces 00:21:30
Esto es un patroncito chorra, sin más 00:21:33
Es una forma de organizar las cosas 00:21:35
En una aplicación que usa persistencia 00:21:37
¿Significa eso que si una aplicación 00:21:39
Sigue el patrón, ya no pueda seguir ningún otro? 00:21:42
No, cada patrón 00:21:44
Se ocupa de organizar 00:21:45
Cuestiones diferentes 00:21:48
desde la aplicación. Este patrón se ocupa de organizar la parte de hacer persistencia 00:21:50
de los datos. Es decir, el CRUD, de esto se ocupa. ¿Y qué es el CRUD? Pues ya sabemos 00:21:58
que es crear datos, consultar datos, actualizar datos y borrar datos. Porque esto es lo que 00:22:09
con los datos. Eso es lo que 00:22:20
hacemos con los datos. No hacemos más que esto. 00:22:22
Pues este patrón 00:22:25
trata de 00:22:26
separar 00:22:28
estas funciones, 00:22:30
separarlas, y luego 00:22:32
tú ya las usas desde tu aplicación, 00:22:34
pero estás absolutamente abstraído 00:22:37
de la parte de la 00:22:38
persistencia que es esa. 00:22:40
Estás absolutamente abstraído. 00:22:42
En esta aplicación no lo estábamos. 00:22:43
Tenemos... 00:22:46
En esta aplicación no estamos 00:22:47
abstraídos porque 00:22:54
tenemos aquí metido el fichero 00:22:56
que yo de repente 00:22:58
cambio y ya esta aplicación 00:23:00
el usuario me ha dicho, el cliente 00:23:02
es que ya no son 20 alumnos 00:23:04
de repente he pasado a 20.000 00:23:06
por favor, cámbiame 00:23:08
la aplicación, tú tienes que moverla a una base 00:23:10
de datos, con la aplicación 00:23:12
hecha así, mover a una base de datos 00:23:14
implica hacer mil cambios 00:23:16
Con una aplicación hecha con un patrón DAO 00:23:17
Mover a una base de datos 00:23:20
Todo esto significa 00:23:22
No tocar la aplicación 00:23:23
Solamente tocar 00:23:25
Unas clasecitas que están ahí aparcadas 00:23:27
Solo tocar esas 00:23:29
Tu aplicación no se entera 00:23:30
Aquí esta aplicación se entera de principio a fin 00:23:32
Si yo tengo que cambiar una base de datos 00:23:34
¿Vale? 00:23:36
Bueno, pues entonces 00:23:39
Versión 2 00:23:41
que sí, que sí, tranquilos 00:23:50
pero bueno, podemos escribir la clase 00:23:55
¿no? bueno, espera, espera 00:23:58
versión, bueno, voy a hacer la clase 00:23:59
la aplicación 00:24:01
a ver, gestión alumnos 00:24:03
versión 2 00:24:06
esta sería la main 00:24:07
pero la main se va a apoyar en otras 00:24:09
¿vale? 00:24:11
vale, aquí vamos a 00:24:13
hacer nuestra nueva aplicación 00:24:15
esta aplicación 00:24:17
ya no lo va a tener aquí todo dentro 00:24:19
tendrá aquí 00:24:22
idealmente 00:24:24
la parte de la vista 00:24:26
¿vale? 00:24:28
pero la parte de acceso a datos 00:24:30
la sacamos fuera 00:24:32
¿vale? venga pues vamos a 00:24:34
a dejarlo aquí 00:24:38
vale 00:24: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:
6
Fecha:
30 de septiembre de 2025 - 18:58
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
24′ 44″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
473.28 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid