1
00:00:03,379 --> 00:00:04,419
Vale, que se me había olvidado.

2
00:00:06,000 --> 00:00:08,679
Pues vamos a implementar entonces este método

3
00:00:08,679 --> 00:00:14,359
que está asociado a un file output string,

4
00:00:20,280 --> 00:00:22,980
file, que se llamaba esto,

5
00:00:24,260 --> 00:00:25,359
fichero alumnos.

6
00:00:36,920 --> 00:00:57,740
Entonces, aquí, vale,

7
00:00:57,880 --> 00:01:01,299
aquí tendríamos que distinguir si el fichero existe o no.

8
00:01:02,200 --> 00:01:04,159
En este caso, si el fichero no existe,

9
00:01:04,840 --> 00:01:07,260
recordad que este flujo de salida lo crea,

10
00:01:07,480 --> 00:01:09,439
lo crea y lo crea vacío.

11
00:01:09,859 --> 00:01:11,480
¿Vale? Entonces aquí en principio

12
00:01:11,480 --> 00:01:13,680
si es el primer alumno que introducimos

13
00:01:13,680 --> 00:01:15,420
pues lo va a crear el fichero

14
00:01:15,420 --> 00:01:16,680
con lo cual no tengo que preocuparme

15
00:01:16,680 --> 00:01:19,120
y si no es el primer alumno

16
00:01:19,120 --> 00:01:21,200
la idea es abrirlo

17
00:01:21,200 --> 00:01:22,640
pero abrirlo para añadir.

18
00:01:23,480 --> 00:01:25,680
Entonces, FileOutputString

19
00:01:25,680 --> 00:01:27,219
por defecto, si no poníamos

20
00:01:27,219 --> 00:01:29,459
un segundo parámetro, recordad

21
00:01:29,459 --> 00:01:31,579
que el parámetro de añadir

22
00:01:31,579 --> 00:01:32,480
lo ponía a falso.

23
00:01:33,420 --> 00:01:35,680
Entonces, si en el caso de que exista

24
00:01:35,680 --> 00:01:37,659
yo quiero abrir para añadir

25
00:01:37,659 --> 00:01:39,019
lo tengo que poner específicamente.

26
00:01:39,859 --> 00:01:41,900
vale, porque si no por defecto es

27
00:01:41,900 --> 00:01:43,920
falso, que es, si ya existe

28
00:01:43,920 --> 00:01:45,180
lo limpio y lo creo de nuevo

29
00:01:45,180 --> 00:01:46,980
que no es lo que quiero que ocurra

30
00:01:46,980 --> 00:01:52,780
claro, si, si, pero no vamos a hacer eso

31
00:01:52,780 --> 00:01:57,579
entonces, ahora ya

32
00:01:57,579 --> 00:02:00,340
ya tenemos

33
00:02:00,340 --> 00:02:01,299
el fichero abierto

34
00:02:01,299 --> 00:02:04,180
y este es el método

35
00:02:04,180 --> 00:02:04,739
más fácil

36
00:02:04,739 --> 00:02:08,379
vamos a escribir este objeto

37
00:02:08,379 --> 00:02:11,120
en

38
00:02:11,120 --> 00:02:12,340
el fichero

39
00:02:12,340 --> 00:02:23,780
vale, entonces

40
00:02:23,780 --> 00:02:25,159
Sería este método

41
00:02:25,159 --> 00:02:28,300
Ahora vamos a probar

42
00:02:28,300 --> 00:02:29,780
La aplicación

43
00:02:29,780 --> 00:02:31,520
Para empezar a depurar errores

44
00:02:31,520 --> 00:02:33,879
Que nos van a salir, o eso espero

45
00:02:33,879 --> 00:02:35,699
Vale, vamos a hacer este rápido

46
00:02:35,699 --> 00:02:38,379
Y así ya, bueno, tenemos estos tres

47
00:02:38,379 --> 00:02:39,719
Se podrían, lógicamente

48
00:02:39,719 --> 00:02:42,419
No hemos puesto muchos más métodos

49
00:02:42,419 --> 00:02:44,219
Que irían aquí, pues, de eliminar

50
00:02:44,219 --> 00:02:45,879
De mil cosas, pero bueno, eso

51
00:02:45,879 --> 00:02:47,840
Sería hacer lo mismo una y otra vez

52
00:02:47,840 --> 00:02:50,199
El de eliminar

53
00:02:50,199 --> 00:02:51,900
Como podéis intuir, pues se llamaría

54
00:02:51,900 --> 00:02:52,400
delete

55
00:02:52,400 --> 00:02:55,139
o delete by nif

56
00:02:55,139 --> 00:02:57,360
uno lo llama como le dé la gana, pero siempre

57
00:02:57,360 --> 00:02:58,860
repito, intentamos

58
00:02:58,860 --> 00:03:01,599
hacer aplicaciones que sigan unos criterios

59
00:03:01,599 --> 00:03:02,039
un poquito

60
00:03:02,039 --> 00:03:05,439
universales

61
00:03:05,439 --> 00:03:07,580
vale, recuperar nota módulo

62
00:03:07,580 --> 00:03:09,560
pues tendríamos que leer

63
00:03:09,560 --> 00:03:10,259
al del

64
00:03:10,259 --> 00:03:13,879
leer al del nif

65
00:03:13,879 --> 00:03:15,580
y cuando lo tengamos devolver su módulo

66
00:03:15,580 --> 00:03:17,580
o sea, sería el mismo método

67
00:03:17,580 --> 00:03:19,560
que este, pero en lugar de devolver

68
00:03:19,560 --> 00:03:21,000
el objeto entero

69
00:03:21,000 --> 00:03:23,719
Devolver la nota del módulo correspondiente

70
00:03:23,719 --> 00:03:25,740
Entonces, sería este mismo método

71
00:03:25,740 --> 00:03:28,340
Pero en lugar de devolver el objeto

72
00:03:28,340 --> 00:03:32,240
Uy, que este mismo método de aquí

73
00:03:32,240 --> 00:03:34,620
Result

74
00:03:34,620 --> 00:03:35,460
Yo aquí he puesto

75
00:03:35,460 --> 00:03:37,099
Result

76
00:03:37,099 --> 00:03:38,080
Return

77
00:03:38,080 --> 00:03:39,500
Null

78
00:03:39,500 --> 00:03:41,580
Y sería return result, lógicamente

79
00:03:41,580 --> 00:03:45,159
Vale, pues entonces sería este mismo método de aquí

80
00:03:45,159 --> 00:03:50,819
Y ahora modificamos lo que toque

81
00:03:50,819 --> 00:03:53,620
Get nota módulo

82
00:03:53,620 --> 00:04:07,259
Pues venga, si el fichero no existe o tiene tamaño cero, no hay ningún alumno ahí, pues entonces ahí ya sí que devolvemos null, ¿vale?

83
00:04:08,639 --> 00:04:15,400
Entonces, bien pensado el devolver el envolvente, no el primitivo, ¿vale?

84
00:04:15,580 --> 00:04:23,920
Normalmente por eso trabajamos con envolventes, no con primitivos, porque el envolvente admite la opción de ponerle null, ponerle nada, el primitivo no.

85
00:04:23,920 --> 00:04:26,100
entonces si yo devuelvo el primitivo

86
00:04:26,100 --> 00:04:28,079
tendría que devolver aquí un numerito siempre

87
00:04:28,079 --> 00:04:29,420
que se podría confundir con la nota

88
00:04:29,420 --> 00:04:31,639
aunque yo podría hacer un java2 que fuera

89
00:04:31,639 --> 00:04:33,279
si devuelven menos 7

90
00:04:33,279 --> 00:04:35,079
es porque no hay nota

91
00:04:35,079 --> 00:04:38,199
pero ya eso es una cosa muy poco intuitiva

92
00:04:38,199 --> 00:04:39,980
entonces le obligo al tío a mirar

93
00:04:39,980 --> 00:04:41,920
el java2 a ver qué significa el menos 7

94
00:04:41,920 --> 00:04:43,000
el null

95
00:04:43,000 --> 00:04:45,879
es una cosa absolutamente intuitiva

96
00:04:45,879 --> 00:04:47,620
cuando uno ve que su método devuelve null

97
00:04:47,620 --> 00:04:50,220
es porque no ha podido obtener el dato

98
00:04:50,220 --> 00:04:51,939
no porque el dato sea null

99
00:04:51,939 --> 00:04:53,399
¿vale?

100
00:04:53,399 --> 00:04:57,560
aún así el null es un poco feo

101
00:04:57,560 --> 00:04:59,279
porque un método que devuelve null

102
00:04:59,279 --> 00:05:01,740
es un riesgo de null pointer exception

103
00:05:01,740 --> 00:05:05,079
si el de arriba no lo ha gestionado correctamente

104
00:05:05,079 --> 00:05:08,040
entonces aquí lo ideal sería devolver

105
00:05:08,040 --> 00:05:11,139
pero bueno, eso ya surgirá más adelante

106
00:05:11,139 --> 00:05:13,120
en otras cosas para no mezclarlo todo

107
00:05:13,120 --> 00:05:15,819
devolver otro envolvente de este

108
00:05:15,819 --> 00:05:17,399
o sea, ya tenemos dos envolventes

109
00:05:17,399 --> 00:05:19,500
al primitivo le envuelve este

110
00:05:19,500 --> 00:05:22,660
y a este le envolvería una clase opcional

111
00:05:22,660 --> 00:05:24,060
que es una cajita

112
00:05:24,060 --> 00:05:26,620
en la que tú metes el objeto

113
00:05:26,620 --> 00:05:28,060
si ese objeto es null

114
00:05:28,060 --> 00:05:30,639
es una cajita que tiene null pero la cajita no es null

115
00:05:30,639 --> 00:05:32,819
con lo cual tú no devuelves un null

116
00:05:32,819 --> 00:05:34,879
y luego el de arriba al ver que devuelves

117
00:05:34,879 --> 00:05:36,540
un optional pues ya

118
00:05:36,540 --> 00:05:38,540
se ve forzado a acceder

119
00:05:38,540 --> 00:05:40,560
dentro y de alguna manera le haces

120
00:05:40,560 --> 00:05:42,439
consciente de que ahí puede haber un null

121
00:05:42,439 --> 00:05:44,480
cuidado, es mucho más complicado que se genere

122
00:05:44,480 --> 00:05:46,480
un null pointer exception, ya se tiene que emperrar

123
00:05:46,480 --> 00:05:48,579
el de arriba en sacarlo del optional y llamar

124
00:05:48,579 --> 00:05:50,939
al método para que salga un null pointer exception

125
00:05:50,939 --> 00:05:53,300
Pero bueno, lo del optional

126
00:05:53,300 --> 00:05:56,319
Como va a salir en más situaciones

127
00:05:56,319 --> 00:05:58,019
No hace falta que pongamos aquí

128
00:05:58,019 --> 00:06:00,139
Un optional integer por ahora

129
00:06:00,139 --> 00:06:02,300
Vale, vamos a devolver la nota

130
00:06:02,300 --> 00:06:04,139
Estábamos buscando al

131
00:06:04,139 --> 00:06:06,399
Al chaval con este

132
00:06:06,399 --> 00:06:07,920
NIF, ya lo habíamos encontrado

133
00:06:07,920 --> 00:06:10,360
Y ahora ya, cuando teníamos al chaval

134
00:06:10,360 --> 00:06:11,139
Con este NIF

135
00:06:11,139 --> 00:06:13,420
Ahora lo que queremos es

136
00:06:13,420 --> 00:06:16,060
La nota del módulo

137
00:06:16,060 --> 00:06:17,040
Entonces

138
00:06:17,040 --> 00:06:23,569
es una colección, vamos a sacarlo

139
00:06:23,569 --> 00:06:27,170
a ver si lo sacamos rápidamente

140
00:06:27,170 --> 00:06:31,430
el alumno A tendrá su lista de módulos

141
00:06:31,430 --> 00:06:37,110
que es getModules, lo vamos a serializar

142
00:06:37,110 --> 00:06:40,990
y de aquí queremos

143
00:06:40,990 --> 00:06:44,689
quedarnos con un solo elemento, ¿verdad?

144
00:06:44,689 --> 00:06:48,470
queremos quedarnos con el elemento de la lista de módulos

145
00:06:48,470 --> 00:06:49,970
Cuyo nombre sea el que me han dado

146
00:06:49,970 --> 00:06:52,310
Eso automáticamente, ¿qué método sería de stream?

147
00:06:55,959 --> 00:06:56,819
Un filter

148
00:06:56,819 --> 00:06:58,360
¿Vale?

149
00:06:59,579 --> 00:07:00,540
Un filter

150
00:07:00,540 --> 00:07:01,319
Entonces

151
00:07:01,319 --> 00:07:03,459
Uy, a ver

152
00:07:03,459 --> 00:07:06,259
Hacemos un filter

153
00:07:06,259 --> 00:07:07,439
Lo paso abajo

154
00:07:07,439 --> 00:07:09,480
¿Qué me ha hecho este?

155
00:07:10,939 --> 00:07:12,199
A ver, yo quiero aquí un

156
00:07:12,199 --> 00:07:14,060
A ver si me deja hacer el enter tranquilamente

157
00:07:14,060 --> 00:07:14,319
Sí

158
00:07:14,319 --> 00:07:16,860
Hacemos un filter

159
00:07:16,860 --> 00:07:20,459
Al filter hay que pasarle una interfaz

160
00:07:20,459 --> 00:07:22,259
O función lambda de tipo predicado

161
00:07:22,259 --> 00:07:24,139
Que es, con cada elemento

162
00:07:24,139 --> 00:07:26,959
Cada elemento del string

163
00:07:26,959 --> 00:07:29,480
¿Cuál va a ser

164
00:07:29,480 --> 00:07:30,660
True para nosotros?

165
00:07:31,019 --> 00:07:32,319
O sea, claro

166
00:07:32,319 --> 00:07:34,600
Nos vamos a quedar con aquel

167
00:07:34,600 --> 00:07:36,319
Cuyo nombre

168
00:07:36,319 --> 00:07:38,439
Sea igual

169
00:07:38,439 --> 00:07:40,779
Al que nos han dado

170
00:07:40,779 --> 00:07:41,920
Que es

171
00:07:41,920 --> 00:07:43,399
Módulo

172
00:07:43,399 --> 00:07:47,860
Nos vamos a quedar con este

173
00:07:47,860 --> 00:07:51,000
Y hombre, siempre hacemos

174
00:07:51,000 --> 00:07:52,879
La aplicación un poquito más

175
00:07:52,879 --> 00:07:55,420
robustilla

176
00:07:55,420 --> 00:07:57,079
si nos acostumbramos

177
00:07:57,079 --> 00:07:59,399
en el equals de cadenas

178
00:07:59,399 --> 00:08:01,060
a poner ignore case, a ver siempre y cuando

179
00:08:01,060 --> 00:08:01,980
mi aplicación

180
00:08:01,980 --> 00:08:05,079
esté diseñada

181
00:08:05,079 --> 00:08:07,019
de esa manera, para que le dé igual mayúsculas

182
00:08:07,019 --> 00:08:09,040
o minúsculas, porque es que

183
00:08:09,040 --> 00:08:11,040
si es equals y el tío me ha metido

184
00:08:11,040 --> 00:08:13,019
el módulo con tilde, no perdón

185
00:08:13,019 --> 00:08:14,399
con tilde no, con tilde no sería

186
00:08:14,399 --> 00:08:17,139
con mayúscula y yo lo tengo guardado

187
00:08:17,139 --> 00:08:19,220
en mi base de datos, todo con minúscula

188
00:08:19,220 --> 00:08:21,000
pues será un rollo de

189
00:08:21,000 --> 00:08:22,939
aplicación, vale, pues entonces ya tenemos

190
00:08:22,939 --> 00:08:23,759
el predicado

191
00:08:23,759 --> 00:08:25,660
este

192
00:08:25,660 --> 00:08:28,500
acaba aquí, vale

193
00:08:28,500 --> 00:08:30,600
y ahora

194
00:08:30,600 --> 00:08:34,960
¿qué queremos hacer con

195
00:08:34,960 --> 00:08:37,279
ese elemento? con ese elemento

196
00:08:37,279 --> 00:08:39,059
queremos solo

197
00:08:39,059 --> 00:08:40,899
la nota, ese

198
00:08:40,899 --> 00:08:42,960
elemento ahora mismo es un módulo

199
00:08:42,960 --> 00:08:44,440
entero con su nombre y nota

200
00:08:44,440 --> 00:08:46,879
pero solo queremos

201
00:08:46,879 --> 00:08:48,740
quedarnos con la nota, luego

202
00:08:48,740 --> 00:08:50,799
ahora ¿qué método tendríamos que

203
00:08:50,799 --> 00:08:51,220
poner

204
00:08:51,220 --> 00:08:53,100
de stream

205
00:08:53,100 --> 00:08:59,039
quiero, vete abajo y un punto

206
00:08:59,039 --> 00:09:00,820
queremos, ahora tenemos

207
00:09:00,820 --> 00:09:02,480
una filita con un único elemento

208
00:09:02,480 --> 00:09:04,620
bueno, en realidad podría ser con muchos si hubiera muchos

209
00:09:04,620 --> 00:09:06,240
módulos que se llamaran igual, pero no es la idea

210
00:09:06,240 --> 00:09:08,659
tenemos una filita con un único elemento

211
00:09:08,659 --> 00:09:10,759
esa filita

212
00:09:10,759 --> 00:09:12,600
tiene su nombre y su

213
00:09:12,600 --> 00:09:14,019
módulo, ese único elemento

214
00:09:14,019 --> 00:09:16,539
queremos quedarnos solo con su nota

215
00:09:16,539 --> 00:09:18,559
porque es lo que hay que devolver

216
00:09:18,559 --> 00:09:20,559
lo que dice el método, pues que

217
00:09:20,559 --> 00:09:22,240
método pondríamos ahí de stream

218
00:09:22,240 --> 00:09:24,000
eh

219
00:09:24,000 --> 00:09:30,250
pondríamos map

220
00:09:30,250 --> 00:09:32,250
muy bien, voy a poner la nota

221
00:09:32,250 --> 00:09:34,450
directamente y así no te examinas, es un coñazo corregir

222
00:09:34,450 --> 00:09:35,590
vale

223
00:09:35,590 --> 00:09:38,210
map, que tras el

224
00:09:38,210 --> 00:09:39,129
objeto completo

225
00:09:39,129 --> 00:09:41,330
lo lleva a

226
00:09:41,330 --> 00:09:44,210
lo convierte en su nota, porque eso es lo único

227
00:09:44,210 --> 00:09:46,210
que nos interesa, su nota, nada más

228
00:09:46,210 --> 00:09:47,970
entonces map sería

229
00:09:47,970 --> 00:09:50,409
mi objetito

230
00:09:50,409 --> 00:09:51,090
completo

231
00:09:51,090 --> 00:09:55,490
Conviértemelo a x.getNota

232
00:09:55,490 --> 00:09:56,970
Vale

233
00:09:56,970 --> 00:10:00,309
Y ahora

234
00:10:00,309 --> 00:10:05,190
Todo esto de aquí

235
00:10:05,190 --> 00:10:07,169
Todo esto de aquí

236
00:10:07,169 --> 00:10:11,720
Yo lo quiero guardar en un ínteger

237
00:10:11,720 --> 00:10:13,419
A ver si ya

238
00:10:13,419 --> 00:10:18,080
Espera, vamos a poner el resultado

239
00:10:18,080 --> 00:10:19,539
En este caso, el resultado

240
00:10:19,539 --> 00:10:21,139
En este caso va a ser un ínteger

241
00:10:21,139 --> 00:10:23,100
Con lo cual el resultado

242
00:10:23,100 --> 00:10:24,340
Nada de ser alumno

243
00:10:24,340 --> 00:10:27,600
Integer, lo que yo voy a devolver

244
00:10:27,600 --> 00:10:29,519
Y ahora, todo esto de aquí

245
00:10:29,519 --> 00:10:31,659
El objetivo es meterlo en un result

246
00:10:31,659 --> 00:10:32,620
Ay

247
00:10:32,620 --> 00:10:40,120
El objetivo es meterlo ahí, entonces

248
00:10:40,120 --> 00:10:44,200
Vale, los paréntesis ya están, ¿no?

249
00:10:45,340 --> 00:10:46,519
Vale, ah, no, no, no

250
00:10:46,519 --> 00:10:47,559
Esto, que mal

251
00:10:47,559 --> 00:10:50,039
Vale, vale, entonces

252
00:10:50,039 --> 00:10:52,320
Ya lo he convertido con el

253
00:10:52,320 --> 00:10:53,360
Map a

254
00:10:53,360 --> 00:10:56,200
Esa fila de un único elemento

255
00:10:56,200 --> 00:10:57,899
Podría ser muchos, pero vamos

256
00:10:57,899 --> 00:11:00,279
va a ser de uno, acepto práctico

257
00:11:00,279 --> 00:11:02,220
ya lo he convertido en una fila

258
00:11:02,220 --> 00:11:02,860
de notas

259
00:11:02,860 --> 00:11:06,220
pero el resultado del map sigue siendo

260
00:11:06,220 --> 00:11:07,700
una fila, ¿vale?

261
00:11:07,759 --> 00:11:09,539
sigue siendo una fila, ahora

262
00:11:09,539 --> 00:11:11,019
me tengo que quedar

263
00:11:11,019 --> 00:11:13,960
con alguno de los elementos de la fila

264
00:11:13,960 --> 00:11:16,179
entonces algún método tengo que invocar

265
00:11:16,179 --> 00:11:17,480
para quedarme con uno de ellos

266
00:11:17,480 --> 00:11:19,320
entonces, en este caso

267
00:11:19,320 --> 00:11:22,039
vamos a ver si hay algún método que me permita

268
00:11:22,039 --> 00:11:23,980
quedarme con el primero, por ejemplo

269
00:11:23,980 --> 00:11:26,159
o, pues sí

270
00:11:26,159 --> 00:11:28,700
hay un findFirst, no solamente tiene un elemento

271
00:11:28,700 --> 00:11:30,600
pues hay un findFirst

272
00:11:30,600 --> 00:11:32,740
que se queda con el primero

273
00:11:32,740 --> 00:11:34,360
de todos, y de hecho

274
00:11:34,360 --> 00:11:36,759
ya detecta que va a ser un entero

275
00:11:36,759 --> 00:11:38,580
porque el string que te ha dado

276
00:11:38,580 --> 00:11:39,559
el map es de enteros

277
00:11:39,559 --> 00:11:42,600
el string que te ha dado el map es de enteros

278
00:11:42,600 --> 00:11:44,279
entonces findFirst

279
00:11:44,279 --> 00:11:46,500
se devuelve en el primero, en nuestro caso

280
00:11:46,500 --> 00:11:48,639
el primero es el que nos interesa

281
00:11:48,639 --> 00:11:52,899
sí

282
00:11:52,899 --> 00:11:55,100
vale

283
00:11:55,100 --> 00:11:56,899
y ya por último

284
00:11:56,899 --> 00:11:59,639
este pues como es muy listo

285
00:11:59,639 --> 00:12:01,700
te ha devuelto el primero

286
00:12:01,700 --> 00:12:03,580
pero te lo han vuelto en el optional

287
00:12:03,580 --> 00:12:05,960
vale, porque podría ser

288
00:12:05,960 --> 00:12:07,539
un null o podría ser

289
00:12:07,539 --> 00:12:09,240
porque está diseñada así

290
00:12:09,240 --> 00:12:11,940
la interfaz, el frame

291
00:12:11,940 --> 00:12:13,519
de streams este, está diseñada así

292
00:12:13,519 --> 00:12:14,700
entonces te lo envuelve en un optional

293
00:12:14,700 --> 00:12:17,620
vale, pues vamos a sacarlo del optional, no pasa nada

294
00:12:17,620 --> 00:12:20,139
lo saco del optional para guardar un result que se entere

295
00:12:20,139 --> 00:12:22,000
¿cómo se saca de un optional?

296
00:12:22,000 --> 00:12:24,720
pues como no podría ser de otra manera

297
00:12:24,720 --> 00:12:25,639
con el método get

298
00:12:25,639 --> 00:12:31,100
ya lo he sacado del optional

299
00:12:31,100 --> 00:12:38,740
y ya está

300
00:12:38,740 --> 00:12:43,480
bueno pues ya tengo aquí

301
00:12:43,480 --> 00:12:44,419
la nota

302
00:12:44,419 --> 00:12:47,519
del alumno A

303
00:12:47,519 --> 00:12:49,580
para el módulo correspondiente

304
00:12:49,580 --> 00:12:51,639
que podía haber hecho esto

305
00:12:51,639 --> 00:12:53,559
con un for, recorrer la colección

306
00:12:53,559 --> 00:12:55,539
y cuando lo he encontrado, pues sí, podía haberlo hecho

307
00:12:55,539 --> 00:12:57,460
con un for, pero es que esto

308
00:12:57,460 --> 00:12:59,799
sale de corrido, tú serializas

309
00:12:59,799 --> 00:13:02,179
Vas poniendo punto, vas seleccionando métodos

310
00:13:02,179 --> 00:13:03,840
Y es que te sale mucho más de corrido

311
00:13:03,840 --> 00:13:04,899
Que hacerlo con un for

312
00:13:04,899 --> 00:13:06,480
¿Vale?

313
00:13:07,759 --> 00:13:09,120
Aparte de lo bonito que queda

314
00:13:09,120 --> 00:13:17,529
Bueno

315
00:13:17,529 --> 00:13:19,889
Pues ahora ya

316
00:13:19,889 --> 00:13:25,269
La nota del módulo se ha guardado en result

317
00:13:25,269 --> 00:13:27,750
Y se devuelve aquí

318
00:13:27,750 --> 00:13:28,549
Y se acabó

319
00:13:28,549 --> 00:13:31,250
Vale, ya tenemos los tres métodos

320
00:13:31,250 --> 00:13:33,889
Ahora ya podemos probar la aplicación

321
00:13:33,889 --> 00:13:35,950
Y arreglar los tropecientos errores

322
00:13:35,950 --> 00:13:37,669
que seguramente no salgan

323
00:13:37,669 --> 00:13:38,649
dime

324
00:13:38,649 --> 00:13:40,090
en lo que pasaste

325
00:13:40,090 --> 00:13:41,289
no está lo de

326
00:13:41,289 --> 00:13:42,809
adgestión de alumnos

327
00:13:42,809 --> 00:13:45,409
solo hay

328
00:13:45,409 --> 00:13:48,149
las carpetas de BIM y la de Logical

329
00:13:48,149 --> 00:13:49,129
uy pero se

330
00:13:49,129 --> 00:13:51,450
se comprimió el proyecto

331
00:13:51,450 --> 00:13:58,049
pues nuestra

332
00:13:58,049 --> 00:13:59,590
aplicación ahora sería

333
00:13:59,590 --> 00:14:00,490
esto de aquí

334
00:14:00,490 --> 00:14:03,509
con el menú

335
00:14:03,509 --> 00:14:05,190
entonces vamos a insertar un alumno

336
00:14:05,190 --> 00:14:07,590
mostrar la nota

337
00:14:07,590 --> 00:14:15,649
de un alumno, recuperar un alumno y como esto no lo tenemos hecho, nuestra opción 3 va

338
00:14:15,649 --> 00:14:29,220
a ser mostrar nota. Y así usamos solo lo que tenemos, mostrar nota. Vale, entonces

339
00:14:29,220 --> 00:14:37,779
ahora lo que necesitamos es instanciar un objeto de acceso a datos. Lo necesitamos instanciar

340
00:14:37,779 --> 00:14:57,299
Y ya está. Aquí en esta aplicación estamos directamente instanciando este objeto para llamar a sus métodos cada vez que tengamos que guardar lo que sea. Sobre esto muchas veces se hace otra capa más, que es una capa de servicio que trata de traducirlo a un idioma más humano.

341
00:14:57,299 --> 00:15:00,340
entonces, la capa de servicio

342
00:15:00,340 --> 00:15:02,559
sería a su vez una interfaz con métodos

343
00:15:02,559 --> 00:15:04,600
como encuentra alumno, no sé cuántos

344
00:15:04,600 --> 00:15:06,179
y esa capa de servicio

345
00:15:06,179 --> 00:15:08,299
llamaría a esta, que es la que tiene

346
00:15:08,299 --> 00:15:09,919
los nombres raros, pero bueno

347
00:15:09,919 --> 00:15:11,759
aquí no estamos poniendo esa capa adicional

348
00:15:11,759 --> 00:15:13,860
sino llamamos a esto directamente y ya está

349
00:15:13,860 --> 00:15:18,179
pues venga, insertar alumno

350
00:15:18,179 --> 00:15:19,759
en el caso 1

351
00:15:19,759 --> 00:15:21,960
pedimos los datos del alumno

352
00:15:21,960 --> 00:15:24,120
vamos a copiarlos de la otra

353
00:15:24,120 --> 00:15:25,899
versión que también tendría

354
00:15:25,899 --> 00:15:27,740
pedir datos alumno

355
00:15:27,740 --> 00:15:30,159
de hecho

356
00:15:30,159 --> 00:15:32,340
tenía un solicita datos, pues vamos a copiar

357
00:15:32,340 --> 00:15:33,019
este método

358
00:15:33,019 --> 00:15:35,919
solicita datos de la otra

359
00:15:35,919 --> 00:15:36,960
versión

360
00:15:36,960 --> 00:15:42,330
solicita datos era un método de aquí

361
00:15:42,330 --> 00:15:47,080
que lo ponemos

362
00:15:47,080 --> 00:15:48,080
también aquí abajo

363
00:15:48,080 --> 00:15:55,419
y ahora aquí haríamos

364
00:15:55,419 --> 00:15:58,710
alumno a

365
00:15:58,710 --> 00:16:01,590
igual a solicita

366
00:16:01,590 --> 00:16:04,250
datos

367
00:16:04,250 --> 00:16:05,909
vale

368
00:16:05,909 --> 00:16:10,950
Solicita datos

369
00:16:10,950 --> 00:16:15,049
Y ahora

370
00:16:15,049 --> 00:16:17,509
Se llama dao

371
00:16:17,509 --> 00:16:18,330
La clase

372
00:16:18,330 --> 00:16:20,750
Pues dao.save

373
00:16:20,750 --> 00:16:23,269
Ala, ya está

374
00:16:23,269 --> 00:16:27,409
Vale, entonces los detalles de cómo se hace el save

375
00:16:27,409 --> 00:16:28,110
Nos dan igual

376
00:16:28,110 --> 00:16:30,129
Los podríamos cambiar en un momento dado

377
00:16:30,129 --> 00:16:32,330
Podríamos cambiar el fichero, podríamos cambiar cosas

378
00:16:32,330 --> 00:16:34,149
Esta aplicación le da exactamente igual

379
00:16:34,149 --> 00:16:37,490
Vale, el caso 2

380
00:16:37,490 --> 00:16:39,070
Recuperar alumno

381
00:16:39,070 --> 00:16:40,690
Pues recuperar alumno

382
00:16:40,690 --> 00:16:42,789
Aquí sí que tendríamos que pedir el NIF

383
00:16:42,789 --> 00:16:49,690
NIF alumno

384
00:16:49,690 --> 00:16:54,429
Entonces, aquí

385
00:16:54,429 --> 00:16:57,029
Aquí no tenemos un escáner

386
00:16:57,029 --> 00:16:58,549
Así sí tenemos uno

387
00:16:58,549 --> 00:17:03,879
Leemos el NIF del alumno

388
00:17:03,879 --> 00:17:06,059
Y ahora ya tendríamos

389
00:17:06,059 --> 00:17:07,519
A nuestro alumno A

390
00:17:07,519 --> 00:17:09,839
Reutilizo esa variable A

391
00:17:09,839 --> 00:17:11,619
Que sería

392
00:17:11,619 --> 00:17:12,339
DAO

393
00:17:12,339 --> 00:17:13,440
DAO

394
00:17:13,440 --> 00:17:15,759
Find by NIF

395
00:17:15,759 --> 00:17:23,299
Vale, y ahora

396
00:17:23,299 --> 00:17:25,440
si a es

397
00:17:25,440 --> 00:17:27,299
diferente de null

398
00:17:27,299 --> 00:17:29,839
bueno, vamos a meterlo en un

399
00:17:29,839 --> 00:17:31,640
si, si muestra null, muestra null, así no

400
00:17:31,640 --> 00:17:35,730
engordamos esto, mostramos

401
00:17:35,730 --> 00:17:37,490
a uno y ya está, que alumno creo que tenía

402
00:17:37,490 --> 00:17:38,849
ya un toString, ya lo habíamos hecho

403
00:17:38,849 --> 00:17:41,670
ala, pues este ya estaría

404
00:17:41,670 --> 00:17:43,970
como hace

405
00:17:43,970 --> 00:17:45,789
localizar por

406
00:17:45,789 --> 00:17:47,369
clave primaria, no

407
00:17:47,369 --> 00:17:49,769
lo sabemos y nos importa, es otro

408
00:17:49,769 --> 00:17:51,569
problema que está desacoplado por otro lado

409
00:17:51,569 --> 00:17:53,930
y ahora vamos a hacer lo último

410
00:17:53,930 --> 00:17:58,230
Mostrar nota de módulo

411
00:17:58,230 --> 00:18:00,089
Pues aquí habrá que pedirle

412
00:18:00,089 --> 00:18:02,349
Nif alumno y nombre del módulo

413
00:18:02,349 --> 00:18:03,950
Bueno, lo que pasa es que

414
00:18:03,950 --> 00:18:04,730
Hola

415
00:18:04,730 --> 00:18:12,490
Nif alumno

416
00:18:12,490 --> 00:18:18,849
Y nombre de módulo

417
00:18:18,849 --> 00:18:26,839
Y vamos a tener que añadir

418
00:18:26,839 --> 00:18:28,559
Muy rápidamente otra funcionalidad

419
00:18:28,559 --> 00:18:30,519
Que será insertarle módulo al alumno

420
00:18:30,519 --> 00:18:31,759
Por eso no vamos a poder probar esta

421
00:18:31,759 --> 00:18:41,309
Pues esto de aquí

422
00:18:41,309 --> 00:18:43,529
No alteréis

423
00:18:43,529 --> 00:19:00,230
Y ahora, ya aquí podríamos hacer un mostrar dao.getnotamódulo, con if y nombre módulo.

424
00:19:02,309 --> 00:19:02,809
Y ya está.

425
00:19:08,289 --> 00:19:12,190
Vamos a probar primero el insertar y recuperar.

426
00:19:13,730 --> 00:19:19,329
Para probar el mostrar nota habría que añadir uno de insertar módulo a un alumno.

427
00:19:20,190 --> 00:19:22,450
Que no lo tenemos todavía puesto

428
00:19:22,450 --> 00:19:23,829
Entonces

429
00:19:23,829 --> 00:19:29,359
DAO implementación

430
00:19:29,359 --> 00:19:32,819
Tenemos

431
00:19:32,819 --> 00:19:34,380
Primer problema

432
00:19:34,380 --> 00:19:34,700
Aquí

433
00:19:34,700 --> 00:19:37,740
Cuando arranque la aplicación

434
00:19:37,740 --> 00:19:40,420
O sea, cuando hagamos la primera

435
00:19:40,420 --> 00:19:42,420
Llamada a DAO

436
00:19:42,420 --> 00:19:44,640
Aquí ya va a haber

437
00:19:44,640 --> 00:19:45,359
Un problema, ¿no?

438
00:19:49,539 --> 00:19:51,539
Que el fichero del mundo está sin inicializar, ¿verdad?

439
00:19:52,099 --> 00:19:53,240
Claro, entonces

440
00:19:53,240 --> 00:19:55,579
Aquí lo normal es que las clases

441
00:19:55,579 --> 00:19:57,740
de implementación tengan un constructor

442
00:19:57,740 --> 00:19:59,559
que inicialice la fuente de datos

443
00:19:59,559 --> 00:20:01,460
entonces antes de esperar

444
00:20:01,460 --> 00:20:03,160
que nos salga y no perder más tiempo

445
00:20:03,160 --> 00:20:04,980
vamos a hacerlo y ya está

446
00:20:04,980 --> 00:20:15,000
entonces esto inicializaría la fuente

447
00:20:15,000 --> 00:20:16,259
de datos

448
00:20:16,259 --> 00:20:20,990
si fuera una base de datos

449
00:20:20,990 --> 00:20:23,509
pues ese método inicializaría la conexión

450
00:20:23,509 --> 00:20:24,890
a la base de datos, lo que fuera

451
00:20:24,890 --> 00:20:26,430
en este caso se inicializa

452
00:20:26,430 --> 00:20:28,369
nuestro fichero y ya está

453
00:20:28,369 --> 00:20:30,910
pero que ocurre que cuando arranca la aplicación

454
00:20:30,910 --> 00:20:32,190
aquí

455
00:20:32,190 --> 00:20:34,549
nos va a pasar una cosa muy fea

456
00:20:34,549 --> 00:20:36,150
Que es que vamos a tener que pedirle al usuario

457
00:20:36,150 --> 00:20:36,930
¿Cuál es el fichero?

458
00:20:37,630 --> 00:20:39,950
Esta cosa tan fea la arreglaremos ahora después

459
00:20:39,950 --> 00:20:41,170
Con un archivo de properties

460
00:20:41,170 --> 00:20:43,029
Y así no tenemos que pedirle al usuario

461
00:20:43,029 --> 00:20:45,670
Pero ahora mismo vamos a decirle

462
00:20:45,670 --> 00:20:46,930
Cuando arranque la aplicación

463
00:20:46,930 --> 00:20:49,910
El técnico, el que la despliega en el servidor

464
00:20:49,910 --> 00:20:51,769
Tendrá que decir, este es el fichero de trabajo

465
00:20:51,769 --> 00:20:59,839
Y ahora, fichero de alumnos

466
00:20:59,839 --> 00:21:01,619
Pues tendremos que leerlo aquí

467
00:21:01,619 --> 00:21:08,680
Bueno, ni siquiera hace falta

468
00:21:08,680 --> 00:21:10,480
Vamos a ponerle el scan aquí

469
00:21:10,480 --> 00:21:11,039
Y ya está

470
00:21:11,039 --> 00:21:13,240
Y así no

471
00:21:13,240 --> 00:21:14,599
New file

472
00:21:14,599 --> 00:21:22,660
Y hacemos aquí un scan.nextline

473
00:21:22,660 --> 00:21:30,609
Vale, pues ese error que nos hubiera salido de un null pointer exception

474
00:21:30,609 --> 00:21:33,089
Al acceder al archivo ya no nos va a salir

475
00:21:33,089 --> 00:21:35,789
Entonces

476
00:21:35,789 --> 00:21:39,750
Venga, pues vamos a arrancar esto

477
00:21:39,750 --> 00:21:48,500
Venga, ¿con qué fichera vamos a trabajar?

478
00:21:49,059 --> 00:21:52,160
Vamos a trabajar con alumnos.dam2

479
00:21:52,160 --> 00:21:55,279
Insertamos un alumno

480
00:21:55,279 --> 00:21:57,500
NIF 1111

481
00:21:57,500 --> 00:21:59,519
Nombre 1111

482
00:21:59,519 --> 00:22:02,160
No sabemos insertarlo

483
00:22:02,160 --> 00:22:03,779
Vamos a probar a recuperarlo

484
00:22:03,779 --> 00:22:05,920
1111

485
00:22:05,920 --> 00:22:07,599
El alumno es este

486
00:22:07,599 --> 00:22:08,420
Vale

487
00:22:08,420 --> 00:22:11,440
Vamos a insertar otro

488
00:22:11,440 --> 00:22:12,819
2222

489
00:22:12,819 --> 00:22:16,599
Nombre 2222

490
00:22:16,599 --> 00:22:19,400
Vamos a ver si se ha insertado

491
00:22:19,400 --> 00:22:21,140
2, recuperar alumno

492
00:22:21,140 --> 00:22:22,680
Vamos a ver si el primero sigue

493
00:22:22,680 --> 00:22:27,859
Y nos sale lo que nos imaginábamos e intuíamos del año pasado

494
00:22:27,859 --> 00:22:28,599
¿Verdad?

495
00:22:29,480 --> 00:22:31,000
Que lo arreglamos rápidamente

496
00:22:31,000 --> 00:22:35,539
Me dice, uy, el stream del que estoy cogiendo los datos

497
00:22:35,539 --> 00:22:36,519
O lo que es lo mismo

498
00:22:36,519 --> 00:22:39,380
Los objetos serializados del fichero

499
00:22:39,380 --> 00:22:43,099
Están muy corruptos

500
00:22:43,099 --> 00:22:43,940
De hecho es un asco

501
00:22:43,940 --> 00:22:47,480
Vale, ¿de dónde venía este problema?

502
00:22:48,160 --> 00:22:49,920
Este problema venía

503
00:22:49,920 --> 00:22:52,039
A ver si ha aparecido

504
00:22:52,039 --> 00:23:01,019
este problema venía de que cuando

505
00:23:01,019 --> 00:23:04,579
hacíamos un object output string

506
00:23:04,579 --> 00:23:05,819
por primera vez

507
00:23:05,819 --> 00:23:09,200
pues la máquina virtual

508
00:23:09,200 --> 00:23:11,839
abría ese fichero para escribir

509
00:23:11,839 --> 00:23:13,799
y le ponía aquí una cabecera

510
00:23:13,799 --> 00:23:18,059
donde daba detalles del tipo de objeto

511
00:23:18,059 --> 00:23:19,019
que iba a serializar

512
00:23:19,019 --> 00:23:21,019
pues las propiedades que tenía todo

513
00:23:21,019 --> 00:23:23,339
luego ya que hacíamos un write object

514
00:23:23,339 --> 00:23:24,920
pues escribía el objeto

515
00:23:24,920 --> 00:23:26,240
que hacíamos otro write object

516
00:23:26,240 --> 00:23:30,339
Una vez que ya cerrábamos el flujo

517
00:23:30,339 --> 00:23:31,539
Object-OutputString

518
00:23:31,539 --> 00:23:32,980
Este cuchillo ya

519
00:23:32,980 --> 00:23:35,339
Se quedaba cerrado y se acabó

520
00:23:35,339 --> 00:23:38,000
Que volvíamos a abrirlo con Object-OutputString

521
00:23:38,000 --> 00:23:39,640
Porque queremos añadir otro más

522
00:23:39,640 --> 00:23:40,599
Queremos añadir otro

523
00:23:40,599 --> 00:23:43,079
Pues se lo abría con Object-OutputString

524
00:23:43,079 --> 00:23:45,660
Y si lo habíamos abierto con True

525
00:23:45,660 --> 00:23:48,059
La opción de añadir la habíamos puesto a True

526
00:23:48,059 --> 00:23:50,259
Pues se lo habría localizado

527
00:23:50,259 --> 00:23:50,920
En este punto

528
00:23:50,920 --> 00:23:53,140
Porque lo habría para

529
00:23:53,140 --> 00:23:54,299
Añadir

530
00:23:54,299 --> 00:23:54,900
no ve la cabecera.

531
00:23:56,019 --> 00:23:58,140
Más que no ve, es que el obvio de

532
00:23:58,140 --> 00:24:00,299
output stream, independientemente del

533
00:24:00,299 --> 00:24:02,660
punto donde lo abra, si es al principio

534
00:24:02,660 --> 00:24:04,160
porque le hemos dicho sobre escribir

535
00:24:04,160 --> 00:24:06,019
o es al final, pero me he dicho de añadir,

536
00:24:06,119 --> 00:24:07,900
independientemente de donde lo abra, él siempre,

537
00:24:08,200 --> 00:24:10,039
así, de forma autómata,

538
00:24:10,180 --> 00:24:12,519
sin pensar, él siempre te crea una cabecera.

539
00:24:13,180 --> 00:24:13,480
Siempre.

540
00:24:14,200 --> 00:24:15,920
Con lo cual, si tú abres el archivo

541
00:24:15,920 --> 00:24:17,920
oye tu output stream, para

542
00:24:17,920 --> 00:24:20,440
serializar, pero añadiendo,

543
00:24:21,180 --> 00:24:22,240
te has cargado el archivo.

544
00:24:22,700 --> 00:24:24,160
Porque la cabecera sólo

545
00:24:24,160 --> 00:24:30,160
debe figurar aquí. No podemos meter cabeceras por medio. Entonces, lo que ha pasado aquí

546
00:24:30,160 --> 00:24:33,859
es eso. Hemos creado un objeto y lo hemos serializado y se acabó. Ahora hemos vuelto

547
00:24:33,859 --> 00:24:39,220
a meter a otro. Al meter a otro para añadir, ese otro, pues ha hecho que el objeto put

548
00:24:39,220 --> 00:24:43,259
string meta aquí una cabecera y el segundo se ha metido aquí. Cuando ahora ya hemos

549
00:24:43,259 --> 00:24:47,960
abierto con object input string, él ha leído la cabecera bien y ha empezado a leer el objeto.

550
00:24:48,480 --> 00:24:53,779
El primero lo ha leído correctamente, pero luego cuando ha seguido leyendo, aquí ya

551
00:24:53,779 --> 00:24:55,740
he encontrado datos que no son de objetos

552
00:24:55,740 --> 00:24:58,079
sino que son datos que no entiendo

553
00:24:58,079 --> 00:24:59,319
¿vale?

554
00:24:59,819 --> 00:25:01,619
bueno, pues ¿cómo arreglábamos esto?

555
00:25:01,779 --> 00:25:03,500
pues nos interesa una versión de

556
00:25:03,500 --> 00:25:04,500
object output string

557
00:25:04,500 --> 00:25:06,900
que no cree la cabecera

558
00:25:06,900 --> 00:25:10,200
para usarla cuando vamos a añadir

559
00:25:10,200 --> 00:25:10,920
¿vale?

560
00:25:11,799 --> 00:25:13,940
y entonces eso, gracias a la herencia

561
00:25:13,940 --> 00:25:15,119
pues lo hacíamos muy

562
00:25:15,119 --> 00:25:16,880
rápidamente

563
00:25:16,880 --> 00:25:22,609
eso, gracias a la herencia, pues hacíamos

564
00:25:22,609 --> 00:25:24,569
a ver, para no

565
00:25:24,569 --> 00:25:26,410
complicar con más paquetes, voy a meter

566
00:25:26,410 --> 00:25:32,650
aquí dentro de lógica. Vamos a crearnos nuestra propia versión de object-output-string

567
00:25:32,650 --> 00:25:45,259
pero que no cree cabecera. Voy a llamar a la primera o a esta en función de si el fichero

568
00:25:45,259 --> 00:25:57,900
existe o no existe y ya está. Venga, pues aquí me hago mi clase. Quiero que sea un

569
00:25:57,900 --> 00:26:02,640
object-output-string tal cual, idéntico al otro, que funcione igual, con lo cual voy

570
00:26:02,640 --> 00:26:03,660
hacer que herede

571
00:26:03,660 --> 00:26:18,819
no

572
00:26:18,819 --> 00:26:19,539
o sea

573
00:26:19,539 --> 00:26:22,299
tú lo puedes programar de otras maneras

574
00:26:22,299 --> 00:26:22,700
pues

575
00:26:22,700 --> 00:26:26,420
claro, cuando vayas a añadir

576
00:26:26,420 --> 00:26:28,119
en lugar de añadir, leerlos todos

577
00:26:28,119 --> 00:26:29,240
y volverlos a escribir

578
00:26:29,240 --> 00:26:31,960
pero eso es muy chapuza

579
00:26:31,960 --> 00:26:33,500
porque lees todos los objetos

580
00:26:33,500 --> 00:26:36,359
y los tienes todos en memoria

581
00:26:36,359 --> 00:26:36,920
entonces

582
00:26:36,920 --> 00:26:39,079
gracias a que esta clase

583
00:26:39,079 --> 00:26:41,079
no es final, podemos hacer

584
00:26:41,079 --> 00:26:42,819
el extens, claro, si fuera final

585
00:26:42,819 --> 00:26:44,980
recordad que no se puede heredar de una clase final

586
00:26:44,980 --> 00:26:46,920
vale, entonces queremos

587
00:26:46,920 --> 00:26:48,559
que sea igualita, igualita en todo

588
00:26:48,559 --> 00:26:50,019
salvo

589
00:26:50,019 --> 00:26:51,759
en un método

590
00:26:51,759 --> 00:26:54,900
que sea, bueno, primero vamos a importar esto

591
00:26:54,900 --> 00:27:03,319
putString

592
00:27:03,319 --> 00:27:14,089
vamos a

593
00:27:14,089 --> 00:27:16,289
hacer el constructor ahora

594
00:27:16,289 --> 00:27:18,410
pero lo único que queremos que cambie

595
00:27:18,410 --> 00:27:20,690
esta clase respecto a aquella que

596
00:27:20,690 --> 00:27:25,289
sobreescribimos, lo único que queremos que cambie es el método de escribir cabecera

597
00:27:25,289 --> 00:27:29,730
que queremos que no haga nada. Pues vamos a sobreescribir, y aquí es importante poner

598
00:27:29,730 --> 00:27:34,470
el override para asegurar que estamos acertando con el método, el método de object.putString

599
00:27:34,470 --> 00:27:44,750
que escribe la cabecera. Entonces, este método, creo recordar, y si no, lo buscamos, que se

600
00:27:44,750 --> 00:27:47,029
llamaba writeStream

601
00:27:47,029 --> 00:27:52,259
header. Debe ser

602
00:27:52,259 --> 00:27:54,099
que sí que se llama así, porque

603
00:27:54,099 --> 00:27:56,180
si no se llamara así, me habría

604
00:27:56,180 --> 00:27:57,660
saltado con el overwrite.

605
00:27:58,460 --> 00:28:00,259
¿Vale? Por eso es importante poner el overwrite.

606
00:28:00,500 --> 00:28:02,059
Para asegurarme de que no me estoy

607
00:28:02,059 --> 00:28:04,000
inventando otro, sino que estoy

608
00:28:04,000 --> 00:28:05,059
sobreescribiendo de arriba.

609
00:28:05,339 --> 00:28:07,880
O sea, que el método write a secas llama también al método

610
00:28:07,880 --> 00:28:08,539
writeStream.

611
00:28:12,319 --> 00:28:14,720
No, la instanciación,

612
00:28:14,839 --> 00:28:16,279
el constructor del object output.

613
00:28:17,279 --> 00:28:18,980
Luego el writeObject escribe el objeto,

614
00:28:19,079 --> 00:28:20,759
pero cuando tú creas el object outputStream,

615
00:28:20,759 --> 00:28:22,299
claro, mete la cabecera

616
00:28:22,299 --> 00:28:24,559
vale, entonces debe ser que si existe un método

617
00:28:24,559 --> 00:28:26,079
que se llama así, que por su nombre

618
00:28:26,079 --> 00:28:28,460
deducimos que escribe la cabecera

619
00:28:28,460 --> 00:28:29,900
pues este en blanco

620
00:28:29,900 --> 00:28:32,059
este en blanco, vale

621
00:28:32,059 --> 00:28:34,160
y con el constructor que podemos hacer, pues cuando

622
00:28:34,160 --> 00:28:36,599
instanciemos este de aquí

623
00:28:36,599 --> 00:28:38,559
lo queremos hacer

624
00:28:38,559 --> 00:28:40,759
apoyándonos en el constructor del de arriba

625
00:28:40,759 --> 00:28:42,400
pero es que nuestro uso

626
00:28:42,400 --> 00:28:44,039
del constructor del de arriba

627
00:28:44,039 --> 00:28:46,500
es de todas las versiones

628
00:28:46,500 --> 00:28:48,279
que tiene, está aquí

629
00:28:48,279 --> 00:28:49,339
el constructor

630
00:28:49,339 --> 00:28:53,319
la versión que estamos usando del constructor desde arriba

631
00:28:53,319 --> 00:28:57,400
es la que le pasas el flujo, pues vamos

632
00:28:57,400 --> 00:29:00,019
a apoyarnos en ese

633
00:29:00,019 --> 00:29:05,920
entonces vamos a apoyarnos en ese al cual le pasamos

634
00:29:05,920 --> 00:29:09,559
un file output string

635
00:29:09,559 --> 00:29:25,480
que le vamos a pasar desde aquí también, vale, repito

636
00:29:25,480 --> 00:29:29,380
como esta es la versión del constructor que estamos usando

637
00:29:29,380 --> 00:29:31,599
que es la versión del constructor de arriba

638
00:29:31,599 --> 00:29:33,019
al que le pasas el fichero

639
00:29:33,019 --> 00:29:35,720
pues nuestra versión

640
00:29:35,720 --> 00:29:37,640
del constructor le vamos a pasar el fichero

641
00:29:37,640 --> 00:29:39,799
y él se lo va a pasar, se va a apoyar en el de arriba

642
00:29:39,799 --> 00:29:40,660
y va a pasarse al de arriba

643
00:29:40,660 --> 00:29:43,880
la única diferencia entonces entre este y el otro

644
00:29:43,880 --> 00:29:45,220
es que este no escribe cabecera

645
00:29:45,220 --> 00:29:47,000
todo lo demás funciona exactamente igual

646
00:29:47,000 --> 00:29:50,319
entonces vamos a parar unos minutos

647
00:29:50,319 --> 00:29:51,680
pero lo único que nos faltaría

648
00:29:51,680 --> 00:29:54,059
es cambiar en el escribir archivo

649
00:29:54,059 --> 00:29:55,220
que existe

650
00:29:55,220 --> 00:29:57,880
uso este, que no existe uso el otro

651
00:29:57,880 --> 00:29:59,299
y se acabó

652
00:29:59,299 --> 00:29:59,819
¿Vale?