Saltar navegación

20251007 EjerDAO_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 7 de octubre de 2025 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues sí, eso no lo había pensado nunca. 00:00:00
No lo sé. 00:00:02
Se podrían medir los milisegundos. 00:00:07
Podríamos ponerlo en una línea y ponerlo así y medir los milisegundos que tarda. 00:00:10
O nanosegundos. 00:00:15
Pero bueno, los nanosegundos en una vida entera, ¿qué significa? 00:00:18
Venga, entonces, lo que he añadido simplemente. 00:00:24
la opción 4, insertar módulo en un alumno 00:00:27
entonces la opción 4, pide los datos del módulo 00:00:31
que es este método auxiliar para pedir el nombre y la nota 00:00:35
del módulo, sin más, pide el NIF del alumno 00:00:39
y ahora llama a este método 00:00:43
insert módulo del objeto este dado de aquí 00:00:45
este método de aquí, lo que pasa es que este método tenemos que implementarle 00:00:49
Tenemos los otros tres, pero nos falta este 00:00:55
Vamos a implementar este, ya el último 00:00:57
Y probamos la aplicación 00:00:59
Insertar módulo a un alumno 00:01:00
Entonces 00:01:03
Aquí abriríamos con 00:01:07
Object input string 00:01:10
Hola 00:01:12
¿Se puede? 00:01:14
Ay, Dios mío 00:01:18
Que generación esta, que nos va a llevar al desastre 00:01:20
Vale 00:01:23
Vamos a volver a 00:01:27
Vamos a volver a copiar esto 00:01:29
Porque estamos leyendo 00:01:32
Entonces voy a volver a copiar 00:01:34
Lo de recuperar por NIF 00:01:36
Y ahora ya modifico 00:01:38
Copio entre el recuperar por NIF 00:01:39
Porque estamos recuperando por NIF 00:01:43
Lo que pasa es que en este caso no para devolver 00:01:44
Sino solo para insertar 00:01:46
Entonces 00:01:49
Aquí si el fichero no existe 00:01:50
o la longitud es 0 00:01:56
no tiene sentido insertar módulo 00:01:58
entonces aquí podríamos, ya que tenemos 00:01:59
un void, vamos a aprovechar 00:02:02
y aprovecharle 00:02:04
en lugar de que estemos ahí perdiendo el tiempo 00:02:06
vamos a aprovecharle con un boolean que sea 00:02:08
true si te lo he hecho, false si no te lo he hecho 00:02:10
si devolviéramos algo 00:02:12
no nos quedaría más remedio que avisar con una excepción 00:02:14
pero como lo tenemos ahí desocupado 00:02:16
pues venga 00:02:18
ala 00:02:20
si no existe 00:02:22
falso, ahora vamos a ver que existe 00:02:24
pues recuperamos al alumno 00:02:26
y cuando ya tenemos al alumno 00:02:27
en lugar de mandarle 00:02:30
al resultado 00:02:32
en lugar de mandarle al resultado 00:02:33
lo que tenemos que hacer es 00:02:38
a.getModules 00:02:39
y con getModules 00:02:42
.addModule 00:02:44
y ya está 00:02:46
es lo que tenemos que hacer con él 00:02:47
y podemos irnos 00:02:49
Aunque esto es muy feo 00:02:55
Y si Rosa me viera 00:02:57
Me mataría 00:02:59
Pero no está 00:03:00
Así que voy a poner aquí un retuntru 00:03:02
Y ya está, ¿vale? 00:03:05
Y me piro de ahí 00:03:07
A ver, la verdad es que 00:03:08
Este es demasiado feo 00:03:11
Porque es que ni cierro el flujo ni cierro nada 00:03:13
No, es que hasta a mí me duele hacer esto 00:03:15
Con lo vaga que soy 00:03:17
Hasta a mí me duele 00:03:19
Entonces 00:03:20
Sí, pero 00:03:21
Puedo hacer un try cat 00:03:25
Sí, puedo leer 00:03:27
Este aquí dentro, dices 00:03:29
Sí, puedo hacer 00:03:31
Este try 00:03:33
Que lea el este dentro, pero bueno 00:03:34
Vamos a complicarlo 00:03:37
Y ya está 00:03:38
Sí, a ver 00:03:39
El try con recursos 00:03:43
Es una tontería 00:03:45
El try siempre lo usamos así 00:03:46
Pero el try se le pueden poner unos paréntesis aquí 00:03:48
Claro 00:03:51
¿y para qué se suele usar el try 00:03:53
con recursos? cuando tú dentro 00:03:56
del try vas a usar flujos 00:03:58
¿vale? entonces 00:04:00
pues puedes abrir 00:04:02
el flujo aquí, entonces ese 00:04:04
recurso en lugar de luego tener que cerrarlo 00:04:06
específicamente pues se cierra 00:04:08
automáticamente ¿vale? 00:04:10
entonces yo no lo tendría que 00:04:12
instanciar aquí, pero bueno 00:04:13
para no complicar este código 00:04:15
vamos ahora mismo a dejarlo, ya lo usamos en otra 00:04:17
ocasión 00:04:20
Entonces en lugar del return true 00:04:21
Que aquí no lo voy a hacer 00:04:24
Porque este se que me quedaría 00:04:26
Sin cerrar 00:04:28
Pues vamos a salir 00:04:29
Correctamente del try catch 00:04:32
Con su finally 00:04:34
Y el return 00:04:36
Ahora ya si que lo hacemos aquí 00:04:38
Y lo que si que ocurre 00:04:39
Es que hay caminos que se me han quedado 00:04:45
Sin return 00:04:46
Se me ha quedado sin return 00:04:47
Este 00:04:50
Si sale un error de estos 00:04:51
Yo quiero un falso 00:04:56
Y si sale un error de estos 00:04:57
Yo quiero un falso 00:05:02
Y ahora ya sí que tengo 00:05:03
Todos los caminos contemplados 00:05:07
No, ¿hay algún camino? 00:05:09
Me falta por contemplar 00:05:11
No, es que en el DAO 00:05:13
Ah, es por la clase DAO 00:05:15
Vale, vale, vale 00:05:18
Entonces, aquí 00:05:19
Esto es Boolean 00:05:21
Y en el DAO implementación 00:05:22
Pues listo 00:05:29
Vale 00:05:30
Ala, pues ya lo tenemos 00:05:33
Vamos a probar a ver si esto tiene algún sentido o no 00:05:36
Como el fichero ya es 00:05:39
Ah bueno, el cambio de la cabecera 00:05:42
Que para eso nos hemos hecho la clase 00:05:43
Ese cambio afectaba al save 00:05:45
A este de aquí 00:05:47
Al save del DAO implementación 00:05:49
Exacto 00:05:52
El save que está 00:05:54
Aquí 00:05:56
Entonces, ahora aquí sí que hay que hacer 00:05:58
Fichero 00:06:03
Alumnos 00:06:08
No, ¿cómo se llama? 00:06:11
Si fichero alumnos 00:06:14
Si fichero alumnos 00:06:15
Save 00:06:19
Aquí 00:06:21
No existe 00:06:22
O su longitud es vacía 00:06:25
Es igual a cero 00:06:33
Entonces 00:06:50
Efectivamente 00:06:52
este objeto de aquí 00:06:54
vamos a declarar la referencia afuera 00:06:56
y lo instanciamos dentro de 00:06:58
live, para 00:07:00
no hacerlo en un bloque local 00:07:01
a live, entonces la referencia 00:07:04
es un output stream 00:07:06
este es null y ahora 00:07:08
si el fichero 00:07:15
no existe 00:07:18
lo creamos 00:07:20
con la instancia original 00:07:22
pero si 00:07:26
si existe 00:07:28
entonces 00:07:29
lo creamos 00:07:30
donde me falta, no da igual 00:07:33
porque es la superclase 00:07:35
entonces 00:07:37
vale 00:07:39
o sea esta es superclase 00:07:41
de los dos 00:07:43
la referencia la pongo de la superclase 00:07:44
porque si no tendría que hacer dos referencias 00:07:46
bueno, poner el object que 00:07:48
la otra es subclase, también valdría 00:07:50
efectivamente 00:07:53
y si no, pues hacemos lo mismo 00:07:54
pero con la otra versión 00:07:57
Y ahora este de aquí 00:07:58
Sería object output string 00:08:07
Sin 00:08:09
Cabecera 00:08:10
Importado 00:08:13
Vale 00:08:25
Y esto de aquí es 00:08:26
El constructor no es visible 00:08:30
Me lo he puesto solo y no me he enterado 00:08:36
Vale 00:08:38
Ahora si es visible 00:08:39
Aún así tenemos 00:08:46
Ah, bueno, vale 00:08:48
Pues vais a tener razón 00:08:51
Object 00:08:53
Vale, por vaga 00:08:57
Venga 00:08:58
Vale, pues ya está 00:09:00
Ya está toda completa 00:09:06
Vamos a borrar el fichero viejo 00:09:10
De alumnos 00:09:13
El que estaba corrupto 00:09:14
Refresh, qué bien 00:09:18
Vamos a borrar los dos 00:09:20
Y ahora, a ver si somos capaces de que funcione todo sin ningún error 00:09:25
Fichero de alumnos 00:09:35
Alumnos 00:09:38
Insertamos uno 00:09:40
1, 2, 3, 4 00:09:41
1, 2, 3, 4 00:09:43
Recuperar alumno 00:09:44
1, 2, 3, 4 00:09:47
Este, vale 00:09:48
Vamos a insertar otro 00:09:50
2, 2, 2, 2, 2, 2 00:09:52
Aparentemente insertado 00:09:55
Vamos a ver si esta vez no ha corrompido el fichero 00:09:57
Vamos a recuperar el segundo 00:09:59
Perfecto 00:10:02
Si recuperamos el primero 00:10:04
También está 00:10:06
Luego insertar, recuperar 00:10:09
Con esa clase sin cabecera funciona 00:10:11
Y ahora vamos a hacerlo de dos módulos 00:10:14
Vamos a insertar 00:10:16
Un módulo 00:10:18
De nombre, tenía que haber puesto nombre módulo 00:10:18
Porque es poco explicativo 00:10:22
De nombre, datos 00:10:23
Y nota, un 10 00:10:25
¿A qué alumno? 00:10:27
1, 1, 1, 1 00:10:28
veremos a ver 00:10:30
y ahora 00:10:32
vamos a mostrar 00:10:34
la nota de el alumno 00:10:35
1111 00:10:38
en su módulo 00:10:40
datos 00:10:42
magnífico 00:10:44
no sé si es un error 00:10:47
con lo cual tenemos la oportunidad de ver que ha pasado aquí 00:10:48
porque el uso lo he hecho bien 00:10:50
había que pedirle 00:10:53
mostrar nota 00:10:54
no value 00:10:55
present en el optional, no ha 00:10:58
encontrado un módulo que se llame 00:11:00
datos, o sea 00:11:02
no lo ha debido insertar bien 00:11:04
ah, es que somos 00:11:06
bastante idiotas 00:11:08
sí 00:11:09
claro, es que, pero por qué no me decís las cosas 00:11:11
si las veis 00:11:15
cuando hemos hecho el método 00:11:16
insertar alumno 00:11:19
hemos recuperado al alumno 00:11:20
le hemos enseñado el módulo, pero luego ese alumno 00:11:22
no se ha ido al 00:11:24
al fichero, o sea que hay que ser tontos 00:11:26
¿no? está claro el problema ¿no? 00:11:28
es decir, no hemos actualizado 00:11:31
nada, vale, claro 00:11:32
es que lo hemos hecho todo así a lo 00:11:34
vale, entonces 00:11:36
aquí, insertar 00:11:40
módulo es un ejemplo de que estamos 00:11:42
modificando el fichero 00:11:44
luego aquí como trabajamos 00:11:46
con un 00:11:48
fichero temporal, recordáis 00:11:50
del año pasado ¿no? abrimos para leer 00:11:52
este 00:11:54
cada 00:11:55
objeto que vamos leyendo 00:11:58
si es el que tengo que modificar 00:12:01
o sea, si no lo es 00:12:03
lo escribo en el temporal tal cual 00:12:04
y si es el que tengo que modificar 00:12:06
lo escribo modificado 00:12:09
cuando ya hemos terminado, borramos el primero 00:12:10
y nombramos el otro 00:12:12
así es como trabajábamos cuando modificábamos un fichero 00:12:13
de acceso secuencial 00:12:16
entonces, aquí 00:12:18
insertar módulo 00:12:20
para leer 00:12:22
abrimos el primero 00:12:24
Pero tenemos que crear 00:12:25
Uno temporal para escribir 00:12:27
Output 00:12:30
Stream 00:12:37
New 00:12:39
File 00:12:41
Output 00:12:42
Stream 00:12:44
Pues 00:12:47
El nombre que nos dé la gana 00:12:48
Temp 00:12:53
Vale, entonces me he creado uno para escribir 00:12:54
Que es 00:13:00
El que va a ser el definitivo 00:13:02
Luego tendría que cambiarle el nombre y borrar el otro 00:13:04
Y esto 00:13:07
Está lógicamente 00:13:11
Sin declarar 00:13:12
OutputStream 00:13:14
Vale, aquí 00:13:23
Hace 00:13:25
No sé cuánto 00:13:30
Me encontré con una cosa curiosa 00:13:32
Que seguramente vosotros ya sabíais 00:13:34
Y yo no era consciente 00:13:35
Que como era un fichero auxiliar 00:13:37
Pues a mí no se me ocurrió otra cosa que llamarle 00:13:39
Aus al fichero 00:13:41
Pues fíjate por donde 00:13:43
aux es el único nombre de fichero 00:13:45
o uno de los poquitos que no puedo usar en Windows 00:13:46
porque aux tiene 00:13:49
un flujo propio 00:13:51
asociado para Windows, en Linux no habría 00:13:53
problema, puedes llamar a un fichero 00:13:55
aux, no pasa nada 00:13:57
pero en Windows no puede 00:13:58
si yo pongo aquí aux 00:14:00
pues va a dar un error, que encima el error es poco 00:14:03
explicativo, entonces 00:14:05
hasta que me di cuenta de que el problema 00:14:07
era que un sistema Windows 00:14:09
no admite un nombre de fichero aux 00:14:11
Porque ya tiene su propio flujo asociado 00:14:13
Pues 00:14:15
Perdí ahí unos cuantos minutos 00:14:16
Vale 00:14:19
Ahora 00:14:20
¿Qué vamos a hacer con cada alumno? 00:14:22
Leemos alumno 00:14:26
Si es el que tenemos que modificar 00:14:27
Lo modificamos 00:14:29
Bueno, no hace falta 00:14:31
Y luego ya 00:14:34
Ese alumno se va al fichero 00:14:37
De maniobras 00:14:39
O el temporal 00:14:41
Right 00:14:41
object 00:14:45
a, vale 00:14:47
entonces el fichero temporal 00:14:50
se va quedando 00:14:53
con 00:14:55
todos los alumnos 00:14:56
leemos alumno, si hay que modificarlo 00:14:59
se modifica y se va al temporal 00:15:01
entonces el fichero temporal ya se queda 00:15:03
con todos los alumnos modificados 00:15:06
lo que pasa es que claro, hay que eliminar el temporal 00:15:07
y cambiar el nombre al otro, pero para eso tenemos 00:15:10
los métodos de file 00:15:12
o los de path 00:15:12
Entonces cuando ya hemos terminado 00:15:17
Y ya tenemos todos los flujos cerrados 00:15:20
Que será aquí 00:15:22
Ya tenemos todos los flujos cerrados 00:15:24
Que ya será aquí 00:15:29
Ahora ya solamente nos falta 00:15:30
Borrar y renombrar 00:15:32
Entonces vamos a tener que hacer 00:15:37
Venga vamos a hacerlo con pad para variar 00:15:38
Pad fichero 1 00:15:42
Fichero original 00:15:44
Igual a 00:15:48
Pads.get 00:15:56
Y aquí el nombre de mi fichero 00:15:58
Que es 00:16:03
Bueno, lo que pasa es que el original 00:16:04
Es el fichero alumnos 00:16:08
Entonces 00:16:11
La verdad es que 00:16:12
Como ya lo tengo en file el fichero alumnos 00:16:14
La verdad es que es un poco tontería 00:16:16
Voy a hacer el file del otro y ya está 00:16:18
El original es el que tiene los datos originales 00:16:19
Fichero alumno 00:16:24
Sí, ese, ese, claro 00:16:25
Bueno, el que yo estoy llamando original es a ese 00:16:28
Vale, entonces 00:16:31
El fichero temporal 00:16:32
Es igual a new file 00:16:33
De tem 00:16:38
Y ahora 00:16:40
¿Qué tenemos que hacer? 00:16:42
Pues vamos a 00:16:45
Cambiar el nombre 00:16:46
De fichero alumnos 00:16:48
bueno antes vamos a borrar 00:16:50
porque si no el sistema operativo colapsaría 00:16:53
en un agujero negro 00:16:55
dime 00:16:57
porque es que no tengo esa referencia 00:16:57
de antes, la unidad que tengo 00:17:01
era para el 00:17:03
object output string aquí 00:17:05
y en el object output string 00:17:06
se lo he dado directamente 00:17:11
entonces como no tengo la referencia file la tengo que 00:17:12
hacer abajo 00:17:15
aquí es que no puedo abrirlo 00:17:15
simultáneamente el mismo para leer y escribir? 00:17:21
Sí, no. 00:17:23
O sea, file 00:17:28
no, file es un puntero 00:17:30
a un recurso 00:17:32
del sistema de archivos con esa ruta. 00:17:34
Pero no lo modifica ni le toca 00:17:36
ni hace nada. Entonces 00:17:38
lo primero que vamos a hacer va a ser 00:17:40
borrar el original 00:17:42
que es fichero alumnos. 00:17:44
Fichero alumnos punto fuera. 00:17:48
Este fuera. 00:17:50
Y ahora al temporal 00:17:52
Vamos a cambiarle el nombre para que se llame como el original o el del principio. 00:17:54
Y ya está. 00:18:06
Fichero TEM hace referencia al nombre TEM. 00:18:15
Y ahora, ese recurso del sistema de archivos que ahora mismo está con el nombre TEM, 00:18:21
pues ese recurso del sistema de archivos, renómbralo con el nombre que tiene este recurso del sistema de archivos. 00:18:25
Ese recurso ya no existe, pero nos da igual. 00:18:30
Es que claro, si no hubiéramos hecho el delete antes 00:18:33
El sistema operativo colapsaría 00:18:35
Porque diría, tengo dos recursos, no puedo 00:18:37
¿Vale? 00:18:39
Pero sigue asociado al nombre 00:18:41
Aunque ya vas a hacer un punto delete 00:18:42
Claro, yo he hecho un punto delete 00:18:45
Pero el objeto file sigue existiendo 00:18:47
Asociado a ese nombre, al nombre alumnos 00:18:49
Aunque ese recurso ya no existe 00:18:51
Claro, ese recurso ya no existe 00:18:54
Pero sigue asociado al nombre alumnos 00:18:55
Entonces 00:18:57
Entonces, los alumnos que no has añadido un módulo 00:18:58
No son alumnos 00:19:01
Sí, porque los estoy escribiendo igualmente aquí en este if. Es decir, yo leo y todos ellos los escribo. Leo y escribo. Solo alguno de ellos lo escribo además con una modificación. Pero leer y escribir, leer y escribir, leer y escribir se hace con todos. Pero si alguno fuera el del if correspondiente, ese además hay una modificación previa antes de escribirlo. 00:19:02
Claro, es que insert módulo a un alumno 00:19:28
implica, yo abro el original 00:19:35
con todos los alumnos 00:19:37
voy cogiendo cada uno de ellos 00:19:38
¿Tengo que modificarte? No, te pasas al temporal 00:19:40
¿Tengo que modificarte? No, te pasas 00:19:43
¿Tengo que modificarte? Sí, te modifico 00:19:45
y te paso, y ahora ya 00:19:47
borro este y renombro este 00:19:48
y el efecto final es 00:19:50
que están todos los alumnos tal cual, salvo uno 00:19:52
que se ha copiado o modificado 00:19:55
Bueno, creo que es lo que he hecho 00:19:56
Entonces, aquí 00:20:03
Si solo creas alumnos sin añadirle módulos 00:20:06
No estás siempre tirando de alumnos 00:20:15
Si solo creas alumnos sin añadir módulos 00:20:17
Bueno, crea alumnos sin módulos 00:20:21
Es que no te entiendo la pregunta 00:20:25
Sí, o sea, la aplicación siempre usa... 00:20:26
Claro, en cuanto hay una modificación, 00:20:30
pero tira en ese momento, 00:20:34
crea un temporal 00:20:36
y luego le cambia el nombre. 00:20:36
O sea, el fichero físicamente se ha movido, 00:20:39
pero cuando ese método ha terminado 00:20:41
se sigue llamando como se llamaba, 00:20:43
con lo cual la aplicación le da lo mismo. 00:20:45
¿Vale? 00:20:47
Entonces, 00:20:50
estos deletes 00:20:53
son peligrosos 00:20:54
porque 00:20:57
solamente, este 00:20:58
delete de hecho 00:21:00
devuelve un boolean, un boolean que te dice 00:21:02
si realmente lo ha borrado o no 00:21:05
porque borrar un fichero no es tan fácil 00:21:07
solo lo va a borrar 00:21:09
si el fichero está absolutamente soltado 00:21:10
de todos los que 00:21:13
navegan por ahí 00:21:15
claro, entonces 00:21:16
en este caso nosotros lo hemos soltado 00:21:18
sí 00:21:21
Debería poder ser cerrado 00:21:22
Pero si hay algún otro proceso para que lo tenga abierto 00:21:24
Yo es que con los deletes 00:21:26
Esto siempre me vuelvo loca 00:21:28
Porque 00:21:30
A veces me funciona, a veces no 00:21:31
Entonces aquí siempre hay que asegurarse de que 00:21:33
Lo tenga uno todo bien cerrado 00:21:35
Como tengas algo abierto y no te hayas dado cuenta 00:21:38
Ya lo han liado 00:21:41
Ahora mismo lo tengo todo cerradísimo 00:21:41
Vale 00:21:44
Venga, vamos a volver a 00:21:45
Dime 00:21:48
Sí, aplicaciones como esta 00:21:48
Podemos poner muchas 00:22:03
A ver, aquí no hay ejercicios cortos 00:22:05
¿Vale? 00:22:09
Entonces, enunciados de aplicaciones 00:22:11
Para que hagan cosas 00:22:14
Claro que sí 00:22:15
Vamos a ir dejando continuamente 00:22:16
Más del resto del contenido 00:22:18
Que de esto, porque esto de ficheros 00:22:21
Pues tampoco quiero que perdamos demasiado tiempo 00:22:23
Porque no lo vais a usar mucho 00:22:26
pero eso sí, no son ejercicios 00:22:27
de programación que se hacen en un PIPAS 00:22:30
si queréis practicar tenéis que 00:22:32
hacerlos, claro 00:22:33
claro 00:22:35
sí, pero ya es pues eso 00:22:37
una aplicación, un ejercicio 00:22:40
corto es que no se puede hacer 00:22:42
claro 00:22:43
sí, hay que hacer métodos 00:22:44
que hagan cosas y para probarlos pues tienes que 00:22:49
hacer, vale, pero sí 00:22:51
tranquilo que si quieres podrás practicar 00:22:53
vale 00:22:56
Estamos diciendo que ahora sí 00:22:57
Que vamos a probar esta cosa 00:23:01
Ya teníamos un fichero de alumnos 00:23:02
Que no se había tocado 00:23:14
Porque el alumno no hacía nada 00:23:15
Así que vamos a seguir usando ese 00:23:17
Vamos a ver 00:23:19
Uy, es que le he dado aquí sin querer 00:23:21
Vamos a ver si siguen estando los alumnos que estaban 00:23:22
Efectivamente 00:23:25
Sigue estando este 00:23:27
Y sigue estando 00:23:28
Este otro, pero que no tenía módulo 00:23:31
Porque el insertar no funcionaba 00:23:33
Vamos a ver si ahora podemos insertar algo. Nombre de módulo. Nota. NIF del alumno. Al primero de ellos. Bien. Entonces, este lo esperábamos. 00:23:34
Sí, lo esperábamos 00:23:55
Porque yo todo el rato me he ido dejando 00:23:59
No, alumno serializable 00:24:01
Pero cuando me he ido a serializable 00:24:05
Yo lo he ido dejando 00:24:06
A ver si en algún momento conectabais 00:24:07
¿Recordáis? 00:24:09
Alumno serializable 00:24:11
Pero es que alumno tiene módulos dentro 00:24:12
También tienen que ser serializables 00:24:15
Y módulo no lo he puesto serializable 00:24:17
Pero este error no es peligroso 00:24:20
Porque es que me lo dice tal cual. 00:24:23
Me dice módulo no es serializable. 00:24:26
¿Vale? 00:24:29
Entonces, aunque se me haya olvidado. 00:24:29
Pero yo cuando uso una lista, ¿cuándo sería? 00:24:31
Cuando guardas una lista entera de... 00:24:33
¿Cuándo se guarda la lista de alumnos? 00:24:45
No sé exactamente. 00:24:53
No lo sé. 00:24:56
Podríamos probarlo. 00:24:56
Pero eso no ha quedado hecho. 00:25:00
Puede ser que no. 00:25:01
Porque la forma en la que lo envuelve la lista, no lo sé. 00:25:02
No sabría responderte ahora mismo. 00:25:06
Serializable 00:25:08
Pero bueno, es que este lo estamos 00:25:10
Serializando específicamente 00:25:14
Más que nada que nos ha salido el error 00:25:15
Pues bueno, vamos a 00:25:17
¿Eh? 00:25:18
Vale, cuando una clase 00:25:27
La hacemos que implemente serializable 00:25:30
Nos suele salir un aviso 00:25:32
Amarillo 00:25:34
En realidad este aviso siempre lo ignoramos 00:25:35
porque nosotros ya usamos 00:25:38
nuestras propias claves en realidad 00:25:40
este aviso amarillo está relacionado 00:25:42
con cuidado 00:25:44
con una idea básica 00:25:46
cuidado cuando tus objetos 00:25:48
se van a sitios 00:25:50
que no son tu aplicación 00:25:52
sea bases de datos o sea 00:25:53
ficheros, cuidado 00:25:56
porque deberías mantener la unicidad 00:25:57
un criterio de unicidad de todos ellos 00:26:01
cuidadín 00:26:03
de ahí las claves primarias, de las bases de datos 00:26:03
etcétera, para meter la audiencia. Normalmente 00:26:07
uno ya se gestiona esas cosas 00:26:09
y nosotros lo estamos gestionando con el 00:26:11
NIF, que no sé yo si es una 00:26:13
elección muy buena para una clave primaria 00:26:16
pero bueno 00:26:18
entonces este te dice, oye 00:26:20
igual puedes añadir 00:26:21
un parámetro 00:26:24
que es el parámetro 00:26:26
la clave de serialización 00:26:28
que 00:26:30
va a ser único 00:26:31
y esa clave de serialización 00:26:33
pues clases 00:26:35
que serializan 00:26:38
usan métodos que a lo mejor 00:26:39
lo necesitan y necesitan 00:26:41
la garantía de que sea único 00:26:44
va un poco por ahí, pero normalmente 00:26:45
normalmente uno gestiona 00:26:47
sus propios criterios de seguridad con sus propias claves 00:26:49
otra cosa es que tú de repente 00:26:52
incorpores un framework o algo 00:26:53
que te exija que esté 00:26:55
ese parámetro, que te lo exija 00:26:57
¿vale? pues si te lo exige lo pones 00:26:59
en algún caso, ahora mismo 00:27:01
no me viene a la cabeza cuál 00:27:04
pero en algún ejemplo de alguna cosa que usamos 00:27:05
en algún momento más adelante, una muy específica 00:27:08
como eso no tengas 00:27:10
este parámetro aquí 00:27:12
de serialización, se queja 00:27:14
porque lo usa específicamente 00:27:16
¿vale? entonces 00:27:17
haberlo puesto aquí me vale 00:27:21
para algo, para quitar el amarillo ahora mismo 00:27:23
porque no lo estamos usando y nadie lo está usando 00:27:25
pues para eso vale 00:27:27
para quitar el amarillo 00:27:29
venga, pues 00:27:30
vamos a 00:27:34
siguiente intento de ejecutar 00:27:36
aquí a lo mejor ya se nos ha roto el fichero 00:27:38
Pero cuando he intentado escribirlo, no sé si ya se habrá roto el fichero. 00:27:41
Vamos a ver. 00:27:46
Espera, vamos a... 00:27:48
A mí aquí, cuidado, porque es que para que el delete funcione, asegurar de que están todos los procesos cerrados. 00:27:52
¿Ves a decir algo? 00:27:59
¿Es que se refiere hasta cuando vas a crear un repositorio y Bernatel que te pide que pongas la clave primaria? 00:27:59
No me refiero a eso. 00:28:09
Cuando lleguemos a eso 00:28:10
Lo sacas, acuérdate 00:28:12
Para, yo estaba pensando en otra cosa 00:28:14
Pero eso puede ser también 00:28:17
Una oportunidad pues para ver 00:28:19
Una forma de usar ese parámetro 00:28:20
¿Vale? 00:28:22
Vale, pues venga 00:28:25
Ejecutamos esto 00:28:27
Ahora sí que sí, fichero 00:28:28
Alumnos, vamos a ver si se ha 00:28:30
Roto el fichero 00:28:33
Un, dos, tres y cuatro 00:28:34
Parece que no se ha roto 00:28:36
Un, dos, tres y cuatro 00:28:39
Parece que no se ha roto 00:28:41
Ahora sí que vamos a insertar 00:28:43
Un módulo 00:28:44
A ver si ahora ya lo hacemos bien 00:28:46
Nota 10 00:28:48
NIF de alumno 00:28:50
El adiós es por 00:28:52
Algún break se me ha escapado en el switch case 00:28:56
Porque si no 00:28:58
No se da cuenta de que saca el adiós todo el rato 00:29:01
Vale 00:29:03
Ya hemos insertado y ahora vamos a mostrar 00:29:04
Ahora ya sí que va a llamar a toda su sucesión 00:29:07
De funciones lambda 00:29:09
del alumno 1111 00:29:10
el nombre de módulo datos 00:29:12
un 10 00:29:14
que con estas pruebas 00:29:16
garantizamos que lo hemos hecho perfecto, no 00:29:18
seguro que nos podemos hacer más pruebas 00:29:20
y empiezan a salir errores por todos lados 00:29:21
pero lo que nos interesa a nosotros 00:29:24
lo que de alguna manera queríamos hacer 00:29:26
suficiente 00:29:28
vale, pues entonces 00:29:29
la visión general de lo que es 00:29:34
un DAO está claro, no 00:29:36
aquí ya casi 00:29:37
Lo único que nos ha quedado un poquito feo 00:29:42
Y vamos a dejar 00:29:44
Vamos a intentar dejarlo un pelín más bonito 00:29:45
Antes de irnos 00:29:48
Lo que nos ha quedado un poco feo 00:29:49
Es esto de 00:29:52
Espera, voy a asegurarme con el refresh 00:29:53
De que ha borrado el temp 00:29:59
Que ni me ha 00:30:00
¿Veis? El delete ha funcionado 00:30:02
Porque me ha borrado el temp y ha quedado solo alumnos 00:30:07
De hecho, si no, no me habría hecho lo de recuperar correctamente 00:30:09
Bueno, todo funciona estupendo 00:30:12
Pero que es un poco feo de esta aplicación 00:30:13
Bueno vamos a darle a salir 00:30:16
Lo que es un poco feo 00:30:19
De esta aplicación 00:30:23
Es que cada vez que la arranquemos 00:30:24
Porque 00:30:27
Tenga que llegar alguien ahí 00:30:28
Entonces cuando se reinician los servidores 00:30:30
Pues se inician por la noche 00:30:32
Entonces si tienes que pagar a un tío que está ahí por la noche 00:30:34
Para cuando se inicia el servidor 00:30:37
Y la aplicación meter el nombre del usuario 00:30:38
Verte el nombre del fichero 00:30:40
Pues no te sale rentable 00:30:42
claro 00:30:43
lo natural es que los parámetros 00:30:45
de configuración 00:30:48
inicial de una aplicación 00:30:51
no los dejas meter tú a mano 00:30:53
que esté en un fichero y tú lo leas 00:30:54
claro, lo podríamos hacer patatero 00:30:56
meterlo en un fichero y leerlo con un file reader 00:30:58
pero hombre, primero 00:31:00
aparte de que es patatero, como es algo 00:31:02
que se hace tanto 00:31:04
tener parámetros de configuración en un fichero 00:31:05
es algo que se hace tanto, pues ya hay una clase 00:31:08
que te facilita 00:31:11
tanto escribir parámetros de configuración 00:31:12
como leerlos, que es la clase 00:31:15
properties, que lo que te facilita 00:31:17
es leer y escribir 00:31:19
en los famosos ficheros properties 00:31:21
o de propiedades 00:31:23
entonces aquí lo ideal es que uno 00:31:24
dijera, vamos a ver 00:31:27
¿cuáles son los parámetros 00:31:28
de inicialización de esta aplicación? 00:31:30
este sencillo, el nombre del fichero 00:31:33
solo el nombre del fichero 00:31:35
pero podrían ser muchos, podrían ser 00:31:36
la URL de la base de datos, el puerto, el usuario 00:31:38
podrían ser muchos 00:31:41
En este caso es el nombre del fichero 00:31:42
¿Vale? Pero ese 00:31:44
Único dato vamos a ponerlo 00:31:46
En un fichero de propiedades 00:31:48
Aparte no lo vamos a tener al tío ahí toda la noche 00:31:49
Para escribir esto 00:31:52
Pues venga 00:31:53
Nos hacemos un fichero de propiedades 00:31:55
Que debería estar en el pad 00:31:57
Del sistema 00:32:00
Aquí como todavía 00:32:02
No hemos metido una estructura 00:32:04
De maven 00:32:06
Pues para asegurarnos de que está 00:32:07
en el path del sistema, vamos a poner el raíz 00:32:10
y ya está 00:32:12
pero cuando ya necesitemos dependencias 00:32:13
y ya le demos a este fichero para facilitar 00:32:16
eso, una estructura de maven, pues hay una 00:32:18
carpeta específica para ese tipo de recursos 00:32:20
que está en el path, etc. 00:32:22
pero ahora mismo no tenemos esa estructura 00:32:24
tenemos la por defecto de Eclipse 00:32:26
entonces, para que la máquina 00:32:28
virtual encuentre ese fichero 00:32:30
sí o sí, sin problemas 00:32:32
vamos a ponerlo en la carpeta 00:32:34
que esté en el path, recordad que el path 00:32:36
para la máquina virtual 00:32:38
son todas las rutas 00:32:40
de las cuales cuelgan 00:32:42
paquetes o clases que necesitan 00:32:44
bueno, pues el raíz 00:32:46
está en el path 00:32:48
y no solo el raíz 00:32:49
sino también estos paquetes 00:32:52
también están en el path, etc. 00:32:54
entonces vamos a poner en el raíz 00:32:56
directamente un ficherito que es el de propiedades 00:32:58
y no pasa nada porque 00:33:01
está en el raíz, en el raíz de las aplicaciones 00:33:04
van muchos ficheros de configuración 00:33:06
si no tienen un 00:33:08
ni maven, ni gradle, ni nada de eso 00:33:09
Venga, vamos a ponerle aquí un fichero 00:33:11
Venga 00:33:14
Pues nada 00:33:17
Normalmente este fichero 00:33:19
Tiene como extensión properties 00:33:21
¿Vale? 00:33:25
0 properties 00:33:29
¿Es necesario 00:33:30
Que se llame con extensión .properties? 00:33:33
Pues no 00:33:36
Porque luego la clase properties 00:33:37
Ya cuando lo abramos 00:33:39
Ya le decimos como se llama y todo 00:33:41
Pero de nuevo, si todos nos ponemos de acuerdo en que los ficheros de propiedades tengan extensión properties, cuando tú vas a abrir una aplicación de alguien y quieres ver su configuración inicial, buscas un fichero que se llame properties. 00:33:42
Si nos llega la gana llamarlo hola Pepito, pues el que abre la aplicación no se le pasaría por la cabeza que hay en hola Pepito. 00:33:57
Si le llamamos properties sí que se le pasa. 00:34:04
Pues ahora, los ficheros de propiedades, para que la clase properties los maneje, tienen un formato que es propiedad, igual valor, propiedad, igual valor, propiedad, igual valor, cada una de una línea diferente. 00:34:07
Bueno, pues aquí qué única propiedad nos interesa, el nombre del fichero, ya está. 00:34:23
Pues venga, esa propiedad la vamos a llamar 00:34:27
Fichero, por ejemplo 00:34:30
Y aquí 00:34:31
Y aquí pongo yo el valor que yo quiera 00:34:34
A la alumnos 00:34:38
Ya está 00:34:40
Que dentro de tres días 00:34:41
Ha cambiado mi fichero de alumnos 00:34:44
Lo cambio aquí 00:34:46
En el properties 00:34:47
Y no tengo que tener a un tío cada vez que arranca la aplicación 00:34:48
Metiéndolo 00:34:52
Bueno, pues entonces 00:34:52
Ahora lo único que ocurre es que cuando la aplicación 00:34:56
Arranca 00:34:58
En el punto en el que arranca 00:34:58
Que en este caso mío es aquí directamente 00:35:01
En lugar del 00:35:04
System.out.println que es horrible 00:35:06
Y el scan.nestline y todo esto 00:35:08
Que es horrible 00:35:10
Me voy a abrir 00:35:11
Una clase 00:35:13
Properties 00:35:16
¿Vale? Que esto está en Java 00:35:17
Útil, a ver, voy a ver si me acuerdo 00:35:28
De memoria y si no 00:35:30
Lo chuleteamos 00:35:31
¿Vale? Y esta clase 00:35:33
Es la que te permite trabajar 00:35:37
Con ficheros de properties 00:35:39
Entonces lo primero que hay que hacer 00:35:41
Es cargarlo 00:35:44
Para lo cual 00:35:47
Tendrá un load 00:35:50
Y aquí le tenemos que pasar 00:35:50
El file input string asociado al fichero 00:35:53
Pues no pasa nada 00:35:56
Le paso yo el file input 00:35:58
String 00:36:00
Asociado a mi fichero 00:36:04
De propiedades 00:36:06
Que se llama en mi caso 00:36:07
Lo he llamado 00:36:09
Conv.properties 00:36:10
Vale 00:36:13
Entonces este nombre 00:36:14
Si que no va a cambiar nunca 00:36:16
Uno hace la aplicación y este nombre 00:36:18
Permanece siempre así 00:36:19
Por tanto no tenemos que reescribir este código 00:36:21
No se como lo he llamado 00:36:24
Lo he llamado fichero.properties 00:36:27
Vale 00:36:29
Pues entonces 00:36:32
Aquí file input string 00:36:33
A ver 00:36:36
Decíais que 00:36:45
Si no me lo ofrece aquí porque tengo 00:36:46
Alguna otra cosa rara o lo que sea 00:36:49
Que hay un atajo para que lo importe 00:36:50
Lo decías tú antes 00:36:52
¿Cuál? 00:36:53
Vale, los atajos me dan 00:36:58
Un miedo siempre, pero bueno 00:37:03
Algunos están bien 00:37:04
Vale 00:37:06
Vale, pues entonces ahora 00:37:09
una vez que lo tenemos cargado 00:37:11
ahora ya podemos sacar la propiedad que nos dé la gana 00:37:13
con getProperty y la clave 00:37:15
la clave como se llamaba 00:37:18
la clave la hemos llamado fichero 00:37:20
getProperty 00:37:21
y le damos la clave 00:37:23
y ya está 00:37:25
y esta propiedad 00:37:27
ya es el string valor 00:37:28
entonces la podemos ya poner aquí 00:37:31
alumno de implementación 00:37:33
new file 00:37:36
y le pasamos esto 00:37:37
vale 00:37:41
este te puede lanzar lógicamente 00:38:00
una excepción y aquí 00:38:03
aquí lo único es que 00:38:13
uno ya decide 00:38:17
pues que hace, si no puedes cargar 00:38:17
el fichero, no vas a poder, la propiedad 00:38:21
no va a ser correcta, entonces aquí 00:38:23
no hace falta que lo pongamos 00:38:24
o bien 00:38:25
le dices al usuario 00:38:27
me falta parámetro de configuración 00:38:30
introdúcelo o cerramos la aplicación 00:38:32
por falta de fichero 00:38:35
de configuración, lo que uno decida 00:38:37
podemos aquí decirle 00:38:39
directamente 00:38:44
le podemos, mala, para que 00:38:45
me faltan datos de inicio 00:38:48
y le hacemos un 00:38:52
system.exit 00:38:56
y a tomar por saco 00:38:58
vale, pues esto sería mucho mejor 00:39:00
que cambio el 00:39:18
fichero de alumnos en algún momento, lo cambio 00:39:19
en el fichero de configuración 00:39:21
Y ya está 00:39:23
¿Vale? 00:39:24
Eso sí, la aplicación la tendría que recargar 00:39:28
¿Vale? 00:39:31
La aplicación la tendría que recargar 00:39:33
Pero bueno, eso lo hago 00:39:35
En el momento en el que yo cambio esto 00:39:37
Porque cargo la aplicación 00:39:39
Porque no se recarga automáticamente 00:39:40
El properties 00:39:43
¿Vale? 00:39:45
Y ya está 00:39:49
Ya está, ya está 00:39:50
Vamos a ver que no hayamos escrito algo mal 00:39:55
En el properties 00:39:59
No hemos debido escribir algo mal 00:39:59
Porque 00:40:02
Porque ha entrado 00:40:03
Entonces sí 00:40:05
Ha leído bien del properties 00:40:08
Y ya está 00:40:10
¿Vale? 00:40:12
Venga, pues ahora ya sí que 00:40:17
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
2
Fecha:
7 de octubre de 2025 - 13:44
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
40′ 20″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
178.70 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid