1
00:00:01,710 --> 00:00:12,330
A ver, nosotros en este ejemplo que acabamos de hacer aquí, cuando hemos mandado los archivos con el object output string aquí abajo, en guardar,

2
00:00:13,550 --> 00:00:17,429
lo hemos asociado a un file output string al que no le hemos dado la opción de añadir.

3
00:00:17,929 --> 00:00:18,769
Esto no se lo hemos dicho.

4
00:00:19,649 --> 00:00:22,589
Con lo cual, el fichero lo creaba siempre limpio.

5
00:00:22,589 --> 00:00:32,670
Y no pasaba nada, porque como volcábamos antes todos a la lista, en la lista añadíamos lo demás y luego la lista entera se iba al fichero pisándolo de antes.

6
00:00:33,090 --> 00:00:36,170
Pero no había nada, porque es que en la lista ya habíamos volcado previamente a lo anterior.

7
00:00:36,329 --> 00:00:38,429
Entonces el funcionamiento estaba bien.

8
00:00:38,530 --> 00:00:43,189
Pero bueno, puede haber una situación en la que nosotros no hemos recuperado el archivo previamente,

9
00:00:43,189 --> 00:00:50,189
sino nuestra aplicación crea objetos nuevos y esos objetos nuevos que los mande al archivo a continuación de los que hubiera.

10
00:00:51,030 --> 00:00:52,270
Y ya está, a continuación de los que hubiera.

11
00:00:53,350 --> 00:00:56,710
No ha recuperado previamente los otros porque esos ya están ahí y no quiere trabajar con ellos.

12
00:00:57,329 --> 00:01:00,130
En ese caso, habríamos añadido el true ahí, ¿no?

13
00:01:00,130 --> 00:01:04,390
Pues vamos a hacerlo en este otro proyecto

14
00:01:04,390 --> 00:01:10,459
Vale, vamos a hacer un método

15
00:01:10,459 --> 00:01:13,420
Para guardar un objeto en el archivo

16
00:01:13,420 --> 00:01:14,900
Simplemente

17
00:01:14,900 --> 00:01:21,260
Vamos a hacer un método para

18
00:01:21,260 --> 00:01:23,640
Guardar un alumno en el archivo

19
00:01:23,640 --> 00:01:27,659
Y ahora le vamos a pasar aquí el nombre del archivo

20
00:01:27,659 --> 00:01:33,459
Fichero alumnos

21
00:01:33,459 --> 00:01:40,060
Bueno, pues que tendríamos que hacer aquí

22
00:01:40,060 --> 00:01:41,500
Pues como vamos a guardar un objeto

23
00:01:41,500 --> 00:02:09,469
Pues otra vez, el object output string, new file output string, y aquí el fichero alumnos.

24
00:02:18,469 --> 00:02:19,449
¡Hala! Ya está.

25
00:02:19,629 --> 00:02:21,030
Venga, importamos.

26
00:02:21,590 --> 00:02:22,949
No importa si importamos.

27
00:02:28,180 --> 00:02:28,939
Import.

28
00:02:30,939 --> 00:02:32,879
Y propagamos excepción.

29
00:02:32,879 --> 00:02:40,740
bueno, queremos escribir

30
00:02:40,740 --> 00:02:42,840
un único, ah bueno y perdón

31
00:02:42,840 --> 00:02:44,439
queremos este objeto

32
00:02:44,439 --> 00:02:46,780
añadirlo a los que hubiera de antes

33
00:02:46,780 --> 00:02:48,080
a los que hubiera de antes

34
00:02:48,080 --> 00:02:51,139
luego al file output

35
00:02:51,139 --> 00:02:52,560
stream al que nos enganchamos

36
00:02:52,560 --> 00:02:53,539
le tenemos que añadir un true

37
00:02:53,539 --> 00:02:57,039
añadimos un true a este file output stream

38
00:02:57,039 --> 00:02:58,800
para que añada a los objetos

39
00:02:58,800 --> 00:02:59,699
que hubiera de antes

40
00:02:59,699 --> 00:03:02,659
y ahora ya escribimos el objeto

41
00:03:02,659 --> 00:03:04,460
este es solo uno

42
00:03:04,460 --> 00:03:05,719
pues venga

43
00:03:05,719 --> 00:03:10,319
escribimos nuestro objeto

44
00:03:10,319 --> 00:03:12,699
bueno, guardar alumno es que no le hemos pasado

45
00:03:12,699 --> 00:03:15,000
a guardar, vaya tontería

46
00:03:15,000 --> 00:03:16,300
no le hemos pasado

47
00:03:16,300 --> 00:03:18,439
ala, este

48
00:03:18,439 --> 00:03:23,550
y ahora hemos terminado

49
00:03:23,550 --> 00:03:34,270
bueno, pues ahora vamos a hacer una aplicación

50
00:03:34,270 --> 00:03:36,250
que lo que hace es

51
00:03:36,250 --> 00:03:38,409
solicitar objetos alumno

52
00:03:38,409 --> 00:03:39,990
y mandarlos al fichero

53
00:03:39,990 --> 00:03:42,210
ya está, entonces que la aplicación

54
00:03:42,210 --> 00:03:44,409
arranca una segunda vez

55
00:03:44,409 --> 00:03:46,490
los nuevos que le pidamos

56
00:03:46,490 --> 00:03:48,289
irán al fichero y se acabó

57
00:03:48,289 --> 00:03:50,430
Y ya está, pues bien, vamos a hacer una aplicación

58
00:03:50,430 --> 00:03:51,210
Simplemente

59
00:03:51,210 --> 00:03:54,349
Que esté todo el rato

60
00:03:54,349 --> 00:03:56,569
Bueno, todo el rato

61
00:03:56,569 --> 00:03:58,610
Mientras no le digamos

62
00:03:58,610 --> 00:04:00,349
Que introduzca

63
00:04:00,349 --> 00:04:06,639
Vamos a decirle

64
00:04:06,639 --> 00:04:07,919
Venga, mete NIF

65
00:04:07,919 --> 00:04:11,120
Pues que meta el NIF

66
00:04:11,120 --> 00:04:18,079
Ver cadena

67
00:04:18,079 --> 00:04:21,699
Este será

68
00:04:21,699 --> 00:04:24,000
Vamos a hacer aquí

69
00:04:24,000 --> 00:04:24,779
El alumno A

70
00:04:24,779 --> 00:04:32,810
Y este alumno A

71
00:04:32,810 --> 00:04:34,689
Le hacemos que su NIF

72
00:04:34,689 --> 00:04:41,620
.setNif

73
00:04:41,620 --> 00:04:46,220
Que su Nif sea el resultado de leer del teclado

74
00:04:46,220 --> 00:04:51,779
Esto así no

75
00:04:51,779 --> 00:04:56,550
Ah, esta ya tiene Nif

76
00:04:56,550 --> 00:04:59,870
Y vamos a pedirle el nombre, que es la única otra propiedad que tenía

77
00:04:59,870 --> 00:05:03,269
Nombre

78
00:05:03,269 --> 00:05:12,889
Vale, y ahora

79
00:05:12,889 --> 00:05:16,149
Guardamos el objeto alumno en el fichero

80
00:05:16,149 --> 00:05:20,910
Guardar alumno era esto

81
00:05:20,910 --> 00:05:23,370
Guardar alumno

82
00:05:23,370 --> 00:05:26,269
al que le damos el alumno que acabamos de crear

83
00:05:26,269 --> 00:05:28,529
y el fichero de alumnos

84
00:05:28,529 --> 00:05:30,149
este

85
00:05:30,149 --> 00:05:33,589
y este bucle va a estar así todo el rato

86
00:05:33,589 --> 00:05:35,790
mientras él no nos diga a continuar

87
00:05:35,790 --> 00:05:37,029
sí o no y ya está

88
00:05:37,029 --> 00:06:05,949
aquí vamos a hacer

89
00:06:05,949 --> 00:06:06,990
la respuesta

90
00:06:06,990 --> 00:06:12,180
así

91
00:06:12,180 --> 00:06:17,870
y ahora mientras

92
00:06:17,870 --> 00:06:22,509
la opción sea

93
00:06:22,509 --> 00:06:23,670
distinta

94
00:06:23,670 --> 00:06:29,379
de continuar

95
00:06:29,379 --> 00:06:30,139
de no

96
00:06:30,139 --> 00:06:32,500
Mientras sea distinta de no

97
00:06:32,500 --> 00:06:33,300
Continúas

98
00:06:33,300 --> 00:06:35,540
Y nos falta declararla aquí

99
00:06:35,540 --> 00:06:43,899
Igual a esto

100
00:06:43,899 --> 00:06:46,970
Vale, pues nada

101
00:06:46,970 --> 00:06:49,910
No hace falta ni inicializarla

102
00:06:49,910 --> 00:06:51,889
Porque la le stream

103
00:06:51,889 --> 00:06:54,449
Vale, pues nada

104
00:06:54,449 --> 00:06:57,209
Y esto es la excepción

105
00:06:57,209 --> 00:07:02,850
Vale, pues nada

106
00:07:02,850 --> 00:07:04,790
Pide alumno, lo guarda

107
00:07:04,790 --> 00:07:05,629
¿Quieres continuar?

108
00:07:06,730 --> 00:07:08,389
Mientras él no diga que no

109
00:07:08,389 --> 00:07:10,850
Otra vez, pide alumno, guarda, etc

110
00:07:10,850 --> 00:07:11,529
Y todo el rato

111
00:07:11,529 --> 00:07:12,829
Que he hecho mal

112
00:07:12,829 --> 00:07:16,230
Ah, perdón, perdón

113
00:07:16,230 --> 00:07:18,649
Sí, sí, sí

114
00:07:18,649 --> 00:07:21,290
Sí, vale

115
00:07:21,290 --> 00:07:24,779
Vale, pues nada

116
00:07:24,779 --> 00:07:27,220
Vamos a meter con esta aplicación

117
00:07:27,220 --> 00:07:27,819
Un alumno

118
00:07:27,819 --> 00:07:40,500
Nif1234

119
00:07:40,500 --> 00:07:43,220
Nombre Pepito

120
00:07:43,220 --> 00:07:45,839
Ah, que alumno

121
00:07:45,839 --> 00:07:46,620
No es serializable

122
00:07:46,620 --> 00:07:49,639
¿Veis? Como decía que esto es lo típico

123
00:07:49,639 --> 00:07:50,519
Que siempre se olvida

124
00:07:50,519 --> 00:07:54,040
Implements

125
00:07:54,040 --> 00:07:55,819
Por eso

126
00:07:55,819 --> 00:07:58,160
Es bueno haber visto la opción una primera vez

127
00:07:58,160 --> 00:07:59,319
El error

128
00:07:59,319 --> 00:08:04,610
Vale, pues venga

129
00:08:04,610 --> 00:08:06,689
Lo ejecutamos otra vez

130
00:08:06,689 --> 00:08:09,860
3, 4

131
00:08:09,860 --> 00:08:12,079
1, 2, 3, 4

132
00:08:12,079 --> 00:08:18,490
No, solo uno

133
00:08:18,490 --> 00:08:20,050
Pues hala, ya está

134
00:08:20,050 --> 00:08:22,310
Ya tenemos ahí

135
00:08:22,310 --> 00:08:30,110
Nuestro fichero de alumnos

136
00:08:30,110 --> 00:08:32,990
Que madre de Dios

137
00:08:32,990 --> 00:08:37,899
No, este no puede ser

138
00:08:37,899 --> 00:08:39,539
Es demasiado largo

139
00:08:39,539 --> 00:08:41,820
¿Dónde me he metido yo?

140
00:08:42,559 --> 00:08:43,580
No, sí

141
00:08:43,580 --> 00:08:53,809
Ah, esta es porque tiene

142
00:08:53,809 --> 00:08:58,960
Uf, qué fichero tan horriblemente largo

143
00:08:58,960 --> 00:09:05,960
No, es que esto no me cuadra

144
00:09:05,960 --> 00:09:06,720
Este contenido

145
00:09:06,720 --> 00:09:11,139
No me cuadra nada este contenido

146
00:09:11,139 --> 00:09:12,919
A ver

147
00:09:12,919 --> 00:09:17,690
Alumno A

148
00:09:17,690 --> 00:09:25,309
Y aquí qué he hecho

149
00:09:25,309 --> 00:09:28,570
Guardar alumno A

150
00:09:28,570 --> 00:09:29,970
Año alumno

151
00:09:29,970 --> 00:09:31,789
A, sednif

152
00:09:31,789 --> 00:09:36,779
Bueno, no sé

153
00:09:36,779 --> 00:09:38,720
Ese contenido se me resulta un poco raro, pero bueno

154
00:09:38,720 --> 00:09:42,240
claro, es que me tendría que aparecer

155
00:09:42,240 --> 00:09:44,139
sobre una línea, por eso digo

156
00:09:44,139 --> 00:09:45,320
que qué he hecho yo aquí raro

157
00:09:45,320 --> 00:09:48,610
vale, ahora

158
00:09:48,610 --> 00:09:51,669
nuestros datos, los de esta aplicación

159
00:09:51,669 --> 00:09:53,389
aquí ya no hay lista que tenga datos

160
00:09:53,389 --> 00:09:54,769
ni nada, están todos en archivo

161
00:09:54,769 --> 00:09:57,370
imaginaos que ahora queremos hacer un método que me diga

162
00:09:57,370 --> 00:09:59,549
oye, dime el nombre del alumno con este

163
00:09:59,549 --> 00:10:01,509
nif, por ejemplo, pues ese

164
00:10:01,509 --> 00:10:03,250
método tendrá que trabajar con el archivo

165
00:10:03,250 --> 00:10:05,289
porque aquí no hay una lista que tenga los datos

166
00:10:05,289 --> 00:10:07,570
ni nada, pues vamos a hacer ese método

167
00:10:07,570 --> 00:10:11,330
vamos a hacer el método de

168
00:10:11,330 --> 00:10:13,330
recuperar nombre de alumno

169
00:10:13,330 --> 00:10:21,909
dado un if

170
00:10:21,909 --> 00:10:24,289
y dado

171
00:10:24,289 --> 00:10:26,389
el nombre del archivo donde están los datos

172
00:10:26,389 --> 00:10:35,110
venga, pues aquí tenemos

173
00:10:35,110 --> 00:10:37,250
una funcionalidad que dado

174
00:10:37,250 --> 00:10:38,509
un if public

175
00:10:38,509 --> 00:10:41,070
recupera nombre, le vamos a poner aquí

176
00:10:41,070 --> 00:10:42,730
un return null para que se calle

177
00:10:42,730 --> 00:10:44,210
vale

178
00:10:44,210 --> 00:10:46,850
pues aquí tenemos una funcionalidad

179
00:10:46,850 --> 00:10:49,230
dado un if, devuélveme el

180
00:10:49,230 --> 00:10:51,169
nombre de ese alumno

181
00:10:51,169 --> 00:10:54,169
aquí ahora ya la diferencia

182
00:10:54,169 --> 00:10:56,330
respecto al resto de aplicaciones pasadas

183
00:10:56,330 --> 00:10:58,149
es que nosotros antes teníamos

184
00:10:58,149 --> 00:11:00,070
todos los alumnos

185
00:11:00,070 --> 00:11:02,090
los teníamos en una lista

186
00:11:02,090 --> 00:11:04,049
o en un set o en un map, ahí estaban todos

187
00:11:04,049 --> 00:11:06,029
y entonces aquí tranquilamente

188
00:11:06,029 --> 00:11:08,289
nos íbamos a esa lista, ese set y ese map

189
00:11:08,289 --> 00:11:09,590
y lo buscábamos

190
00:11:09,590 --> 00:11:12,529
aquí no hay ninguna lista, no hay ningún set

191
00:11:12,529 --> 00:11:13,710
no hay ningún map, no hay nada

192
00:11:13,710 --> 00:11:16,029
los alumnos están en el fichero

193
00:11:16,029 --> 00:11:18,169
pues tendremos que abrir el fichero

194
00:11:18,169 --> 00:11:20,570
empezar a leer de él, a tirar de los objetos

195
00:11:20,570 --> 00:11:22,850
hasta que encontremos un objeto cuyo NIF sea ese.

196
00:11:23,490 --> 00:11:24,470
Porque ahí es donde están.

197
00:11:24,710 --> 00:11:25,269
Están solo ahí.

198
00:11:26,590 --> 00:11:28,610
En toda esta aplicación, por más que miremos,

199
00:11:28,690 --> 00:11:30,049
no hay ninguna lista con alumnos.

200
00:11:30,629 --> 00:11:31,529
Están todos aquí.

201
00:11:32,250 --> 00:11:33,690
En este archivo que me han dado.

202
00:11:34,549 --> 00:11:37,009
Vale, pues venga, vamos a empezar a leer del archivo.

203
00:11:37,210 --> 00:11:39,090
Vamos a recuperar alumno por alumno.

204
00:11:39,230 --> 00:11:41,370
Cuando encontremos aquel cuyo NIF es esto,

205
00:11:41,529 --> 00:11:42,889
accedemos al nombre y lo mostramos.

206
00:11:43,029 --> 00:11:43,950
Eso es lo que haríamos, ¿no?

207
00:11:45,110 --> 00:11:46,830
En lugar de recorrer la lista,

208
00:11:47,149 --> 00:11:48,169
vamos a leer el archivo.

209
00:11:48,169 --> 00:11:52,409
Vale, pues vamos a hacer el bucle de lectura otra vez

210
00:11:52,409 --> 00:11:58,330
Voy a copiar y pegar el anterior

211
00:11:58,330 --> 00:12:10,799
Que lo tendré aquí abajo

212
00:12:10,799 --> 00:12:24,460
Bueno, de hecho lo voy a copiar todo para que si el fichero no existe lo diga

213
00:12:24,460 --> 00:12:30,440
Vale, ahora lo...

214
00:12:30,440 --> 00:12:34,360
Aquí estamos

215
00:12:34,360 --> 00:12:36,019
Vamos a copiar y ahora lo vemos

216
00:12:36,019 --> 00:12:37,279
Vale, pues lo primero que hacemos

217
00:12:37,279 --> 00:12:40,340
fichero alumnos se llama

218
00:12:40,340 --> 00:12:44,049
vamos a ver si existe

219
00:12:44,049 --> 00:12:45,309
porque si no existe

220
00:12:45,309 --> 00:12:46,789
el nombre

221
00:12:46,789 --> 00:12:50,190
no hay nombre, no existe el archivo

222
00:12:50,190 --> 00:12:52,090
es que no puedo recuperar el nombre de ningún

223
00:12:52,090 --> 00:12:53,990
alumno, ya está

224
00:12:53,990 --> 00:12:55,470
vale, ahora el archivo existe

225
00:12:55,470 --> 00:12:57,950
pues ahora ya vamos a abrirlo para leer

226
00:12:57,950 --> 00:13:00,230
como tiene objetos

227
00:13:00,230 --> 00:13:01,210
serializados

228
00:13:01,210 --> 00:13:03,250
pues con object input string

229
00:13:03,250 --> 00:13:08,120
fichero alumnos, nada, no doy un

230
00:13:08,120 --> 00:13:12,450
fichero alumnos

231
00:13:12,450 --> 00:13:15,029
hala, ya está, ya está abierto

232
00:13:15,029 --> 00:13:17,049
y ahora, bucle de lectura, vamos a empezar a leer

233
00:13:17,049 --> 00:13:22,340
esto lo quito, el bucle de lectura

234
00:13:22,340 --> 00:13:24,200
es el mismo, intento

235
00:13:24,200 --> 00:13:26,500
hacer mi lectura de mi objeto

236
00:13:26,500 --> 00:13:29,990
readObject

237
00:13:29,990 --> 00:13:32,070
que sé que es un objeto de tipo alumno

238
00:13:32,070 --> 00:13:33,830
le hago el casting y esto me dirá

239
00:13:33,830 --> 00:13:35,909
que excepción que haces, postRows

240
00:13:35,909 --> 00:13:37,769
vale

241
00:13:37,769 --> 00:13:40,029
y ahora, ¿qué hacemos con

242
00:13:40,029 --> 00:13:41,070
este alumno que hemos leído?

243
00:13:41,850 --> 00:13:44,049
pues venga, vamos a ver si

244
00:13:44,049 --> 00:13:46,169
el need de este alumno que acabo de leer

245
00:13:46,169 --> 00:13:47,090
es el que me han dicho

246
00:13:47,090 --> 00:13:49,570
porque si lo es, pues ya tengo el nombre

247
00:13:49,570 --> 00:13:50,769
bla bla bla

248
00:13:50,769 --> 00:13:53,450
entonces el resultado, vamos a guardarlo aquí

249
00:13:53,450 --> 00:13:54,309
el resultado

250
00:13:54,309 --> 00:13:56,669
el nombre resultado

251
00:13:56,669 --> 00:13:58,470
lo vamos a poner aquí

252
00:13:58,470 --> 00:14:01,450
inicialmente es esto

253
00:14:01,450 --> 00:14:02,769
y ahora

254
00:14:02,769 --> 00:14:05,850
si a.getNif

255
00:14:05,850 --> 00:14:07,590
resulta

256
00:14:07,590 --> 00:14:08,690
que es igual

257
00:14:08,690 --> 00:14:10,450
al nombre

258
00:14:10,450 --> 00:14:12,909
perdón, al Nif

259
00:14:12,909 --> 00:14:15,389
que me han pasado como parámetro

260
00:14:15,389 --> 00:14:17,769
pues ya tengo el resultado

261
00:14:17,769 --> 00:14:19,950
el resultado es

262
00:14:19,950 --> 00:14:21,470
el nombre de este alumno

263
00:14:21,470 --> 00:14:26,549
y no se llama result sino nombre

264
00:14:26,549 --> 00:14:32,100
y ahora cuando

265
00:14:32,100 --> 00:14:33,820
esto ya ha terminado

266
00:14:33,820 --> 00:14:35,799
devuelvo

267
00:14:35,799 --> 00:14:44,669
vale, pues mi método es este, primero

268
00:14:44,669 --> 00:14:47,029
si no existe no tengo nada que hacer

269
00:14:47,029 --> 00:14:48,190
devuelvo un null como nombre

270
00:14:48,190 --> 00:14:50,909
si existe, lo abro para

271
00:14:50,909 --> 00:14:51,789
leer objetos

272
00:14:51,789 --> 00:14:54,710
me hago el bucle de lectura, me voy leyendo

273
00:14:54,710 --> 00:14:55,649
alumno por alumno

274
00:14:55,649 --> 00:14:59,090
y con cada uno de ellos

275
00:14:59,090 --> 00:15:01,350
su nombre es igual, su if es igual

276
00:15:01,350 --> 00:15:02,070
que me han pasado

277
00:15:02,070 --> 00:15:04,049
sí, pues ya lo tengo

278
00:15:04,049 --> 00:15:06,990
y ya está, y return nombre

279
00:15:06,990 --> 00:15:08,970
aquí incluso

280
00:15:08,970 --> 00:15:11,730
podría ya de paso en este if

281
00:15:11,730 --> 00:15:13,710
meter un fin archivo

282
00:15:13,710 --> 00:15:15,809
para que el while ya termine

283
00:15:15,809 --> 00:15:16,590
y no siga leyendo

284
00:15:16,590 --> 00:15:21,240
podría, y así ya, porque si tiene mil alumnos

285
00:15:21,240 --> 00:15:22,759
y lo he encontrado en el primero

286
00:15:22,759 --> 00:15:24,080
pues hombre

287
00:15:24,080 --> 00:15:27,039
podría ya hacer esto

288
00:15:27,039 --> 00:15:33,720
y así no se está ese leyendo

289
00:15:33,720 --> 00:15:35,679
hasta fin de archivo cuando ya lo ha encontrado

290
00:15:35,679 --> 00:15:37,559
entonces este bucle ahora saldría

291
00:15:37,559 --> 00:15:39,360
por dos motivos, o bien

292
00:15:39,360 --> 00:15:41,659
porque ha encontrado ya al alumno con ese nif

293
00:15:41,659 --> 00:15:43,519
o bien porque ha llegado

294
00:15:43,519 --> 00:15:44,519
al final y no lo ha encontrado

295
00:15:44,519 --> 00:15:47,059
por una de las dos razones

296
00:15:47,059 --> 00:15:49,440
podría salir, porque ha llegado al final

297
00:15:49,440 --> 00:15:50,720
y no lo ha encontrado

298
00:15:50,720 --> 00:15:52,580
o porque lo ha encontrado

299
00:15:52,580 --> 00:15:54,919
y ya me lo ha devuelto

300
00:15:54,919 --> 00:15:57,080
vale, retú un nombre y ya está

301
00:15:57,080 --> 00:16:01,019
y aquí tengo

302
00:16:01,019 --> 00:16:03,659
un rojo en este porque este

303
00:16:03,659 --> 00:16:05,779
no hace parte de importar

304
00:16:05,779 --> 00:16:07,759
que este está en el propio paquete

305
00:16:07,759 --> 00:16:09,240
ahí, vale

306
00:16:09,240 --> 00:16:14,710
vale, pues venga, entonces

307
00:16:14,710 --> 00:16:17,129
este recuperaría directamente

308
00:16:17,129 --> 00:16:18,870
del archivo, es que no los tengo en una lista

309
00:16:18,870 --> 00:16:19,649
los tengo en el archivo

310
00:16:19,649 --> 00:16:22,210
pues ahora, nuestro main

311
00:16:22,210 --> 00:16:24,649
ha metido un alumno

312
00:16:24,649 --> 00:16:29,059
hemos metido solo uno

313
00:16:29,059 --> 00:16:32,019
que en mi caso tenía un 234

314
00:16:32,019 --> 00:16:35,620
voy a comentarlo para que no meta

315
00:16:35,620 --> 00:16:45,500
más, porque no quiero que meta más por una razón. Y ahora vamos a leer el alumno. Vamos

316
00:16:45,500 --> 00:16:57,340
a buscar un alumno. Introduce NIF de búsqueda. Introduce NIF de búsqueda. Vamos a leer el

317
00:16:57,340 --> 00:17:14,200
NIF de búsqueda. Y ahora llamamos al método para que nos devuelva el nombre que el método

318
00:17:14,200 --> 00:17:16,099
se llamaba recupera nombre

319
00:17:16,099 --> 00:17:22,029
recupera nombre

320
00:17:22,029 --> 00:17:24,250
para este nif sobre el archivo alumnos

321
00:17:24,250 --> 00:17:25,890
que es sobre el que estamos trabajando

322
00:17:25,890 --> 00:17:27,990
y ahora si nombre es

323
00:17:27,990 --> 00:17:29,829
diferente, si nombre es null

324
00:17:29,829 --> 00:17:31,450
pues es que no existe

325
00:17:31,450 --> 00:17:32,769
¿verdad?

326
00:17:39,279 --> 00:17:41,259
el alumno no existe

327
00:17:41,259 --> 00:17:43,859
y si no

328
00:17:43,859 --> 00:17:46,079
pues devolvemos el nombre y ya está

329
00:17:46,079 --> 00:17:50,609
vale, y esto me da

330
00:17:50,609 --> 00:17:55,680
una excepción y listo

331
00:17:55,680 --> 00:17:58,200
vale, pues entonces yo había ejecutado esto antes una sola

332
00:17:58,200 --> 00:17:59,220
vez, con lo cual

333
00:17:59,220 --> 00:18:01,039
El fichero de alumnos

334
00:18:01,039 --> 00:18:02,140
Solo tiene un alumno

335
00:18:02,140 --> 00:18:04,940
Que aquí, aunque yo no entienda nada

336
00:18:04,940 --> 00:18:08,519
Como que no matricula

337
00:18:08,519 --> 00:18:09,519
Este no es

338
00:18:09,519 --> 00:18:11,640
Estoy volviendo loca, claro

339
00:18:11,640 --> 00:18:12,920
Es que es este

340
00:18:12,920 --> 00:18:17,119
Yo tengo este, que aunque no entienda nada

341
00:18:17,119 --> 00:18:19,240
Aquí puedo ver que me ha metido solo uno

342
00:18:19,240 --> 00:18:20,980
Porque veo aquí un NIF

343
00:18:20,980 --> 00:18:23,720
Patatín

344
00:18:23,720 --> 00:18:25,240
Y veo aquí un nombre

345
00:18:25,240 --> 00:18:26,940
Que es Pepito, veo el NIF

346
00:18:26,940 --> 00:18:28,880
1, 2, 3, 4, o sea, solo tengo uno

347
00:18:28,880 --> 00:18:30,920
Vale

348
00:18:30,920 --> 00:18:33,740
Pues venga, vamos a hacer nuestro main

349
00:18:33,740 --> 00:18:35,940
A ver si encuentra el de 1, 2, 3, 4

350
00:18:35,940 --> 00:18:42,430
1, 2, 3, 4

351
00:18:42,430 --> 00:18:44,430
Bien, perfecto

352
00:18:44,430 --> 00:18:46,230
Y no estamos trabajando ni con

353
00:18:46,230 --> 00:18:48,509
Datos en la aplicación, en listas

354
00:18:48,509 --> 00:18:50,069
Ni en nada, los datos están en el archivo

355
00:18:50,069 --> 00:18:51,789
Están en el archivo

356
00:18:51,789 --> 00:18:53,369
No tengo aquí una colección

357
00:18:53,369 --> 00:18:55,670
Y tiene sentido trabajar así

358
00:18:55,670 --> 00:18:58,450
Porque si, imaginaos que esta aplicación

359
00:18:58,450 --> 00:19:00,730
Trabaja con 2000 alumnos

360
00:19:00,730 --> 00:19:02,710
Si tiene que tener los 2000

361
00:19:02,710 --> 00:19:04,130
En la lista todo el rato

362
00:19:04,130 --> 00:19:06,329
pedazo de ocupación

363
00:19:06,329 --> 00:19:07,329
que se hace de la RAM

364
00:19:07,329 --> 00:19:10,069
hombre, está en el archivo, él los tiene

365
00:19:10,069 --> 00:19:11,990
que quiere hacer una consulta, lee del archivo

366
00:19:11,990 --> 00:19:14,009
como hemos visto, va leyendo hasta que lo encuentra

367
00:19:14,009 --> 00:19:15,869
que quiere insertar uno nuevo

368
00:19:15,869 --> 00:19:17,009
lo añade al final

369
00:19:17,009 --> 00:19:20,210
y así yo tengo mis datos en el archivo

370
00:19:20,210 --> 00:19:21,529
que son 50.000

371
00:19:21,529 --> 00:19:23,569
son 50.000, están en el archivo

372
00:19:23,569 --> 00:19:25,690
no están en una lista de la aplicación

373
00:19:25,690 --> 00:19:28,349
venga, pues entonces

374
00:19:28,349 --> 00:19:30,049
seguimos, a ver que nos pasa aquí ahora

375
00:19:30,049 --> 00:19:32,269
vamos a volver a ejecutar este main

376
00:19:32,269 --> 00:19:33,269
para meter otro nuevo

377
00:19:33,269 --> 00:19:35,809
vamos a meter otro nuevo

378
00:19:35,809 --> 00:19:42,039
vale, entonces vamos a

379
00:19:42,039 --> 00:19:43,500
volver a, vamos a

380
00:19:43,500 --> 00:19:46,500
lanzar el main, nos va a pedir otro alumno

381
00:19:46,500 --> 00:19:48,539
vamos a meter otro nuevo

382
00:19:48,539 --> 00:19:49,859
como

383
00:19:49,859 --> 00:19:52,420
guardar alumno tiene la opción

384
00:19:52,420 --> 00:19:53,559
de añadir a true

385
00:19:53,559 --> 00:19:56,480
nos agregará ese alumno

386
00:19:56,480 --> 00:19:58,039
después del que hubiera de antes

387
00:19:58,039 --> 00:20:00,559
no lo borra de nuevas, vale, después del que hubiera

388
00:20:00,559 --> 00:20:02,440
de antes, pues venga, vamos a

389
00:20:02,440 --> 00:20:04,420
agregar otro y vamos a volver

390
00:20:04,420 --> 00:20:06,440
y vamos a volver a buscar el de nombre

391
00:20:06,440 --> 00:20:08,619
1, 2, 3, 4, por el de nif1, 2, 3, 4

392
00:20:08,619 --> 00:20:09,960
O el que sea, vamos a volver a buscar

393
00:20:09,960 --> 00:20:11,339
A ver si nos lo encuentra ahora

394
00:20:11,339 --> 00:20:13,900
Pues venga, ejecutamos el main

395
00:20:13,900 --> 00:20:18,309
Este es el alumno

396
00:20:18,309 --> 00:20:19,630
Que me está pidiendo, vamos a meter

397
00:20:19,630 --> 00:20:20,990
1, 5, 6, 7, 8

398
00:20:20,990 --> 00:20:23,369
Nombre este, vale

399
00:20:23,369 --> 00:20:25,410
Continuar, no, uno más solo

400
00:20:25,410 --> 00:20:26,430
No quiero continuar

401
00:20:26,430 --> 00:20:29,170
Ahora tendrá dos, se supone

402
00:20:29,170 --> 00:20:30,490
1, 2, 3, 4, 5, 6, 7, 8

403
00:20:30,490 --> 00:20:33,269
Vamos a buscar el 1, 2, 3, 4 de antes

404
00:20:33,269 --> 00:20:39,650
No me tendría que haber funcionado

405
00:20:39,650 --> 00:20:48,259
Claro, porque en el primero

406
00:20:48,259 --> 00:20:49,880
Todavía no se ha roto

407
00:20:49,880 --> 00:20:51,440
Vale, bueno

408
00:20:51,440 --> 00:20:53,380
Sí, vamos a volverlo a

409
00:20:53,380 --> 00:20:55,039
Ya ha terminado, ¿no?

410
00:20:55,420 --> 00:20:56,259
Vamos a hacer otra prueba

411
00:20:56,259 --> 00:20:58,079
Este caso de prueba lo ha pasado

412
00:20:58,079 --> 00:21:01,839
Vale, vamos a hacer otro caso de prueba

413
00:21:01,839 --> 00:21:06,619
Hasta luego, vamos a meter otro alumno más

414
00:21:06,619 --> 00:21:07,599
Otro alumno más

415
00:21:07,599 --> 00:21:10,059
8, 8, 8, 8. Venga, un tercer alumno.

416
00:21:11,339 --> 00:21:11,839
Tenemos ya

417
00:21:11,839 --> 00:21:13,539
tres alumnos. ¿Continuar? No, no.

418
00:21:13,619 --> 00:21:15,799
Tenemos tres. Vamos a buscar

419
00:21:15,799 --> 00:21:17,759
el 5, 6, 7, 8, que era el

420
00:21:17,759 --> 00:21:19,119
segundo. Vamos a volver a buscar el primero.

421
00:21:19,339 --> 00:21:21,660
El 5, 6, 7, 8.

422
00:21:21,759 --> 00:21:23,500
5, 6, 7, 8. Vale.

423
00:21:24,420 --> 00:21:25,740
Y efectivamente, sin

424
00:21:25,740 --> 00:21:27,599
tener ni idea, sin saber

425
00:21:27,599 --> 00:21:29,700
por qué, no nos lo ha

426
00:21:29,700 --> 00:21:31,779
encontrado. Y nos dice

427
00:21:31,779 --> 00:21:33,799
cabecera corrupta.

428
00:21:34,500 --> 00:21:35,680
Y este error ya de nuevo

429
00:21:35,680 --> 00:21:37,720
y que no lo conocemos, no sabemos a qué se refiere

430
00:21:37,720 --> 00:21:38,900
con cabecera corrupta

431
00:21:38,900 --> 00:21:42,019
bueno, vamos a ver qué ocurre, ver cómo arreglarlo

432
00:21:42,019 --> 00:21:43,619
y ya todo esto de desalinización de objetos

433
00:21:43,619 --> 00:21:44,920
ya lo dejamos al completo

434
00:21:44,920 --> 00:21:46,660
para poder usarlo

435
00:21:46,660 --> 00:21:49,519
para guardar y recuperar objetos y hacer con ellos

436
00:21:49,519 --> 00:21:50,279
lo que nos dé la gana

437
00:21:50,279 --> 00:21:53,839
y con algo así podríamos pasar de una base

438
00:21:53,839 --> 00:21:55,299
de datos, si lo necesitamos

439
00:21:55,299 --> 00:21:57,599
podríamos pasar de una base de datos, los objetos se van ahí

440
00:21:57,599 --> 00:21:58,599
los recupero

441
00:21:58,599 --> 00:22:01,880
vale, pues qué ha pasado aquí, cuál es el rollo

442
00:22:01,880 --> 00:22:02,220
este

443
00:22:02,220 --> 00:22:05,180
con el que nos hemos encontrado

444
00:22:05,180 --> 00:22:46,720
vale, rotulamos

445
00:22:46,720 --> 00:22:58,950
bueno, pues que hace el

446
00:22:58,950 --> 00:23:01,069
great object, nosotros hemos hecho, teníamos un objeto

447
00:23:01,069 --> 00:23:01,549
alumno

448
00:23:01,549 --> 00:23:04,849
aquí nuestro objeto alumno con if y nombre

449
00:23:04,849 --> 00:23:06,390
nuestro objeto a

450
00:23:06,390 --> 00:23:08,910
entonces, hemos hecho

451
00:23:08,910 --> 00:23:14,539
un great object, de este objeto

452
00:23:14,539 --> 00:23:15,900
a, vale

453
00:23:15,900 --> 00:23:18,140
vamos a poner que estamos en el primer great object

454
00:23:18,140 --> 00:23:19,680
en el que el archivo todavía no existía

455
00:23:19,680 --> 00:23:21,880
bueno, pues ha creado el archivo de nuevas

456
00:23:21,880 --> 00:23:24,119
y el great object

457
00:23:24,119 --> 00:23:25,539
que es cuando

458
00:23:25,539 --> 00:23:28,180
al crear el archivo de nuevas, lo primero que hemos

459
00:23:28,180 --> 00:23:29,880
hecho es hacer el

460
00:23:29,880 --> 00:23:31,559
object output string

461
00:23:31,559 --> 00:23:35,930
bueno pues el object output string lo primero

462
00:23:35,930 --> 00:23:37,730
que hace cuando hago un archivo para escribir

463
00:23:37,730 --> 00:23:39,789
lo primero que hace es

464
00:23:39,789 --> 00:23:43,880
hacer una cabecera aquí, te hace

465
00:23:43,880 --> 00:23:45,920
una cabecera el object output string y se

466
00:23:45,920 --> 00:23:47,900
queda abierto para que a partir

467
00:23:47,900 --> 00:23:50,099
de ahí todos los objetos vayan a partir

468
00:23:50,099 --> 00:23:51,839
de la cabecera, hemos hecho

469
00:23:51,839 --> 00:23:53,539
un great object de A pues ha ido ahí

470
00:23:53,539 --> 00:23:55,819
que con este mismo

471
00:23:55,819 --> 00:23:57,799
flujo sin cerrar hubiéramos escrito

472
00:23:57,799 --> 00:23:59,859
otro, pues ese otro hubiera ido

473
00:23:59,859 --> 00:24:01,220
ahí, todos a partir de la cabecera

474
00:24:01,220 --> 00:24:03,900
cuando ya lo hemos cerrado, hemos hecho esto un close

475
00:24:03,900 --> 00:24:05,220
pues se acabó

476
00:24:05,220 --> 00:24:07,599
este fichero terminó, vale

477
00:24:07,599 --> 00:24:09,900
ahora hemos vuelto a ejecutar el programa

478
00:24:09,900 --> 00:24:11,880
otra vez hemos vuelto

479
00:24:11,880 --> 00:24:14,119
a instanciar un object output string

480
00:24:14,119 --> 00:24:15,980
asociado a este que ya existía

481
00:24:15,980 --> 00:24:17,059
que ya existía

482
00:24:17,059 --> 00:24:20,119
pues que es lo que hace, como lo hemos dado con la opción

483
00:24:20,119 --> 00:24:22,059
de true, de añadir

484
00:24:22,059 --> 00:24:23,539
lo que ha hecho ha sido

485
00:24:23,539 --> 00:24:26,039
como es añadir

486
00:24:26,039 --> 00:24:27,759
me coloco aquí, pues aquí en medio

487
00:24:27,759 --> 00:24:29,380
cojo y planto otra cabecera

488
00:24:29,380 --> 00:24:31,660
planta otra en medio

489
00:24:31,660 --> 00:24:33,200
y ahí la ha plantado

490
00:24:33,200 --> 00:24:35,519
cada vez que se hace un object output stream

491
00:24:35,519 --> 00:24:37,059
él planta una cabecera

492
00:24:37,059 --> 00:24:39,619
que el fichero está limpio, es fenomenal

493
00:24:39,619 --> 00:24:41,019
la ha plantado al principio

494
00:24:41,019 --> 00:24:43,619
que el fichero ya tenía cosas y le hemos dado a añadir

495
00:24:43,619 --> 00:24:44,519
la planta aquí en medio

496
00:24:44,519 --> 00:24:47,319
y luego ya se escriben los objetos

497
00:24:47,319 --> 00:24:49,920
¿qué ocurre? que la única cabecera que tiene sentido

498
00:24:49,920 --> 00:24:51,720
que exista, la única que tiene sentido

499
00:24:51,720 --> 00:24:54,039
que exista, es la primera

500
00:24:54,039 --> 00:24:55,980
la que te informa del tipo

501
00:24:55,980 --> 00:24:57,740
de objeto que hay, para eso sus propiedades

502
00:24:57,740 --> 00:24:59,039
el resto de cabeceras

503
00:24:59,039 --> 00:25:01,940
lo que hacen es corromper el fichero

504
00:25:01,940 --> 00:25:03,880
y lo estropean, porque ahora ya

505
00:25:03,880 --> 00:25:04,940
si uno abre un

506
00:25:04,940 --> 00:25:08,019
con object input string para abrir y se pone

507
00:25:08,019 --> 00:25:09,859
a leer, el object input string

508
00:25:09,859 --> 00:25:11,880
lee la cabecera del principio, una vez

509
00:25:11,880 --> 00:25:14,059
y se acabó, y a partir de ahí se pone

510
00:25:14,059 --> 00:25:15,920
a leer, y él espera

511
00:25:15,920 --> 00:25:18,039
todo el rato alumnos, alumno, alumno, alumno

512
00:25:18,039 --> 00:25:20,099
y de repente cuando llega aquí se encuentra

513
00:25:20,099 --> 00:25:22,180
algo que no es un objeto alumno y dice, no entiendo nada

514
00:25:22,180 --> 00:25:24,200
y ahí es cuando sale el error

515
00:25:24,200 --> 00:25:26,299
este del string corrupted, bla bla bla

516
00:25:26,299 --> 00:25:28,900
entonces, ¿cuál es el problema?

517
00:25:29,759 --> 00:25:32,019
que cuando abrimos con object output stream

518
00:25:32,019 --> 00:25:33,759
para añadir

519
00:25:33,759 --> 00:25:34,799
para añadir

520
00:25:34,799 --> 00:25:36,619
tenemos que hacer algo

521
00:25:36,619 --> 00:25:39,500
para que este object output stream

522
00:25:39,500 --> 00:25:41,420
no escriba esto y se lo salte

523
00:25:41,420 --> 00:25:43,799
tenemos que hacer algo para que no lo escriba y se lo salte

524
00:25:43,799 --> 00:25:45,579
solo en ese caso

525
00:25:45,579 --> 00:25:47,519
en el caso de que abramos

526
00:25:47,519 --> 00:25:49,460
object output stream para añadir

527
00:25:49,460 --> 00:25:50,579
en un fichero que ya existe

528
00:25:50,579 --> 00:25:53,440
si lo hacemos en un fichero que no existe

529
00:25:53,440 --> 00:25:55,500
entonces no, queremos que lo escriba

530
00:25:55,500 --> 00:25:57,619
pero si es en un fichero que existe

531
00:25:57,619 --> 00:25:58,500
tenemos que hacer algo

532
00:25:58,500 --> 00:25:59,920
¿y ese algo cómo lo hacemos?

533
00:26:00,720 --> 00:26:02,700
bueno, pues como sabemos cómo va esto de la herencia

534
00:26:02,700 --> 00:26:04,380
y no sé qué, pues vamos a hacer un truco rápido

535
00:26:04,380 --> 00:26:06,079
vamos a hacerlo

536
00:26:06,079 --> 00:26:08,339
vale

537
00:26:08,339 --> 00:26:33,190
vale, pues vamos a hacernos

538
00:26:33,190 --> 00:26:34,190
una clase

539
00:26:34,190 --> 00:26:36,369
object output string nosotros

540
00:26:36,369 --> 00:26:38,789
que sea igualita

541
00:26:38,789 --> 00:26:41,069
que la verdadera, que la real igualita

542
00:26:41,069 --> 00:26:42,809
pero que lo único

543
00:26:42,809 --> 00:26:44,990
que haga sea cambiar el método

544
00:26:44,990 --> 00:26:46,829
de escribir cabecera para que ahí

545
00:26:46,829 --> 00:26:47,769
no haga nada

546
00:26:47,769 --> 00:26:50,990
entonces vamos a hacernos lo siguiente

547
00:26:50,990 --> 00:26:53,190
vamos a hacernos

548
00:26:53,190 --> 00:26:54,890
en el paquete este en el que estamos de objetos

549
00:26:54,890 --> 00:26:57,069
vamos a hacernos una clase object output string

550
00:26:57,069 --> 00:26:58,789
copia de la otra

551
00:26:58,789 --> 00:27:00,849
pero que solamente cambio

552
00:27:00,849 --> 00:27:02,450
de escribir cabecera para que no lo escriba

553
00:27:02,450 --> 00:27:05,170
y en cada momento decidimos

554
00:27:05,170 --> 00:27:06,890
si nos interesa usar la original

555
00:27:06,890 --> 00:27:08,230
o la modificada

556
00:27:08,230 --> 00:27:10,750
vale, pues vamos a hacernos entonces

557
00:27:10,750 --> 00:27:11,450
una clase

558
00:27:11,450 --> 00:27:14,549
la vamos a llamar object output string

559
00:27:14,549 --> 00:27:16,869
sin cabecera, como lo queráis llamar

560
00:27:16,869 --> 00:27:17,670
porque es nuestra

561
00:27:17,670 --> 00:27:26,460
sin cabecera, venga

562
00:27:26,460 --> 00:27:29,660
entonces como queremos que sea igualita que la otra

563
00:27:29,660 --> 00:27:31,619
la forma de hacerla igualita

564
00:27:31,619 --> 00:27:33,079
es haciendo la heredera de la otra

565
00:27:33,079 --> 00:27:34,700
porque coge todo lo de la de arriba

566
00:27:34,700 --> 00:27:37,539
pues la vamos a hacer

567
00:27:37,539 --> 00:27:39,299
heredera de object output

568
00:27:39,299 --> 00:27:41,859
voy a pasarlo aquí abajo

569
00:27:41,859 --> 00:27:43,740
heredera de

570
00:27:43,740 --> 00:27:45,640
object output stream

571
00:27:45,640 --> 00:27:48,930
a la heredera de esta

572
00:27:48,930 --> 00:27:50,829
entonces al ser heredera

573
00:27:50,829 --> 00:27:52,470
de esta

574
00:27:52,470 --> 00:27:55,390
que ocurre

575
00:27:55,390 --> 00:27:57,910
que hereda todo, todo es una copia

576
00:27:57,910 --> 00:27:59,309
calcada de la otra

577
00:27:59,309 --> 00:28:01,829
menos el constructor, los constructores no

578
00:28:01,829 --> 00:28:04,069
pues entonces vamos a hacer un constructor específico

579
00:28:04,069 --> 00:28:07,730
a esta, vamos a hacerlo

580
00:28:07,730 --> 00:28:09,410
un constructor específico

581
00:28:09,410 --> 00:28:13,960
público, claro

582
00:28:13,960 --> 00:28:16,640
que use

583
00:28:16,640 --> 00:28:18,299
la de arriba

584
00:28:18,299 --> 00:28:21,059
pero el constructor de object output string

585
00:28:21,059 --> 00:28:23,059
que recibía, el constructor

586
00:28:23,059 --> 00:28:24,220
de object output string

587
00:28:24,220 --> 00:28:26,500
lo hemos usado aquí

588
00:28:26,500 --> 00:28:31,200
object output string

589
00:28:31,200 --> 00:28:32,819
recibe

590
00:28:32,819 --> 00:28:34,920
un file output string

591
00:28:34,920 --> 00:28:36,460
pues este también tiene que recibirlo

592
00:28:36,460 --> 00:28:37,539
entonces

593
00:28:37,539 --> 00:28:40,880
vamos a ponerle

594
00:28:40,880 --> 00:28:42,539
esto

595
00:28:42,539 --> 00:28:47,119
string

596
00:28:47,119 --> 00:28:50,779
y vamos a hacer que este constructor

597
00:28:50,779 --> 00:28:52,500
llame al de arriba y ya está

598
00:28:52,500 --> 00:28:56,160
pasándole eso

599
00:28:56,160 --> 00:28:57,319
f

600
00:28:57,319 --> 00:29:03,339
y aquí esto me dice

601
00:29:03,339 --> 00:29:04,519
que importe

602
00:29:04,519 --> 00:29:05,920
pues importo

603
00:29:05,920 --> 00:29:10,099
y aquí que importe

604
00:29:10,099 --> 00:29:18,920
Vale, y aquí me dice que puede lanzar una excepción, pues la propago.

605
00:29:22,609 --> 00:29:25,970
Vale, pues ya le he hecho un constructor que hace lo mismo que el constructor de arriba.

606
00:29:26,250 --> 00:29:29,430
Lo mismo, el parámetro que yo le pase aquí, se lo pasa a este.

607
00:29:30,750 --> 00:29:33,309
Entonces esta clase y esta son calcadas.

608
00:29:34,009 --> 00:29:39,190
Vale, pero yo esta la quiero modificar para que el método que tiene esta,

609
00:29:39,710 --> 00:29:43,890
que es el que utiliza para escribir la cabecera, pues que ese método está vacío, para que no escriba nada.

610
00:29:43,890 --> 00:29:46,369
Y así tengo una versión de esta

611
00:29:46,369 --> 00:29:48,950
Que en el momento de escribir la cabecera

612
00:29:48,950 --> 00:29:50,089
No escriba nada

613
00:29:50,089 --> 00:29:52,589
Bueno, vamos a sobreescribir el método

614
00:29:52,589 --> 00:29:53,490
Escribir cabecera

615
00:29:53,490 --> 00:29:56,130
Ese método no tendría que buscar a ver cuál es

616
00:29:56,130 --> 00:29:58,009
Y si uno busca

617
00:29:58,009 --> 00:30:00,329
Pues encontraría que ese método

618
00:30:00,329 --> 00:30:05,230
Creo que se llama así

619
00:30:05,230 --> 00:30:07,750
Si no lo comprobamos poniéndolo de raíz

620
00:30:07,750 --> 00:30:13,089
Esto public

621
00:30:13,089 --> 00:30:16,190
Void

622
00:30:16,190 --> 00:30:17,630
Vale

623
00:30:17,630 --> 00:30:21,109
Vale, ¿cómo puedo yo asegurarme

624
00:30:21,109 --> 00:30:22,970
de que este método no es uno que yo

625
00:30:22,970 --> 00:30:25,190
me he inventado, sino que sobrescribe

626
00:30:25,190 --> 00:30:25,970
uno de arriba.

627
00:30:27,210 --> 00:30:29,029
Aparte de porque el eclipse pone el triangulito

628
00:30:29,029 --> 00:30:30,829
verde, aparte de porque

629
00:30:30,829 --> 00:30:32,809
me lo pone, que eso dependería del entorno de desarrollo.

630
00:30:33,430 --> 00:30:35,210
Lo que no depende del entorno de desarrollo

631
00:30:35,210 --> 00:30:36,549
es si yo pongo la anotación

632
00:30:36,549 --> 00:30:37,529
y pongo esto.

633
00:30:39,089 --> 00:30:40,609
Si yo pongo la anotación

634
00:30:40,609 --> 00:30:42,750
y no peta nada,

635
00:30:43,390 --> 00:30:44,950
es que efectivamente este

636
00:30:44,950 --> 00:30:47,069
método existe en la clase de arriba.

637
00:30:47,809 --> 00:30:49,150
Porque si yo me hubiera equivocado

638
00:30:49,150 --> 00:30:50,829
y hubiera puesto este, que esto significa

639
00:30:50,829 --> 00:30:52,869
método nuevo y pongo

640
00:30:52,869 --> 00:30:54,829
el overrack y me dice, uh, este método no

641
00:30:54,829 --> 00:30:56,029
sobrescribe nada de arriba

642
00:30:56,029 --> 00:30:58,789
si quito la anotación ya sí que no pasa nada

643
00:30:58,789 --> 00:31:00,710
me echo uno nuevo y ya está, no pasa nada

644
00:31:00,710 --> 00:31:03,109
pero la anotación me permite

645
00:31:03,109 --> 00:31:04,410
comprobar

646
00:31:04,410 --> 00:31:06,910
que este método que yo he puesto realmente

647
00:31:06,910 --> 00:31:08,309
sobrescribe alguno de arriba

648
00:31:08,309 --> 00:31:11,269
vale, pues writeStringHeader

649
00:31:11,269 --> 00:31:12,029
por el nombre

650
00:31:12,029 --> 00:31:14,910
deducimos que este es el método

651
00:31:14,910 --> 00:31:16,430
que llama object.putString

652
00:31:16,430 --> 00:31:18,289
cuando quiere escribir la cabecera

653
00:31:18,289 --> 00:31:20,630
y yo quiero que esta versión

654
00:31:20,630 --> 00:31:22,630
mía, quiero que esta versión no escriba

655
00:31:22,630 --> 00:31:24,569
nada, cuando llame a ese método, que no escriba

656
00:31:24,569 --> 00:31:26,529
nada, pues entonces lo dejo así

657
00:31:26,529 --> 00:31:26,910
vacío

658
00:31:26,910 --> 00:31:29,950
pues ya tengo dos versiones de

659
00:31:29,950 --> 00:31:32,710
object output string, la que escribe cabecera y la que no

660
00:31:32,710 --> 00:31:34,490
¿cuándo uso

661
00:31:34,490 --> 00:31:36,329
una? ¿cuándo uso

662
00:31:36,329 --> 00:31:37,869
la que escribe cabecera?

663
00:31:38,309 --> 00:31:40,390
cuando mi archivo lo escriba limpio

664
00:31:40,390 --> 00:31:42,630
desde arriba, ¿cuándo uso la otra?

665
00:31:42,829 --> 00:31:44,609
cuando lo que quiera sea añadir

666
00:31:44,609 --> 00:31:46,650
¿vale? entonces si el fichero

667
00:31:46,650 --> 00:31:48,630
ya existe, uso

668
00:31:48,630 --> 00:31:50,930
la nueva y si el fichero no existe

669
00:31:50,930 --> 00:31:53,029
uso la original

670
00:31:53,029 --> 00:31:54,609
vale, ¿cómo

671
00:31:54,609 --> 00:31:56,809
modificaría eso nuestra aplicación?

672
00:31:57,630 --> 00:31:58,829
pues en guardar alumno

673
00:31:58,829 --> 00:32:00,730
en guardar alumno yo tengo que ver si el

674
00:32:00,730 --> 00:32:02,029
fichero en el que voy a guardarlo

675
00:32:02,029 --> 00:32:04,710
existe de antes de alumnos o no existe

676
00:32:04,710 --> 00:32:07,049
porque si no existe

677
00:32:07,049 --> 00:32:08,789
lo creo con

678
00:32:08,789 --> 00:32:10,829
este para que cree cabecera y todo eso

679
00:32:10,829 --> 00:32:12,710
pero si existe de

680
00:32:12,710 --> 00:32:14,690
antes, entonces tengo que

681
00:32:14,690 --> 00:32:16,630
abrirlo con la otra clase para que

682
00:32:16,630 --> 00:32:18,589
no meta la cabecera, porque lo que voy a hacer es

683
00:32:18,589 --> 00:32:21,750
añadir. Entonces tendríamos que hacer aquí un if

684
00:32:21,750 --> 00:32:24,269
previo y decir, vamos a ver

685
00:32:24,269 --> 00:32:27,829
vamos a hacer un objeto file para ese archivo

686
00:32:27,829 --> 00:32:35,980
new file, fichero

687
00:32:35,980 --> 00:32:41,670
alumnos. Vale, y vamos a ponernos aquí

688
00:32:41,670 --> 00:32:44,930
la referencia object output

689
00:32:44,930 --> 00:32:47,650
stream, que ahora mismo no tiene

690
00:32:47,650 --> 00:32:53,269
nada, en la que yo voy a guardar un objeto

691
00:32:53,269 --> 00:32:56,009
de una clase o de la otra. Pues me pregunto

692
00:32:56,009 --> 00:32:58,529
vamos a ver, este fichero f

693
00:32:58,529 --> 00:33:00,210
ya existe

694
00:33:00,210 --> 00:33:07,480
porque si este fichero

695
00:33:07,480 --> 00:33:08,539
f existe

696
00:33:08,539 --> 00:33:11,779
entonces yo voy a abrirlo

697
00:33:11,779 --> 00:33:12,559
para añadir

698
00:33:12,559 --> 00:33:14,640
y no quiero meter cabecera

699
00:33:14,640 --> 00:33:16,660
pues en ese caso

700
00:33:16,660 --> 00:33:19,259
lo que querré guardar

701
00:33:19,259 --> 00:33:20,599
en la referencia esta de aquí

702
00:33:20,599 --> 00:33:23,460
será un objeto

703
00:33:23,460 --> 00:33:25,440
de la clase obviedad put string

704
00:33:25,440 --> 00:33:27,559
sin cabecera, el que me he hecho yo

705
00:33:27,559 --> 00:33:28,700
este

706
00:33:28,700 --> 00:33:32,450
para añadir

707
00:33:32,450 --> 00:33:36,599
y por supuesto por la herencia

708
00:33:36,599 --> 00:33:38,599
ya sabemos, yo puedo guardar

709
00:33:38,599 --> 00:33:40,559
un objeto de este tipo en esta referencia

710
00:33:40,559 --> 00:33:42,400
porque he hecho que esta era la de este otro

711
00:33:42,400 --> 00:33:44,519
entonces este

712
00:33:44,519 --> 00:33:46,720
objeto cae en esta referencia sin problema

713
00:33:46,720 --> 00:33:48,559
vale, esto si el fichero

714
00:33:48,559 --> 00:33:49,000
existe

715
00:33:49,000 --> 00:33:52,759
pero si el fichero no existe

716
00:33:52,759 --> 00:33:54,160
entonces

717
00:33:54,160 --> 00:33:56,359
mi referencia esta

718
00:33:56,359 --> 00:33:58,720
se llenará con un objeto del original

719
00:33:58,720 --> 00:34:00,500
porque en ese caso hay que hacer la cabecera

720
00:34:00,500 --> 00:34:01,539
porque no existe, etc

721
00:34:01,539 --> 00:34:04,440
pues en este caso

722
00:34:04,440 --> 00:34:06,500
este será un new

723
00:34:06,500 --> 00:34:08,699
todo esto, pero del

724
00:34:08,699 --> 00:34:10,440
control c

725
00:34:10,440 --> 00:34:14,880
será todo esto

726
00:34:14,880 --> 00:34:17,440
pero este será

727
00:34:17,440 --> 00:34:18,500
sin cabecera

728
00:34:18,500 --> 00:34:20,239
será el original

729
00:34:20,239 --> 00:34:23,860
y de aquí quito el true, porque no voy a añadirlo, estoy haciendo de nuevas

730
00:34:23,860 --> 00:34:29,239
y ya está, apañado

731
00:34:29,239 --> 00:34:32,599
¿vale?

732
00:34:35,179 --> 00:34:37,019
esta llave la voy a quitar

733
00:34:37,019 --> 00:34:38,059
también si quiero

734
00:34:38,059 --> 00:34:43,329
ala, pues ya está, ya está arreglado ese problema

735
00:34:43,329 --> 00:34:46,920
que el fichero existe

736
00:34:46,920 --> 00:34:49,139
lo abrimos

737
00:34:49,139 --> 00:34:50,960
de tal manera que no meta cabecera

738
00:34:50,960 --> 00:34:53,079
y se ponga a escribir los objetos

739
00:34:53,079 --> 00:34:55,260
y más, que el fichero no existe

740
00:34:55,260 --> 00:34:57,460
lo abrimos de tal manera que meta cabecera

741
00:34:57,460 --> 00:34:58,420
y ya está

742
00:34:58,420 --> 00:35:00,820
escribimos el objeto y cerramos

743
00:35:00,820 --> 00:35:06,090
vale, pues ahora ya voy a

744
00:35:06,090 --> 00:35:08,369
borrar el fichero de antes, porque ese ya se ha quedado

745
00:35:08,369 --> 00:35:09,690
ese ya estaba roto

746
00:35:09,690 --> 00:35:12,210
pues lo vamos a borrar

747
00:35:12,210 --> 00:35:18,179
y ahora vamos a volver

748
00:35:18,179 --> 00:35:19,880
a ejecutar el programa

749
00:35:19,880 --> 00:35:25,329
este de aquí

750
00:35:25,329 --> 00:35:30,250
objetos main

751
00:35:30,250 --> 00:35:32,849
este main era

752
00:35:32,849 --> 00:35:35,030
con el bucle

753
00:35:35,030 --> 00:35:41,190
venga, no hay fichero

754
00:35:41,190 --> 00:35:43,329
vamos a meter 1, 1, 2, 3, 4

755
00:35:43,329 --> 00:35:45,309
nombre Pepito

756
00:35:45,309 --> 00:35:47,650
vale, vamos a meter otro más

757
00:35:47,650 --> 00:35:49,090
entonces

758
00:35:49,090 --> 00:35:50,670
aquí llegaría el problema

759
00:35:50,670 --> 00:35:53,130
si no hubiéramos hecho el arreglo que hemos hecho

760
00:35:53,130 --> 00:35:54,210
porque al meter el otro

761
00:35:54,210 --> 00:35:56,170
sin el cambio que hemos hecho

762
00:35:56,170 --> 00:35:59,269
en el otro ya se habría metido también una cabecera

763
00:35:59,269 --> 00:36:01,630
pero con el arreglo que hemos hecho ya no va a haber problema

764
00:36:01,630 --> 00:36:03,349
vamos a meter otro

765
00:36:03,349 --> 00:36:04,650
5, 6, 7, 8

766
00:36:04,650 --> 00:36:09,559
Venga, y vamos a meter un tercero

767
00:36:09,559 --> 00:36:11,599
9, 9, 9, 9

768
00:36:11,599 --> 00:36:14,340
¿Queremos más alumnos? No

769
00:36:14,340 --> 00:36:17,300
Se supone que hay tres alumnos metidos

770
00:36:17,300 --> 00:36:21,219
Vamos de hecho a verlo

771
00:36:21,219 --> 00:36:25,179
Aunque no sé si me va a dejar refrescar

772
00:36:25,179 --> 00:36:28,059
Alumnos

773
00:36:28,059 --> 00:36:33,139
Tiene ahí Pepito

774
00:36:33,139 --> 00:36:37,059
El Juan y el Luis este

775
00:36:37,059 --> 00:36:39,360
los tiene ahí, ya está cerrado

776
00:36:39,360 --> 00:36:39,820
y ya está

777
00:36:39,820 --> 00:36:42,860
vamos a ver si ha metido las cabeceras entre medias o no

778
00:36:42,860 --> 00:36:44,679
como haya metido las cabeceras entre medias

779
00:36:44,679 --> 00:36:45,860
cada vez que escribe un objeto

780
00:36:45,860 --> 00:36:48,019
no va a funcionar el main

781
00:36:48,019 --> 00:36:51,219
vamos a, venga, vamos a buscar

782
00:36:51,219 --> 00:36:52,579
al último

783
00:36:52,579 --> 00:36:55,989
pues sí que está

784
00:36:55,989 --> 00:36:57,969
vamos a buscar ahora al

785
00:36:57,969 --> 00:37:00,769
ah no, que ya acaba el main, no está en un bucle

786
00:37:00,769 --> 00:37:01,750
o no puedo buscar más

787
00:37:01,750 --> 00:37:04,889
vale, pues ya está, ya tenemos todo arreglado

788
00:37:04,889 --> 00:37:06,150
y todo lo que necesitamos

789
00:37:06,150 --> 00:37:08,369
no necesitamos

790
00:37:08,369 --> 00:37:09,769
en realidad ni más métodos

791
00:37:09,769 --> 00:37:11,630
de estas clases, ni conocer más nada

792
00:37:11,630 --> 00:37:13,929
para trabajar con objetos

793
00:37:13,929 --> 00:37:15,769
directamente en un fichero

794
00:37:15,769 --> 00:37:17,750
aquí yo no los tengo en lista

795
00:37:17,750 --> 00:37:19,090
no los tengo en nada, este main

796
00:37:19,090 --> 00:37:23,489
inserta alumnos

797
00:37:23,489 --> 00:37:25,969
los recupera, podría hacer mil cosas

798
00:37:25,969 --> 00:37:28,130
modifica nombre, podría hacer mil historias

799
00:37:28,130 --> 00:37:30,150
y los alumnos no están en el fichero

800
00:37:30,150 --> 00:37:31,829
perdón, no están en una lista

801
00:37:31,829 --> 00:37:32,449
están ahí

802
00:37:32,449 --> 00:37:43,400
¿a qué parte?

803
00:37:57,619 --> 00:38:25,539
Pues venga, vamos a hacer esta

804
00:38:25,539 --> 00:38:31,820
Vale, esta funcionalidad

805
00:38:31,820 --> 00:38:33,219
Aquí

806
00:38:33,219 --> 00:38:35,539
Esto se complica un poco más

807
00:38:35,539 --> 00:38:36,519
Porque tenemos que

808
00:38:36,519 --> 00:38:38,480
Leer y escribir

809
00:38:38,480 --> 00:38:41,340
En principio uno pensaría que simultáneamente

810
00:38:41,340 --> 00:38:43,539
Porque primero, del archivo hay que leer

811
00:38:43,539 --> 00:38:45,559
Sí o sí, porque hay que ir leyendo

812
00:38:45,559 --> 00:38:47,780
Hasta llegar al alumno cuyo NIF sea ese

813
00:38:47,780 --> 00:38:50,400
y una vez que hemos llegado

814
00:38:50,400 --> 00:38:52,039
con el archivo abierto para lectura

815
00:38:52,039 --> 00:38:54,380
y leyendo, resulta que hay que escribir

816
00:38:54,380 --> 00:38:56,340
ese objeto otra vez, hay que escribirlo

817
00:38:56,340 --> 00:38:56,739
de nuevas

818
00:38:56,739 --> 00:39:00,280
porque hay que escribir el objeto con el nombre cambiado

819
00:39:00,280 --> 00:39:01,840
entonces, hemos dicho que

820
00:39:01,840 --> 00:39:04,420
o leemos o escribimos, pero las dos cosas no

821
00:39:04,420 --> 00:39:06,619
entonces, ¿qué tendríamos que hacer?

822
00:39:06,699 --> 00:39:07,820
podemos hacerlo de muchas maneras

823
00:39:07,820 --> 00:39:09,340
vamos a hacer la forma más cómoda

824
00:39:09,340 --> 00:39:11,480
me los leo todos, los llevo a una lista

825
00:39:11,480 --> 00:39:13,500
ahí lo cambio y otra vez la lista para allá

826
00:39:13,500 --> 00:39:16,159
pero claro, efectivamente es menos eficiente

827
00:39:16,159 --> 00:39:17,340
si tengo 50.000

828
00:39:17,340 --> 00:39:19,460
o 50.000 y todo es para allá, pues no

829
00:39:19,460 --> 00:39:21,699
otra manera es trabajar directamente

830
00:39:21,699 --> 00:39:23,500
con archivos a través de un archivo

831
00:39:23,500 --> 00:39:25,579
intermedio, que es

832
00:39:25,579 --> 00:39:27,480
leo de

833
00:39:27,480 --> 00:39:29,639
tengo mi archivo de lectura

834
00:39:29,639 --> 00:39:31,280
y mi archivo final

835
00:39:31,280 --> 00:39:33,199
entonces, leo

836
00:39:33,199 --> 00:39:35,699
es el que tengo que modificar, lo escribo tal cual

837
00:39:35,699 --> 00:39:37,840
leo, es el que tengo que modificar

838
00:39:37,840 --> 00:39:38,699
lo escribo tal cual

839
00:39:38,699 --> 00:39:41,820
leo, es el que tengo que modificar, sí, este sí es

840
00:39:41,820 --> 00:39:43,780
pues lo escribo con la modificación

841
00:39:43,780 --> 00:39:45,800
y entonces ya en el

842
00:39:45,800 --> 00:39:47,179
fichero destino

843
00:39:47,179 --> 00:39:50,139
estará el resultado final

844
00:39:50,139 --> 00:39:50,940
¿vale?

845
00:39:51,260 --> 00:39:53,480
lo que pasa es que ese fichero de estilo tendrá otro nombre

846
00:39:53,480 --> 00:39:55,639
no es la idea, pues lo que nos faltará será

847
00:39:55,639 --> 00:39:57,820
eliminar este y a este cambiarle de nombre

848
00:39:57,820 --> 00:39:58,539
y se acabó

849
00:39:58,539 --> 00:40:01,519
y entonces el efecto final es como si hubiéramos

850
00:40:01,519 --> 00:40:03,760
leído y escrito a la vez, pero no, hemos leído de uno

851
00:40:03,760 --> 00:40:05,679
escrito en otro con las

852
00:40:05,679 --> 00:40:07,679
modificaciones y luego hemos eliminado el original

853
00:40:07,679 --> 00:40:08,780
y cambiado el nombre a este

854
00:40:08,780 --> 00:40:11,699
entonces, esto sería

855
00:40:11,699 --> 00:40:13,980
tendríamos que

856
00:40:13,980 --> 00:40:14,980
abrir para leer

857
00:40:14,980 --> 00:40:19,670
el archivo este

858
00:40:19,670 --> 00:40:23,079
Abriríamos para leer

859
00:40:23,079 --> 00:40:24,780
El fichero alumnos

860
00:40:24,780 --> 00:40:27,280
Y esto me lanzaría

861
00:40:27,280 --> 00:40:28,760
Una excepción, pues Alan

862
00:40:28,760 --> 00:40:35,260
¿Te molesta la operación?

863
00:40:36,179 --> 00:40:36,460
Sí

864
00:40:36,460 --> 00:40:41,230
Vale

865
00:40:41,230 --> 00:40:47,110
Y ahora vamos a hacernos uno temporal para escribir

866
00:40:47,110 --> 00:40:50,400
Este lo vamos a escribir

867
00:40:50,400 --> 00:40:52,260
Desde arriba, enterito

868
00:40:52,260 --> 00:40:54,219
Uno temporal

869
00:40:54,219 --> 00:40:55,260
Para escribir

870
00:40:55,260 --> 00:41:01,059
Pues nada

871
00:41:01,059 --> 00:41:18,929
y aquí le damos cualquier nombre, nos da igual

872
00:41:18,929 --> 00:41:19,989
si luego se lo vamos a cambiar

873
00:41:19,989 --> 00:41:24,190
es el fichero temporal

874
00:41:24,190 --> 00:41:27,010
que va a tener el resultado final

875
00:41:27,010 --> 00:41:28,510
y ahora ya

876
00:41:28,510 --> 00:41:30,210
leemos de uno y escribimos en el otro

877
00:41:30,210 --> 00:41:33,030
lo habrá que hacer, pues el bucle de lectura

878
00:41:33,030 --> 00:41:34,349
otra vez enterito

879
00:41:34,349 --> 00:41:37,150
pues venga, vamos a ponernos un fin archivo

880
00:41:37,150 --> 00:41:39,889
igual a falso

881
00:41:39,889 --> 00:41:59,230
Y ahora, mientras no hayamos llegado a fin archivo, pues ahora vamos leyendo alumno por alumno.

882
00:42:08,269 --> 00:42:15,489
Ahora, ¿este alumno es el alumno de búsqueda que estamos buscando?

883
00:42:17,289 --> 00:42:18,269
Pues vamos a ver.

884
00:42:21,210 --> 00:42:26,050
¿Este alumno resulta que es igual al que estamos buscando?

885
00:42:26,050 --> 00:42:32,849
si es igual al que estamos buscando

886
00:42:32,849 --> 00:42:34,090
lo escribimos tal cual

887
00:42:34,090 --> 00:42:35,989
a temp

888
00:42:35,989 --> 00:42:38,289
entonces ya lo escribimos tal cual

889
00:42:38,289 --> 00:42:47,760
ah perdón, no lo escribimos tal cual

890
00:42:47,760 --> 00:42:49,860
lo escribimos modificado, o sea, si este es el que hay que

891
00:42:49,860 --> 00:42:51,659
estoy, ahí

892
00:42:51,659 --> 00:42:56,469
si este es el que hay que

893
00:42:56,469 --> 00:42:58,210
modificar

894
00:42:58,210 --> 00:43:00,210
pues entonces

895
00:43:00,210 --> 00:43:02,250
a este objeto a

896
00:43:02,250 --> 00:43:03,690
le vamos a poner el nuevo nombre

897
00:43:03,690 --> 00:43:06,369
el nuevo nombre, que es este nuevo nombre

898
00:43:06,369 --> 00:43:08,969
y ahora ya lo escribimos

899
00:43:08,969 --> 00:43:10,829
ya está

900
00:43:10,829 --> 00:43:12,650
entonces

901
00:43:12,650 --> 00:43:15,230
le escribe

902
00:43:15,230 --> 00:43:17,070
le escribe, le escribe

903
00:43:17,070 --> 00:43:18,949
de uno se copia en otro

904
00:43:18,949 --> 00:43:21,150
de uno se copia en otro, le escribe, le escribe

905
00:43:21,150 --> 00:43:22,789
pero solo hay una salvedad

906
00:43:22,789 --> 00:43:25,510
si el que ha leído es el que hay que modificar

907
00:43:25,510 --> 00:43:27,150
antes de escribirlo

908
00:43:27,150 --> 00:43:28,829
de nuevas, antes de escribirlos

909
00:43:28,829 --> 00:43:30,789
le cambia el nombre y ya está

910
00:43:30,789 --> 00:43:35,579
y ahora podríamos aprovechar

911
00:43:35,579 --> 00:43:37,780
ya aquí dentro de este

912
00:43:37,780 --> 00:43:39,360
if, poner esto a true

913
00:43:39,360 --> 00:43:41,760
Para que no esté comprobando ya

914
00:43:41,760 --> 00:43:43,980
Ah no, es que los demás los tiene que escribir también

915
00:43:43,980 --> 00:43:45,500
Esto lo necesitamos

916
00:43:45,500 --> 00:43:46,679
Perdón

917
00:43:46,679 --> 00:43:53,880
Uno cualquiera

918
00:43:53,880 --> 00:43:55,519
Porque es uno temporal

919
00:43:55,519 --> 00:44:00,539
Vale, entonces

920
00:44:00,539 --> 00:44:02,880
Le escribe, le escribe, le escribe

921
00:44:02,880 --> 00:44:03,900
Y simplemente

922
00:44:03,900 --> 00:44:07,500
Si el que ha leído es el del NIF correspondiente

923
00:44:07,500 --> 00:44:08,940
Le cambia el nombre antes de escribir

924
00:44:08,940 --> 00:44:10,199
Y ya está

925
00:44:10,199 --> 00:44:12,960
Y todo esto habrá que meterlo en un try-catch, claro

926
00:44:12,960 --> 00:44:16,099
habrá que meterlo en un try-catch

927
00:44:16,099 --> 00:44:20,099
para que si ha llegado a la excepción

928
00:44:20,099 --> 00:44:26,440
pues entonces

929
00:44:26,440 --> 00:44:28,159
si hemos llegado a la excepción

930
00:44:28,159 --> 00:44:32,730
eof

931
00:44:32,730 --> 00:44:40,210
excepción

932
00:44:40,210 --> 00:44:42,949
pues si hemos llegado a la excepción

933
00:44:42,949 --> 00:44:44,130
pues entonces

934
00:44:44,130 --> 00:44:48,280
fin archivo igual a

935
00:44:48,280 --> 00:44:48,980
true

936
00:44:48,980 --> 00:44:53,260
bueno pues este código

937
00:44:53,260 --> 00:44:55,840
hará la modificación pero la dejará en temp

938
00:44:55,840 --> 00:44:57,579
el otro lo deja tal cual

939
00:44:57,579 --> 00:44:59,960
vale, pues entonces

940
00:44:59,960 --> 00:45:01,940
ahora nos tocará borrar uno y cambiar de nombre

941
00:45:01,940 --> 00:45:04,139
el otro, pero para eso tenemos los métodos de file

942
00:45:04,139 --> 00:45:06,000
entonces antes que nada vamos a cerrar

943
00:45:06,000 --> 00:45:07,039
los flujos de estos

944
00:45:07,039 --> 00:45:09,880
el oiz y el temp, estos los vamos a cerrar

945
00:45:09,880 --> 00:45:22,420
y ahora vamos a crearnos un objeto

946
00:45:22,420 --> 00:45:24,039
file asociado a cada uno de ellos

947
00:45:24,039 --> 00:45:26,239
un objeto

948
00:45:26,239 --> 00:45:27,260
el original

949
00:45:27,260 --> 00:45:33,920
este va a ser un new file

950
00:45:33,920 --> 00:45:35,980
de el nombre archivo

951
00:45:35,980 --> 00:45:36,860
archivo alumnos

952
00:45:36,860 --> 00:45:44,710
archivo alumnos, no se llamaba archivo alumnos

953
00:45:44,710 --> 00:45:46,570
yo creo que lo he llamado aquí fichero alumnos

954
00:45:46,570 --> 00:45:46,869
¿verdad?

955
00:45:47,650 --> 00:45:49,489
sí, fichero alumnos

956
00:45:49,489 --> 00:45:55,190
fichero alumnos

957
00:45:55,190 --> 00:46:01,440
y ahora, el destino

958
00:46:01,440 --> 00:46:03,579
el temporal

959
00:46:03,579 --> 00:46:07,349
es este

960
00:46:07,349 --> 00:46:09,150
asociado al nombre temp

961
00:46:09,150 --> 00:46:15,440
¿y ahora qué queremos?

962
00:46:15,960 --> 00:46:17,659
vamos a borrar el primero de todos

963
00:46:17,659 --> 00:46:19,599
para eso tenemos

964
00:46:19,599 --> 00:46:22,800
original.delete

965
00:46:22,800 --> 00:46:25,780
ala, el original ya está borrado

966
00:46:25,780 --> 00:46:27,599
y ahora

967
00:46:27,599 --> 00:46:29,440
a este temporal le queremos

968
00:46:29,440 --> 00:46:30,320
cambiar el nombre

969
00:46:30,320 --> 00:46:34,960
temporal.entonces hay un

970
00:46:34,960 --> 00:46:35,599
rename to

971
00:46:35,599 --> 00:46:37,639
donde te dice

972
00:46:37,639 --> 00:46:41,000
dime un objeto file asociado al

973
00:46:41,000 --> 00:46:41,920
nombre que tú quieres

974
00:46:41,920 --> 00:46:44,300
bueno, pues ya este directamente

975
00:46:44,300 --> 00:46:48,309
vale, hemos borrado el original

976
00:46:48,309 --> 00:46:50,369
y al temporal le hemos cambiado

977
00:46:50,369 --> 00:46:52,389
para que tenga como nombre el que está asociado

978
00:46:52,389 --> 00:46:54,170
a este, que es el fichero alumnos

979
00:46:54,170 --> 00:46:59,119
Y esto es lo que funciona o no, a veces depende del sistema operativo.

980
00:46:59,719 --> 00:47:02,980
No he acabado yo nunca de ver muy claro cuándo funciona y cuándo no.

981
00:47:03,559 --> 00:47:04,360
Pero vamos a probarlo.

982
00:47:05,119 --> 00:47:09,420
Venga, vamos a, si no lo veremos en temp, la modificación.

983
00:47:10,460 --> 00:47:15,280
En nuestro main vamos a comentar, nuestro main ya tenía alumnos,

984
00:47:15,320 --> 00:47:16,960
que los hemos buscado, que funcionaban.

985
00:47:18,000 --> 00:47:24,360
Entonces vamos a comentar todo lo que tenía para no seguir perdiendo tiempo con esto.

986
00:47:24,360 --> 00:47:28,059
Y ahora vamos simplemente a

987
00:47:28,059 --> 00:47:29,840
Tratar de modificar el nombre de un alumno

988
00:47:29,840 --> 00:47:30,980
A ver si lo hace

989
00:47:30,980 --> 00:47:33,239
Entonces

990
00:47:33,239 --> 00:47:35,260
Este se llamaba

991
00:47:35,260 --> 00:47:37,199
ModificaNombre

992
00:47:37,199 --> 00:47:41,699
ModificaNombre

993
00:47:41,699 --> 00:47:44,639
Y recibía el nif a modificar

994
00:47:44,639 --> 00:47:46,179
Este que existía

995
00:47:46,179 --> 00:47:47,159
Es el primero que metimos

996
00:47:47,159 --> 00:47:49,960
El nuevo nombre, vale

997
00:47:49,960 --> 00:47:54,079
Y ahora el fichero

998
00:47:54,079 --> 00:47:55,440
Donde están esos alumnos

999
00:47:55,440 --> 00:47:57,159
Que se llama así

1000
00:47:57,159 --> 00:47:59,900
vale, entonces el fichero

1001
00:47:59,900 --> 00:48:00,699
alumnos

1002
00:48:00,699 --> 00:48:03,840
tenía nuestros objetos

1003
00:48:03,840 --> 00:48:06,380
pues todos estos, tenía uno, un dos, tres, cuatro

1004
00:48:06,380 --> 00:48:08,179
luego tenía

1005
00:48:08,179 --> 00:48:09,739
el cinco, seis, siete, ocho

1006
00:48:09,739 --> 00:48:12,000
luego tenía el nueve, nueve, nueve, nueve

1007
00:48:12,000 --> 00:48:16,780
y ya está, vale, pues venga

1008
00:48:16,780 --> 00:48:17,780
modifica nombre

1009
00:48:17,780 --> 00:48:28,230
vale, pues vamos a ver que ha hecho

1010
00:48:28,230 --> 00:48:30,130
le damos aquí a refresh

1011
00:48:30,130 --> 00:48:39,409
y temp ha desaparecido

1012
00:48:39,409 --> 00:48:41,409
con lo cual tiene pinta de que ha funcionado

1013
00:48:41,409 --> 00:48:43,210
a ver, tendríamos que leer

1014
00:48:43,210 --> 00:48:45,329
ahora, pero lo vamos a ver

1015
00:48:45,329 --> 00:48:46,590
así a ojo directamente

1016
00:48:46,590 --> 00:48:49,349
vamos a ver aquí el 1, 2, 3, 4 que le ha pasado

1017
00:48:49,349 --> 00:48:51,449
pues sí, efectivamente

1018
00:48:51,449 --> 00:48:52,130
lo ha cambiado

1019
00:48:52,130 --> 00:48:55,150
si ejecutáramos ahora este main

1020
00:48:55,150 --> 00:48:57,170
vamos a poner de este main

1021
00:48:57,170 --> 00:48:59,230
vamos a buscar ese nif, a ver si ahora me lo

1022
00:48:59,230 --> 00:49:00,590
muestra con el nombre de

1023
00:49:00,590 --> 00:49:03,670
Raquel, para verlo bien, no verlo con el

1024
00:49:03,670 --> 00:49:05,610
editor de texto

1025
00:49:05,610 --> 00:49:06,550
que es un poco chapuza

1026
00:49:06,550 --> 00:49:09,110
vale, voy a hacer de nuevo el main

1027
00:49:09,110 --> 00:49:10,849
pero solamente con

1028
00:49:10,849 --> 00:49:12,349
voy a buscar el 1, 2, 3, 4

1029
00:49:12,349 --> 00:49:13,610
a ver si

1030
00:49:13,610 --> 00:49:17,889
venga, 1, 2, 3, 4

1031
00:49:17,889 --> 00:49:20,449
que lo había modificado antes, efectivamente lo ha modificado

1032
00:49:20,449 --> 00:49:21,130
vale

1033
00:49:21,130 --> 00:49:26,750
pues entonces podemos insertar

1034
00:49:26,750 --> 00:49:29,530
si quisiéramos eliminar un alumno del archivo

1035
00:49:29,530 --> 00:49:30,530
lo mismo

1036
00:49:30,530 --> 00:49:32,510
tendría que ser un temporal

1037
00:49:32,510 --> 00:49:34,510
leemos, copiamos, leemos, copiamos

1038
00:49:34,510 --> 00:49:36,289
pero nos saltamos en la copia

1039
00:49:36,289 --> 00:49:37,690
nos saltamos en la copia

1040
00:49:37,690 --> 00:49:40,809
el del nif a eliminar, nos lo saltamos

1041
00:49:40,809 --> 00:49:42,889
entonces ya podemos hacer cualquier cosa

1042
00:49:42,889 --> 00:49:44,150
insertar el archivo

1043
00:49:44,150 --> 00:49:46,250
eliminar con un temporal

1044
00:49:46,250 --> 00:49:47,550
como hemos hecho de modificar

1045
00:49:47,550 --> 00:49:49,250
modificar como lo acabamos de hacer

1046
00:49:49,250 --> 00:49:51,449
y recuperar como lo acabamos de hacer

1047
00:49:51,449 --> 00:49:53,070
las cuatro opciones básicas

1048
00:49:53,070 --> 00:49:56,190
consultas, lecturas, modificaciones y borrados

1049
00:49:56,190 --> 00:49:58,429
pues las podemos hacer sobre el archivo de objetos

1050
00:49:58,429 --> 00:50:00,309
y no necesitamos

1051
00:50:00,309 --> 00:50:01,809
ni lista, ni colección, ni nada

1052
00:50:01,809 --> 00:50:04,269
todo el archivo más eficiente

1053
00:50:04,269 --> 00:50:06,789
y más, o sea, menos memoria gastada

1054
00:50:06,789 --> 00:50:07,849
¿vale?

1055
00:50:07,889 --> 00:50:10,110
podéis hacer vosotros este método

1056
00:50:10,110 --> 00:50:12,429
de eliminar un alumno

1057
00:50:12,429 --> 00:50:13,989
y ya tendríamos todas las funcionalidades

1058
00:50:13,989 --> 00:50:16,050
modificar, eliminar, insertar y recuperar

1059
00:50:16,050 --> 00:50:20,369
Podríais hacer aquí la funcionalidad

1060
00:50:20,369 --> 00:50:24,230
Elimina alumno

1061
00:50:24,230 --> 00:50:26,190
Dado nif

1062
00:50:26,190 --> 00:50:30,849
Y dado el fichero de alumnos

1063
00:50:30,849 --> 00:50:44,570
Pero vamos, este método sería idéntico al de modificar

1064
00:50:44,570 --> 00:50:47,570
Con la única diferencia es que aquí

1065
00:50:47,570 --> 00:50:49,989
Lo que hay que hacer es

1066
00:50:49,989 --> 00:50:52,630
Escribir si no coincide

1067
00:50:52,630 --> 00:50:53,829
Y si coincide no hacer nada

1068
00:50:53,829 --> 00:50:55,210
No escribirlo

1069
00:50:55,210 --> 00:50:58,730
¿Vale? O sea, sería un método idéntico al de arriba.

1070
00:50:59,869 --> 00:51:04,070
O sea, idéntico, salvo esto cambiaría simplemente, pero vamos, con una...

1071
00:51:04,070 --> 00:51:06,070
Vale, pues hacedlo y ya tendréis las cuatro funcionalidades.

1072
00:51:07,750 --> 00:51:12,949
Y ya entonces podemos trabajar con objetos ya no solo en colecciones, sino también en archivos.

1073
00:51:14,170 --> 00:51:16,289
¿Vale? Si no queremos mantenerlos todos ahí a mogollón.

1074
00:51:17,969 --> 00:51:18,849
Venga, pues ya está.