Saltar navegación

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

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues yo he hecho solamente, ahora mismo, para forzar esta excepción, la de insertar y recuperar, ¿vale? Entonces, en mi destino dao, pues mi destino dao, insertar, este sería, si quisierais hacer el método de validación, pues un método de validación he puesto yo aquí aparte si existe el destino falso para que no haga nada. 00:00:00
entonces existe destino 00:00:25
ahora mismo está sin hacer 00:00:26
entonces le he puesto que devuelva 00:00:29
false todo el rato para que nunca exista el destino 00:00:31
pero aquí, ¿qué haríamos? 00:00:33
pues abrir el fichero, ir leyendo 00:00:35
y en el momento en el que encontramos 00:00:37
un destino cuyo nombre es 00:00:39
igual que este de aquí, que este nombre 00:00:41
de aquí, pues ya devolveríamos 00:00:43
true, ¿vale? pero bueno, esto es lo de menos 00:00:45
entonces 00:00:47
ahora mi 00:00:49
mi insert 00:00:50
pues si pasa la validación 00:00:54
si la pasa 00:00:56
ahora ya me hace el try catch 00:00:57
¿vale? entonces ¿qué try catch 00:01:00
habréis hecho vosotros? 00:01:02
un try catch como este de aquí 00:01:05
que tengo yo en el get, lo pongo aquí un momentito 00:01:06
¿no? aquí 00:01:08
un try 00:01:10
habréis abierto, object output 00:01:12
en este caso, object output string 00:01:14
habréis escrito y habréis cerrado 00:01:16
y ya está, y eso está bien 00:01:18
pero hay una cosa que 00:01:19
se llama el try con recursos 00:01:22
que significa, si tú dentro de un try 00:01:24
creas un recurso que es cerrable 00:01:27
y los flujos de ficheros 00:01:30
input, output, string, tanto si es 00:01:33
object como file son cerrables porque tienen close 00:01:36
ser cerrable significa que tiene el método close 00:01:38
son cerrables, pues entonces nos podemos 00:01:40
despreocupar de hacer el close siempre, que es algo que siempre 00:01:44
deberíamos hacer si hacemos el try catch de esta manera 00:01:47
es decir, fijaos yo en mi try catch que he hecho 00:01:50
mi try-catch 00:01:54
en lugar de 00:01:56
hacer try 00:01:58
la llave y hacer dentro 00:02:00
en el try le añado 00:02:02
un paréntesis con cositas 00:02:04
este try, el try empieza aquí 00:02:06
y en este paréntesis yo abro ya 00:02:07
todos los recursos que quiera 00:02:10
todos los que vaya a necesitar aquí dentro 00:02:12
todos los flujos que yo vaya a necesitar 00:02:14
en este caso solo voy a necesitar uno 00:02:16
este object output stream para escribir 00:02:18
pues lo abro aquí entre los paréntesis 00:02:20
que me invento ahí en el try 00:02:23
y luego aquí ya se abre 00:02:25
mi try, claro, con la llave 00:02:27
es que esto nos ha quedado muy largo 00:02:29
¿vale? entonces lo bajamos 00:02:31
aquí abajo a lo mejor 00:02:33
para que se vea mejor 00:02:35
¿vale? o sea, veis el try 00:02:38
entre unos paréntesis 00:02:39
que me he inventado ahí 00:02:42
abre el recurso 00:02:43
esto es otra forma de escribirlo 00:02:44
en lugar de hacer el try normal sin paréntesis 00:02:46
y abrirlo aquí dentro 00:02:49
¿qué gano? abriéndolo aquí entre paréntesis 00:02:50
que se cierra solo cuando salimos del try catch 00:02:54
me da igual que salga por aquí 00:02:58
que salga por aquí 00:03:00
cuando el try catch ya termina y continuamos por aquí abajo 00:03:01
me da igual que sea por este camino que por otro 00:03:05
este se cierra solo 00:03:07
es una ventaja porque si no tenemos que asegurarnos de cerrarlo siempre 00:03:09
tanto si me voy por el try como por el catch 00:03:12
porque a lo mejor aquí ponemos os.close después del great object y estupendo 00:03:15
pero si resulta que hemos salido por el catch 00:03:19
y no se ha llegado a hacer el close 00:03:22
ese recurso se queda abierto 00:03:24
tendríamos que hacer 00:03:25
asegurarnos de que el close está en las dos partes 00:03:28
para lo cual lo mejor 00:03:30
es hacer aquí la clausa final 00:03:32
y esa de la que os hablaba que se puede poner opcional 00:03:34
y el final y se hace 00:03:36
tanto si vas por aquí como por aquí 00:03:38
¿vale? y ahí pone el close 00:03:40
pero es mucho más sencillo 00:03:42
usar esta sintaxis 00:03:44
del try que es try con paréntesis 00:03:46
y lo que se pone ahí dentro es la sentencia 00:03:48
de abrir el recurso que tú quieras 00:03:50
file input, file output 00:03:52
el que tú quieras, que quieres abrir 00:03:54
más de uno, haces todas las 00:03:56
aperturas una tras otra, y ya está 00:03:58
bueno, pues en este caso 00:04:01
en mi try, que estamos escribiendo el archivo 00:04:02
yo lo he abierto aquí 00:04:04
para que se cierre solo y me despreocupe 00:04:06
con lo cual dentro del try catch 00:04:08
lo único que me queda es escribir el objeto 00:04:11
estoy en el método insertar 00:04:13
escribir el objeto, se acabó 00:04:14
si salta la excepción pongo que devuelva 00:04:16
false porque el método no se pudo ejecutar 00:04:18
correctamente, que devuelva false 00:04:20
y si no salta la excepción 00:04:22
y hemos llegado a este punto, devuelva true 00:04:24
el great object ha funcionado 00:04:26
vale, pues el insert ha sido solamente eso 00:04:28
validar si es que 00:04:30
tenemos esa validación, si no nada 00:04:32
y abrir 00:04:34
el object output string, que si el 00:04:36
fichero no existe lo creará de nuevas 00:04:38
y si existe lo abre 00:04:40
para añadir, porque aquí he puesto un true 00:04:42
para añadir y luego escribe el objeto 00:04:44
muy bien, ya está, ahora el get 00:04:47
que es el otro único que he hecho 00:04:49
el get, pues nada, el fichero 00:04:52
ah, bueno, por cierto, el fichero 00:04:56
¿dónde he declarado la información del fichero? 00:04:57
el fichero son los propios datos 00:05:00
entonces tiene sentido 00:05:02
que esa información esté recogida 00:05:04
dentro de la clase DAO, tiene sentido 00:05:07
esta clase DAO mía 00:05:10
recorre, recoge todos los intríngulis, 00:05:12
toda la basurilla asociada con el acceso a datos. 00:05:16
Y esa basurilla son los métodos y el propio fichero. 00:05:18
Toda esa basurilla tiene sentido que esté en esta clase. 00:05:22
Bueno, pues en esta misma clase 00:05:25
meto como propiedad el fichero 00:05:26
donde van a estar los datos. 00:05:30
Cuando yo instancie esta clase para usarla, 00:05:34
se lo pasaré por constructor. 00:05:36
Y así mi main puede elegir un fichero de datos 00:05:38
cada vez, el que le dé la gana. 00:05:40
cada vez elige, ahora quiero que mi destino 00:05:41
esté aquí, ahora quiero que estén aquí 00:05:44
¿vale? se la metemos por constructor 00:05:45
a esta clase, por ejemplo, una opción 00:05:48
y ya está 00:05:49
entonces aquí la he metido, bueno pues entonces el get 00:05:51
el get que hace 00:05:53
mi get 00:05:55
bueno 00:05:56
si el fichero no existe, datos es el fichero 00:05:59
si el fichero no existe, nada 00:06:02
no he podido recuperar, el result es null 00:06:03
porque no he podido recuperarlo, claro 00:06:06
y ahora si existe, pues me hago 00:06:07
el flujo este del que hablamos 00:06:10
veis, aquí este me lo ponen 00:06:12
amarillo porque se me ha olvidado cerrarlo 00:06:13
ah no, no se me ha olvidado cerrarlo, entonces, ah vale 00:06:15
me está diciendo que 00:06:17
podría 00:06:19
no estar cerrado, ¿por qué? porque si yo 00:06:21
me voy por el catch, no lo he cerrado 00:06:23
veis, aquí lo he cerrado 00:06:26
pero aquí no, si me fuera yo por el catch 00:06:28
¿por qué ha fallado algo aquí en la mitad? 00:06:29
¡pum! 00:06:32
si me fuera por el catch io exception 00:06:33
es decir, me sale un 00:06:35
io exception aquí 00:06:37
cuando yo hago un read object se ha roto algo 00:06:38
en el ordenador y me sale un io exception 00:06:41
yo saldría por aquí 00:06:44
aquí no tengo el 00:06:45
punto close, luego por eso 00:06:47
me está avisando, cuidado que podrías 00:06:49
escaparte sin cerrar el flujo 00:06:51
por eso es mucho mejor meter 00:06:53
esto 00:06:55
como 00:06:56
está antes, meterlo aquí 00:06:59
pero profe, yo no he hecho la inicialización 00:07:01
dentro del try, lo he hecho fuera 00:07:06
bueno, es otra 00:07:08
opción, pero entonces, vale 00:07:10
¿qué error? 00:07:12
el de stream 00:07:14
sí, pero no tiene nada que ver, lo que yo estoy diciendo no tiene 00:07:15
nada que ver con ese error independiente, esto es otras cosas 00:07:18
que estoy metiendo, claro, claro, no tiene nada que ver 00:07:20
no, no, no, esto es otra, es una cuestión 00:07:22
de sintaxis, de organización del código 00:07:24
a eso no hemos llegado todavía 00:07:26
vale, estoy 00:07:28
explicando como yo soy yo el método 00:07:30
lo estoy explicando, vale 00:07:32
vale, pues entonces 00:07:34
si yo lo meto aquí dentro y este punto 00:07:35
y coma, entonces ahora ya me sobra 00:07:38
ya me ahorro el problema 00:07:40
del close 00:07:42
y este close de aquí 00:07:43
me sobra 00:07:46
este close de aquí 00:07:48
me sobra 00:07:50
vale, bueno pues que hace mi método de get 00:07:51
abre el 00:07:54
fichero 00:07:56
y ahora se mete en el bucle 00:07:57
este famoso en el que está 00:08:00
leyendo destinos 00:08:02
leyendo destinos 00:08:03
desde el momento en el que encuentre uno 00:08:04
cuyo nombre coincide con el que me han pasado 00:08:07
en el parámetro, ala, ya está 00:08:09
ya tengo el destino 00:08:12
de retorno, lo guardo aquí en resul 00:08:14
para devolverlo luego 00:08:16
y ya está, si he llegado 00:08:17
a fin de fichero, aviso para que el while pare 00:08:20
esto es otra posible 00:08:22
excepción que puede salir, pues bueno, la capturo 00:08:24
si me sale, devuelvo null, porque no he podido 00:08:26
trabajar 00:08:28
y si llego a este punto, todo ha ido 00:08:28
bien, todo estupendo, devuelvo null 00:08:32
bueno, pues hasta aquí 00:08:33
esto está bien programado, suponemos 00:08:35
tal y como hemos visto 00:08:38
el insert de aquí arriba 00:08:39
este 00:08:46
el insert, de esto olvídate 00:08:47
porque no lo está devolviendo 00:08:49
falso todo el rato 00:08:52
y el insert es 00:08:53
abro para escribir 00:08:56
para añadir, porque podría 00:08:58
haber destinos de antes 00:09:00
escribo el objeto y punto 00:09:01
es lo único que tiene el insert 00:09:03
entonces ahora 00:09:05
lo ejecutamos, voy a borrar 00:09:08
el fichero que hubiera de antes 00:09:10
este 00:09:11
delete 00:09:12
va a empezar de cero 00:09:14
ah bueno, que tengo la aplicación 00:09:17
abierta, entonces al tenerla abierta 00:09:20
no puedo acceder al fichero 00:09:21
vale, ya está 00:09:23
ahora 00:09:27
ejecutamos, venga 00:09:29
voy a insertar un destino 00:09:32
nuevo, no existe el fichero 00:09:34
no existe, lo va a tener que crear 00:09:36
pues venga 00:09:37
Nos vamos a París 00:09:39
Mil euros 00:09:41
Teóricamente está, no he puesto aviso de nada 00:09:42
Un poco cutre, pero bueno 00:09:45
Vale, vamos a recuperarlo, a ver si está 00:09:46
¿Tengo yo algún destino a París? 00:09:49
Vamos a ver si me lo encuentra el get 00:09:50
Esto no 00:09:52
Ah, es que ya lo tenía de 00:09:55
Vale, es que 00:09:57
A ver, bórrate 00:09:59
Vale, a ver 00:10:03
Voy a 00:10:04
Perdón, ya tenía 00:10:06
vale, voy a ver 00:10:11
refresh 00:10:13
no existe el fichero, empezamos otra vez 00:10:14
venga, vamos a insertar 00:10:18
un destino 00:10:21
este es el primer destino 00:10:22
del fichero porque no existe 00:10:25
mil, venga, voy a ver si tengo 00:10:26
algún destino a París y cuánto cuesta 00:10:29
paso el parámetro de búsqueda que es este 00:10:31
aquí lo tengo 00:10:33
lo ha encontrado en el fichero, vale 00:10:35
son los únicos dos métodos que tengo 00:10:37
venga, voy a insertar otro, ahora vamos a 00:10:39
ir, vamos a hacer un destino 00:10:41
un posible destino a Oslo que este cuesta 00:10:43
2000 euros 00:10:45
se supone que ha hecho el right object 00:10:46
ahora vamos a recuperarlo 00:10:48
venga, vamos a recuperar el primero otra vez 00:10:50
a ver si me lo encuentra 00:10:53
y aquí es cuando me sale 00:10:54
la excepción, cuando me sale 00:10:57
cuando yo añado 00:10:59
un objeto 00:11:01
a un fichero 00:11:02
que ya tenía cosas 00:11:05
ahí me dice, uy, algo se ha 00:11:06
roto. El problema es que no nos da tiempo a arreglarlo. 00:11:09
A ver, ¿por dónde van los tiros? 00:11:12
Los tiros van porque 00:11:14
cuando la máquina virtual de Java 00:11:15
escribe en un fichero 00:11:17
No, yo quería 00:11:19
pisar. 00:11:25
Vale, cuando la 00:11:28
máquina virtual de Java, pues, escribe 00:11:31
en un fichero, tiene los objetos. 00:11:33
Cuando lo 00:11:37
abre con el object output string para 00:11:38
escribir. 00:11:39
¿Qué es lo que hace? Antes de nada, 00:11:41
antes de nada, mete 00:11:44
una cabecera, una header 00:11:45
con información sobre los objetos 00:11:47
qué tipo de objeto es, qué propiedades tiene 00:11:51
con información, para luego poder 00:11:53
deserializarlos bien, metes a cabecera 00:11:55
lo primero de todo, y ahora ya 00:11:57
cada write object te escribe un objeto 00:11:59
ya está 00:12:01
¿vale? entonces ¿qué ocurre? 00:12:02
cuando lo abrimos para añadir 00:12:05
cuando lo abrimos para añadir 00:12:07
pues cuando lo abrimos para añadir 00:12:09
él 00:12:12
vuelve a colar en medio otra vez 00:12:13
cada vez que hace un new object output string 00:12:16
vuelve a colar la cabecera 00:12:18
entonces 00:12:20
si yo estoy añadiendo 00:12:22
me ha metido una cabecera ahí en medio 00:12:25
la cabecera es una información de datos 00:12:27
que mete él para facilitar la serialización 00:12:30
o sea es una información sobre 00:12:32
los objetos que hay en este archivo 00:12:34
tienen estas propiedades 00:12:37
son de esta clase, etc 00:12:38
para luego cuando le demos a read object 00:12:39
del ubicar la clase, recolocarlo, 00:12:42
etcétera. Entonces, esa cabecera es imprescindible 00:12:44
que esté al principio 00:12:46
del fichero, pero sólo al principio. 00:12:48
Entonces, la primera vez que hemos 00:12:51
metido un objeto París, ha hecho 00:12:52
la cabecera, ha metido París, 00:12:54
y se ha quedado el fichero estupendo. Cuando 00:12:56
hemos entrado para leer, 00:12:57
él lee la cabecera del principio y muy bien. 00:13:00
Vale, cuando hemos ahora, 00:13:03
lo hemos vuelto a abrir, pero ahora para añadir, 00:13:04
que ya tenía el París este. 00:13:07
Pues cada vez que se hace Object Output 00:13:08
String, esa clase 00:13:10
en el punto en el que se abre 00:13:11
que si es para añadir 00:13:14
es ahí en la mitad, si es para añadir 00:13:16
te mete la cabecera otra vez 00:13:18
y ahí es donde te lo has tropeado 00:13:20
entonces me ha metido la cabecera 00:13:21
y me ha metido oslo 00:13:23
y así se ha quedado, con una cabecera parís 00:13:24
otra cabecera este 00:13:27
y así se ha quedado, ya corrupto 00:13:29
entonces cuando ahora lo hemos abierto para leer 00:13:31
el object input string 00:13:33
lee la primera cabecera, que esa es buena 00:13:35
la lee la interpreta y se pone el objeto 00:13:37
cuando llega aquí dice 00:13:39
uy, esto no lo entiendo, esto no es objeto 00:13:42
yo espero que haya una lista de objetos 00:13:44
por eso sale, esto está corrupto 00:13:45
¿vale? 00:13:48
no, la cabecera es una información 00:13:49
que se ha colado ahí en medio por haber añadido 00:13:52
entonces, ese es el problema 00:13:54
esa cabecera que se ha quedado ahí en medio 00:13:56
¿vale? 00:13:58
entonces, bueno, esto se puede arreglar de forma 00:14:00
sencilla, pero bueno, ya no lo 00:14:02
hagamos hoy, si podéis aguantar hasta el momento 00:14:04
sería curioso ver cómo te lo arregla 00:14:06
HGPT, así que pregúntaselo 00:14:13
y nos lo cuentas el lunes 00:14:15
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:
5
Fecha:
22 de marzo de 2026 - 12:46
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
14′ 17″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
59.48 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid