Saltar navegación

20260323 FicherosObjetos_AppReservas_3 - 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 esta excepción si recordáis 00:00:00
vinimos a decir 00:00:05
porque nos daba 00:00:07
y era 00:00:07
porque cuando el object 00:00:09
output string no se ve nada 00:00:12
cuando el object output 00:00:14
string 00:00:23
lo abrimos para escribir en un 00:00:23
fichero, pues el object 00:00:26
output string según se abre 00:00:28
y se asocia al fichero 00:00:30
en el punto en el que se asocie 00:00:32
que puede ser 2, o el comienzo 00:00:34
si el añadir 00:00:37
está a false, el parámetro de añadir del 00:00:38
constructor está a false, o aquí al final 00:00:40
si el parámetro 00:00:42
del constructor de añadir está a true 00:00:44
el object output string se engancha 00:00:46
a dos puntos, o al comienzo 00:00:48
del fichero eliminando todo lo que 00:00:50
hubiera, o al final 00:00:52
dejando lo que hubiera 00:00:54
pues en el momento en que se abre 00:00:56
y se engancha a un fichero 00:00:58
él ya 00:01:00
por el hecho de abrirse y asociarse 00:01:01
a un fichero, ya mete una cabecera 00:01:04
o bien aquí 00:01:06
o bien aquí 00:01:08
¿vale? 00:01:10
depende de donde se haya enganchado 00:01:11
entonces, esta cabecera 00:01:13
tiene información sobre 00:01:16
que describe 00:01:18
el objeto que se va a escribir 00:01:20
es una información 00:01:22
para describir, de alguna manera está pensada 00:01:24
para describir que ahí van a ir objetos 00:01:26
que es un fichero de objetos 00:01:28
entonces esa cabecera para que luego el 00:01:30
object input string 00:01:32
pueda deserializar 00:01:34
cuando abrimos el object input 00:01:36
sino un fichero y empezamos a leer con el 00:01:38
buque de lectura un objeto, otro objeto, otro objeto 00:01:40
pues para que el object input 00:01:42
string pueda deserializar 00:01:44
esta cabecera tiene que estar 00:01:46
pero solo una vez 00:01:48
y al principio 00:01:50
entonces es obligatorio que esta cabecera esté 00:01:51
la que ha creado este, pero solo una vez 00:01:54
y al principio 00:01:56
entonces que ocurre 00:01:57
que si nosotros estamos abriendo 00:01:59
un fichero de objetos para añadir 00:02:01
esta cabecera 00:02:03
se va a ir colando 00:02:05
entre medias y ahí viene 00:02:07
el problema, cuando abrimos 00:02:09
un fichero de objetos para añadir 00:02:11
cuando abrimos un fichero de objetos para añadir 00:02:13
se cuela esta cabecera 00:02:15
y entonces ya 00:02:17
el fichero se queda corrupto 00:02:19
porque cuando el object imputation 00:02:21
empiece a leer, quita la primera cabecera 00:02:23
fenomenal, está muy bien 00:02:25
Y ahora se pone a leer objetos 00:02:27
Llega un momento en que llega una cosa rara 00:02:28
Que no es un objeto como él espera 00:02:30
Y entonces tú dices 00:02:32
El string en el que estoy leyendo 00:02:34
Mi string de entrada está corrupto 00:02:35
Porque esto ha dejado de ser un objeto 00:02:38
¿Vale? 00:02:40
Bueno, pues podemos arreglar esto 00:02:42
Ayudándonos de la herencia en realidad 00:02:44
Ahora que ya sabemos usar 00:02:45
Es decir, el arreglo puede ser 00:02:47
Oye tú, object output string 00:02:49
Me gustaría cambiarte un poco 00:02:52
Modificarte 00:02:54
me gustaría modificarte 00:02:55
y que cuando escribes 00:02:57
la cabecera lo hagas 00:02:59
solo cuando 00:03:01
abres un fichero que no existe 00:03:03
o está vacío 00:03:05
sin bytes y sin nada 00:03:06
en ese caso quiero que escribas la cabecera 00:03:08
pero cuando tú te asocias 00:03:11
a un fichero que ya existe y tiene bytes 00:03:13
en ese caso 00:03:15
no quiero que hagas nada 00:03:16
esa es una pequeña modificación de esta clase 00:03:18
querríamos modificar esta clase 00:03:21
modificarla un pelín, para modificarla un pelín 00:03:23
el comportamiento, y es que cuando 00:03:26
se asocia en modo añadir 00:03:28
entonces esto no lo haga 00:03:29
simplemente no lo haga, se asocia y ya está 00:03:31
entonces esta clase 00:03:34
lógicamente no podemos tocarla 00:03:36
hombre, como poder, podríamos 00:03:38
yo me podría ir a la librería 00:03:40
a la librería de la máquina virtual 00:03:42
cogerla, decompilarla 00:03:43
porque ahí están todas en punto clase 00:03:46
decompilarla, cambiarla 00:03:48
volverla a compilar y meterla en la JR 00:03:50
es absurdo, no vamos a hacer eso 00:03:52
pero lo que podemos hacer es 00:03:53
oye, como yo quiero 00:03:56
una casi igual que esta 00:03:58
igual que esta 00:04:00
casi en todo menos en una cosa 00:04:02
pues bueno, que mecanismo 00:04:04
tenemos muy sencillo para hacer una clase 00:04:06
que tenga 00:04:08
todo lo que tiene otra 00:04:09
pero la modifique en alguna cosa 00:04:11
si quiere o la sobreescriba 00:04:14
pues la herencia, ¿verdad? 00:04:16
la herencia, entonces oye 00:04:18
vamos a hacernos una clase 00:04:20
que herede de esta, con lo cual 00:04:21
por el hecho de heredar, ya es igualita 00:04:23
lo tiene todo, salvo el constructor 00:04:26
pero el constructor lo podemos hacer 00:04:28
nosotros, y ahora 00:04:29
vamos a modificar en esta clase 00:04:31
lo que queramos que funcione 00:04:33
diferente de esta otra, entonces el 00:04:35
mecanismo de herencia, siempre 00:04:37
nos vale para hacer clones de una clase 00:04:39
con una pequeña modificación, que es justo lo que queremos 00:04:41
hacer aquí 00:04:43
nada 00:04:44
no trates de desentrañarlo 00:04:46
yo que sé 00:04:50
A ver, mi objetivo era poner 00:04:51
M de la mía 00:04:53
Object output string, o sea, un modificada 00:04:54
De modificada object output string, pero vamos, queda igual 00:04:57
¿Vale? 00:04:59
Entonces, si ya 00:05:01
Pero no necesita como modificar 00:05:03
La cabecera que ya hay 00:05:05
O sea, no escribir una nueva 00:05:06
Si no detectar que ya hay una 00:05:12
Bueno, pero 00:05:14
Claro, detectar que ya hay una, va a haber una 00:05:17
Si el fichero ya tiene cosas 00:05:20
Si el fichero tiene cosas 00:05:21
Entonces no escribas cabecera 00:05:24
Ni la modifica, claro 00:05:26
No tiene por qué modificarla 00:05:29
Porque esta cabecera ya ha descrito correctamente 00:05:32
Que es un fichero de objetos y ya está 00:05:34
No hay que añadir nada nuevo 00:05:36
Lo único que tiene que hacer es añadir los objetos 00:05:37
No hay que añadir información de los nuevos objetos 00:05:39
No, no es necesario 00:05:42
Esta cabecera es más simple 00:05:45
Es una cosa más sencilla 00:05:47
entonces una vez que tengamos esta variante 00:05:49
ahora ya, cuando queramos 00:05:51
añadir, usamos esta 00:05:54
y cuando el fichero 00:05:56
sea 00:05:58
lo arranquemos de nuevas, usaremos 00:05:58
esta otra, y ya está 00:06:02
entonces este puede ser nuestro array 00:06:03
¿cuál es la idea entonces? 00:06:05
hacer una variante de object 00:06:07
output string que no escriba 00:06:09
cabecera, simplemente 00:06:11
se abra para añadir, entonces esa variante 00:06:13
la usaremos, cuando tengamos 00:06:16
que añadir algo 00:06:18
y la original 00:06:19
la de la JRE 00:06:22
la usaremos cuando el fichero empiece 00:06:24
de nuevas desde el principio vacío 00:06:26
vale 00:06:27
vale, pues entonces 00:06:29
vamos a modificar entonces esta aplicación 00:06:31
tal y como la teníamos para que ya no nos dé 00:06:34
este problema 00:06:36
entonces 00:06:36
vamos a hacernos 00:06:38
dígame 00:06:42
que si lo he enseñado 00:06:42
pues el otro día sí 00:06:46
que era este 00:06:49
vamos, está grabado 00:06:51
claro que está enseñado 00:06:54
estaban enseñados los dos que hice 00:06:58
que eran solo el insert y el get 00:07:00
los vimos 00:07:02
de arriba a abajo, de hecho nos sirvió 00:07:04
el insert para contarlo del 00:07:06
try con recursos 00:07:08
¿dónde estabas el viernes? 00:07:09
dormida 00:07:13
recordáis esto, ¿no? 00:07:14
El try con recursos que dijimos 00:07:18
Que si lo tenía aquí dentro se cerraba automáticamente 00:07:20
Y no teníamos que hacer el close 00:07:22
Habéis hecho una desconexión total 00:07:24
Del viernes a las 2 y cuarto 00:07:28
2 y media 00:07:29
Hasta hoy ha sido una desconexión absoluta 00:07:30
Vale, bueno pues entonces vamos a hacer el arreglo 00:07:34
Pues vamos a hacer esa otra clase modificada 00:07:38
Vale 00:07:40
App agencia de viajes 00:07:42
Que es esta 00:07:44
Pues venga 00:07:45
Como tiene que ver con acceso a datos 00:07:47
Vamos a meterlo en DAO directamente 00:07:48
Y ya está en el paquete DAO 00:07:50
Pues venga 00:07:51
Una clase que sea 00:07:55
Object.putString.add 00:07:56
Por ejemplo 00:07:59
Porque esta es la clase 00:08:00
Que vamos a usar para añadir 00:08:04
A ver que se le puede poner 00:08:07
Uno el nombre que quiera 00:08:09
Es decir 00:08:10
Para añadir objetos al fichero 00:08:17
Para añadir 00:08:19
Esta es la que nos va 00:08:20
Interesante instanciar 00:08:22
Porque esta no va a escribir cabecera 00:08:24
Vale 00:08:26
Entonces queremos que sea igualita 00:08:27
Que object output string 00:08:32
Pues nuestro mecanismo de hacer una clase 00:08:34
Clon de otra 00:08:36
Es esta 00:08:37
Es este, herencia y ya está 00:08:38
Vale 00:08:41
Entonces el primer error que nos da 00:09:04
Es que necesitamos hacer 00:09:08
Nos da el error 00:09:10
porque no hemos 00:09:11
hecho constructor, al no hacer 00:09:14
constructor 00:09:16
solamente tiene el por defecto 00:09:17
entonces el por defecto 00:09:20
se supone que llama 00:09:22
el super de arriba por defecto 00:09:24
también, que object output string 00:09:26
no tiene por defecto 00:09:28
entonces ese es el error que nos está dando 00:09:29
que ya lo hemos visto otras veces 00:09:32
vale, silencio 00:09:34
vamos a hacer un 00:09:36
constructor entonces específico 00:09:38
basado en el constructor de Object Output String 00:09:40
y el constructor de Object Output String 00:09:43
que nos pedía, vamos a ver 00:09:45
si nos vamos aquí a los otros métodos 00:09:46
cuando lo hemos usado 00:09:49
el Object Output String 00:09:51
como veis 00:09:54
su constructor necesita un 00:09:55
File Output String 00:09:58
¿vale? recordad ¿no? 00:10:00
el constructor de Object Output String 00:10:01
le pasamos un String de salida 00:10:03
al recurso que sea 00:10:07
¿vale? 00:10:09
Entonces yo aquí le he pasado directamente un file output string 00:10:10
Pero en general a object output string se le puede pasar cualquier cosa 00:10:15
Que sea output string, output string es la super clase 00:10:20
¿Vale? Output string es la super clase 00:10:23
¿Y qué implementaciones hay? 00:10:27
Pues un output string de fichero, un output string de socket 00:10:29
Vamos a ver la jerarquía rápidamente para que no suene rara 00:10:32
jerarquía 00:10:39
imágenes 00:10:42
output 00:10:49
a ver si así me sale una buena 00:11:07
vale, aquí por ejemplo 00:11:11
vale, nosotros estamos usando 00:11:18
como flujo de salida 00:11:26
un fichero, un flujo de salida tal cual 00:11:28
de Bison Fichero, File Output String 00:11:30
¿vale? 00:11:32
File Output String es una implementación más 00:11:33
de esta clase abstracta 00:11:36
Output String que significa 00:11:38
cualquier flujo de salida de bytes 00:11:40
cualquier flujo de salida de bytes 00:11:42
es decir 00:11:44
outputString es una clase abstracta 00:11:48
esta no la instanciamos 00:11:50
pero su significado es 00:11:51
cualquier flujo a partir del cual 00:11:54
yo pueda mandar bytes hacia algún lado 00:11:56
hacia algún lado 00:11:58
yo los enchufo por aquí desde mi aplicación Java 00:12:00
con el write 00:12:02
con el write los voy enchufando 00:12:03
con lo cual outputString tendrá el método write 00:12:05
yo con el write 00:12:08
voy aquí enchufando los bytes 00:12:09
un byte, un byte, un byte, lo enchufo con el write 00:12:11
y sale hacia algún sitio 00:12:13
ese sitio 00:12:15
hacia el que sale 00:12:17
esos bytes que yo voy enchufando 00:12:19
con el método write de output string 00:12:21
ese sitio cual es? 00:12:23
ese sitio ya depende de la implementación 00:12:25
por eso hay diferentes implementaciones 00:12:27
¿vale? 00:12:29
entonces la única implementación que hemos usado nosotros 00:12:31
es esta 00:12:33
que es el caso particular 00:12:34
en el cual los bytes que tú enchufas con el write 00:12:37
¿dónde salen? 00:12:39
hago un fichero y ahí se quedan 00:12:41
¿vale? y ahí se quedan 00:12:43
pero bueno, hay más implementaciones 00:12:45
de output string 00:12:47
entre ellas esta 00:12:49
¿vale? que también hemos usado 00:12:50
esto va 00:12:52
a una tubería, bueno, cosas 00:12:55
que ahora mismo no nos interesa 00:12:57
entonces, ¿qué quiero? esto para que 00:12:58
a cuento de que ha venido 00:13:00
pues para decir que al constructor de object 00:13:02
output string, al constructor le hemos pasado 00:13:05
nosotros un file output string, pero le puedes 00:13:07
pasar cualquier flujo 00:13:09
de salida general, cualquier flujo 00:13:11
de salida, entonces vamos a 00:13:13
nosotros ahora 00:13:15
declarar nuestro constructor 00:13:16
a ver 00:13:18
dime 00:13:20
con cualquier cosa que sea 00:13:21
una instancia de output stream 00:13:33
en general y file output stream lo es 00:13:35
acuérdate de la herencia, en una 00:13:37
superclase cae 00:13:39
cualquier instancia de cualquier subclase 00:13:40
exacto 00:13:43
con otro output string 00:13:46
entonces por eso el constructor 00:13:48
cuando ahora yo llame al super 00:13:50
de object output string 00:13:53
le voy a pasar una output string en general 00:13:54
entonces, a ver, vamos a hacer 00:13:56
el constructor que me pide 00:13:59
porque me pide hace un constructor explícito 00:14:00
porque el de por defecto no me vale 00:14:02
porque el por defecto es sin parámetros 00:14:04
llama al sin parámetros del de arriba 00:14:06
El de arriba no tiene sin parámetros 00:14:08
Entonces haz uno explícito que encaje 00:14:10
Pues en eso estamos 00:14:12
Haciendo uno explícito que encaje 00:14:13
Pues vamos a hacer un constructor 00:14:15
Explícito que encaje 00:14:18
Y a este constructor ¿Qué le pasamos? 00:14:19
Un output string 00:14:23
Y ahora lo hacemos 00:14:25
Llamando al constructor de la superclase 00:14:32
Que la superclase ahora ya sí que es esta 00:14:35
Que recibe este 00:14:37
¿Vale? 00:14:40
entonces da un errorcito 00:14:48
porque al instanciar 00:14:50
oye output stream puede salir una 00:14:53
excepción 00:14:54
pero bueno 00:14:56
la propago y se acabó 00:14:57
fijaos que aquí, cosa curiosa 00:15:23
cuando yo he quitado el este 00:15:26
aquí 00:15:27
no me ofrece 00:15:29
capturarla 00:15:35
no me ofrece el try catch 00:15:38
aquí en el constructor que es un método muy especialito 00:15:40
no me ofrece capturarla 00:15:43
me ofrece solamente propagarla 00:15:45
¿veis? 00:15:48
solo me ofrece propagarla 00:15:51
no me ofrece capturarla 00:15:53
porque el constructor es un método especialito 00:15:54
es un método, es el único método 00:15:57
si recordáis, el único método 00:16:01
que aquí no se pone ni void 00:16:03
ni valor de retorno, ni nada 00:16:05
¿por qué? 00:16:07
porque el constructor 00:16:08
se supone que devuelve 00:16:10
el objeto que se acaba de instanciar 00:16:12
es obligatorio que el constructor 00:16:14
Devuelva el objeto que se acaba de instanciar 00:16:17
¿Vale? 00:16:19
Entonces 00:16:22
Aquí el try-catch 00:16:22
Ni siquiera te lo permite 00:16:25
Porque si hiciéramos un try-catch 00:16:26
Bueno 00:16:28
Se va a volverlo a que se lo voy a hacer 00:16:33
Es decir, no solo te devuelve el objeto 00:16:35
Sin más 00:16:42
En memoria 00:16:43
Sino que te devuelve otro objeto 00:16:44
Que declara 00:16:47
Las propiedades de ESL que obtenemos con un get class 00:16:48
Bueno, unas cosas extrañas 00:16:51
lo digo solo como explicación 00:16:52
de por qué ni siquiera me ha ofrecido el try-catch 00:16:54
¿vale? 00:16:57
entonces, si yo hago un try-catch 00:16:59
y no funcionara el super 00:17:01
la instanciación en el catch 00:17:03
en el catch, tendría yo 00:17:04
que hacer el trabajo del super que no ha podido 00:17:07
funcionar, y no podemos 00:17:09
hacerlo, ese trabajo tendríamos que hacerlo 00:17:11
llamando al super otra vez, y otra vez 00:17:13
volveríamos a crear la misma sección 00:17:15
entonces, es imposible 00:17:16
hacer aquí un try-catch que tenga sentido 00:17:18
en un constructor 00:17:21
entonces 00:17:22
por eso ni siquiera me ofrece 00:17:24
el try catch 00:17:27
vale 00:17:29
pero si se acabó, si no puede instanciar 00:17:30
este pues 00:17:33
se lanza excepción y listo y se para el programa 00:17:34
y el constructor 00:17:37
no completa su tarea, no devuelve 00:17:39
nada y nada, bueno 00:17:41
pues esta clase ahora 00:17:43
es un clon idéntico, es la misma 00:17:45
que esta de aquí 00:17:47
porque tiene todo lo que tiene esta 00:17:48
y hemos hecho el constructor, pero el constructor 00:17:51
no se hereda, el constructor hay que hacerlo específicamente 00:17:54
lo hemos hecho, pero el constructor está basado en llamar 00:17:55
al constructor de arriba, ya está, con lo cual 00:17:57
es un clone, vale, pero queremos hacer 00:18:00
un cambio, que es, queremos 00:18:02
que esta clase no escriba la 00:18:03
cabecera, entonces en algún sitio 00:18:05
tiene que estar el método que escribe en la cabecera 00:18:07
y ese método habría que 00:18:10
sobrescribirlo 00:18:11
entonces, hombre, uno 00:18:13
se puede poner a buscar los métodos que tiene 00:18:15
object output string, a ver 00:18:17
cuál de esos métodos tiene pinta de estar relacionado 00:18:19
con escribir en la cabecera 00:18:22
y encontrará uno que se llama así. 00:18:24
Voy a asegurarme de si es este. 00:18:35
¿Cómo puedo yo asegurarme de que he acertado con el nombre 00:18:37
y el que he escrito es el de la superclase? 00:18:41
Muy bien, poniendo la anotación. 00:18:45
Vale, acepta la anotación sin problema. 00:18:55
Entonces, al aceptar la anotación 00:18:58
es que existe un método en la superclase 00:19:00
que es este, que hace 00:19:02
el que, pues deducimos que lo que hace 00:19:03
es escribir la cabecera, porque parece que se llama así 00:19:05
por algo se llama así, ¿no? 00:19:07
pues ¿qué vamos a hacer? dejarlo vacío 00:19:09
ya está, y ya está, ya tenemos la clase 00:19:11
modificada, es un clon 00:19:13
de object output string, pero esta no 00:19:15
escribe cabecera, no la escribe 00:19:17
pues perfecto, es justo lo que queremos 00:19:19
hacer un 00:19:22
object output string asociado al 00:19:23
fichero, pero que no escriba cabecera 00:19:25
se quede ahí, simplemente esperando a los 00:19:27
para escribir los objetos, punto pelota 00:19:29
ya está, ya tenemos esta clase 00:19:31
ahora 00:19:37
lo que cambia aquí es 00:19:38
nuestro insert 00:19:41
si nos vamos al destino dado con el insert 00:19:43
ahora 00:19:47
esto cambia 00:19:49
ahora hay que distinguir si el fichero 00:19:52
existe o no existe 00:19:55
cuando vamos a insertar un destino nuevo 00:19:56
Si el fichero no existe 00:19:59
No lo abrimos 00:20:03
Para añadir 00:20:07
Perdón, si el fichero existe 00:20:07
Lo abrimos con el 00:20:10
Objeto put string de añadir 00:20:12
Y si no existe con el otro 00:20:14
Bueno, pues entonces nuestro insert 00:20:16
Cambiará aquí 00:20:20
Y será 00:20:21
El fichero existe 00:20:25
Y mi fichero es este 00:20:28
Si datos 00:20:29
Ya existe 00:20:33
Si datos existe 00:20:35
Entonces 00:20:38
Yo me voy a hacer un output string 00:20:39
Lo voy a hacer 00:20:43
Vale, más claro 00:20:49
Si el fichero existe, entonces tenemos que añadirlo 00:20:51
Con el object output string de añadir 00:20:54
Entonces, si el fichero existe 00:20:56
Sería 00:20:58
Esto que hemos hecho aquí 00:21:00
Si el fichero existe 00:21:01
Pero sería 00:21:06
Esta 00:21:10
el que queremos 00:21:11
si el fichero existe 00:21:15
el que queremos es este 00:21:18
que es el que no escribe cabecera 00:21:19
este es el que queremos 00:21:21
que no escribe cabecera 00:21:23
y si el fichero 00:21:26
no existe, quiero el original 00:21:35
mío, vale, ha quedado 00:21:48
un ifelse muy feo 00:22:03
porque estoy repitiendo código 00:22:04
entonces 00:22:07
veis esta sentencia 00:22:09
y esta sentencia 00:22:11
Pues son la misma 00:22:13
Entonces podríamos sacar este objeto 00:22:14
En lugar de meterlo en el try 00:22:17
Con recursos aquí 00:22:19
Podríamos sacarlo aquí 00:22:20
Y luego instanciarlo 00:22:22
Aquí dentro sin más 00:22:25
Pero bueno, esto ya sería en arreglos de 00:22:26
Por encima del método 00:22:28
Por encima del método 00:22:31
Este es el nombre del fichero 00:22:34
No tiene nada, entonces 00:22:36
Ahora hemos modificado el try 00:22:39
Sí, lo hemos modificado haciendo que no haga nada 00:22:47
Ya está modificado 00:22:52
WriteStreamHeader escribe la cabecera 00:22:52
Y esta variante nuestra 00:22:55
No queremos que escriba nada, pues se queda en blanco 00:22:57
Vale, pues entonces si el fichero 00:22:59
Existe, lo abrimos 00:23:04
En nuestra versión, que es la que no escribe 00:23:06
Cabecera 00:23:08
Lo abrimos en nuestra versión 00:23:08
Y escribimos el objeto 00:23:10
Y si el fichero si existe 00:23:14
Entonces 00:23:17
Y si el fichero no existe 00:23:20
Perdón 00:23:22
Entonces ahora lo abro en la versión original 00:23:23
¿Vale? 00:23:27
Este true aquí lo puedo quitar 00:23:35
Porque como no existe 00:23:36
Añadir 00:23:37
Es como escribir desde el principio 00:23:39
O sea, si el fichero no existe, abro con esta 00:23:42
Pero bueno, esto es lo mismo que teníamos el otro día 00:23:44
¿Vale? 00:23:51
¿Hasta dónde? 00:24:26
¿Pero qué quieres ver por aquí? 00:24:28
¿Por encima si no hay nada? 00:24:29
no, quiero ver lo que has puesto 00:24:30
en file nada 00:24:33
esto ya en el programa principal 00:24:37
ya se lo pasaré 00:24:39
el existe destino 00:24:40
lo habíamos dejado en blanco 00:24:48
por ejemplo, esto si queremos validar 00:24:50
si existe destino se hace este método 00:24:52
yo ahora mismo 00:24:54
pongo false para que 00:24:54
poder trabajar y que me diga que no existe 00:24:57
y avance, pero este se validaría 00:25:00
leyendo el fichero, etc 00:25:02
no os acordáis de nada del viernes 00:25:03
Está el viernes olvidado en toda vuestra cabeza 00:25:06
¿Eh? 00:25:08
¿En serio? 00:25:16
Vale, vale, bueno 00:25:27
Joder 00:25:29
Madre de Dios 00:25:31
La que 00:25:32
Pero vamos 00:25:33
Joder, ¿cómo os habéis puesto, por favor? 00:25:39
Tampoco habéis hecho muchos esfuerzos 00:25:47
Por mirarlo el fin de semana, ¿no? 00:25:48
Bueno 00:25:53
Está todo en la grabación en cualquier caso 00:25:54
El viernes 00:25:56
Vale 00:25:57
Ya está 00:25:58
Si el fichero existe 00:26:01
Abrimos con este y escribimos 00:26:05
Y si el fichero no existe 00:26:08
Abremos con este otro 00:26:10
Y se acabó 00:26:11
Y nada más 00:26:13
Vamos a volver a probarlo 00:26:15
A ver si ahora no nos da ese error 00:26:16
Vamos a borrar el que existía 00:26:18
Porque ese ya está corrupto 00:26:20
El que existía 00:26:22
Vamos a borrarlo 00:26:24
Esto vamos a 00:26:33
vale, cuidado cuando probáis ejecuciones 00:26:36
que tienen menú 00:26:39
y el programa no lo habéis 00:26:40
no habéis salido de él 00:26:43
porque los ficheros a los que esté asociado 00:26:44
se pueden quedar bloqueados 00:26:47
entonces ya no os funciona ni el rename 00:26:50
ni todo eso 00:26:52
entonces 00:26:52
venga, vamos a volver a probarlo 00:26:55
insertamos un destino 00:26:57
de nuevas, cuyo nombre 00:27:05
Madrid y precio 00:27:07
1000, vale 00:27:09
Y vamos a ver si está 00:27:11
Vamos a recuperar 00:27:12
A ver este destino, a ver si está ahí 00:27:14
Está ahí, vale 00:27:16
Ahora insertamos un segundo 00:27:18
Que aquí venía el problema 00:27:20
Vamos a insertar un segundo 00:27:21
Oslo 2000 00:27:23
Vale 00:27:26
Entonces en principio lo ha insertado 00:27:28
Sin colar la cabecera entre medias 00:27:30
Eso es lo que esperamos 00:27:32
Porque lo ha hecho con la clase nueva 00:27:33
Entonces el fichero se habrá quedado bonito 00:27:35
Con la primera cabecera 00:27:38
esa no se ha tocado, la primera original 00:27:39
el fichero de Madrid que ya estaba 00:27:41
el destino, perdón, el objeto 00:27:43
y el siguiente, en principio se ha debido 00:27:44
quedar sin corromper porque al haber añadido 00:27:47
los sin cabecera 00:27:49
se han quedado los objetos uno detrás de otro 00:27:51
sin problema, vamos a ver 00:27:53
si es verdad, vamos a recuperar 00:27:55
el primero de todos 00:27:57
pues sí, vamos a recuperar 00:27:58
el segundo 00:28:01
pues sí, vale 00:28:01
pues arreglado 00:28:05
vale, a ver 00:28:07
¿qué ocurre? diréis, jo, qué cosa tan rara hemos tenido que hacer 00:28:14
heredar de una clase y hacer una variante, pues sí, es un poco rara 00:28:18
¿pero por qué? porque estamos trabajando 00:28:21
contra los ficheros como si fuera una base de datos 00:28:24
que es, yo tengo cada objeto que yo voy a insertar 00:28:29
lo inserto directamente en el fichero, cuando voy a recuperar, recupero del fichero 00:28:33
entonces cuando uno trabaja con ficheros, como dijimos el otro día 00:28:37
hasta 00:28:40
10.000, 100.000 00:28:42
bueno, no sé si 100.000 me he pasado 00:28:44
pero unos cuantos miles 00:28:46
no merece la pena trabajar así, es mucho más 00:28:47
sencillo, lees 00:28:50
todo el contenido del fichero 00:28:52
lo vuelcas a una colección 00:28:53
y trabajas con la colección 00:28:55
y ahí ya insertas 00:28:57
guardas, borras, eliminas 00:28:59
lo que quieras, y luego 00:29:02
cuando ya has terminado, toda esa colección 00:29:03
entera va al fichero entero 00:29:05
sobre escribiendo lo que había 00:29:07
Con lo cual ahí no hay problemas 00:29:09
De estar añadiendo 00:29:11
Al fichero 00:29:12
No hay ese problema 00:29:14
¿Vale? Entonces si trabajamos así 00:29:16
Este tema de la cabecera nos da igual 00:29:19
Que es, cojo 00:29:20
Todos los objetos que hay 00:29:22
Los vuelco enteros a una colección 00:29:25
Trabajo con la colección 00:29:27
Yo olvidándome de ficheros, todo 00:29:28
Insertar, recuperar, lo que quiera 00:29:30
Y ahora ya cuando he acabado y me voy a mi casa 00:29:32
O cuando quiero 00:29:35
Que se refleje en el fichero, cuando quiero 00:29:36
Pum, todo entero 00:29:38
Borrando lo que hubiera 00:29:40
Me da igual, todo entero 00:29:43
Borrando lo que hubiera 00:29:44
Luego ahí no hubiera tenido este problema 00:29:45
¿Vale? 00:29:47
Y esa es la solución habitual 00:29:50
A menos que uno tenga muchos 00:29:52
Unos cuantos miles de objetos ya 00:29:54
Unos cuantos miles de objetos 00:29:56
¿Vale? Nosotros lo estamos haciendo así pues 00:29:57
Para verlo 00:30:00
Y porque estamos simulando 00:30:02
Una situación real que es como se trabaja con la base de datos 00:30:04
Con una base de datos no vuelcas la base de datos entera 00:30:07
A una colección 00:30:09
Tú cada vez que quieres hacer algo 00:30:10
Vas directamente a la base de datos 00:30:12
Pues estamos simulando esa forma de trabajar 00:30:14
Que es la real 00:30:16
Vale, pues ya que teníamos ese 00:30:17
Ya que tenemos ese problemilla arreglado 00:30:20
Nuestro insert ya funciona perfectamente 00:30:22
Nuestro get 00:30:26
Pues recupera del fichero 00:30:27
Con el bucle de lectura 00:30:29
Y delete y update 00:30:30
¿Estos lo teníais hechos? 00:30:33
¿estáis en ellos? 00:30:35
venga, pues completad delete y update 00:30:38
de destino solamente 00:30:41
¿qué? delete y update 00:30:42
estos necesitan el famoso 00:30:44
fichero temporal o de maniobras 00:30:46
¿vale? delete 00:30:48
pues bucle de lectura del original 00:30:53
con cada objeto 00:30:55
decido si lo copio tal cual 00:30:57
o no lo copio, ¿de qué dependerá 00:30:59
que lo copio o no? pues si 00:31:01
el nombre de ese destino es el que quiero 00:31:03
eliminar, no lo copio, si no lo ves lo copio 00:31:05
el de modificar, lo mismo 00:31:07
leo objeto, copio, leo objeto, copio 00:31:09
pero si el que leo 00:31:12
su nombre es este 00:31:14
pues lo copio modificado 00:31:16
con el precio de este 00:31:18
y luego ya borro original 00:31:19
y cambio nombre 00:31:22
vale, pues venga 00:31:23
completad estos dos 00:31:25
y ahora los corregimos 00:31:27
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:18
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
31′ 31″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
126.64 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid