Saltar navegación

20260320 FicherosObjetos_AppReservas_1 - 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 22 de marzo de 2026 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, pues vamos a hacer 00:00:00
una pequeña aplicacioncilla 00:00:05
hoy para 00:00:07
cerrar ya este tema de 00:00:08
persistencia de objetos 00:00:10
con object output stream 00:00:13
y object input stream 00:00:14
vale, pues haciendo 00:00:18
otra aplicación más, dándole otra 00:00:19
estructura, otro diseño 00:00:21
un diseño un poquito más 00:00:23
más profesional 00:00:24
vale, y usando 00:00:26
los ficheros de objetos 00:00:29
como si fueran tablas 00:00:31
de bases de datos 00:00:33
¿vale? es decir 00:00:34
nosotros normalmente 00:00:39
nuestras aplicaciones 00:00:41
cuando sean persistentes que este año 00:00:44
pues no lo son salvo por esto de 00:00:46
de los ficheros 00:00:47
vale pues 00:00:49
vale pues nosotros 00:00:55
vale pues 00:01:04
normalmente una aplicación 00:01:16
vale esto 00:01:17
es mi aplicación Java que hace las cosas 00:01:33
¿vale? aquí está 00:01:35
el usuario 00:01:37
aquí está la vista de la aplicación 00:01:39
¿vale? nosotros 00:01:45
estamos haciendo 00:01:47
la vista de la aplicación, lo que el 00:01:48
usuario ve cuando accede a ella 00:01:52
nosotros la estamos haciendo ahora mismo 00:01:54
con consola 00:01:57
System.out para mostrarle mensajes 00:01:58
al usuario 00:02:00
y leyendo lo que él nos 00:02:01
diga, leyéndolo con el escáner 00:02:05
¿vale? esa es nuestra vista 00:02:07
¿Vale? Pero esta vista podría estar programada de otra manera 00:02:08
Podría ser un HTML con Javascript 00:02:12
Bueno, podría ser con JavaFX, con Swin 00:02:14
Es decir, esta vista podría estar programada de otra manera 00:02:18
Para nosotros es simplemente System.out 00:02:21
Para mostrarle mensajes 00:02:24
Y el escáner para ver la información 00:02:25
¿Vale? 00:02:27
Esta vista, que es la parte de la aplicación 00:02:29
Que se ocupa de comunicarse con el usuario 00:02:32
esta vista lógicamente llamará 00:02:36
métodos de mi aplicación 00:02:38
esos métodos de mi aplicación 00:02:39
pues ya son los que hacen las cosas 00:02:42
esta es 00:02:44
la lógica de mi aplicación 00:02:46
y esto ya se puede organizar de muchas maneras 00:02:48
aquí ya es donde viene un diseño de clases 00:02:50
con las entidades del modelo 00:02:52
donde meto los métodos 00:02:54
pues bueno, pues depende 00:02:56
las propias clases o métodos estáticos 00:02:57
en un método aparte 00:03:00
aquí ya mi diseño de clases ya será el que sea 00:03:01
¿vale? 00:03:04
Lo mejor estudiado posible para que la aplicación se pueda luego ir ampliando, lógicamente. Si mi diseño fuera un programa enorme, pues esa aplicación no se podría ir ampliando, no se le podrían ir corrigiendo posibles errores que salieran a posteriori, sería un desastre. 00:03:06
Entonces, este diseño de clases tiene que estar lo más estudiado posible, ¿vale? Como mínimo, siempre tendrá que haber un buen modelo, un buen modelo de alumno, matrícula, no sé qué, y luego ya, ¿dónde meto yo las operaciones? Bueno, una clase aparte, en las propias entidades, depende. 00:03:23
En cualquier caso 00:03:45
Estos métodos y todo esto 00:03:47
Lo que haga, lógicamente 00:03:49
Trabajará con datos y como hemos 00:03:51
Dicho estos días 00:03:53
Nuestros datos hasta ahora 00:03:55
Los cargábamos de nuevas 00:03:56
Limpios cada vez que los íbamos pidiendo 00:03:59
Al usuario y esos datos 00:04:01
Lógicamente están aquí en la memoria RAM 00:04:03
¿Vale? En la memoria RAM 00:04:05
Pues están 00:04:08
Los datos en los que la aplicación 00:04:09
Trabaja y en donde va a estar 00:04:11
Pues en colecciones, en variables 00:04:13
¿Vale? Aquí están nuestras variables 00:04:15
Nuestras colecciones de datos 00:04:17
¿Vale? Entonces 00:04:19
Cuando esta aplicación 00:04:28
Se cierra, estos datos se van 00:04:30
Que es lo que hemos estado diciendo estos días 00:04:33
Y ese sería el funcionamiento 00:04:35
De una aplicación no persistente 00:04:37
¿Vale? 00:04:39
Entonces si queremos que la aplicación 00:04:41
Ahora se convierta en una aplicación 00:04:43
Con persistencia 00:04:45
Este esquema pues se tiene 00:04:46
Que ampliar 00:04:49
si queremos que la aplicación se convierta 00:04:50
en una aplicación persistente 00:04:53
con datos persistentes 00:04:55
este esquema se tiene que ampliar 00:04:57
se tiene que ampliar porque aparece 00:04:58
pues un almacén de datos 00:05:01
persistentes que normalmente 00:05:03
es una base 00:05:05
de datos con sus tablitas 00:05:07
¿vale? normalmente sus tablitas 00:05:09
etcétera ¿vale? 00:05:11
estoy un poco recopilando 00:05:13
lo que me he hecho estos días 00:05:15
entonces mi aplicación 00:05:16
tiene que comunicarse con esta base 00:05:19
de datos, no hay otra, los métodos de esta 00:05:21
aplicación tienen que 00:05:23
comunicarse con la base de datos 00:05:25
entonces pues para eso 00:05:26
hay toda una serie de historias 00:05:29
que ya veremos en particular el año 00:05:31
que viene, lo que nos importa a nosotros 00:05:33
ahora mismo es que esta parte 00:05:35
esta parte hay que programarla 00:05:37
también, esta parte 00:05:39
hay que programarla 00:05:41
entonces eso serán 00:05:42
unas clases entre 00:05:47
si hacemos un buen diseño 00:05:48
Eso serán unas clases aparte aquí, unas clases aparte que se ocupan exclusivamente del acceso a datos. Entonces, esas clases se ocupan exclusivamente de comunicarse con la base de datos. Y ya digo, comunicarse con la base de datos no es trivial, ¿vale? No es trivial comunicarse con la base de datos. Ya lo resolveremos, ¿vale? 00:05:50
Entonces, estas clases se comunican con la base de datos de esa manera, no trivial, que hay que programar bien y ofrecen su comportamiento, ofrecen sus métodos a la lógica de mi aplicación. 00:06:19
Y este ya que quiere insertar un objeto, pues llama a este y este ya lo inserta. Que quiere recuperar un objeto, pues llama a este y este ya lo recupera. 00:06:33
¿Vale? Y a través de estas clases que están ahí en medio, a través de estas clases, la información de esta base de datos, pues va llegando a estas colecciones. Va llegando y va saliendo. ¿Vale? A través de estas clases intermedias. Va llegando y saliendo. ¿Vale? 00:06:43
entonces en nuestro caso 00:07:01
podemos hacer esto mismo 00:07:05
podemos simular esto 00:07:07
quitando la base de datos y poniendo 00:07:08
ficheros, ya está 00:07:11
podemos simular este comportamiento 00:07:12
en lugar de con base 00:07:15
de datos 00:07:17
pues cambiando esto 00:07:17
por ficheros 00:07:20
y ya está, entonces nosotros 00:07:22
tenemos ahí nuestros ficheros 00:07:25
donde están los datos, a lo mejor en alguno 00:07:26
tengo los alumnos 00:07:34
en otro tengo las matrículas 00:07:35
en otro tengo pues lo que sea 00:07:37
lo podemos simular con ficheros 00:07:38
entonces mi aplicación 00:07:41
va a trabajar con objetos como siempre 00:07:43
bueno pues entonces 00:07:45
estas clases de aquí 00:07:47
lo que tendrán es que acceder a los ficheros 00:07:48
para guardar los objetos, recuperarlos 00:07:51
bueno y que clases son 00:07:53
las que usamos para eso 00:07:55
pues las que vimos ayer 00:07:56
object input stream 00:07:58
para leer objetos 00:08:00
y object output string para escribirlos. 00:08:03
Ya está, podemos simular el acceso a la base de datos 00:08:10
como si fuera una base de datos con estas clases. 00:08:13
¿Vale? 00:08:17
Bueno, asumido este esquema, 00:08:20
tendríamos en realidad dos formas de plantear la aplicación. 00:08:24
Una, voy a estar yo cada vez que tenga que recuperar 00:08:28
un alumno por DNI o insertar una matrícula, 00:08:32
voy a estar yo todo el rato teniendo que llamar 00:08:36
a los métodos de esta clase 00:08:38
y esta clase accediendo 00:08:40
al fichero? 00:08:42
No tengo por qué. A ver, eso es pesado, 00:08:44
es costoso. Es lo que haríamos si esto 00:08:46
fuera una base de datos. Es lo que 00:08:48
haríamos. Cada vez que yo quiera algo en la base de datos, 00:08:50
lo recupero. Cuando quiera guardar 00:08:53
algo, lo mando. 00:08:54
Pues aquí, cada vez que yo quiera 00:08:56
recuperar un alumno o 00:08:58
modificar un alumno dado su DNI, 00:09:00
voy a tener que estar todo el rato 00:09:02
para cada una de esas acciones, llamando 00:09:04
a esta clase y esta clase comunicándose. 00:09:06
no tendría por qué 00:09:08
si lo que hago es 00:09:10
lo que hicimos ayer 00:09:12
en la aplicación de ayer que es 00:09:15
cuando la aplicación arranca 00:09:16
lo primero que hace la aplicación es mover 00:09:18
todo esto 00:09:21
a las colecciones que se adapten 00:09:22
lo mueve todo 00:09:25
y ahí está ya la colección 00:09:27
con los datos, con lo cual a partir de ahí 00:09:29
esto ya no pinta nada 00:09:31
toda la lógica 00:09:34
de la aplicación 00:09:36
de recuperar alumnos 00:09:37
insertar, modificar, toda la lógica 00:09:39
se hace con la colección 00:09:41
ahí ya me da igual que haya fichero o no 00:09:43
cuando la aplicación 00:09:45
termine, antes de terminar 00:09:47
o cuando yo le dé a la acción 00:09:48
correspondiente de guardar, si tengo 00:09:51
habilitado el botón de guardar 00:09:53
pues todo esto, pum, se va aquí 00:09:54
¿vale? luego el acceso 00:09:57
al fichero se va a reducir a dos momentos 00:09:59
cuando la aplicación arranca 00:10:01
todo esto se vuelca aquí 00:10:02
y a partir de ahí ya no hay ficheros 00:10:04
hay acciones lógicas con las colecciones 00:10:06
y al momento de terminar 00:10:09
de todo lo que hay aquí 00:10:10
se vuelca los ficheros y ya está 00:10:11
entonces 00:10:14
con ficheros es el planteamiento más sencillo 00:10:16
en realidad 00:10:19
solo tiene una pega 00:10:19
que es 00:10:23
si la información es gigantesca 00:10:24
si la información es gigantesca 00:10:27
no la volcamos en una RAM 00:10:29
lo que pasa es que cuando la información 00:10:31
es gigantesca 00:10:33
está en bases de datos, no está en ficheros. 00:10:34
Todo lo demás, salvo que la información gigantesca 00:10:40
se queda ahí en RAM ocupando, 00:10:43
todo lo demás son ventajas. 00:10:45
Es mucho más rápido operar directamente con la RAM 00:10:46
para insertar, para hacer lo que sea, 00:10:49
mucho más rápido que cada vez que tenemos que hacer algo 00:10:51
ir al fichero, lógicamente. 00:10:53
Mucho más rápido directamente aquí. 00:10:55
Entonces, nosotros, aunque nuestras situaciones, 00:11:04
que no son millones de millones de datos, 00:11:07
nuestras situaciones se prestarían 00:11:10
a que trabajáramos como ayer 00:11:13
que es cuando la aplicación arranca 00:11:15
leo todos mis alumnos 00:11:17
o lo que fuera que teníamos en el fichero que no me acuerdo 00:11:19
los leo, ya en la colección 00:11:21
hago lo que sea 00:11:23
y luego antes de irme los guardo 00:11:25
aunque en nuestras situaciones reales 00:11:27
se prestarían así, porque tenemos millones de datos 00:11:29
vamos a hacer 00:11:31
ahora esta otra aplicación 00:11:33
con esta otra arquitectura 00:11:34
que es la arquitectura real, porque es la que se 00:11:36
usaría si tuviéramos una base de datos 00:11:39
que es 00:11:40
unas clases 00:11:42
específicas para acceso a datos que te 00:11:44
ofrecen los métodos de insertar 00:11:47
objeto, recuperar, modificar 00:11:49
los que sea y cada vez que tú quieres 00:11:51
hacer algo, llamas a 00:11:53
eso y eso te lo hace en el fichero directamente 00:11:55
entonces el fichero está actualizado 00:11:57
todo el rato 00:11:58
de la otra manera 00:11:59
el fichero solo se queda actualizado 00:12:02
cuando la aplicación termina 00:12:05
¿vale? 00:12:06
Venga, vamos a plantear una aplicación así 00:12:09
Con clases de acceso a datos 00:12:11
Y cada vez que queremos hacer una acción con los datos 00:12:15
Hacerla directamente con el fichero 00:12:17
No hacerla con la colección 00:12:19
Porque hemos volcado previamente todo 00:12:21
¿Vale? Y así tenemos una arquitectura más real 00:12:23
Como si fuera 00:12:27
Acceder a una base de datos 00:12:27
Que no es una base de datos, es un fichero 00:12:30
Pero la arquitectura va a ser la misma 00:12:31
Que aproveche 00:12:33
Uno y no más 00:12:33
Ah, que es un caramelo 00:12:36
Bueno, se tolera 00:12:39
¿Vale? Entonces, bueno, pues a ver 00:12:41
¿Qué os apetece gestionar? 00:12:46
Porque yo no tengo imaginación ya 00:12:52
Y ya no queremos 00:12:54
Alumnos, ni clientes, ni libros 00:12:56
Ni discos 00:12:58
Ni kebabs 00:12:58
A ver, algo que se traduzca 00:13:02
En entidades que podamos describir 00:13:07
yo de un kebab no sé describir un kebab 00:13:09
sí, pero eso sería un restaurante 00:13:13
puede ser un restaurante con menús 00:13:17
pero siempre que os pregunto eso 00:13:19
habláis de menús y de comidas 00:13:22
eso nos lo prohíbe 00:13:23
nuestra religión musulmana 00:13:28
y hoy acaba el ramadán 00:13:29
así que no estamos para eso 00:13:31
Entonces, vamos a plantear la estructura y luego ya hacéis los métodos. 00:13:32
A ver, una app de agencia de viajes, muy bien, muy bonita. 00:13:56
Vale, el paquete del modelo. 00:14:04
El modelo tiene la reserva. 00:14:12
Bueno, primero vamos a poner el destino, que es la pequeñita. 00:14:19
El destino se va a caracterizar por el nombre del destino y lo que cuesta, por ejemplo. 00:14:27
Lo que cuesta ir allí. 00:14:46
Lo que cuesta ir a ese destino. 00:14:49
Cada destino tiene un precio asociado, lo que cuesta ir ahí. 00:14:50
vale, pues por ahora 00:14:52
por rapidez le hacemos los getter y setter 00:14:54
solamente y ya está 00:14:57
y ahora, lo que realmente gestiona 00:14:58
la agencia de viajes son sus reservas 00:15:07
tiene su lista de reservas 00:15:09
que es la que tiene que tener ahí guardadita 00:15:11
eso es lo que va a 00:15:13
gestionar las reservas, para crear reservas 00:15:15
eliminar reservas, consultar 00:15:17
el precio de una reserva 00:15:19
las fechas, etc 00:15:21
entonces, la reserva 00:15:23
se va a caracterizar 00:15:25
por el código 00:15:27
venga, le vamos a poner long 00:15:28
porque nunca usamos long 00:15:31
y es una pena 00:15:33
y tiene un montón de reservas 00:15:34
entonces cuanto más long, mejor 00:15:37
código de reserva 00:15:39
vale, le vamos a poner un cliente 00:15:43
con stream, para no hacer más clases 00:15:46
y le vamos a poner 00:15:48
una fecha 00:15:51
fecha del viaje 00:15:52
lo que sea, fecha, ya está 00:15:57
date, no, le vamos a poner 00:15:59
Local date 00:16:03
Más modernita 00:16:04
¿Vale? 00:16:06
Local date 00:16:09
Es de 00:16:11
Exactamente 00:16:14
Muy bien 00:16:18
¿Vale? 00:16:19
¿Dónde te vas y cuánto te gastas? 00:16:34
Y ahora los getter y los setter 00:16:38
¿Perdón? 00:16:40
Efectivamente 00:16:48
Que sí, que se me ha olvidado 00:16:49
Efectivamente 00:16:50
Es que estamos ya 00:16:53
El destino 00:16:58
Lógicamente 00:17:03
Getter y setter 00:17:05
Vale 00:17:08
Vale 00:17:08
A medida que se vaya haciendo la aplicación 00:17:15
Pues iremos incorporando 00:17:18
Porque lo irá pidiendo 00:17:21
O iréis incorporando constructores 00:17:22
EqualHasCode, toString 00:17:24
Lo que haga falta 00:17:26
Ahí lo dejamos a bajo mínimos 00:17:27
Ahora 00:17:30
Con getter y setter 00:17:30
A ver, es que se va a confundir un poco 00:17:32
Le debería llamar nombre, yo creo 00:17:40
Nombre del destino 00:17:42
Sí, porque 00:17:43
Si no 00:17:46
Sí, pero como refactorizar 00:17:46
No quita los getter y setter 00:17:51
Pues así 00:17:53
Nombre y nombre 00:17:54
Vale, pues ahí tenemos nuestro modelo 00:18:08
Podría ser muchísimo más complicado 00:18:16
Pero se queda así de sencillo 00:18:19
En condiciones normales, pues el modelo 00:18:20
Pues hombre, serían 10, 11, 12 clases 00:18:22
Aquí son 2 00:18:25
Pero bueno, a los efectos viene a ser lo mismo 00:18:27
Una vez que ya está bien diseñado 00:18:29
Bien planteado sobre el papel 00:18:32
Pues uno ya lo planta en 00:18:33
En sus clases y listo 00:18:36
Ahora, ¿qué es lo siguiente que hacemos? 00:18:39
Una vez que hemos decidido dónde se van a guardar los datos de manera persistente y nosotros ya hemos decidido que es un fichero, una vez que lo hemos decidido, ahora ya vamos a hacer las clases de acceso a datos. 00:18:42
Es decir, las clases que me van a ofrecer los métodos para insertar reservas, recuperar reservas, lo que yo quiera hacer. 00:18:55
pues venga 00:19:03
vamos a hacer 00:19:05
ese paquete 00:19:07
y como ese paquete es 00:19:08
un paquete para clases exclusivamente 00:19:11
que me ofrecen acceso a los datos 00:19:13
lo vamos a llamar 00:19:15
DAO 00:19:17
porque DAO que significa pues 00:19:18
Data Access Object y como 00:19:20
nos gusta mucho el inglés 00:19:22
pues al paquete lo vamos a llamar 00:19:24
DAO 00:19:27
ese paquete que va a tener 00:19:27
las clases que me permiten 00:19:30
acceder a los datos directamente 00:19:33
en su fuente 00:19:35
sea fichero, base de datos 00:19:36
vale, pues a ver, ¿qué queremos 00:19:38
hacer? nuestra aplicación lo que quiere es 00:19:43
quiere 00:19:45
a ver 00:19:48
porque con ficheros no quiero complicarlo 00:19:52
mucho, de destino 00:19:55
hacemos un fichero aparte de 00:19:57
destinos, pero si hacemos un fichero aparte de 00:19:58
destinos, reserva 00:20:00
Venga, sí, que somos unos, sois unos valientes. 00:20:06
Vamos a hacer un fichero. 00:20:09
Esto es como si fuera una base de datos. 00:20:13
Pensadlo como si fuera una base de datos, 00:20:14
pero vamos a simular en ficheros. 00:20:15
Para hacerlo más parecido a una situación real. 00:20:17
En una situación real tendríamos una tabla con destinos. 00:20:19
¿Verdad que sí? 00:20:23
Con los campos que fueran. 00:20:24
En este caso, dos, nombre y precio. 00:20:26
Una tablita. 00:20:27
Y luego tendríamos una tabla con reservas. 00:20:28
Con todos sus datos, fecha, código. 00:20:31
Y habría un campo que es la clave ajena, 00:20:33
al destino, ¿verdad? 00:20:36
Eso implica que tiene que haber 00:20:39
una clave primaria en destino, porque si no 00:20:40
¿cómo hago una clave ajena? 00:20:42
Vale, pues nombre nos vale. 00:20:44
¿Vale? Entonces, 00:20:47
eso sería 00:20:49
si lo hiciéramos en una base de datos. 00:20:51
Tendríamos una tabla con los 00:20:52
destinos y otra tabla con las 00:20:54
reservas que mediante una clave ajena 00:20:56
me lleva al 00:20:58
destino correspondiente. 00:21:00
Nosotros vamos a hacernos 00:21:03
un fichero con los destinos. 00:21:04
Porque puede ocurrir que mi agencia de viajes quiera incorporar destinos nuevos, 00:21:06
eliminar destinos porque ya no trabaja con ese país, lo que sea. 00:21:13
Entonces, un fichero con destinos. 00:21:18
Y luego vamos a hacernos un fichero con las reservas. 00:21:20
Lo que pasa es que ese fichero que tiene las reservas 00:21:24
no va a ser exactamente como una tabla que tiene solamente el nombre del destino 00:21:26
y que me lleva al destino. 00:21:33
ese fichero con las reservas tiene la reserva entera 00:21:34
porque ese fichero con las reservas 00:21:36
tendrá estos objetos 00:21:39
enteritos, los tendrá estos 00:21:40
objetos enteros, con lo cual 00:21:42
ese fichero de reservas 00:21:45
tiene dentro toda la información de la 00:21:46
reserva, el destino incluido 00:21:48
el destino incluido 00:21:50
¿vale? pero aún así 00:21:52
está bien tener un fichero aparte de destinos 00:21:54
para tener ahí los posibles destinos que tiene 00:21:56
mi aplicación, entonces yo si me 00:21:58
voy a hacer una reserva 00:22:01
A este destino, pues tengo ese fichero para ver si el destino existe, sacar los datos de él para crear el objeto y meterlo aquí, ¿vale? Como si fuera una base de datos. 00:22:02
Bueno, pues entonces vamos a tener dos ficheros. Un fichero con los posibles destinos y un fichero con las reservas que hay hechas. 00:22:13
vale, pues entonces 00:22:19
vamos a hacer dos clases dentro de DAO 00:22:22
una que me va a ofrecer 00:22:24
los métodos 00:22:26
para acceder al fichero de destinos 00:22:27
insertar un destino nuevo 00:22:30
eliminar un destino, por ejemplo 00:22:32
cambiar el precio de un destino 00:22:34
y otra clase que me va a ofrecer los métodos 00:22:35
para acceder a las reservas 00:22:38
hacer una reserva nueva 00:22:40
eliminar reserva, modificar fecha 00:22:41
de reserva, lo que yo decida que quiere 00:22:44
hacer mi aplicación 00:22:46
¿vale? 00:22:47
bueno pues entonces como vamos a tener dos ficheros 00:22:49
y vamos a hacer dos clases 00:22:52
venga vamos a empezar con la clase 00:22:53
que me va a ofrecer los métodos para 00:22:55
cambiar los destinos 00:22:57
esa clase pues tiene sentido 00:22:59
que la llamemos para organizarnos 00:23:02
destino dao 00:23:03
vale destino dao es la clase 00:23:05
que tiene los métodos que me van a permitir 00:23:11
acceder al fichero de destinos 00:23:13
ahora aquí ya si que tenemos que pensar 00:23:16
nosotros que métodos me importa meter 00:23:19
normalmente por defecto 00:23:21
en estas clases DAO 00:23:24
se meten las cuatro cosas que se pueden hacer 00:23:25
con los datos 00:23:28
que es insertar 00:23:28
eliminar, consultar 00:23:31
y modificar 00:23:34
el cruz famoso, normalmente por defecto 00:23:35
se meten los cuatro 00:23:37
luego a lo mejor nosotros solo nos interesa 00:23:38
implementar uno de ellos o dos de ellos 00:23:41
pues vamos a hacer una cosa 00:23:44
vamos a hacer 00:23:46
una interfaz destino DAO 00:23:47
no porque si luego la implemento 00:23:49
implementar los cuatro, vamos a 00:23:51
aunque normalmente se meterían los cuatro 00:23:54
vamos por ahora a meter 00:23:56
las únicas dos cosas que 00:23:57
nos puede interesar hacer, que luego se pueda ampliar 00:24:00
insertar un destino 00:24:02
nuevo, porque mi agencia ha ampliado 00:24:04
su escala de países y 00:24:06
ya puede ir a un destino nuevo 00:24:07
pues venga, ese método se llamaría 00:24:09
insert 00:24:12
insert 00:24:25
vale, ¿por qué 00:24:26
puesto un boolean, bueno vamos a aprovechar 00:24:40
ya que este método 00:24:42
no me tiene por qué devolver nada 00:24:43
porque lo que hace es meter un objeto en un fichero 00:24:46
es decir, este método 00:24:48
tendrá que hacer el object output string 00:24:50
con el fichero que tiene los destinos 00:24:52
hacer el write object 00:24:54
y poco más 00:24:56
pues como este método 00:24:57
no me tiene por qué devolver nada de retorno 00:25:00
podemos aprovechar 00:25:02
podemos aprovechar 00:25:04
y poner un boolean y true se ha funcionado 00:25:05
bien y false si no, por ejemplo 00:25:08
o lo dejamos en void 00:25:10
y lanzamos una excepción si algo no ha funcionado 00:25:11
porque el fichero no exista 00:25:15
vale, si no queremos 00:25:16
tener a la aplicación 00:25:19
principal luego toda loca y con los 00:25:20
trycatch que se ha vuelto toda loca 00:25:22
pues mira, un boolean 00:25:24
falso, si te devuelvo falso 00:25:26
es que esto no ha ido bien 00:25:28
y ya está, y no hay tantos trycatch 00:25:30
obligatorios arriba 00:25:32
vale, venga, pues con los destinos por ahora 00:25:33
vamos a hacer insertar un destino 00:25:36
y eliminar uno 00:25:38
porque ya no trabajamos 00:25:40
con ese país 00:25:42
vale, borrar 00:25:43
se borra por clave primaria siempre 00:25:49
entonces la clave primaria del destino es el nombre 00:25:52
vale, pues estos dos 00:25:54
métodos tendrá y estos métodos 00:26:06
actuarán sobre el fichero 00:26:08
el insert 00:26:09
ahora cuando lo hagáis 00:26:12
pues que será 00:26:14
abrir con object input 00:26:16
string, perdón, object 00:26:18
output string 00:26:20
pero claro, cuidado, si el fichero ya tiene cosas 00:26:21
tenemos que abrir 00:26:24
para añadir 00:26:26
porque si no me borra todo lo anterior 00:26:27
entonces, para añadir 00:26:29
lo único que tenemos que hacer 00:26:32
si recordáis ayer cuando abríamos 00:26:34
el object output 00:26:36
string 00:26:38
aquí 00:26:39
aquí cuando escribíamos con 00:26:41
object output string que era 00:26:51
aquí 00:26:53
vale, le pasábamos 00:26:55
al object output string un flujo 00:27:01
file output string que hay que pasarle 00:27:03
entonces este flujo es como 00:27:04
el file writer, admite 00:27:07
un segundo parámetro en el 00:27:09
constructor, que es el de 00:27:11
abres para añadir o abres para 00:27:12
borrar de cero y empezar nuevo 00:27:14
recordad que si ese segundo 00:27:16
parámetro en el constructor no está, por defecto 00:27:18
es como si estuviera falso, que es no abres para añadir 00:27:20
abres para pulirte lo entero 00:27:23
y empezar de nuevo 00:27:25
Entonces, si queremos abrir nuestro fichero de objetos para añadir, que se posiciona al final y entonces añadamos, pues este flujo que abramos le ponemos aquí coma true, ¿vale? Coma true y entonces el objeto put string se abre para añadir en este flujo, ¿vale? Se abre para añadir. 00:27:25
¿Pero el file output string también crea el archivo si no lo encuentro? 00:27:44
Sí, sí, sí, sí, como el file writer. 00:27:50
La única diferencia entre este y el file writer es que este envía el byte directamente 00:27:52
y el file writer tiene en cuenta que es un ASCII, entonces lo interpreta como ASCII 00:27:57
y lo codifica luego en Java en el unicode para que luego coincida. 00:28:02
Es la única diferencia, pero lo demás... 00:28:07
Vale, pues entonces, este método primero será abrir para añadir, 00:28:10
mandar el objeto nuevo y listo. 00:28:16
Y este, este no es tan fácil porque tenemos que borrar del archivo. 00:28:18
Entonces, este habrá que hacerlo como hacíamos los dos ejercicios, 00:28:23
con un archivo temporal, el archivo de maniobras de toda la vida. 00:28:26
Entonces, abriremos el original para leer, un temporal limpio para escribir. 00:28:32
vamos, leyendo del original 00:28:37
¿coincide en destino 00:28:40
con el que tengo que borrar? 00:28:42
no lo copio, ¿no coincide? 00:28:44
lo copio 00:28:46
una vez que hemos creado el temporal 00:28:46
con los objetos nuevos 00:28:49
que son los originales menos el que hay que borrar 00:28:51
borro el original y cambio el nombre 00:28:54
pues ese sería el delete de destino 00:28:56
y podríamos añadir 00:28:58
si hacemos todo esto muy rápido 00:29:01
pues modificar 00:29:02
el precio de un destino 00:29:04
pero modificar precio de un destino 00:29:06
sería prácticamente un copia y pega del delete 00:29:09
porque es a través de un temporal 00:29:11
lees copias, lees copias 00:29:13
cuando estás leyendo 00:29:15
aquel cuyo nombre 00:29:16
coincide con el que tengo que modificar 00:29:19
lo copio pero con el precio nuevo 00:29:20
luego el modificar 00:29:22
precio del destino 00:29:25
este que lo podríamos hacer así 00:29:27
public 00:29:32
boolean 00:29:34
update 00:29:35
a este sí que le pasaríamos 00:29:36
un destino enterito 00:29:39
y que hace el 00:29:41
UGDATE 00:29:47
pues el UGDATE 00:29:48
del destino del archivo de destinos 00:29:54
cuyo nombre sea 00:29:57
el de este objeto 00:29:59
le cambia el precio por el precio que tenga 00:29:59
este objeto, o sea en este objeto está 00:30:03
el nombre del que tienes que 00:30:04
modificar y el precio nuevo que tienes 00:30:07
que modificar y nos faltaría 00:30:09
del destino dado y en este 00:30:14
caso ya habríamos hecho los cuatro del 00:30:16
CRUD, recuperar porque claro 00:30:18
uno tiene que poder consultar 00:30:20
vamos a consultar un destino 00:30:22
a ver cuánto cuesta 00:30:24
entonces este 00:30:25
sería 00:30:28
get y que le pasaríamos 00:30:28
la clave 00:30:35
return null, vale 00:30:35
pues este se le pasa un nombre 00:30:46
y te devuelve el objeto 00:30:52
destino, el objeto destino 00:30:55
que tiene ese nombre para consultarlo 00:30:57
pues este sería el DAO 00:30:58
para acceder al fichero de destinos 00:31:00
para manipularlo, lo que fuera 00:31:03
entonces 00:31:05
si nosotros tuviéramos ya 00:31:07
nuestro main 00:31:09
ahora ya esto 00:31:11
o lo llamamos desde una interfaz gráfica 00:31:13
o lo que sea 00:31:14
entonces 00:31:15
vamos a hacernos un main 00:31:17
vale, pues nuestra clase main 00:31:20
pues es un rollo porque 00:31:50
hay que hacer el menú 00:31:52
si queremos probar esto 00:31:55
y que no 00:31:57
Y no engorronarla 00:31:57
Vamos a tener que hacer un menú 00:32:00
Y ahora, do, pues venga 00:32:01
¿Qué opciones tenemos? 00:32:26
Pues sobre destinos 00:32:32
Pues sobre destinos 00:32:34
Insertar 00:32:41
A ver, por ahora vamos a meter las cuatro de destinos 00:32:46
Porque es la primera parte que vais a hacer 00:33:00
Gestionar los destinos y más 00:33:02
Y luego ya las reservas 00:33:04
Que ya las reservas 00:33:05
Nos permite introducir otra capa adicional 00:33:08
Para que vaya engordando esta aplicación 00:33:10
Insertar destino 00:33:12
Recuperar destino 00:33:14
Dado nombre 00:33:17
Eliminar 00:33:18
Y modificar 00:33:23
Que modificar es solamente el precio 00:33:26
Lo que se puede modificar 00:33:28
Modificar 00:33:29
Vale 00:33:30
Entonces aquí le iríamos la opción 00:33:32
Que lo mismo 00:33:35
Para olvidarme del rollo de los báferes 00:33:40
Lo voy a leer con Nesline 00:33:43
Y lo convierto al íntegro 00:33:44
Y ahora nuestro 00:33:46
Suite 00:34:03
Case 1 00:34:05
Case 2 00:34:18
Case 3 00:34:23
Case 4 00:34:30
Ya, ya, ya, ya lo sé 00:34:39
Hay muchas cosas que tendría que hacer 00:34:41
No hago por vaguería 00:34:45
Pero bueno, yo me puedo permitir 00:34:47
Ser vaga, porque ya 00:34:51
Ya tengo la vida resuelta 00:34:52
Pero vosotros no, vosotros no os podéis permitir ser vagos 00:34:55
Vale 00:34:57
Vale 00:34:59
Y en el caso de cero está salir 00:35:01
Saliendo 00:35:03
Cerrando 00:35:17
Y en default opción incorrecta 00:35:18
Claro 00:35:32
Ahora ya opción incorrecta 00:35:34
Entonces aquí ahora ya 00:35:37
No hay un map 00:35:43
una lista que tenga todos los destinos 00:35:44
o todos los viajes 00:35:46
no hay por qué, tú aquí todos los 00:35:48
accesos para consultar para lo que sea 00:35:50
van a través de los métodos estos de DAO 00:35:52
que van al archivo 00:35:54
vale, pues entonces esto es lo de mi while 00:35:55
y se acabó, pues venga 00:35:57
primera parte 00:36:08
hace de estos cuatro métodos 00:36:09
de destino para poder 00:36:12
probarlos ahora desde el main 00:36:15
venga, primera parte 00:36:16
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:
2
Fecha:
22 de marzo de 2026 - 12:45
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
36′ 24″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
141.83 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid