Saltar navegación

20260324 FicherosObjetos_AppReservas_6 - 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 25 de marzo de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, solamente le importan a él, por eso son privadas, que son el fichero de datos con el que va a trabajar, información interna suya, y el map en el que va a volcar los datos para trabajar de forma óptima con la RAM, teniéndolo todo ahí en la RAM. 00:00:03
entonces solo le importa a él, son privadas 00:00:20
y es que aquí no tiene sentido hacer 00:00:22
ni get ni set, esto no es una entidad 00:00:24
que refleje algo con lo que 00:00:26
va a trabajar mi aplicación, una factura 00:00:28
entonces 00:00:30
estas propiedades las van a usar estos métodos 00:00:31
solamente 00:00:34
pues entonces aquí estos métodos 00:00:35
ya accederán a estas dos propiedades 00:00:38
no hay que exponerlas para afuera 00:00:40
no hay necesidad 00:00:42
bueno, entonces reserva dado 00:00:46
el constructor 00:00:47
el constructor necesita 00:00:48
que la aplicación que use este 00:00:51
le diga el fichero concreto 00:00:53
el fichero concreto 00:00:55
dime el fichero concreto que quieres 00:00:57
porque cada main usará un fichero 00:00:59
distinto, cada aplicación 00:01:01
usará un fichero distinto 00:01:03
entonces dime el fichero concreto que tienes 00:01:04
pásamelo por constructor 00:01:07
que es la manera de pasarles 00:01:09
las propiedades a las entidades 00:01:11
por constructor, pásamela por constructor 00:01:13
y yo ya 00:01:16
aparte de inicializar 00:01:17
mi file, aparte de inicializarlo 00:01:19
con este que me has pasado 00:01:22
ya aprovecho y vuelco 00:01:23
el contenido de ese fichero en mi map 00:01:26
para que ahora ya 00:01:28
todos los métodos trabajen con 00:01:29
ese map directamente, aprovecho y lo vuelco 00:01:32
entonces como lo vuelco 00:01:34
pues como hemos hecho hasta ahora, un bucle de lectura 00:01:35
en el file, si el fichero 00:01:38
no existiera 00:01:40
o si existiendo estuviera limpio 00:01:41
o vacío 00:01:44
si no existiera 00:01:44
o estuviera limpio y vacío 00:01:47
importante aquí 00:01:49
las dos barras y no solo una 00:01:51
aquí cambiaría la cosa horriblemente 00:01:53
¿no? pues si pongo una 00:01:56
barra, esta cláusula se ejecutaría 00:01:57
sí o sí y aquí me 00:01:59
daría un null pointer exception 00:02:01
si el fichero no existe 00:02:03
pues podría ser null 00:02:05
entonces 00:02:06
vale, pues si el fichero no existe 00:02:07
o existiendo 00:02:11
su tamaño es cero 00:02:13
pues entonces créate un map 00:02:14
nuevo limpio, porque no tengo todavía 00:02:17
ninguna reserva, un map limpio 00:02:19
y en el else, es decir 00:02:21
si sí que existe y tiene datos 00:02:23
pues hará ya el bucle de lectura 00:02:25
de toda la vida, asociamos un 00:02:27
file input string a ese fichero 00:02:29
del que vamos a leer 00:02:31
y ahora ya vamos leyendo reserva 00:02:33
por reserva y cada 00:02:35
reserva se va a mi map 00:02:37
con su código extraído 00:02:38
fuera y su 00:02:41
Objeto reserva enterito. 00:02:43
Su valor aquí. 00:02:45
Y ya está. 00:02:46
¿Vale? 00:02:49
Si optáramos por la opción. 00:02:50
Que también es posible. 00:02:51
De. 00:02:54
Oye. 00:02:54
Como este dado. 00:02:55
Reserva. 00:02:56
Por dentro hace lo que le da la gana. 00:02:57
Y lo tiene todo ahí oculto y encapsulado. 00:03:00
A la aplicación. 00:03:03
Lo único que le importa es hacer un insert. 00:03:03
Hacer un delete. 00:03:06
Lo único que le importa. 00:03:07
Pues como este puede hacer lo que le da la gana. 00:03:09
Podría haber optado por. 00:03:10
Oye. 00:03:12
Este map. 00:03:13
cuando yo lo tenga que guardar en el fichero 00:03:14
para actualizarlo, en lugar de ir 00:03:16
reserva por reserva 00:03:18
lo voy a guardar entero, write object 00:03:19
el map enterito, porque no deja de ser un objeto 00:03:22
también el map 00:03:24
¿vale? pues entonces si hubiera optado por eso 00:03:25
no me haría falta 00:03:28
ni bucle de lectura 00:03:29
porque podría haber 00:03:31
hecho esta sentencia 00:03:34
mi objeto 00:03:35
reservas, le me 00:03:37
el único objeto que haya en el fichero 00:03:39
que es el map enterito 00:03:42
Que es el map enterito 00:03:43
Dime 00:03:45
Mira, yo lo hice así 00:03:47
Pero en otro método 00:03:49
Hice que lo leyera uno a uno 00:03:52
Porque en el de abajo 00:03:54
Entonces no puedes 00:03:55
Claro, las cabeceras 00:03:56
Una cosa es la cabecera que te dice 00:03:58
Aquí hay un map, bla, bla, bla 00:04:00
Y otra cosa es la cabecera que te dice 00:04:01
Aquí hay una lista de reservas 00:04:03
No tiene nada que ver un fichero con el otro 00:04:05
No puedes mezclar 00:04:06
Vale, bueno, pues entonces 00:04:07
El constructor te inicializa el map 00:04:10
Con un map vacío 00:04:13
o con un map con todas 00:04:15
las reservas. Y ya está. Eso hace 00:04:17
el constructor. Y ahora ya los métodos 00:04:19
se quedan más sencillos. 00:04:21
Recuperar todos. 00:04:23
Otra vez no. La primera, pero no la he enseñado 00:04:27
nunca. Este es el constructor. 00:04:29
O sea, vamos uno por uno. 00:04:31
El find all. 00:04:33
¿El constructor quieres? 00:04:36
Es que creía 00:04:38
que me estabas diciendo el insert, que te estabas adelantando. 00:04:39
¿Qué parte del constructor quieres? 00:04:41
para meterlo en el map 00:04:43
el objeto reserva que voy leyendo 00:04:53
voy de uno en uno 00:04:56
claro, porque aquí 00:04:57
para probar tengo las dos opciones 00:05:00
esta es una de las dos 00:05:01
vale 00:05:04
entonces, recuperar 00:05:04
bueno, este es el más fácil 00:05:08
si quiero que me devuelva 00:05:10
una lista, pues 00:05:12
me construyo una lista 00:05:14
nueva, limpia, independiente 00:05:16
y a esa lista le voy 00:05:18
metiendo todas 00:05:20
las reservas. 00:05:22
¿Vale? 00:05:25
Entonces, el método values, pues ya 00:05:26
sabemos que nos da una colección con 00:05:28
todas las reservas, pero 00:05:30
cuidado porque 00:05:32
hay que ver bien que hacen los métodos. 00:05:34
Entonces, igual que el entry set era 00:05:37
una vista del map entero, 00:05:38
values es una vista, entonces tiene esas particularidades 00:05:40
no es una lista normal y corriente 00:05:43
entonces yo quiero devolver una lista normal y corriente 00:05:45
perfectamente modificable, lo que haga falta 00:05:49
y no asociada a ningún map 00:05:52
values va a ser una vista que está asociada al map 00:05:54
si el map cambia, cambia values, entonces devolver esto directamente 00:05:57
no quiero, me voy a construir una lista 00:06:01
nueva, limpita, a la que le voy añadiendo 00:06:03
todos los objetos reserva y ya está 00:06:07
vale, pues final, lo habréis hecho como lo hayáis hecho 00:06:10
hay muchas opciones, pero en esencia es esto 00:06:13
ahora el insert, pues nada, el insert yo lo que he hecho es 00:06:16
verificar si la clave ya está 00:06:20
porque si la clave ya está, aviso con el false 00:06:23
de que no he podido hacer la inserción 00:06:26
y si la clave no estuviera, entonces ahora ya 00:06:28
hago el insert y mi insert es hacer un put 00:06:34
y ya está, mi insert es el put 00:06:36
Pero claro, no se me puede olvidar 00:06:39
Después del insert, actualizar el fichero 00:06:42
Después del insert 00:06:44
No se puede olvidar actualizarlo 00:06:46
Y para eso tengo este método auxiliar 00:06:48
Que lo único que hace es escribirlo en el fichero 00:06:50
¿Vale? 00:06:54
Es una posibilidad 00:06:57
Hay más opciones 00:07:09
Reserva.getcode.reserva 00:07:10
El put 00:07:12
Te devuelve algo 00:07:14
Que lo puedes usar 00:07:16
Sí, pero quiero ver el valor de retorno 00:07:18
De previous value asociado con esta clave 00:07:39
Por null, vale 00:07:41
Entonces, podríamos usar directamente 00:07:42
Aquí en el if, if reservas 00:07:45
Put igual a null 00:07:47
Pues entonces, ahí es porque 00:07:49
Se ha hecho la inserción efectiva 00:07:51
Y así no tengo que poner este 00:07:53
Hay diferentes formas, ¿no? 00:07:55
O sea, porque si este te devuelve null 00:07:57
Es porque la inserción se hizo 00:07:59
se hizo de forma efectiva, si no es que ya había 00:08:00
uno de antes y lo está sobre escribiendo 00:08:03
entonces como lo queráis hacer 00:08:05
puedo quitar esto de arriba 00:08:07
y meter esto en el if 00:08:09
si esto es igual a null 00:08:10
entonces returbo o no, no, no, no haría eso 00:08:12
porque entonces estaría modificando el otro 00:08:15
así lo dejaría 00:08:16
verifico 00:08:18
que 00:08:20
a ver si lo contiene, porque si ya lo contiene 00:08:22
aviso con el false de que 00:08:25
no, la inserción mal, ya estaba 00:08:27
no lo puedo insertar, ya estaba 00:08:28
si no he salido con el retún 00:08:31
falso, pues lo inserto 00:08:33
ya de forma efectiva 00:08:35
y actualizo el fichero 00:08:36
porque se ha visto modificado el map 00:08:38
entonces el persist este de aquí 00:08:41
es un método auxiliar dentro del DAO 00:08:43
que ojo 00:08:44
porque aquí yo me he encontrado 00:08:46
un error en la ejecución 00:08:49
pues uno va escribiendo así 00:08:51
y efectivamente mi primera 00:08:52
versión tenía esto que está aquí comentado 00:08:55
que era 00:08:57
Pues me hago esto para escribir 00:08:58
No para añadir 00:09:00
Porque lo voy a escribir siempre de nuevas 00:09:03
O sea, aquí no hay un true 00:09:05
Porque voy a escribir el map 00:09:06
Enterito con todas sus reservas 00:09:08
Y ahora yo 00:09:10
Esta era mi primera versión 00:09:12
Esta 00:09:14
¿Vale? Mi primera versión 00:09:21
En la que yo hacía 00:09:23
Y ahora me voy 00:09:24
Reserva por reserva 00:09:25
Dentro de todos los valores del map 00:09:27
Y escribía la reserva 00:09:30
¿Vale? Muy bien 00:09:32
pero luego cuando intentaba recuperar 00:09:33
y hacía el casting a reserva 00:09:35
de lo que veía en el fichero 00:09:37
me decía, uy, el casting no, este no casting 00:09:38
no me cuadra, claro, cuidado 00:09:41
porque values 00:09:43
de nuevo, al obtenérmelo como 00:09:45
vista, tiene unas marcas 00:09:47
internas y no 00:09:49
se va a guardar como un objeto reserva limpio 00:09:51
porque es una vista, entonces tiene unas marcas 00:09:53
internas, entonces cuidado 00:09:55
con este método, cuando tú quieres una vista 00:09:56
para ver lo que hay en el map, bien, pero cuando 00:09:59
luego quieres esos objetos para hacer 00:10:01
otras cosas, pues no lo saques 00:10:03
con values, porque luego al hacer el casting 00:10:05
a reserva, entonces 00:10:07
esto lo he quitado, lógicamente 00:10:09
y he dejado esto 00:10:13
y esto ya no tiene problemas 00:10:15
¿vale? 00:10:16
¿qué he hecho? pues ahora ya sí que me he 00:10:20
sacado la reserva enterita, no la vista 00:10:22
la reserva entera 00:10:24
me he sacado todas las claves 00:10:26
con el keyset todas las claves y ahora me he ido clave 00:10:28
por clave, y para cada clave 00:10:30
me he escrito la reserva asociada 00:10:32
a esa clave. Y este ya sí que es 00:10:34
el objeto reserva tal cual, el que está 00:10:36
en el map. El objeto reserva que está en el 00:10:38
map. Ni una vista asociada 00:10:40
ni nada. El objeto reserva que está en el 00:10:42
map. ¿Vale? Pues mi persiste 00:10:44
tiene solamente eso. Se hace 00:10:46
el output string 00:10:48
y escribe todas las reservas. 00:10:49
Que quiero la opción 00:10:53
dos, de guardar el map enterito 00:10:54
que es la más cómoda. Todo 00:10:56
este bucle, todo esto de aquí 00:10:58
se sustituiría por esta línea. 00:11:00
De aquí abajo. 00:11:02
Escribo el map entero y listo. 00:11:04
¿Vale? 00:11:08
Todo esto de aquí 00:11:08
se sustituiría por esto. 00:11:09
Escribo el map y se acabó. 00:11:12
¿Vale? 00:11:15
Depende de la opción que haya adoptado. 00:11:16
Hombre, más cómoda 00:11:21
esta, lógicamente. 00:11:22
Si tú no necesitas en el fichero 00:11:24
porque nadie más lo va a usar, que las reservas estén 00:11:26
por separado, pues guardas 00:11:28
el map entero y ya está. Otra cosa es que 00:11:30
Luego en esta aplicación tú quisieras 00:11:32
Acceder a reservas 00:11:34
Sueltas a la reserva 00:11:36
Directamente en el fichero 00:11:38
Entonces pues a lo mejor interesa 00:11:40
Tenerlas así 00:11:42
Pero en este caso 00:11:43
Mucho más cómodo guardar el mapa enterito 00:11:46
Vale, pues el insert 00:11:48
Ese de ahí 00:11:50
Borrar 00:11:52
Pues borrar he hecho lo mismo 00:11:54
Primero he verificado 00:11:56
Que a ver si existe o no existe 00:11:57
Porque si no existe 00:12:00
Aviso con false de que no se ha podido borrar 00:12:01
Aviso con false de que no se ha podido borrar 00:12:05
Y ya está 00:12:07
Todo esto, lógicamente, esta aplicación 00:12:07
Aunque ya se parece más a una real 00:12:10
Porque está ya desacoplada 00:12:12
Tiene la parte de datos, la parte de no sé qué 00:12:14
Le falta una cosa fundamental 00:12:16
Que es comentarla 00:12:18
Y decir 00:12:20
Devuelve false si no se pudo borrar 00:12:22
True si sí se borró 00:12:24
Patatín 00:12:27
Claro, le falta eso, lo básico 00:12:28
Explicar los valores de retorno 00:12:30
Que significan todo eso 00:12:32
Le faltarían esos comentarios 00:12:34
Pero bueno 00:12:37
A no extendernos demasiado 00:12:38
Vale, pues delete 00:12:40
Me devuelve falso si el código no existe 00:12:42
Así el método que lo llama puede decir 00:12:44
Oye, no existe el registro, no lo puedo borrar 00:12:47
Y si sí que existe, pues lo borra con remove y se acabó 00:12:48
Y vuelve a actualizar el archivo 00:12:53
Resiste 00:12:54
El get, pues el más fácil 00:12:55
Me recupera directamente con el código de reserva 00:12:59
ya está, me devolverá null si no está 00:13:02
el get es el más sencillo, una línea 00:13:04
y el update 00:13:05
pues prácticamente igual que el delete 00:13:07
si no existe 00:13:09
me avisa con false 00:13:11
para que el programa principal pueda decir 00:13:13
oye, no existe el que quieres actualizar 00:13:15
lo siento, no existe 00:13:17
pero si existe 00:13:18
ahora ya lo reemplaza 00:13:21
reemplaza 00:13:24
el que tenga ese código 00:13:25
con 00:13:26
el nuevo que me han pasado 00:13:29
y ya estarían todos los métodos 00:13:31
de acceso a datos 00:13:33
entonces esto está 00:13:34
ocultando, encapsulando toda la complejidad 00:13:37
de acceso al fichero 00:13:39
te dice 00:13:40
tú llámame a mí diciendo insert, get, delete 00:13:42
update o find all 00:13:46
y yo te hago toda la mierdecilla 00:13:47
que tenga que hacer 00:13:49
tú sabes que cada vez que llames a alguno de esos métodos 00:13:50
el fichero se va a quedar completamente 00:13:53
actualizado 00:13:55
yo ya me ocupo con todas las mierdecillas que hago por dentro 00:13:56
de que eso sea así 00:13:59
vale, pues ahora ya el main 00:14:00
ya lo usa 00:14:03
y el main ya 00:14:04
usará el reserva dado 00:14:06
vale 00:14:09
usará el reserva dado 00:14:11
vale 00:14:15
entonces el reserva dado 00:14:16
de nuevo hay que pasarle el fichero 00:14:18
lógicamente 00:14:21
en mi caso datos reserva 00:14:22
y el reserva dado 00:14:25
sí que puede lanzar una excepción 00:14:27
sí que puede lanzarlo 00:14:28
porque mi constructor 00:14:30
como mi constructor leía 00:14:32
del fichero, el constructor sí que puede lanzar 00:14:34
una excepción 00:14:37
pues aquí ya en el main, cuando lo instancio 00:14:37
cuando hago el new 00:14:41
tengo que capturar la excepción 00:14:42
porque el constructor 00:14:44
de reserva dado es mucho más complicado 00:14:46
que el de destino dado 00:14:48
el constructor de reserva dado me hace 00:14:49
todo esto de aquí 00:14:52
me hace todo esto 00:14:53
todo esto que es un rollo 00:14:56
y puede lanzar excepción, puede lanzarla 00:14:58
pues entonces en el main 00:15:00
para instanciar el reservadado 00:15:02
lo capturo 00:15:04
y si hay algún problema 00:15:04
es que aquí sí que me interesa que la aplicación 00:15:08
pare, si hay algún problema es que los ficheros 00:15:10
no están en uso, algo no funciona 00:15:12
pues entonces aquí pues sí que le digo 00:15:14
mira, problema con los datos, se cierra 00:15:16
y ya está, ahí me voy, system.exe 00:15:18
y se acabó 00:15:20
aviso de que la aplicación no funciona 00:15:21
porque es que no consigo instanciar esto 00:15:26
si no consigo instanciarlo, es que ¿para qué va a salir 00:15:28
la aplicación? 00:15:30
si este no existe, me voy 00:15:32
bueno, pues mi main ya tiene el dado 00:15:33
destino para los datos del destino 00:15:36
y dado reserva para los datos de reserva 00:15:38
y ahora ya en mi main 00:15:40
yo he añadido solo realizar 00:15:42
reserva y consultarla 00:15:44
pero las otras opciones serían sencillas 00:15:45
he añadido solo estas dos, realizar y consultar 00:15:48
entonces la 5 00:15:50
realizar 00:15:52
pues la 5 00:15:53
Hay que pedir el nombre del cliente 00:15:56
La fecha de la reserva 00:15:58
Aquí para crear el local date 00:16:00
Con la fecha, imagino que habréis consultado 00:16:03
A HGPT 00:16:05
Pero en realidad no hace falta 00:16:06
Si uno tiene más o menos unas pautas básicas 00:16:08
¿Qué tenemos que instanciar? 00:16:11
Tenemos que instanciar un local date 00:16:13
Que transforme 00:16:15
El string 00:16:18
Que me hayan pasado con la fecha 00:16:19
El string, en el formato que yo ya he dicho 00:16:21
No, la fecha me la han pasado 00:16:23
como un string, entonces 00:16:25
si se nos queda la pauta de 00:16:27
las clases nuevas de los paquetes 00:16:29
nuevos y el 00:16:31
java time es nuevo, no se 00:16:33
instancian prácticamente nunca con 00:16:35
constructor, se suelen 00:16:37
instanciar con métodos estáticos 00:16:39
de la propia clase 00:16:41
entonces si yo ya me quedo con eso 00:16:42
las clases nuevas de paquetes nuevos 00:16:45
como java time 00:16:47
no suelen instanciarse con new local 00:16:48
date sino con métodos estáticos de constructor 00:16:51
entonces yo ya busco local date punto 00:16:53
a ver que tiene 00:16:55
si busco local date punto a ver que tiene, veo que tiene un parse 00:16:56
que me explica que justo 00:17:00
a partir de un string 00:17:01
que tú le pases a partir de un string 00:17:04
te crea el local date 00:17:05
eso es lo que me explica el parse, anda justo es el que quiero 00:17:07
ah pero me pide el string 00:17:10
fecha, pero luego me pide 00:17:11
un objeto 00:17:13
de este tipo, porque me lo explica 00:17:15
lo estoy leyendo 00:17:17
un objeto de este tipo con la sintaxis 00:17:18
del string 00:17:21
pues tengo que instanciar este objeto 00:17:22
de nuevo, esto no se suele instanciar 00:17:25
con un constructor 00:17:27
con métodos estáticos, pues si yo pongo 00:17:28
este objeto que es el que me pide que le pase aquí 00:17:30
punto para los estáticos 00:17:33
pues rápidamente vería, encontraría 00:17:35
anda, pero si tengo un método 00:17:37
of pattern que me está 00:17:38
explicando que tú pásale 00:17:41
una sintaxis 00:17:42
y él ya te crea el 00:17:45
datetimeformatter asociado 00:17:47
pues ya está, es que no me ha hecho falta 00:17:48
a consultar a HGPT ni a nada, simplemente 00:17:51
con A 00:17:53
acordarse uno 00:17:55
de que en los 00:17:57
paquetes más recientes, desde hace ya tiempo 00:17:59
los objetos 00:18:01
que uno necesita 00:18:03
no se suelen instanciar directamente 00:18:04
con el constructor 00:18:07
sino a través de métodos estáticos 00:18:08
de la propia clase, veis aquí 00:18:11
el objeto local date lo hemos 00:18:13
instanciado con el método parse de local date 00:18:14
y el objeto dateta 00:18:17
informater lo hemos instanciado con el 00:18:18
Método of pattern de esto. 00:18:20
Ahora ya, sabiendo eso, 00:18:23
uno puede cotillear los métodos estáticos que hay. 00:18:25
Y rápidamente encuentra el método estático que necesita. 00:18:27
Este para crear el local date 00:18:30
y este para crear el formateador 00:18:32
a partir de la sintaxis que a mí me dé la gana. 00:18:38
Yo he puesto esta porque me ha dado la gana 00:18:41
poner esta para el usuario. 00:18:42
Pero podría haber puesto otra. 00:18:45
Vale, pues entonces ya tenemos el local date. 00:18:49
Estamos haciendo la reserva. 00:18:51
Destino. 00:18:53
el destino me dirá París, Roma 00:18:53
lo que sea, pero yo a la reserva 00:18:56
le tengo que pasar un objeto destino 00:18:58
pues que suerte 00:18:59
porque los destinos están en un fichero 00:19:02
¿tengo yo que irme al fichero a abrirlo? 00:19:04
pues no, porque para eso tengo un DAO 00:19:06
destino, para eso son los DAOs 00:19:08
para que yo me olvide desde el main de toda la 00:19:10
complejidad de acceso a datos 00:19:12
anda, yo tengo un DAO destino que tenía 00:19:13
un método get 00:19:16
que le doy el nombre del destino y me da el objeto 00:19:17
completo, entonces aquí 00:19:20
vemos la importancia de los dados, yo me olvido 00:19:24
del acceso a datos 00:19:26
yo pido el nombre del destino, París 00:19:27
pero yo necesito el objeto entero 00:19:30
para pasar eso a la reserva 00:19:32
pues lo saco del dado destino, venga 00:19:34
lo saco 00:19:36
¿qué es null? pues le digo, perdona 00:19:37
pero el que me has dado no existe 00:19:40
y ya está 00:19:41
¿qué no es null? pues ahora ya sí 00:19:42
me creo la reserva 00:19:46
con el código que yo he generado 00:19:47
yo por mi cuenta 00:19:50
para asegurarme de que es único 00:19:52
con el nombre que me han dado 00:19:54
con la fecha local de que he instanciado 00:19:56
y con el objeto destino que he leído del fichero 00:19:58
me creo la reserva 00:20:00
y la inserto a través del dado 00:20:02
reserva y ya está 00:20:04
capturo 00:20:06
la excepción y listo 00:20:08
¿vale? entonces 00:20:12
el main es rollo 00:20:14
porque tiene la parte de comunicación con el 00:20:16
usuario, pues coger los datos 00:20:18
instanciar los objetos 00:20:20
pero toda la parte de acceso 00:20:21
a datos la tiene subcontratada 00:20:24
a los DAOs. 00:20:26
La tiene aquí subcontratada para sacar el destino 00:20:28
a través de un nombre. 00:20:30
La tiene subcontratada 00:20:33
aquí para insertar 00:20:35
la reserva una vez que ya la tiene instanciada. 00:20:37
Lo tiene eso ya subcontratado, que es la idea. 00:20:39
Cada cosa se ocupa de lo suyo. 00:20:41
Y no hay mezcla. 00:20:45
Y bueno, sí. 00:20:47
Sí, lo único que he hecho 00:20:51
es en la propia clase 00:20:52
reserva, como son códigos de reserva 00:20:54
he hecho una variable estática 00:20:56
que inicialmente la he iniciado 00:20:58
a 1 y es la que uso 00:21:01
para cada vez que creo una reserva nueva 00:21:03
le paso esta y la dejo 00:21:05
incrementada y así el usuario 00:21:07
no tiene que meter el código de reserva para crearla 00:21:12
se crea solo 00:21:14
y ya está, efectivamente 00:21:15
sí 00:21:21
efectivamente 00:21:23
L es que 00:21:25
lo interprete como long, como lo ha declarado 00:21:27
como long, vale 00:21:29
cuando lo usas en el main 00:21:32
pero efectivamente tienes razón 00:21:37
que cada vez que arrancas la aplicación de nuevas 00:21:40
y metes una reserva y hay reservas de antes 00:21:42
te va a repetir los códigos 00:21:44
entonces esto deberíamos cambiarlo 00:21:46
para que 00:21:48
como tenemos el dado de reservas 00:21:50
pues podemos tirar del dado de reserva 00:21:54
un find all y coger la última de ellas 00:21:56
y ya está 00:21:59
exacto, claro, porque 00:21:59
esto de aquí efectivamente 00:22:06
no está muy bien pensado así 00:22:08
van a repetirse los códigos 00:22:10
vale 00:22:12
bueno, pues esto 00:22:13
efectivamente habría que modificarlo 00:22:18
y nada, la prueba 00:22:20
del get 00:22:27
es que ya no tiene nada que hacer 00:22:27
se pide el código de reserva 00:22:32
y muestra el 00:22:34
a través del dado de reserva 00:22:36
saca la reserva y la muestra 00:22:38
punto string en reserva 00:22:40
para que lo muestre y se acabó 00:22:42
vale, entonces bueno habría que añadir 00:22:43
el método de borrar y modificar 00:22:48
pero es llamar al dado de reserva 00:22:49
y en cada uno de ellos, en el borrar 00:22:51
pedir el código, ¿cuál quieres borrar? 00:22:53
pides el código y llamas a delete 00:22:55
en actualizar tienes que pedir 00:22:57
los nuevos datos y llamar a update 00:22:59
y ya está 00:23:01
y esto 00:23:02
lo pongo aquí 00:23:05
para que no se me olvide 00:23:07
al más alto 00:23:09
del fichero 00:23:18
si existe 00:23:21
vale, pues entonces 00:23:24
estos serían dos 00:23:27
daos básicos, que son las acciones 00:23:29
básicas, insertar 00:23:31
borrar, consultar 00:23:34
y actualizar 00:23:36
y recuperar todos el find all 00:23:37
que también se suele poner, pues para que tú tengas 00:23:39
un listado de todo, vale 00:23:41
pero puede que mi aplicación 00:23:43
quiera hacer más cosas 00:23:45
aparte de eso 00:23:46
pues por ejemplo 00:23:47
¿cuál es la próxima reserva? 00:23:48
o dame todas las reservas 00:23:52
de un cliente 00:23:53
por ejemplo 00:23:55
o ese tipo de cosas 00:23:56
esas son ya funcionalidades 00:23:57
más específicas 00:23:59
de mi aplicación 00:24:00
no son el cruz genérico 00:24:01
no son el cruz genérico 00:24:03
que es 00:24:05
insert, delete 00:24:05
con get 00:24:06
y update 00:24:08
¿vale? 00:24:09
son cosas específicas 00:24:11
pues como estas que digo 00:24:12
pues eliminar todas las consultas 00:24:13
todas las reservas de un cliente 00:24:16
por ejemplo, esas son cosas específicas 00:24:17
a eso se lo suelen 00:24:20
llamar servicios 00:24:22
los servicios que da mi aplicación, los servicios 00:24:23
entonces los métodos que 00:24:26
hacen eso, no lo suelo 00:24:27
meter en el DAO, porque el DAO suele 00:24:30
tener un uso que es las cuatro acciones 00:24:31
básicas, más el find all que es recuperar 00:24:33
todos, entonces 00:24:36
lo que solemos hacer es una clase 00:24:37
de servicio donde 00:24:40
están los métodos que hacen las cosas específicas y esos métodos se construirán llamando a los 00:24:41
de DAO. Esos métodos no tienen por qué ellos acceder al fichero, no. Esos métodos se construyen 00:24:50
combinando los de DAO para hacer lo que toque hacer. Entonces, nosotros vamos a incorporar aquí 00:24:56
una capa servicio y ya nos quedaríamos tranquilos con esta aplicación. Tenemos ya una capa de main, 00:25:02
La del modelo con reserva y destino 00:25:10
La de DAO, que es el acceso básico 00:25:12
A los datos 00:25:13
Las cuatro cosas que hacen falta 00:25:15
Bueno, hacen falta más 00:25:18
Y ahora vamos a meter una capa 00:25:19
Por aquí, un paquete 00:25:21
Pues service, por ejemplo 00:25:22
Y ahora una clase 00:25:25
Que es 00:25:31
A ver, lo vamos a dejar planteados 00:25:32
Quedáis haciéndolo 00:25:37
Y así ya no sirve de parada 00:25:38
Vale, pues 00:25:41
Reserva 00:25:45
Service 00:25:48
Venga, servicios que queremos hacer aquí 00:25:52
Pues por ejemplo 00:25:58
Vamos a poner tres 00:25:59
Listado 00:26:01
De la 00:26:04
De la 00:26:05
No, que te devuelva 00:26:07
La próxima reserva 00:26:09
Más próxima en tiempo 00:26:11
Entonces 00:26:12
La reserva que esté de más próximo 00:26:13
Vencimiento 00:26:17
A la reserva que esté más próxima en el tiempo 00:26:18
En fecha 00:26:20
¿A qué vez a mañana? 00:26:21
La que esté más cerca de hoy 00:26:22
Vale 00:26:24
Es que no sé cómo llamarlo 00:26:25
Reserva más próxima 00:26:30
Vale 00:26:36
Otro, por ejemplo 00:26:38
Todas las reservas de un cliente 00:26:54
Eso podría ser típico 00:26:57
Reservas 00:26:58
Cliente 00:27:06
Sí, sí, sí 00:27:10
El parámetro que se me ha olvidado pasárselo 00:27:18
Estaba poniendo esto 00:27:20
Lista de 00:27:21
Sí, a ver 00:27:26
Lista de reserva 00:27:27
Y aquí habría que pasarle 00:27:30
Nom del cliente 00:27:32
Y ahora 00:27:36
Pues por ejemplo, un destino 00:27:44
Se ha caído 00:27:46
Pues vamos a eliminar 00:27:48
Todas las reservas de un destino 00:27:50
Por ejemplo 00:27:52
elimina reservas 00:27:53
le pasas el nombre 00:28:01
de un destino 00:28:05
y así esta aplicación 00:28:06
podría tener 00:28:09
tropecientos mil servicios 00:28:11
todos con su nombre 00:28:13
y estos nombres ya si que 00:28:15
son lo más explicativo posible, los de DAO 00:28:16
son como métodos más estándar, GET 00:28:19
UDATE, DELETE 00:28:21
esto es ya lo que haga mi aplicación 00:28:22
como podría ser 00:28:25
hacer un descuento de 10% 00:28:26
al cliente, a un cliente 00:28:30
habría mil servicios que se podrían hacer 00:28:32
como seguro que os aburrís 00:28:34
mucho, vamos a ver, ese me ha gustado 00:28:36
el de hacer un descuento 00:28:38
boolean 00:28:40
descuento 00:28:42
cliente 00:28:45
y al descuento cliente 00:28:46
se le pasaría el nombre del cliente 00:28:48
al que le vamos a hacer 00:28:50
un descuento 00:28:52
y el porcentaje del 00:28:53
descuento 00:28:56
Porcentaje 00:28:57
Descuento 00:29:03
Venga, nos estamos viniendo muy arriba 00:29:04
Doberman, has dicho 00:29:07
Si le 00:29:16
Si le quieres hacer un 3,7 00:29:17
De descuento 00:29:20
Un 0, 00:29:21
Bueno, yo lo dejo en int 00:29:23
Que el label me da ansiedad 00:29:25
Vale, pues entonces 00:29:26
La idea es que estos 00:29:31
Servicios de aquí 00:29:33
Estos servicios 00:29:34
Tengan que llamar 00:29:36
Los métodos del DAO 00:29:39
Hacer cosas con ellos, combinarlos 00:29:40
Yo que sé, hacer lo que toque 00:29:42
Entonces 00:29:44
Esta clase de servicio va a necesitar 00:29:45
Los objetos reserva DAO 00:29:48
Y todos esos de aquí 00:29:50
Y un destino DAO a lo mejor también 00:29:51
Va a necesitar esto 00:29:54
Un objeto 00:29:56
Reserva DAO 00:29:58
Para trabajar 00:30:00
Lo va a necesitar para trabajar 00:30:04
Y puede que también necesite 00:30:05
No lo sabemos, puede que también necesite 00:30:08
Un objeto 00:30:10
Destino dado 00:30:13
Puede que también lo necesite 00:30:14
A lo mejor no 00:30:15
No sabemos 00:30:18
Bueno, si queremos eliminar las reservas 00:30:19
Y eliminar también el destino 00:30:24
Porque ese se ha ido 00:30:25
Vale, entonces 00:30:28
Va a tener que trabajar con estos 00:30:30
Haciendo aquí cosas con ellos 00:30:32
Entonces vamos a pasárselos 00:30:34
Por el constructor los dos 00:30:36
Vamos a hacerle un constructor 00:30:38
Y ahora a ver si conseguimos hacer estos métodos 00:30:40
Apoyándonos en los métodos del DAO 00:31:00
Sin necesidad de acceder al fichero de otra manera distinta 00:31:03
Apoyándonos en los métodos 00:31:07
A ver si conseguimos hacerlos 00:31:09
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:
25 de marzo de 2026 - 11:06
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
31′ 21″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
139.48 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid