Saltar navegación

20260323 FicherosObjetos_AppReservas_5 - 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 23 de marzo de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues para eso vamos a hacer un reservadao también 00:00:00
Para sacar a una clase aparte todos los métodos relacionados con gestionar los datos 00:00:07
De reservas, los datos 00:00:13
Y ya mi main que lo llame y ya está 00:00:15
Mi main o mi interfaz o lo que sea 00:00:17
Entonces, estructura que vamos a hacer 00:00:19
Pues dentro del dao este 00:00:21
Un new reservadao 00:00:23
Vale 00:00:36
Y ahora, este reservadao como va a tener los métodos 00:00:37
se accedan a los datos, sus propiedades, la información que la caracteriza, 00:00:45
está relacionada con la ubicación de los datos, donde están los datos. 00:00:51
Entonces, el fichero de reservas también lo tiene que tener ahí. 00:00:54
Igual que tenía el de destino, su fichero de destino, de destinos, pues este igual. 00:00:57
Vamos a ponerle una propiedad que sean los datos de las reservas y ya está. 00:01:06
Uy, ¿dónde estamos? Vale. 00:01:13
pero hemos dicho 00:01:21
asumimos 00:01:23
que no tenemos miles 00:01:25
de reservas 00:01:27
somos una empresa pequeñita, no tenemos miles 00:01:28
entonces la gestión de los datos 00:01:31
en lugar de cada inserción 00:01:33
cada eliminación, ir al fichero 00:01:34
y hacerla, que es 00:01:37
costoso de alguna manera en tiempo 00:01:39
vamos a cargar todos los datos 00:01:41
y que la gestión de los datos se haga 00:01:47
en la memoria principal de mi aplicación 00:01:48
eso sí, cuando la aplicación se cierre 00:01:50
o en el momento que yo decida 00:01:52
o a lo mejor puedo programar yo cada 5 minutos 00:01:54
cuando sea, pues que se guarde 00:01:57
¿vale? 00:01:59
pero toda mi gestión de inserciones 00:02:01
que se haga en RAM que es muchísimo más rápido 00:02:03
el único precio que pago 00:02:05
es que tengo la RAM ocupada con muchos datos 00:02:06
pero hombre, tendrían que ser muchísimos 00:02:08
para que no me compensara 00:02:10
la rapidez de la gestión de un map o de un list 00:02:12
respecto a accesos al fichero 00:02:14
entonces vamos a poner 00:02:16
vamos a ponerlo aquí 00:02:18
también los datos con los que van a acceder 00:02:19
los métodos, pues hemos dicho que van a hacer un map 00:02:24
para optimizar las búsquedas 00:02:28
las modificaciones, vamos a poner 00:02:32
un map donde la clave del map sea el código 00:02:41
de la reserva porque es lo que lo identifica de forma única 00:02:45
luego la clave del map es de tipo long 00:02:48
Recordad que los tipos genéricos no pueden ser primitivos 00:02:52
Tienen que ser siempre tipos objeto 00:02:59
En este caso reserva es long que es primitivo 00:03:00
Pero tiene su envolvente objeto long con mayúscula sin problema 00:03:04
Y el valor de este map es esto 00:03:09
Vale 00:03:11
Ahora para que ahora yo pueda hacer los métodos de insert de lo que sea 00:03:13
Esos métodos tienen que tener 00:03:26
Esto ya relleno 00:03:29
Con los datos 00:03:30
Pues todo eso lo puedo hacer en el constructor 00:03:32
¿Vale? Cuando se instancie el DAO 00:03:34
Que es el que luego va a llamar el 00:03:37
¿Vale? 00:03:38
Pues cuando se instancie el DAO 00:03:43
Pues a este DAO 00:03:45
Se le pasará el fichero 00:03:51
Donde están los datos 00:03:52
Se le pasará el fichero 00:03:57
Y ahora 00:03:59
Data Access Object 00:04:01
es el acrónimo 00:04:09
habitual que se le pone como coletilla 00:04:10
a las clases 00:04:13
que se ocupan de esa parte 00:04:14
del acceso a los datos 00:04:16
que están por ahí 00:04:18
y que mi aplicación 00:04:19
necesita, vale pues entonces 00:04:22
cuando instanciemos 00:04:25
este objeto, que es el objeto que nos va a permitir 00:04:26
acceder a los datos, cuando lo 00:04:29
instanciemos, se rellenará 00:04:30
esta propiedad imprescindible 00:04:32
para 00:04:35
para poder hacer los datos 00:04:35
y ahora ya de paso pues vamos aquí 00:04:38
a rellenar el map 00:04:41
volcar, vale, volcamos 00:04:42
el fichero en el map 00:04:44
y ya está 00:04:46
y a partir de ahí ya los métodos trabajan con el 00:04:47
dao y se acabó, con el map 00:04:51
y se acabó, vale 00:04:52
entonces para volcar el fichero en el map 00:04:58
pues lo volcáis 00:05:00
y ahora 00:05:01
recordad que de cada objeto reserva 00:05:04
que leáis de este 00:05:07
fichero 00:05:09
tenéis que meter en la clave 00:05:10
la propiedad 00:05:13
código y el objeto 00:05:15
entero en el valor 00:05:17
bueno 00:05:19
y aquí que métodos para reserva queremos 00:05:21
pues los de siempre 00:05:23
queremos, que queremos hacer con las reservas 00:05:24
por insertar una reserva 00:05:27
nueva 00:05:29
el que queráis 00:05:30
tomáis, bueno venga 00:05:41
vamos a hacerlo todos igual, para si luego lo 00:05:43
corrijamos, lo corregimos para que cada uno 00:05:45
vale, pues aquí 00:05:47
¿qué decisión tomaríamos? ¿trimap o hasmap? 00:05:48
por defecto 00:05:51
usaríamos hasmap, ¿vale? 00:05:52
es la más cómoda, la más eficiente, la más todo 00:05:55
trimap también funciona muy bien 00:05:57
y trimap nos puede 00:06:01
ser útil cuando tenemos que hacer 00:06:03
iteraciones a menudo 00:06:05
y nos viene bien que esas iteraciones estén 00:06:06
ordenadas, entonces 00:06:09
alguna funcionalidad de esta aplicación nos puede 00:06:10
interesar que sea sacar las 00:06:13
listados de reservas, por ejemplo 00:06:15
lo que pasa es que si fueran 00:06:17
listados de reservas, nos interesaría algún tipo 00:06:19
de orden 00:06:21
pues 00:06:21
la master panel 00:06:23
venga, muy bien 00:06:25
porque así os habéis complicado mucho la vida 00:06:28
muy bien, vale 00:06:31
vale, entonces 00:06:33
el tree, si queremos que 00:06:35
el tree map, ese de ahí 00:06:37
nos itere por orden de fecha 00:06:38
que tiene sentido, me vaya sacando primero 00:06:41
las que están a punto de vencerse 00:06:43
yo tengo que meter un criterio de orden aquí 00:06:44
¿vale? pero ojo 00:06:48
como me haga aquí un implements comparable 00:06:50
y meta el criterio de orden por fecha 00:06:52
¿qué pasa? 00:06:54
que lo he roto todo, he roto la aplicación 00:06:56
¿por qué? 00:06:58
porque fecha no es la clave 00:07:00
primaria del objeto reserva 00:07:02
entonces 00:07:04
si yo uso un trimap 00:07:06
el trimap 00:07:08
ah bueno no, vale, vale, nada, no, no 00:07:10
porque lo que, perdón 00:07:12
eso sería si estuviéramos usando 00:07:14
un hash 00:07:16
un triset, perdón 00:07:18
un triset, porque el trimap 00:07:20
lo que le preocupa 00:07:22
es la clave 00:07:24
donde tenemos el reservado 00:07:26
aquí 00:07:28
vale, es decir 00:07:29
en el trimap 00:07:32
lo que se guarda en un triset 00:07:33
es la clave 00:07:38
lo que se guarda en un triset son las claves 00:07:40
entonces el que tiene que tener criterio 00:07:42
de orden es la clave 00:07:44
¿vale? entonces 00:07:46
me lo va a dar, la iteración 00:07:48
va a ser por orden de la clave 00:07:50
con lo cual si nosotros queremos 00:07:52
iteraciones por orden de 00:07:54
reserva con el criterio que sea 00:07:56
tendremos que ordenar por nuestra 00:07:58
cuenta, con lo cual en este caso 00:08:00
no ganamos nada poniendo un trimap 00:08:02
salvo que las iteraciones van 00:08:04
por orden de código 00:08:06
si eso nos interesa vale, porque el 00:08:08
trimap necesita orden aquí donde pone 00:08:10
órdenes en el código 00:08:12
no en la clave, en el código 00:08:13
entonces el código 00:08:15
el código de la reserva 00:08:19
entonces bueno 00:08:22
podemos poner un trimap 00:08:24
no hay nada que añadir porque 00:08:25
ya tiene el comparable suyo 00:08:27
orden numérico 00:08:30
orden numérico, podemos poner un trimap 00:08:32
y no tenemos 00:08:34
que añadir nada a la aplicación 00:08:36
no tenemos que hacer nada, un trimap 00:08:38
que ganamos poniendo el trimap 00:08:39
que cada vez que hiteremos 00:08:42
nos va a salir por orden de 00:08:43
código 00:08:45
eso tampoco es que nos aporte mucho 00:08:46
si quisiéramos ordenar por reservas para hacer cosas 00:08:49
pues tenemos que hacerlo aparte 00:08:52
con nuestra cuenta 00:08:53
bueno, vamos a incorporar 00:08:54
un método que lo haga, pero 00:08:58
entonces, has 00:08:59
trimap o has map 00:09:01
me da igual, porque es que el resto de la aplicación 00:09:03
va a ser idéntica, me da igual 00:09:05
el que elijáis, da lo mismo, no hay que 00:09:07
hacer nada, no hay que añadir nada en reserva 00:09:09
por poner trimap, no hay que añadir nada 00:09:11
sería aquí donde hay que añadir, y luego ya lo tiene 00:09:13
así que nada 00:09:15
así que usar la que más os guste 00:09:17
ante la duda, pues siempre 00:09:19
hashmap 00:09:21
más sencilla de implementar por dentro 00:09:22
con lo cual 00:09:25
vale, pues entonces 00:09:26
insert 00:09:29
la que tú quieras 00:09:30
pero sí, yo en una situación así usaría 00:09:33
hashmap y ya está 00:09:35
porque iterar por orden de código 00:09:36
Si no me interesa especialmente 00:09:39
Vale, venga 00:09:42
Pues insert 00:09:44
Insertar una reserva 00:09:45
Vale, entonces 00:09:50
Los del CRUD habría que hacerlos todos 00:09:51
Get 00:09:54
Porque recuperamos 00:10:02
Por código, lógicamente 00:10:05
Código de reserva 00:10:06
No lo vais a hacer vosotros aquí 00:10:10
estamos planteando la aplicación con los huecos 00:10:26
que tenéis que hacer ahora vosotros 00:10:29
el fichero no lo inicializa 00:10:30
porque eso ya lo hará el main, eso no depende del DAO 00:10:32
el DAO 00:10:34
es una clase que 00:10:36
puede funcionar luego ya con cualquier 00:10:38
ejemplo concreto de aplicación 00:10:40
si yo compro una aplicación y ha cambiado el fichero 00:10:42
no tiene sentido que yo me venga aquí 00:10:44
a cambiarlo 00:10:46
entonces se lo pasaré por constructor 00:10:47
esta clase tiene que ser lo más independiente posible 00:10:49
entonces esta clase 00:10:52
cuando se la llame desde un 00:10:54
main, desde una interfaz gráfica 00:10:55
desde una aplicación web, desde donde sea 00:10:58
cuando se la llame, ya se le pasará 00:10:59
el fichero de datos concreto con el que va a trabajar 00:11:02
no tiene sentido que yo 00:11:04
lo hardcodee aquí dentro 00:11:05
porque si lo 00:11:08
hardcodee aquí dentro, en cuanto cambie 00:11:09
mi fichero, me tengo que venir aquí a cambiarlo 00:11:11
y ese es un sitio un poquito 00:11:13
oculto, que seguramente no tenga 00:11:15
ni acceso a esta clase 00:11:18
seguramente no tenga ni acceso a esa clase 00:11:20
Vale, entonces 00:11:21
Insertamos una reserva 00:11:25
Borramos 00:11:28
Una reserva 00:11:33
Borrar, se hará por código 00:11:35
Lógicamente 00:11:42
Recuperar, he puesto aquí 00:11:43
Boolean, recuperar, me tendrá que recuperar 00:11:56
El objeto concreto, completo 00:11:58
Claro, recuperar una 00:12:00
Reserva dado el código 00:12:02
Me falta modificar 00:12:04
Esto como se va a hacer en el map 00:12:09
estos métodos van a ser cortísimos 00:12:11
mucho más fáciles que con el fichero 00:12:14
porque se van a hacer en el map directamente 00:12:15
y ahora me falta modificar 00:12:17
una reserva 00:12:20
vale, pues la reserva con el código 00:12:30
tal y como aparezca esta 00:12:43
la modificamos 00:12:45
porque a lo update le tengo que pasar tanto el código 00:12:46
como los nuevos datos 00:12:57
y es que el código ya va aquí 00:12:58
dentro, porque lo que no hago nunca 00:13:00
es cambiar la clave primaria 00:13:02
pasar un código y ahora decirle 00:13:04
a ese código, cambia 00:13:06
todos los datos que están en reserva, pasarle 00:13:08
una reserva con el código completo, estaría 00:13:10
cambiando la clave primaria, que eso no debo tocarlo 00:13:12
porque voy a hacer una inconsistencia de datos casi seguro 00:13:14
entonces ahí ya va 00:13:16
todo, el código de la que hay que cambiar 00:13:18
y el resto de los datos que hay que cambiar 00:13:20
vale 00:13:22
entonces hay un método típico también en los 00:13:24
datos que no lo han puesto en destino 00:13:26
pero bueno, que es habitual que es 00:13:28
devuélveme todos 00:13:30
Hay un método típico 00:13:31
Que es el 00:13:34
Se suele llamar find all o como sea 00:13:35
Que me devuelve 00:13:38
Todas las reservas 00:13:41
Todas 00:13:43
Normalmente se hace que me devuelva una colección 00:13:45
Vale 00:14:01
Este me va a devolver una colección con todas las reservas 00:14:04
Este me inserta una reserva 00:14:07
Me inserta una reserva nueva 00:14:08
Me borra una reserva 00:14:10
y todo esto trabaja todo con el map 00:14:12
luego van a ser métodos cortitos 00:14:15
¿vale? 00:14:17
entonces 00:14:32
para que lo que haga estos métodos 00:14:33
se refleje en el fichero 00:14:42
podríamos optar por muchas 00:14:43
cosas ¿no? 00:14:47
es decir, que sea la aplicación 00:14:50
la que se preocupe 00:14:51
pero eso hace a la aplicación demasiado 00:14:53
dependiente de cómo está 00:14:55
hecho por dentro el DAO, eso es feo 00:14:57
es decir, mi DAO es muy 00:14:59
cómodo porque yo lo instancio 00:15:01
y él me hace esta trampita 00:15:04
por dentro. 00:15:05
Trampita que no está mal. Me hace esta 00:15:07
trampita, que es volcarlo. Pero el que 00:15:09
lo instancia en realidad no tiene que saber 00:15:11
cómo funciona por dentro. Si está trabajando 00:15:13
directamente con el fichero cada vez que 00:15:15
hace un insert o un get, o si está 00:15:17
trabajando con un map temporal, el que 00:15:19
lo instancia y lo usa en realidad no tendría por qué 00:15:21
saberlo. Esto tiene que estar lo más desacoplado 00:15:23
posible. Bueno, pues 00:15:25
cuando lo instanciamos ha hecho esta trampita, 00:15:27
ha creado el map, 00:15:30
pero claro, también ya que hace 00:15:31
esta trampita, el DAO es responsable 00:15:34
también de cuando hace las acciones 00:15:36
que provocan 00:15:38
modificaciones, que esas acciones 00:15:40
se reflejen en el fichero, es responsable 00:15:42
porque el que lo llama 00:15:44
no tiene por qué decir, uy, soy responsable 00:15:45
yo de después de haber llamado al DAO 00:15:48
que se guarde todo en el fichero 00:15:50
antes de irme, no debería 00:15:52
entonces 00:15:54
dentro de cada uno de estos 00:15:54
podemos incorporar en el DAO 00:15:58
un método sincroniza, por ejemplo 00:15:59
que lleva el map al fichero. 00:16:01
Es un write, lleva el map y se acabó. 00:16:03
¿Vale? 00:16:05
Y ahora, cada uno de estos métodos, 00:16:05
una vez que han hecho lo que tienen que hacer, 00:16:08
llaman a ese sincroniza. 00:16:09
O persiste o con lo queramos llamar. 00:16:11
¿Vale? 00:16:13
Pues vamos a crearlo aquí. 00:16:14
Venga. 00:16:16
Vamos a hacer aquí un... 00:16:17
¿Y este método qué va a hacer? 00:16:33
Va a pasar el contenido del map al fichero. 00:16:35
Entonces, cuando arranque la aplicación, 00:16:55
la primera vez que no hay ninguna reserva, 00:16:57
acordados de más o menos ajustar 00:17:00
todos los flancos, pues el 00:17:02
map habrá que instanciarlo vacío 00:17:04
claro, en ese caso hay que instanciarlo vacío 00:17:05
entonces aquí también tenemos dos 00:17:08
formas de trabajar, la cómoda y la menos cómoda 00:17:10
y no pasa nada, podemos trabajar con 00:17:12
la cómoda, si queremos, aunque es la que 00:17:14
a lo mejor de la que menos aprendemos 00:17:16
la menos cómoda 00:17:17
voy recorriendo 00:17:20
mi map y voy pasando 00:17:22
cada objeto reserva, reserva, reserva 00:17:24
luego me tengo que hacer 00:17:26
el bucle de lectura, la menos 00:17:28
cómoda, la más cómoda, el map 00:17:30
en sí ya es un objeto 00:17:32
pues escribo el map 00:17:33
y ya está, y luego cuando tengo que recuperar 00:17:35
aquí en el constructor 00:17:38
cuando tengo que recuperar aquí en el constructor 00:17:39
hago un único 00:17:43
read object en el que leo el map entero 00:17:46
esa sería la más cómoda 00:17:49
¿vale? ¿entendéis lo que digo? 00:17:51
Sí, sí, pero una pregunta 00:17:57
¿tú quieres que 00:17:58
recuperemos en cuanto se haga 00:17:59
Cuando se hace reservado 00:18:02
Hay dos opciones 00:18:05
Que el fichero exista 00:18:07
Y tenga datos 00:18:09
En ese caso 00:18:10
Lo tenemos que leer y llevarlo al map 00:18:12
¿Vale? 00:18:15
Que el fichero no exista 00:18:17
Que el fichero no exista 00:18:19
O exista y no tenga datos 00:18:22
Este vacío 00:18:24
En ese caso lo que hay que hacer 00:18:24
Es crear un map nuevo y limpio 00:18:27
Ya está, hay que hacer un new map 00:18:29
Nuevo y limpito 00:18:31
se acabó, vale, entonces 00:18:32
cuando arranque la aplicación, la primera vez 00:18:34
que no hay reservas, se hará un map nuevo 00:18:36
y limpito, ahora cuando 00:18:38
empezamos a hacer cosas, el insert 00:18:40
el delete 00:18:43
cuando empezamos a hacer cosas 00:18:45
cada uno de ellos tendrá que llamar 00:18:46
a este método para una vez que 00:18:49
ha terminado con el map de hacer lo que sea 00:18:50
guardarlo en el fichero 00:18:52
vale, pues 00:18:53
entonces, ahora es cuando tenemos dos 00:18:56
posibilidades 00:18:58
Guardar las reservas 00:18:59
Una por una 00:19:02
Y tener un fichero con los objetos reserva 00:19:02
Uno tras otro, reserva, reserva, reserva 00:19:05
A lo cual iremos iterando el map 00:19:08
Opción 2 00:19:09
Darnos cuenta de que el map 00:19:11
Ya es un objeto, objeto map 00:19:13
Guardar el map 00:19:15
Ya está, hago un write object 00:19:16
Y le paso directamente el map 00:19:19
¿Vale? 00:19:21
Entonces lleva map a fichero, entonces aquí tenemos dos posibilidades 00:19:23
Iterar 00:19:26
En el map 00:19:31
Y guardar las reservas una a una 00:19:33
Vamos a hacer esta 00:19:43
Porque así practicamos, no se nos olvide iterar en un map 00:19:44
Opción 2, la cómoda y fácil, que sería una línea 00:19:48
Guardamos el map, el objeto map, en el fichero 00:19:52
Con un único write object, guardo el objeto map 00:20:04
Y ya está 00:20:07
Cuando la aplicación termine 00:20:13
en el fichero ya se habrá quedado 00:20:15
lo del map porque esto ha ido llamando 00:20:17
a persiste cada vez 00:20:19
bueno pues al persiste un segundito 00:20:20
para que el archivo se quede siempre 00:20:29
actualizado no vaya a ser que haya 00:20:32
otra aplicación por ahí accediendo a ella 00:20:34
porque al fichero de reservas 00:20:36
pues igual están accediendo 00:20:38
más aplicaciones y tenemos que tenerlo actualizado 00:20:40
siempre 00:20:42
entonces para tenerlo actualizado siempre 00:20:42
después de hacer 00:20:46
cada modificación 00:20:48
como por ejemplo este insert 00:20:50
pues después de hacer lo que toque 00:20:52
aquí 00:20:55
lo que toque 00:20:56
lo que sea 00:20:58
pues llamaremos al persiste 00:20:59
aquí no hace falta 00:21:03
aquí no hace falta llamarle 00:21:04
porque no se modifica el fichero 00:21:07
no se modifica 00:21:09
aquí si se modifica 00:21:09
pues hay que llamarle 00:21:11
aquí también se modifica en el delete 00:21:12
aquí no se modifica 00:21:15
porque estamos recuperando 00:21:25
y aquí si se modifica 00:21:26
porque estamos actualizando 00:21:28
Vale, vamos a empezar con estos cuatro métodos 00:21:30
Más el constructor 00:21:36
Que vuelca el fichero si el fichero existe 00:21:37
O si no, instancia el map 00:21:40
Vacío, sin más 00:21:42
Venga, vamos a empezar 00:21:44
Con estos cuatro 00:21:46
Y luego ya le añadimos alguna funcionalidad 00:21:47
Que más queramos hacer con reservas 00:21:50
Pues mostrarme la próxima reserva 00:21:52
Que está por vencer 00:21:54
Pues lo que sea 00:21:56
Pues mostrarme si hay dos reservas en la misma fecha 00:21:58
Luego ya podemos añadir 00:22:00
Ya cosas que no son directamente el CRUD, que es consulta, guarda, borra o modifica, que es el CRUD. 00:22:02
Ahora ya podemos añadir cosas que se derivan de esas cuatro acciones, pero ya son más adaptadas a una cosa en particular. 00:22:14
Pues eso, encuéntrame si hay dos reservas que se separen más de un mes. 00:22:21
Ya puedo yo decidir qué cosas le interesa hacer a mi aplicación. 00:22:28
eso ya no son acciones 00:22:30
básicas del CRUD 00:22:33
eso ya se le llamarían servicios, porque ya son 00:22:34
cosas específicas mías, pero ahora mismo 00:22:36
vamos a hacer por ahora 00:22:38
el CRUD este básico 00:22:40
dentro de este reservadao 00:22:42
con el constructor y el persiste 00:22:45
y el persiste con la opción 1 00:22:46
para obligarnos a iterar en el MAC 00:22:48
¿vale? 00:22:50
venga, pues arrancad con estos 4 00:22:53
los métodos van a ser muy 00:22:55
sencillos, porque los métodos ya trabajan con el MAC 00:22:56
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:
23 de marzo de 2026 - 13:20
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
22′ 59″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
86.95 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid