0
00:00:00,000 --> 00:00:11,000
Vale, si habláis durante esta grabación, me estáis dando implícitamente el consentimiento para que os grabe, ¿vale?

1
00:00:11,000 --> 00:00:14,000
Si no, me levantáis la mano y me decís paro, ¿vale?

2
00:00:14,000 --> 00:00:19,000
Lo que vamos a empezar a ver hoy es el concepto de persistencia de datos

3
00:00:19,000 --> 00:00:27,000
La idea es que quiero que los datos persistan en memoria entre una ejecución y otra, ¿vale?

4
00:00:27,000 --> 00:00:30,000
Esto es fundamental para todos los programas que tenemos, ¿vale?

5
00:00:30,000 --> 00:00:40,000
¿Hay una parte de los datos de un programa que se queda persistente entre una ejecución y otra?

6
00:00:41,000 --> 00:00:43,000
De los que habéis dicho vosotros

7
00:00:44,000 --> 00:00:45,000
El propio código, ¿vale?

8
00:00:45,000 --> 00:00:50,000
En otro sentido, el código es parte de los datos de un programa

9
00:00:50,000 --> 00:00:56,000
Es la secuencia, las instrucciones y por ahí dentro está codificado también el concepto de algoritmo

10
00:00:56,000 --> 00:01:04,000
Los pasos que tiene que hacer, el modo de funcionalidad y todas las funciones que tiene vuestro programa

11
00:01:04,000 --> 00:01:07,000
Y eso cuando yo lo apago y lo enciendo otra vez, se queda allí

12
00:01:07,000 --> 00:01:15,000
De hecho se crea un fichero, fichero.java que luego se compila .class y se queda allí ejecutable por una Java Virtual Machine

13
00:01:15,000 --> 00:01:19,000
La misma Java Virtual Machine que es un intérprete, pues son códigos

14
00:01:20,000 --> 00:01:22,000
Es el código que está guardado por allí

15
00:01:22,000 --> 00:01:27,000
Cuando yo lanzo la Java Virtual Machine se carga ese código en memoria principal, en la RAM

16
00:01:27,000 --> 00:01:35,000
Y a partir de allí se empieza a interpretar vuestro ficherito .class que tiene dentro bytecode que se ha hecho

17
00:01:35,000 --> 00:01:47,000
Esta es una primera parte de mi programa que queda guardado en el disco duro, en la memoria secundaria

18
00:01:47,000 --> 00:01:55,000
La memoria que no necesita energía cuando funciona y por lo tanto si le quito la energía sigue allí la información

19
00:01:58,000 --> 00:02:05,000
Los objetos, que son los que utilizamos nosotros, dicen que se componen de atributos, datos y métodos

20
00:02:05,000 --> 00:02:07,000
Código ejecutable

21
00:02:07,000 --> 00:02:12,000
Este código se almacena en dispositivos como discos duros, lo que decimos ahora

22
00:02:13,000 --> 00:02:20,000
Nosotros tenemos, cuando hacemos una clase, que es una abstracción de los objetos, una idea más general

23
00:02:20,000 --> 00:02:26,000
Al que luego yo instancio en varios objetos concretos, tengo la clase cuadrado, son todos los cuadrados del mundo

24
00:02:26,000 --> 00:02:29,000
Y luego creo el cuadrado del lado 3, que es un cuadrado concreto

25
00:02:31,000 --> 00:02:38,000
Todo está almacenado, la parte de métodos está seguramente en el disco duro

26
00:02:38,000 --> 00:02:48,000
Los atributos, si no, en el sentido de la definición de la existencia de estos atributos es parte del código

27
00:02:48,000 --> 00:02:58,000
Pero el valor actual, el valor que he metido dentro del atributo lado de una clase cuadrado

28
00:02:58,000 --> 00:03:07,000
No es real hasta que yo cree un objeto

29
00:03:07,000 --> 00:03:12,000
Al momento que creo el objeto, este objeto tiene asociado un determinado valor

30
00:03:12,000 --> 00:03:22,000
Y esto normalmente, cuando se crean los objetos, en tiempo de ejecución, o en tiempo de compilación, o en tiempo WAN

31
00:03:23,000 --> 00:03:31,000
Cuando ejecuto, al ejecutar el programa, yo tendré las new que se ejecutan y allí es donde creo los objetos

32
00:03:31,000 --> 00:03:33,000
Los objetos donde se guardan

33
00:03:38,000 --> 00:03:41,000
¿Dónde se crean los objetos? ¿En qué memoria se crean los objetos?

34
00:03:41,000 --> 00:03:43,000
¿Se crean en alguna memoria?

35
00:03:43,000 --> 00:03:45,000
¿En la RAM?

36
00:03:45,000 --> 00:03:47,000
En una parte de la RAM especial

37
00:03:48,000 --> 00:03:56,000
Entonces, cuando ejecutamos un programa sobre una Java Editor Machine, el código compilado se carga en memoria RAM y se ejecuta

38
00:03:56,000 --> 00:03:58,000
Entonces, todo se trabaja desde la RAM

39
00:03:58,000 --> 00:04:00,000
¿Por qué la RAM?

40
00:04:03,000 --> 00:04:06,000
¿Se ejecuta desde la RAM directamente?

41
00:04:09,000 --> 00:04:11,000
No, ¿por qué?

42
00:04:12,000 --> 00:04:14,000
El que ejecuta es el procesador, ¿no?

43
00:04:14,000 --> 00:04:18,000
Sí, bueno, el que ejecuta es el procesador, ok

44
00:04:18,000 --> 00:04:21,000
¿Pero lee los datos directamente en RAM?

45
00:04:25,000 --> 00:04:27,000
¿Y dónde los almace?

46
00:04:29,000 --> 00:04:32,000
¿Pero entonces lo lee y lo escribe en la RAM?

47
00:04:33,000 --> 00:04:39,000
Es decir, estas son las memorias que tenemos, memoria secundaria y memoria principal

48
00:04:39,000 --> 00:04:41,000
La RAM y el disco duro

49
00:04:41,000 --> 00:04:44,000
Ya está, V o F, verdadero o falso

50
00:04:46,000 --> 00:04:47,000
¿Cuál hay?

51
00:04:47,000 --> 00:04:48,000
Caché

52
00:04:48,000 --> 00:04:50,000
¿Qué es la caché?

53
00:04:51,000 --> 00:05:01,000
El concepto de caché es que una parte de la RAM me la copio en una memoria más pequeña y más rápida

54
00:05:01,000 --> 00:05:02,000
¿Vale?

55
00:05:02,000 --> 00:05:04,000
¿Hay sólo una memoria caché?

56
00:05:06,000 --> 00:05:08,000
Hay varias

57
00:05:08,000 --> 00:05:09,000
¿Vale?

58
00:05:09,000 --> 00:05:12,000
Memoria nivel 2, memoria nivel 3

59
00:05:13,000 --> 00:05:15,000
Entonces se crea una pirámide de memorias

60
00:05:15,000 --> 00:05:23,000
Cuanto más pequeñas, más rápidas y más cercanas, entre comillas, al procesador

61
00:05:23,000 --> 00:05:26,000
La memoria más rápida de todos y más pequeña de todos son

62
00:05:28,000 --> 00:05:29,000
Los registros

63
00:05:29,000 --> 00:05:30,000
¿Suenan registros?

64
00:05:30,000 --> 00:05:31,000
No suenan

65
00:05:31,000 --> 00:05:37,000
Son memorias, son celdas de memorias que están en el mismo procesador

66
00:05:37,000 --> 00:05:38,000
¿Vale?

67
00:05:39,000 --> 00:05:43,000
Al fin y al cabo el procesador las operaciones las hace siempre entre registros

68
00:05:43,000 --> 00:05:49,000
Lee los datos entre los registros y el resultado lo guarda en un registro

69
00:05:49,000 --> 00:05:57,000
Y luego desde allí hay toda una operación de mover estos datos desde los registros hacia afuera

70
00:05:57,000 --> 00:06:00,000
A los varios niveles de caché o hacia adentro si quiere ejecutar

71
00:06:00,000 --> 00:06:01,000
¿Vale?

72
00:06:01,000 --> 00:06:08,000
La idea es, si yo tengo un programa que son gigas y gigas de datos, algo para decir

73
00:06:08,000 --> 00:06:12,000
No puedo tener todo eso directamente en el procesador

74
00:06:12,000 --> 00:06:17,000
Entonces pillo sólo la parte que se está ejecutando ahora y lo pongo en nivel 3

75
00:06:17,000 --> 00:06:23,000
De esta parte que he puesto en nivel 3 una parte, la que se está ejecutando ahora, la pongo en nivel 2

76
00:06:23,000 --> 00:06:30,000
De esta parte la ejecución de la sentencia que se está ejecutando ahora la pongo a nivel de registros

77
00:06:30,000 --> 00:06:32,000
Y allí trabajo

78
00:06:32,000 --> 00:06:34,000
¿Vale? Entonces hay toda esta cosa

79
00:06:34,000 --> 00:06:39,000
Esto, para los afortunados que acabaran en DAMA, en Programación de Procesos y Servicios

80
00:06:39,000 --> 00:06:41,000
Tiene problemas

81
00:06:41,000 --> 00:06:44,000
¿Vale? Pero lo veremos en segundo

82
00:06:44,000 --> 00:06:46,000
¿Si?

83
00:06:46,000 --> 00:06:49,000
El concepto es que cuando la electricidad se apaga, ¿Vale?

84
00:06:49,000 --> 00:06:53,000
Todo lo que es del programa se pierde

85
00:06:53,000 --> 00:06:54,000
¿Vale?

86
00:06:54,000 --> 00:06:57,000
La parte del disco duro se queda allí

87
00:06:57,000 --> 00:07:00,000
Pero todos los programas que hemos hecho hasta ahora

88
00:07:00,000 --> 00:07:04,000
La única cosa que hacían era cargarse el RAM, el código

89
00:07:04,000 --> 00:07:07,000
Pero todos los objetos que creaban, todas las variables

90
00:07:07,000 --> 00:07:11,000
Todo eso estaba en la memoria no persistente, en la RAM

91
00:07:11,000 --> 00:07:16,000
Y por lo tanto si yo apago el ordenador, pues todos los datos que están allí, perdidos

92
00:07:16,000 --> 00:07:18,000
¿Vale?

93
00:07:20,000 --> 00:07:24,000
Los valores de atributos de los objetos no existen previamente en el disco

94
00:07:24,000 --> 00:07:25,000
¿Vale?

95
00:07:25,000 --> 00:07:28,000
Lo que decíamos antes, cuando yo creo un objeto

96
00:07:28,000 --> 00:07:33,000
Lo ideo, le pongo las cosas, le puedo poner valores en el código

97
00:07:33,000 --> 00:07:36,000
Pero es cuando lo ejecuto que creo un objeto por algún lado

98
00:07:36,000 --> 00:07:38,000
Y le asigno los valores que tiene que tener

99
00:07:38,000 --> 00:07:39,000
¿Vale?

100
00:07:39,000 --> 00:07:42,000
O sea que la memoria relacionada con este objeto

101
00:07:42,000 --> 00:07:44,000
Y la dirección de memoria donde está

102
00:07:44,000 --> 00:07:47,000
A nivel de disco duro no existe

103
00:07:47,000 --> 00:07:50,000
Existe en el momento de ejecución dentro de la RAM

104
00:07:50,000 --> 00:07:51,000
¿Si?

105
00:07:52,000 --> 00:07:55,000
En particular, cuando creamos una new

106
00:07:55,000 --> 00:07:58,000
Y creamos un nuevo objeto

107
00:07:58,000 --> 00:08:02,000
Hay una parte, un espacio de la memoria RAM

108
00:08:02,000 --> 00:08:04,000
Que se llama el heap

109
00:08:04,000 --> 00:08:06,000
Heap es como montón

110
00:08:06,000 --> 00:08:09,000
En español, si no me equivoco

111
00:08:09,000 --> 00:08:10,000
¿Vale?

112
00:08:10,000 --> 00:08:11,000
Es un trozo de memoria

113
00:08:11,000 --> 00:08:14,000
Y en realidad esta es una estructura de datos

114
00:08:14,000 --> 00:08:17,000
Como puede ser una lista, como puede ser un árbol

115
00:08:17,000 --> 00:08:19,000
Como puede ser otra cosa que hemos visto

116
00:08:19,000 --> 00:08:20,000
Pero se llama heap

117
00:08:20,000 --> 00:08:23,000
Y tiene características distintas

118
00:08:23,000 --> 00:08:24,000
Yo puedo pensarlo como

119
00:08:24,000 --> 00:08:26,000
En la memoria RAM asigno un trozo

120
00:08:26,000 --> 00:08:29,000
Donde aquí es donde creo los objetos

121
00:08:29,000 --> 00:08:30,000
¿Vale?

122
00:08:30,000 --> 00:08:32,000
Los objetos que creará la JavaScript Machine

123
00:08:32,000 --> 00:08:34,000
Interpretando mis programas

124
00:08:34,000 --> 00:08:36,000
Se crean todos en esta estructura de datos

125
00:08:36,000 --> 00:08:37,000
Que es un heap

126
00:08:37,000 --> 00:08:38,000
¿Vale?

127
00:08:38,000 --> 00:08:41,000
Y allí dentro, como construyo los objetos

128
00:08:41,000 --> 00:08:44,000
Puedo guardar los valores relacionados

129
00:08:44,000 --> 00:08:46,000
Con cada instancia de cada objeto

130
00:08:47,000 --> 00:08:48,000
¿Dudas?

131
00:08:53,000 --> 00:08:54,000
Otros datos

132
00:08:54,000 --> 00:08:58,000
Lo que no son objetos por sí mismos

133
00:08:58,000 --> 00:09:00,000
Como por ejemplo variables locales

134
00:09:00,000 --> 00:09:03,000
O parámetros de entrada

135
00:09:03,000 --> 00:09:05,000
Cuando llamo un método y cosas por el estilo

136
00:09:05,000 --> 00:09:07,000
No van en el heap

137
00:09:07,000 --> 00:09:11,000
El heap es algo un poquito más persistente

138
00:09:11,000 --> 00:09:12,000
Entre comillas

139
00:09:12,000 --> 00:09:14,000
Porque esta RAM es lo que más persistente

140
00:09:14,000 --> 00:09:17,000
Pero dentro de la ejecución del mismo programa

141
00:09:17,000 --> 00:09:19,000
Mientras el programa está en ejecución

142
00:09:19,000 --> 00:09:22,000
Mi heap es donde almaceno los objetos

143
00:09:22,000 --> 00:09:24,000
Que estoy utilizando

144
00:09:24,000 --> 00:09:26,000
Teniendo en cuenta que si vosotros hacéis un for

145
00:09:26,000 --> 00:09:29,000
int i igual a 1

146
00:09:29,000 --> 00:09:32,000
Este int i es una variable

147
00:09:32,000 --> 00:09:33,000
Pero esta variable ¿Dónde se guarda?

148
00:09:33,000 --> 00:09:34,000
¿Es un objeto?

149
00:09:39,000 --> 00:09:41,000
¿Es un atributo de un objeto?

150
00:09:42,000 --> 00:09:45,000
No, es una variable local

151
00:09:45,000 --> 00:09:46,000
¿Local a qué?

152
00:09:48,000 --> 00:09:50,000
¿Dónde existe esta i?

153
00:09:52,000 --> 00:09:53,000
No

154
00:09:55,000 --> 00:09:56,000
No

155
00:09:57,000 --> 00:10:01,000
Si yo hago for int i igual a 1

156
00:10:01,000 --> 00:10:03,000
y mayor a i más más

157
00:10:03,000 --> 00:10:05,000
Y fuera de este for pregunto

158
00:10:05,000 --> 00:10:07,000
¿Si está puntuado tu punto principal del ni?

159
00:10:07,000 --> 00:10:08,000
¿Funciona?

160
00:10:08,000 --> 00:10:09,000
No

161
00:10:09,000 --> 00:10:10,000
Es local al medio

162
00:10:10,000 --> 00:10:13,000
Es local al bloque de for

163
00:10:13,000 --> 00:10:15,000
Porque lo está declarando ahí dentro

164
00:10:16,000 --> 00:10:18,000
Si quiero que se lea afuera

165
00:10:18,000 --> 00:10:19,000
¿Qué hago?

166
00:10:19,000 --> 00:10:20,000
La declaro antes del for

167
00:10:20,000 --> 00:10:22,000
int i es igual a 0 punto y coma

168
00:10:22,000 --> 00:10:24,000
for i igual a 0

169
00:10:24,000 --> 00:10:26,000
Entonces luego se puede leer el for

170
00:10:26,000 --> 00:10:27,000
¿Vale?

171
00:10:27,000 --> 00:10:31,000
Es local al bloque en el que se define

172
00:10:31,000 --> 00:10:32,000
¿Vale?

173
00:10:32,000 --> 00:10:35,000
Pero no es algo que va asociado a un objeto

174
00:10:35,000 --> 00:10:36,000
O cosa por el estilo

175
00:10:36,000 --> 00:10:39,000
Es una cosa que va asociada localmente

176
00:10:39,000 --> 00:10:41,000
a ese bloque de código

177
00:10:42,000 --> 00:10:45,000
Si yo ejecuto 10 veces ese método

178
00:10:45,000 --> 00:10:47,000
con dentro el for

179
00:10:47,000 --> 00:10:49,000
Por 10 veces crearé la variable i

180
00:10:49,000 --> 00:10:50,000
La usaré

181
00:10:50,000 --> 00:10:52,000
Y cuando salgo de este método

182
00:10:52,000 --> 00:10:53,000
se destruye

183
00:10:53,000 --> 00:10:54,000
Ya no me interesa

184
00:10:54,000 --> 00:10:57,000
La vez siguiente que vuelva a llamar ese método

185
00:10:57,000 --> 00:10:59,000
Es una nueva i

186
00:11:00,000 --> 00:11:02,000
No es la misma i de la última vez

187
00:11:02,000 --> 00:11:04,000
No tiene memoria de lo que ha pasado

188
00:11:04,000 --> 00:11:06,000
con la i de la última vez

189
00:11:06,000 --> 00:11:07,000
Si quiero que esto funcione

190
00:11:07,000 --> 00:11:08,000
La tengo que sacar afuera

191
00:11:08,000 --> 00:11:10,000
Ponerla como atributo

192
00:11:10,000 --> 00:11:11,000
O ponerla estática

193
00:11:11,000 --> 00:11:13,000
O encontrar un método distinto

194
00:11:13,000 --> 00:11:15,000
Pero si es una variable local, no

195
00:11:15,000 --> 00:11:18,000
Este tipo de datos como variables locales

196
00:11:18,000 --> 00:11:20,000
Parámetros de entrada, etc, etc

197
00:11:20,000 --> 00:11:23,000
Estos que tienen una vida relativamente breve

198
00:11:23,000 --> 00:11:26,000
Se guardan en otra zona de memoria

199
00:11:26,000 --> 00:11:28,000
Que es llamada stack

200
00:11:28,000 --> 00:11:30,000
¿Qué es stack?

201
00:11:31,000 --> 00:11:32,000
Fila

202
00:11:32,000 --> 00:11:36,000
¿A qué se refiere con esta pila?

203
00:11:36,000 --> 00:11:38,000
¿Pila de qué?

204
00:11:38,000 --> 00:11:40,000
De procesos, ¿no?

205
00:11:42,000 --> 00:11:44,000
No

206
00:11:46,000 --> 00:11:49,000
Normalmente tiene que ver con el concepto

207
00:11:49,000 --> 00:11:52,000
de pila de llamadas de métodos

208
00:11:52,000 --> 00:11:53,000
¿Sí?

209
00:11:53,000 --> 00:11:55,000
Proceso, cuando yo lanzo el programa

210
00:11:55,000 --> 00:11:57,000
Este es un proceso, un programa en ejecución

211
00:11:57,000 --> 00:11:59,000
Nosotros todavía no tenemos varios procesos

212
00:11:59,000 --> 00:12:01,000
que interaccionan entre ellos

213
00:12:01,000 --> 00:12:02,000
Entonces es uno solo

214
00:12:02,000 --> 00:12:04,000
En los que hacemos nosotros por ahora

215
00:12:04,000 --> 00:12:06,000
Pero sí que llamamos muchos métodos

216
00:12:06,000 --> 00:12:08,000
Y un método puede llamar otro método

217
00:12:08,000 --> 00:12:09,000
Y un método puede llamar otro método

218
00:12:09,000 --> 00:12:10,000
Y un método puede llamar otro método

219
00:12:10,000 --> 00:12:11,000
Y hemos dicho antes

220
00:12:11,000 --> 00:12:13,000
Que si yo declaro una variable int i

221
00:12:13,000 --> 00:12:14,000
Dentro de un método

222
00:12:14,000 --> 00:12:16,000
Esta es local a ese método, a ese bloque

223
00:12:16,000 --> 00:12:18,000
Y cuando se acaba el método

224
00:12:18,000 --> 00:12:19,000
Esa se destruye

225
00:12:19,000 --> 00:12:21,000
¿Y cómo hago a darme cuenta

226
00:12:21,000 --> 00:12:23,000
Si esta i es en este método o no?

227
00:12:23,000 --> 00:12:25,000
Pues lo añado a la stack

228
00:12:25,000 --> 00:12:27,000
A esta pila

229
00:12:27,000 --> 00:12:28,000
¿Llamo un nuevo método?

230
00:12:28,000 --> 00:12:30,000
Añado un nuevo bloque encima de la pila

231
00:12:30,000 --> 00:12:32,000
Y aquí creo sus variables

232
00:12:32,000 --> 00:12:34,000
¿Llamo un otro método?

233
00:12:34,000 --> 00:12:36,000
Añado otro bloque encima de la pila

234
00:12:36,000 --> 00:12:38,000
Y allí añado sus variables locales

235
00:12:38,000 --> 00:12:40,000
Cuando acabo el método

236
00:12:40,000 --> 00:12:42,000
Y por lo tanto

237
00:12:42,000 --> 00:12:44,000
En vez de apilar

238
00:12:44,000 --> 00:12:46,000
Desapilo, quito un bloque

239
00:12:46,000 --> 00:12:48,000
Con él me llevo también

240
00:12:48,000 --> 00:12:50,000
Todas sus variables locales

241
00:12:50,000 --> 00:12:52,000
Por eso no son ya accesibles desde fuera

242
00:12:54,000 --> 00:12:56,000
Estudad

243
00:12:56,000 --> 00:12:58,000
¿Me seguís o no?

244
00:13:02,000 --> 00:13:04,000
Vale

245
00:13:04,000 --> 00:13:06,000
Entonces, al fin y al cabo

246
00:13:06,000 --> 00:13:08,000
Dentro del concepto de Java

247
00:13:08,000 --> 00:13:10,000
Estamos trabajando con dos zonas

248
00:13:10,000 --> 00:13:12,000
De memoria temporal

249
00:13:12,000 --> 00:13:14,000
Memoria no persistente

250
00:13:14,000 --> 00:13:16,000
¿Vale?

251
00:13:16,000 --> 00:13:18,000
El heap que es la que gestiona

252
00:13:18,000 --> 00:13:20,000
Todo lo que es relacionado con los objetos

253
00:13:20,000 --> 00:13:22,000
Y el stack que es lo que relaciona

254
00:13:22,000 --> 00:13:24,000
Los otros tipos de variables

255
00:13:24,000 --> 00:13:26,000
Los variables locales

256
00:13:26,000 --> 00:13:28,000
Son parámetros, etc.

257
00:13:28,000 --> 00:13:30,000
También pensado un parámetro

258
00:13:30,000 --> 00:13:32,000
Una llamada de método con parámetros

259
00:13:32,000 --> 00:13:34,000
Cuando yo llamo cálculo área de 3

260
00:13:36,000 --> 00:13:38,000
Pues este parámetro 3

261
00:13:38,000 --> 00:13:40,000
Tiene que estar guardado por algún lado

262
00:13:40,000 --> 00:13:42,000
Pero cuando yo acabo este método

263
00:13:42,000 --> 00:13:44,000
Este parámetro 3 ya no me sirve de nada

264
00:13:44,000 --> 00:13:46,000
Entonces lo quito

265
00:13:46,000 --> 00:13:48,000
Es algo local también

266
00:13:48,000 --> 00:13:50,000
Dentro del método

267
00:13:50,000 --> 00:13:52,000
Este parámetro me sirve de algo

268
00:13:52,000 --> 00:13:54,000
Lo vimos en primera relación

269
00:13:54,000 --> 00:13:56,000
Si no me equivoco

270
00:13:56,000 --> 00:13:58,000
El concepto de parámetros formales y parámetros actuales

271
00:13:58,000 --> 00:14:00,000
Cuando yo pongo

272
00:14:00,000 --> 00:14:02,000
Método, método 1

273
00:14:02,000 --> 00:14:04,000
Que recibe int x

274
00:14:04,000 --> 00:14:06,000
Y luego aquí hago cosas con x

275
00:14:06,000 --> 00:14:08,000
Ese es un parámetro formal

276
00:14:08,000 --> 00:14:10,000
El parámetro actual es cuando yo llamo

277
00:14:10,000 --> 00:14:12,000
Mi método de 3

278
00:14:12,000 --> 00:14:14,000
Ese es el parámetro actual

279
00:14:14,000 --> 00:14:16,000
Ahora el x que es formal

280
00:14:16,000 --> 00:14:18,000
Ahora actualmente vale 3

281
00:14:22,000 --> 00:14:24,000
Atributos en la programación de objetos

282
00:14:24,000 --> 00:14:26,000
Cuando finaliza el programa

283
00:14:26,000 --> 00:14:28,000
Los datos de los atributos del IP

284
00:14:28,000 --> 00:14:30,000
No persisten

285
00:14:30,000 --> 00:14:32,000
Es decir

286
00:14:32,000 --> 00:14:34,000
Me he quedado todos los objetos del mundo

287
00:14:34,000 --> 00:14:36,000
Acaba el programa

288
00:14:36,000 --> 00:14:38,000
Todo lo que está en el IP lo borro

289
00:14:38,000 --> 00:14:40,000
Pero muchas veces

290
00:14:40,000 --> 00:14:42,000
En un 60%

291
00:14:42,000 --> 00:14:44,000
De los ejercicios un poquito más serios

292
00:14:44,000 --> 00:14:46,000
Que nosotros hemos hecho

293
00:14:46,000 --> 00:14:48,000
Pues me habría gustado que todo lo que he hecho

294
00:14:48,000 --> 00:14:50,000
Se guardara por algún lado

295
00:14:50,000 --> 00:14:52,000
¿Sinceramente por qué?

296
00:14:52,000 --> 00:14:54,000
Porque la vez siguiente que voy a probarlo

297
00:14:54,000 --> 00:14:56,000
Esos datos han desaparecido

298
00:14:56,000 --> 00:14:58,000
Y tengo que volver a ponerlo

299
00:14:58,000 --> 00:15:00,000
En uno de los problemas de examen

300
00:15:00,000 --> 00:15:02,000
Que tengo poco tiempo

301
00:15:02,000 --> 00:15:04,000
Y me pongo allí y digo

302
00:15:04,000 --> 00:15:06,000
Pruebo mi programa a ver si funciona

303
00:15:06,000 --> 00:15:08,000
Le tengo que añadir 3 alumnos

304
00:15:08,000 --> 00:15:10,000
El nombre del alumno, la idea del alumno

305
00:15:10,000 --> 00:15:12,000
Espera me he equivocado

306
00:15:12,000 --> 00:15:14,000
Si yo estos 3 alumnos

307
00:15:14,000 --> 00:15:16,000
Los tuviera ya allí

308
00:15:16,000 --> 00:15:18,000
Que cada vez que lo arranco

309
00:15:18,000 --> 00:15:20,000
Entonces ¿Qué hacéis vosotros?

310
00:15:20,000 --> 00:15:22,000
Lo que habéis hecho hasta ahora

311
00:15:22,000 --> 00:15:24,000
Pues los incrustáis en el código

312
00:15:24,000 --> 00:15:26,000
El código empieza, crea 3 alumnos

313
00:15:26,000 --> 00:15:28,000
Siempre los mismos 3

314
00:15:28,000 --> 00:15:30,000
Y juego con ellos

315
00:15:30,000 --> 00:15:32,000
Y me ahorro de tener que escribirlo yo 3 veces

316
00:15:32,000 --> 00:15:34,000
Pero es una forma un poquito fea de hacer

317
00:15:34,000 --> 00:15:36,000
¿Vale?

318
00:15:36,000 --> 00:15:38,000
La idea es que como no persisten

319
00:15:38,000 --> 00:15:40,000
Pues vamos a ver como podemos hacerlo persistir

320
00:15:40,000 --> 00:15:42,000
Los lenguajes orientados a objetos

321
00:15:42,000 --> 00:15:44,000
No provienen de ningún

322
00:15:44,000 --> 00:15:46,000
Mecanismo automático de persistencia

323
00:15:46,000 --> 00:15:48,000
¿Vale?

324
00:15:48,000 --> 00:15:50,000
O sea que no hay una forma mágica de decir

325
00:15:50,000 --> 00:15:52,000
Y ahora guárdame todo en el disco duro

326
00:15:52,000 --> 00:15:54,000
¿Si?

327
00:15:54,000 --> 00:15:56,000
Y esto esencialmente

328
00:15:56,000 --> 00:15:58,000
Porque

329
00:15:58,000 --> 00:16:00,000
Puede ser

330
00:16:00,000 --> 00:16:02,000
Delicado

331
00:16:02,000 --> 00:16:04,000
Guardar

332
00:16:04,000 --> 00:16:06,000
Los objetos

333
00:16:06,000 --> 00:16:08,000
Si vosotros pensáis en el objeto

334
00:16:08,000 --> 00:16:10,000
Alumno

335
00:16:10,000 --> 00:16:12,000
Que tiene nombre, edad

336
00:16:12,000 --> 00:16:14,000
Guardarlo

337
00:16:14,000 --> 00:16:16,000
Relativamente sencillo

338
00:16:16,000 --> 00:16:18,000
No tiene gran problema

339
00:16:18,000 --> 00:16:20,000
Si, pero pensáis

340
00:16:20,000 --> 00:16:22,000
Al

341
00:16:22,000 --> 00:16:24,000
Al objeto

342
00:16:24,000 --> 00:16:26,000
Escuela

343
00:16:26,000 --> 00:16:28,000
Que dentro tiene una lista

344
00:16:28,000 --> 00:16:30,000
De materia

345
00:16:30,000 --> 00:16:32,000
Que son objetos

346
00:16:32,000 --> 00:16:34,000
Y dentro de materia tenéis

347
00:16:34,000 --> 00:16:36,000
Luego tiene una

348
00:16:36,000 --> 00:16:38,000
Rey de profesores

349
00:16:38,000 --> 00:16:40,000
Y luego tiene un

350
00:16:40,000 --> 00:16:42,000
Set de alumnos

351
00:16:42,000 --> 00:16:44,000
Y ahora

352
00:16:44,000 --> 00:16:46,000
Esta escuela la queréis

353
00:16:46,000 --> 00:16:48,000
Guardar

354
00:16:48,000 --> 00:16:50,000
Ya es un poquito más complicado

355
00:16:50,000 --> 00:16:52,000
Porque no estáis guardando solo escuela

356
00:16:52,000 --> 00:16:54,000
Deberíais guardar también todos los objetos

357
00:16:54,000 --> 00:16:56,000
Dentro de escuela

358
00:16:56,000 --> 00:16:58,000
Y las referencias

359
00:16:58,000 --> 00:17:00,000
Hacia este objeto

360
00:17:00,000 --> 00:17:02,000
Entonces esto se complica

361
00:17:02,000 --> 00:17:04,000
Justo

362
00:17:04,000 --> 00:17:06,000
Vale

363
00:17:06,000 --> 00:17:08,000
Entonces

364
00:17:08,000 --> 00:17:10,000
Digamos que nosotros programadores

365
00:17:10,000 --> 00:17:12,000
Vamos un poquito detrás de cual es la forma

366
00:17:12,000 --> 00:17:14,000
Correcta de mi sistema

367
00:17:14,000 --> 00:17:16,000
Guardar la información

368
00:17:16,000 --> 00:17:18,000
Que quiero guardar

369
00:17:18,000 --> 00:17:20,000
Entonces como se almacenan los datos

370
00:17:20,000 --> 00:17:22,000
Para conservar el valor de un dato

371
00:17:22,000 --> 00:17:24,000
En un dispositivo de almacenamiento como un disco duro

372
00:17:24,000 --> 00:17:26,000
Se puede hacer

373
00:17:26,000 --> 00:17:28,000
De varias maneras

374
00:17:28,000 --> 00:17:30,000
Nosotros

375
00:17:30,000 --> 00:17:32,000
Echaremos un vistazo principalmente

376
00:17:32,000 --> 00:17:34,000
A dos

377
00:17:34,000 --> 00:17:36,000
Luego ya veremos la tercera

378
00:17:36,000 --> 00:17:38,000
Primero es creando un archivo

379
00:17:38,000 --> 00:17:40,000
Escribiendo en él datos en modo row

380
00:17:40,000 --> 00:17:42,000
Es decir

381
00:17:42,000 --> 00:17:44,000
Guardo los datos

382
00:17:44,000 --> 00:17:46,000
Tal y como son

383
00:17:46,000 --> 00:17:48,000
Hay el nombre del alumno

384
00:17:48,000 --> 00:17:50,000
Escribo el nombre del alumno

385
00:17:50,000 --> 00:17:52,000
Estefano

386
00:17:52,000 --> 00:17:54,000
Luego la edad del alumno

387
00:17:54,000 --> 00:17:56,000
Pues le pongo 37 detrás

388
00:18:02,000 --> 00:18:04,000
Voy escribiendo yo los datos

389
00:18:04,000 --> 00:18:06,000
De forma por ejemplo de texto

390
00:18:06,000 --> 00:18:08,000
Entonces me creo

391
00:18:08,000 --> 00:18:10,000
Una cadena

392
00:18:10,000 --> 00:18:12,000
Hicimos un ejercicio hace mucho tiempo

393
00:18:12,000 --> 00:18:14,000
En que se daba una cadena

394
00:18:14,000 --> 00:18:16,000
Y desde esta cadena se sacaban los datos

395
00:18:16,000 --> 00:18:18,000
Cuando trabajábamos todavía

396
00:18:18,000 --> 00:18:20,000
Eramos pequeños

397
00:18:20,000 --> 00:18:22,000
Y trabajábamos con las strings

398
00:18:22,000 --> 00:18:24,000
Tú por ejemplo

399
00:18:24,000 --> 00:18:26,000
Pones todos los datos de tu objeto

400
00:18:26,000 --> 00:18:28,000
Separados por dos puntos

401
00:18:28,000 --> 00:18:30,000
El último

402
00:18:30,000 --> 00:18:32,000
Cuando hayas acabado el objeto

403
00:18:32,000 --> 00:18:34,000
Le pones un punto para decir

404
00:18:34,000 --> 00:18:36,000
Y lo que harás es que cuando luego

405
00:18:36,000 --> 00:18:38,000
Este string

406
00:18:38,000 --> 00:18:40,000
La guardas en un fichero

407
00:18:40,000 --> 00:18:42,000
Que si tú abres el fichero

408
00:18:42,000 --> 00:18:44,000
Lo puedes leer

409
00:18:44,000 --> 00:18:46,000
Y cuando tú quieres

410
00:18:46,000 --> 00:18:48,000
Volver a cargar

411
00:18:48,000 --> 00:18:50,000
Ese objeto

412
00:18:50,000 --> 00:18:52,000
Lo que haces es leerte el string

413
00:18:52,000 --> 00:18:54,000
Dividirlo cada vez que encuentras dos puntos

414
00:18:54,000 --> 00:18:56,000
Este era un dato, este es otro dato

415
00:18:56,000 --> 00:18:58,000
Cuando encuentras el punto

416
00:18:58,000 --> 00:19:00,000
Has acabado de sacar

417
00:19:00,000 --> 00:19:02,000
Los datos distintos

418
00:19:02,000 --> 00:19:04,000
Tienes los datos con un determinado formado

419
00:19:04,000 --> 00:19:06,000
Antes el nombre, luego la edad

420
00:19:06,000 --> 00:19:08,000
Luego no sé qué, luego no sé cuánto

421
00:19:08,000 --> 00:19:10,000
Y eso creas un nuevo objeto con una new

422
00:19:10,000 --> 00:19:12,000
Pasándole los datos que estaban escritos ahí

423
00:19:12,000 --> 00:19:14,000
¿Se entiende la idea?

424
00:19:18,000 --> 00:19:20,000
Es un cierto sentido

425
00:19:20,000 --> 00:19:22,000
Hacer un toString

426
00:19:22,000 --> 00:19:24,000
¿Vale?

427
00:19:24,000 --> 00:19:26,000
Donde en vez de imprimir

428
00:19:26,000 --> 00:19:28,000
Por pantalla todos los datos

429
00:19:28,000 --> 00:19:30,000
De un objeto

430
00:19:30,000 --> 00:19:32,000
Lo que hago es imprimirlos en un fichero

431
00:19:32,000 --> 00:19:34,000
Así que me los tenga allí

432
00:19:34,000 --> 00:19:36,000
Cuando en un futuro me vaya a leer

433
00:19:36,000 --> 00:19:38,000
Esos datos, con esos datos

434
00:19:38,000 --> 00:19:40,000
Puedo volver a crear una nueva instancia

435
00:19:40,000 --> 00:19:42,000
Que pero tiene

436
00:19:42,000 --> 00:19:44,000
Todos los datos de la vieja instancia

437
00:19:44,000 --> 00:19:46,000
Por lo tanto, como objeto

438
00:19:46,000 --> 00:19:48,000
Es un objeto nuevo, pero que me vale como el viejo

439
00:19:50,000 --> 00:19:52,000
¿Qué cambiaría?

440
00:19:52,000 --> 00:19:54,000
¿Qué cambiaría?

441
00:20:00,000 --> 00:20:02,000
La referencia en memoria

442
00:20:02,000 --> 00:20:04,000
Lo que da el toString de object

443
00:20:04,000 --> 00:20:06,000
¿Sí?

444
00:20:06,000 --> 00:20:08,000
Cuando se hace el toString de object

445
00:20:08,000 --> 00:20:10,000
Se da clase, arroba y un numerito

446
00:20:10,000 --> 00:20:12,000
Pues ese numerito posiblemente cambiaría

447
00:20:12,000 --> 00:20:14,000
Pero

448
00:20:14,000 --> 00:20:16,000
En mi sistema ese numerito casi no lo uso

449
00:20:16,000 --> 00:20:18,000
¿Vale?

450
00:20:18,000 --> 00:20:20,000
Cuando yo gestiono un alumno ese numerito no me sirve

451
00:20:20,000 --> 00:20:22,000
Es el alumno por si mismo

452
00:20:22,000 --> 00:20:24,000
Con su nombre, apellido, etc.

453
00:20:24,000 --> 00:20:26,000
¿Sí?

454
00:20:26,000 --> 00:20:28,000
Es una forma de jugar con ello, lo haremos

455
00:20:28,000 --> 00:20:30,000
Si yo mi objeto lo guardo allí

456
00:20:30,000 --> 00:20:32,000
¿Dónde se complica esto?

457
00:20:32,000 --> 00:20:34,000
En si uno de los atributos

458
00:20:34,000 --> 00:20:36,000
De mi

459
00:20:38,000 --> 00:20:40,000
De mi objeto que estoy guardando

460
00:20:40,000 --> 00:20:42,000
No es un tipo primitivo

461
00:20:42,000 --> 00:20:44,000
Si no es otro objeto

462
00:20:44,000 --> 00:20:46,000
Entonces tengo que ver

463
00:20:46,000 --> 00:20:48,000
Como lo hago

464
00:20:48,000 --> 00:20:50,000
Podría a su vez

465
00:20:50,000 --> 00:20:52,000
Guardar toda la información de esto

466
00:20:52,000 --> 00:20:54,000
O guardar un numerito

467
00:20:54,000 --> 00:20:56,000
Un identificador

468
00:20:56,000 --> 00:20:58,000
Que luego me haga referencia a otro objeto

469
00:20:58,000 --> 00:21:00,000
Que está más adelante en el

470
00:21:00,000 --> 00:21:02,000
Fichero

471
00:21:02,000 --> 00:21:04,000
Que yo tendré que crear

472
00:21:04,000 --> 00:21:06,000
Antes este objeto de abajo

473
00:21:06,000 --> 00:21:08,000
Y luego cuando voy a crear el objeto este de arriba

474
00:21:08,000 --> 00:21:10,000
Poner que este link

475
00:21:10,000 --> 00:21:12,000
Se complica la cosa

476
00:21:12,000 --> 00:21:14,000
¿Dudas?

477
00:21:14,000 --> 00:21:16,000
Sobre el primer método

478
00:21:16,000 --> 00:21:18,000
Texto

479
00:21:18,000 --> 00:21:20,000
Segundo método

480
00:21:20,000 --> 00:21:22,000
Pidiéndole a la Java Virtual Machine

481
00:21:22,000 --> 00:21:24,000
Que almacene todos los datos del objeto

482
00:21:24,000 --> 00:21:26,000
En un archivo, pero dejando que gestione

483
00:21:26,000 --> 00:21:28,000
La propia Java Virtual Machine

484
00:21:28,000 --> 00:21:30,000
El formato

485
00:21:30,000 --> 00:21:32,000
Es decir, oye Java Virtual Machine

486
00:21:32,000 --> 00:21:34,000
Yo quiero guardar este objeto

487
00:21:34,000 --> 00:21:36,000
Tú lo tienes almacenado de alguna forma

488
00:21:36,000 --> 00:21:38,000
Pues almacénalo, hazme magia

489
00:21:38,000 --> 00:21:40,000
¿Vale?

490
00:21:40,000 --> 00:21:42,000
Esto tiene que ver con lo que se llama

491
00:21:42,000 --> 00:21:44,000
La serialización

492
00:21:44,000 --> 00:21:46,000
Y la interfaz

493
00:21:46,000 --> 00:21:48,000
Serializable

494
00:21:52,000 --> 00:21:54,000
Serializable

495
00:21:54,000 --> 00:21:56,000
Si un objeto es serializable

496
00:21:56,000 --> 00:21:58,000
Quiere decir que se puede transformar

497
00:21:58,000 --> 00:22:00,000
En una secuencia de bytes

498
00:22:02,000 --> 00:22:04,000
Y si yo consigo transformar un objeto

499
00:22:04,000 --> 00:22:06,000
En una secuencia de bytes

500
00:22:06,000 --> 00:22:08,000
Lo puedo disparar dentro de un flujo de información

501
00:22:08,000 --> 00:22:10,000
Hacia un fichero por ejemplo

502
00:22:10,000 --> 00:22:12,000
O leerlo

503
00:22:12,000 --> 00:22:14,000
¿Vale?

504
00:22:14,000 --> 00:22:16,000
Entonces la idea es, mira Java Virtual Machine

505
00:22:16,000 --> 00:22:18,000
Tú tienes los datos almacenados de alguna forma

506
00:22:18,000 --> 00:22:20,000
Léelos, y los mismos datos que estás leyendo

507
00:22:20,000 --> 00:22:22,000
Los guardas en un fichero

508
00:22:22,000 --> 00:22:24,000
En un futuro yo diría a la Java Virtual Machine

509
00:22:24,000 --> 00:22:26,000
Mira

510
00:22:26,000 --> 00:22:28,000
Una ejecución de la Java Virtual Machine

511
00:22:28,000 --> 00:22:30,000
Anterior

512
00:22:30,000 --> 00:22:32,000
Ha guardado los datos aquí

513
00:22:32,000 --> 00:22:34,000
Vete a releerlos

514
00:22:34,000 --> 00:22:36,000
Y como lo guardas con tu mismo formato

515
00:22:36,000 --> 00:22:38,000
Porque ha sido tú que lo has guardado

516
00:22:38,000 --> 00:22:40,000
O sea, tu hermana que se ha ejecutado antes

517
00:22:40,000 --> 00:22:42,000
Pues ahora lo sabes entender

518
00:22:42,000 --> 00:22:44,000
Este formato, y me construyes un objeto

519
00:22:44,000 --> 00:22:46,000
Parecido a ese

520
00:22:46,000 --> 00:22:48,000
¿Vale?

521
00:22:48,000 --> 00:22:50,000
Esto también tiene sus limitaciones

522
00:22:52,000 --> 00:22:54,000
Y luego se nos da

523
00:22:54,000 --> 00:22:56,000
Sistema gestor de base de datos

524
00:22:56,000 --> 00:22:58,000
Yo me creo una base de datos

525
00:22:58,000 --> 00:23:00,000
Que tenga una tabla

526
00:23:00,000 --> 00:23:02,000
Que más o menos refleje

527
00:23:02,000 --> 00:23:04,000
La información que yo tengo

528
00:23:04,000 --> 00:23:06,000
En mis objetos, por ejemplo

529
00:23:06,000 --> 00:23:08,000
La tabla alumnos tendrá

530
00:23:08,000 --> 00:23:10,000
Apellido, edad

531
00:23:10,000 --> 00:23:12,000
Identificador, y que se yo

532
00:23:12,000 --> 00:23:14,000
Y lo que hago es que cuando voy a guardar

533
00:23:14,000 --> 00:23:16,000
Me conecto con esta base de datos

534
00:23:16,000 --> 00:23:18,000
Hago una

535
00:23:18,000 --> 00:23:20,000
Sentencia SQL de insert

536
00:23:20,000 --> 00:23:22,000
Donde le doy los datos que tiene que hacer

537
00:23:22,000 --> 00:23:24,000
Y me está guardando los datos relevantes

538
00:23:24,000 --> 00:23:26,000
De este objeto en la base de datos

539
00:23:26,000 --> 00:23:28,000
Cuando querré sacar

540
00:23:28,000 --> 00:23:30,000
Esta información voy a hacer

541
00:23:30,000 --> 00:23:32,000
Una SQL

542
00:23:32,000 --> 00:23:34,000
A la base de datos

543
00:23:34,000 --> 00:23:36,000
La base de datos me procesará esa SQL

544
00:23:36,000 --> 00:23:38,000
Me dará un conjunto de records

545
00:23:38,000 --> 00:23:40,000
Un conjunto de

546
00:23:40,000 --> 00:23:42,000
Respuestas

547
00:23:42,000 --> 00:23:44,000
¿No?

548
00:23:44,000 --> 00:23:46,000
De registros

549
00:23:46,000 --> 00:23:48,000
Que corresponden a mi query

550
00:23:48,000 --> 00:23:50,000
Y me lo devolverá

551
00:23:50,000 --> 00:23:52,000
En formato de una lista de objetos

552
00:23:52,000 --> 00:23:54,000
De algún tipo

553
00:23:54,000 --> 00:23:56,000
Y yo iré mirando allí dentro

554
00:23:56,000 --> 00:23:58,000
Sacando los datos y si quiero

555
00:23:58,000 --> 00:24:00,000
Creándome los objetos

556
00:24:00,000 --> 00:24:02,000
Y procesándolos

557
00:24:02,000 --> 00:24:04,000
¿Si?

558
00:24:04,000 --> 00:24:06,000
En realidad

559
00:24:06,000 --> 00:24:08,000
Hoy en día

560
00:24:08,000 --> 00:24:10,000
No se usa ninguno

561
00:24:10,000 --> 00:24:12,000
De los tres

562
00:24:12,000 --> 00:24:14,000
Métodos concretamente

563
00:24:14,000 --> 00:24:16,000
Para persistencia de objetos

564
00:24:16,000 --> 00:24:18,000
¿Vale?

565
00:24:18,000 --> 00:24:20,000
Se usan cosas más avanzadas

566
00:24:20,000 --> 00:24:22,000
Que son framework

567
00:24:22,000 --> 00:24:24,000
Son

568
00:24:24,000 --> 00:24:26,000
Conjuntos de

569
00:24:26,000 --> 00:24:28,000
Librerías

570
00:24:28,000 --> 00:24:30,000
De métodos

571
00:24:30,000 --> 00:24:32,000
Y de opciones

572
00:24:32,000 --> 00:24:34,000
Que tengo por allí

573
00:24:34,000 --> 00:24:36,000
Que me permiten guardar los objetos

574
00:24:36,000 --> 00:24:38,000
De forma más eficaz

575
00:24:38,000 --> 00:24:40,000
Y más interesante

576
00:24:40,000 --> 00:24:42,000
Es un poco

577
00:24:42,000 --> 00:24:44,000
Ocultar

578
00:24:44,000 --> 00:24:46,000
La parte compleja de guardar los objetos

579
00:24:46,000 --> 00:24:48,000
Y cosas por el estilo

580
00:24:48,000 --> 00:24:50,000
Y si lo sé configurar y pierdo tiempo

581
00:24:50,000 --> 00:24:52,000
En hacer las cosas

582
00:24:52,000 --> 00:24:54,000
Bien hechas

583
00:24:54,000 --> 00:24:56,000
Luego guardar y recuperar objetos

584
00:24:56,000 --> 00:24:58,000
Va a ser más fácil

585
00:24:58,000 --> 00:25:00,000
Yo configuro

586
00:25:00,000 --> 00:25:02,000
Una herramienta avanzada

587
00:25:02,000 --> 00:25:04,000
Hecha por otras personas

588
00:25:04,000 --> 00:25:06,000
Y luego la uso

589
00:25:06,000 --> 00:25:08,000
¿Vale? Y esto por ejemplo

590
00:25:08,000 --> 00:25:10,000
No sé si os habéis oído alguna vez

591
00:25:10,000 --> 00:25:12,000
El concepto de hibernate

592
00:25:12,000 --> 00:25:14,000
¿Vale? Hibernate

593
00:25:14,000 --> 00:25:16,000
¿Si? ¿Habéis visto?

594
00:25:16,000 --> 00:25:18,000
No

595
00:25:18,000 --> 00:25:20,000
El próximo año

596
00:25:20,000 --> 00:25:22,000
Posiblemente

597
00:25:22,000 --> 00:25:24,000
Seguramente

598
00:25:24,000 --> 00:25:26,000
No lo sé

599
00:25:26,000 --> 00:25:28,000
Pero es posible que se vea

600
00:25:28,000 --> 00:25:30,000
También en

601
00:25:30,000 --> 00:25:32,000
Un entorno servidor

602
00:25:32,000 --> 00:25:34,000
No lo sé

603
00:25:34,000 --> 00:25:36,000
Pero es posible que surja

604
00:25:36,000 --> 00:25:38,000
Porque es una tecnología que se usa

605
00:25:38,000 --> 00:25:40,000
No es la única

606
00:25:40,000 --> 00:25:42,000
Pero es lo de siempre

607
00:25:42,000 --> 00:25:44,000
A nosotros nos interesa

608
00:25:44,000 --> 00:25:46,000
Empezar por lo fácil

609
00:25:46,000 --> 00:25:48,000
Y lo bajo nivel

610
00:25:48,000 --> 00:25:50,000
Entender que se está haciendo dentro

611
00:25:50,000 --> 00:25:52,000
Cuáles son los problemas que pueden surgir

612
00:25:52,000 --> 00:25:54,000
Y luego sobre esta base

613
00:25:54,000 --> 00:25:56,000
Cuando ya tenemos la base para poder entender

614
00:25:56,000 --> 00:25:58,000
Pues nos metemos a utilizar las cosas

615
00:25:58,000 --> 00:26:00,000
Lo mismo que hemos hecho con la interfaz gráfica

616
00:26:00,000 --> 00:26:02,000
¿Vale?

617
00:26:02,000 --> 00:26:04,000
Con la interfaz gráfica

618
00:26:04,000 --> 00:26:06,000
Cuando ya más o menos entiendo la filosofía

619
00:26:06,000 --> 00:26:08,000
Pues entonces uso Windows 10

620
00:26:08,000 --> 00:26:10,000
¿Si?

621
00:26:10,000 --> 00:26:12,000
¿Dudas hasta aquí?

622
00:26:14,000 --> 00:26:16,000
Java nos proporciona una clase

623
00:26:16,000 --> 00:26:18,000
Que es la clase File ¿Vale?

624
00:26:18,000 --> 00:26:20,000
La clase File es una abstracción de un fichero

625
00:26:20,000 --> 00:26:22,000
¿Vale?

626
00:26:22,000 --> 00:26:24,000
Normalmente cuando creo una clase File

627
00:26:24,000 --> 00:26:26,000
Tengo una ruta

628
00:26:26,000 --> 00:26:28,000
¿Vale?

629
00:26:28,000 --> 00:26:30,000
La ruta donde debería estar este fichero

630
00:26:30,000 --> 00:26:32,000
Si el fichero ya existe

631
00:26:32,000 --> 00:26:34,000
Me hace como un manejador

632
00:26:34,000 --> 00:26:36,000
Un handler, un objeto

633
00:26:36,000 --> 00:26:38,000
Que se relaciona

634
00:26:38,000 --> 00:26:40,000
Con el fichero real

635
00:26:40,000 --> 00:26:42,000
¿Vale?

636
00:26:42,000 --> 00:26:44,000
Y luego yo esto lo usaré para hacer lo que quiera hacer

637
00:26:44,000 --> 00:26:46,000
¿Vale?

638
00:26:46,000 --> 00:26:48,000
Si no existe

639
00:26:48,000 --> 00:26:50,000
File me permite

640
00:26:50,000 --> 00:26:52,000
No recuerdo el método

641
00:26:53,000 --> 00:26:55,000
Pero me permite crear

642
00:26:55,000 --> 00:26:57,000
¿Vale?

643
00:26:57,000 --> 00:26:59,000
Yo puedo crear un fichero y decirle

644
00:26:59,000 --> 00:27:01,000
Este fichero se debe llamar texto.txt

645
00:27:01,000 --> 00:27:03,000
Y estar en esta dirección

646
00:27:03,000 --> 00:27:05,000
¿Vale?

647
00:27:05,000 --> 00:27:07,000
Y puedo preguntar ¿Existe?

648
00:27:07,000 --> 00:27:09,000
Si existe, me da True

649
00:27:09,000 --> 00:27:11,000
Y entonces ya existe, puedo acceder a él

650
00:27:11,000 --> 00:27:13,000
Si no existe, le puedo decir tráemelo

651
00:27:13,000 --> 00:27:15,000
¿Vale?

652
00:27:15,000 --> 00:27:17,000
Puedo crear carpetas

653
00:27:17,000 --> 00:27:19,000
File, si le doy los parámetros correctos

654
00:27:19,000 --> 00:27:21,000
Mkdir

655
00:27:21,000 --> 00:27:23,000
Pues lo que hace es

656
00:27:23,000 --> 00:27:25,000
Me crea una directory

657
00:27:25,000 --> 00:27:27,000
Y luego manejo este fichero

658
00:27:27,000 --> 00:27:29,000
Como si fuera una directory

659
00:27:29,000 --> 00:27:31,000
Le puedo pedir, por ejemplo, dame el listado de lo que tienes

660
00:27:31,000 --> 00:27:33,000
Y cosas por eso

661
00:27:33,000 --> 00:27:35,000
¿Vale?

662
00:27:35,000 --> 00:27:37,000
En general, la clase File

663
00:27:37,000 --> 00:27:39,000
Es una abstracción de un fichero

664
00:27:39,000 --> 00:27:41,000
Que puedo tener en mi sistema

665
00:27:41,000 --> 00:27:43,000
De almacenamiento

666
00:27:43,000 --> 00:27:45,000
A largo plazo

667
00:27:45,000 --> 00:27:47,000
En mi disco 2

668
00:27:47,000 --> 00:27:49,000
En mi file system

669
00:27:49,000 --> 00:27:51,000
Y me sirve para luego poder

670
00:27:51,000 --> 00:27:53,000
Conectar a este fichero

671
00:27:53,000 --> 00:27:55,000
Un flujo de lectura

672
00:27:55,000 --> 00:27:57,000
O un flujo de escritura

673
00:27:57,000 --> 00:27:59,000
De datos

674
00:27:59,000 --> 00:28:01,000
En Java

675
00:28:01,000 --> 00:28:03,000
Lo que creamos normalmente

676
00:28:03,000 --> 00:28:05,000
Son flujos de informaciones

677
00:28:05,000 --> 00:28:07,000
¿Vale?

678
00:28:07,000 --> 00:28:09,000
Este flujo puede ser

679
00:28:09,000 --> 00:28:11,000
Desde no se donde

680
00:28:11,000 --> 00:28:13,000
Hacia el fichero

681
00:28:13,000 --> 00:28:15,000
Entonces será en escritura

682
00:28:15,000 --> 00:28:17,000
O desde el fichero

683
00:28:17,000 --> 00:28:19,000
Hacia no se donde

684
00:28:19,000 --> 00:28:21,000
Quien lo está pidiendo

685
00:28:21,000 --> 00:28:23,000
Entonces sería en lectura

686
00:28:23,000 --> 00:28:25,000
¿Vale?

687
00:28:25,000 --> 00:28:27,000
La forma más baja

688
00:28:27,000 --> 00:28:29,000
La forma más

689
00:28:29,000 --> 00:28:31,000
Digamos

690
00:28:31,000 --> 00:28:33,000
De bajo nivel

691
00:28:33,000 --> 00:28:35,000
Más cercana

692
00:28:35,000 --> 00:28:37,000
A lo que es el hardware

693
00:28:37,000 --> 00:28:39,000
Que podemos encontrar

694
00:28:39,000 --> 00:28:41,000
Es el input stream

695
00:28:41,000 --> 00:28:43,000
El input stream

696
00:28:43,000 --> 00:28:45,000
Es un stream

697
00:28:45,000 --> 00:28:47,000
Un fuente

698
00:28:47,000 --> 00:28:49,000
En input

699
00:28:49,000 --> 00:28:51,000
Este de aquí cuando yo creo esto

700
00:28:51,000 --> 00:28:53,000
Me estoy creando un tubo

701
00:28:53,000 --> 00:28:55,000
Por el que vendrán bits

702
00:28:55,000 --> 00:28:57,000
Desde el fichero

703
00:28:57,000 --> 00:28:59,000
Por ejemplo si está conectado a un fichero

704
00:28:59,000 --> 00:29:01,000
En realidad este es más amplio

705
00:29:01,000 --> 00:29:03,000
No se habla solo de ficheros

706
00:29:03,000 --> 00:29:05,000
Se puede hablar por ejemplo

707
00:29:05,000 --> 00:29:07,000
De una conexión en red

708
00:29:07,000 --> 00:29:09,000
Si yo creo lo que se llama un socket

709
00:29:09,000 --> 00:29:11,000
De conexión entre dos dispositivos

710
00:29:11,000 --> 00:29:13,000
Luego yo en el socket

711
00:29:13,000 --> 00:29:15,000
Para leer lo que este ordenador

712
00:29:15,000 --> 00:29:17,000
Me está mandando por internet

713
00:29:17,000 --> 00:29:19,000
O podría ser

714
00:29:19,000 --> 00:29:21,000
En vez de un fichero

715
00:29:21,000 --> 00:29:23,000
Por ejemplo el teclado

716
00:29:29,000 --> 00:29:31,000
¿Qué es System.in?

717
00:29:35,000 --> 00:29:37,000
No os lo digo porque

718
00:29:37,000 --> 00:29:39,000
Todos habéis ido a mirar

719
00:29:39,000 --> 00:29:41,000
En

720
00:29:41,000 --> 00:29:43,000
En la API

721
00:29:43,000 --> 00:29:45,000
La clase System

722
00:29:45,000 --> 00:29:47,000
Porque con la S mayúscula

723
00:29:47,000 --> 00:29:49,000
Me suena a clase

724
00:29:49,000 --> 00:29:51,000
Y habéis visto

725
00:29:51,000 --> 00:29:53,000
El atributo in de System

726
00:29:53,000 --> 00:29:55,000
Que es

727
00:29:55,000 --> 00:29:57,000
¿Qué tipo tiene?

728
00:29:57,000 --> 00:29:59,000
Por lo tanto ¿Por qué el ruedo?

729
00:29:59,000 --> 00:30:01,000
¿Tipo input?

730
00:30:01,000 --> 00:30:03,000
No lo sé

731
00:30:03,000 --> 00:30:05,000
Entonces

732
00:30:05,000 --> 00:30:07,000
El input stream es esto

733
00:30:07,000 --> 00:30:09,000
Es un tubo por el que vienen bits

734
00:30:09,000 --> 00:30:11,000
Lo que pasa es que yo puedo leer bits

735
00:30:11,000 --> 00:30:13,000
¿Y qué hay al otro lado?

736
00:30:13,000 --> 00:30:15,000
¿Hay un entero?

737
00:30:15,000 --> 00:30:17,000
Pues no, yo leo bits

738
00:30:17,000 --> 00:30:19,000
¿Hay un string?

739
00:30:19,000 --> 00:30:21,000
Pues no, yo leo bits

740
00:30:21,000 --> 00:30:23,000
Eso no me quita que

741
00:30:23,000 --> 00:30:25,000
Puedo leer un montón de bits

742
00:30:25,000 --> 00:30:27,000
Y luego decirle

743
00:30:27,000 --> 00:30:29,000
Todos los bits que has leído

744
00:30:29,000 --> 00:30:31,000
Interpretándolo como un entero

745
00:30:31,000 --> 00:30:33,000
Yo sé que un entero

746
00:30:33,000 --> 00:30:35,000
¿Cuántos bits son?

747
00:30:39,000 --> 00:30:41,000
4 bytes

748
00:30:41,000 --> 00:30:43,000
Entonces si yo quiero leer un entero

749
00:30:43,000 --> 00:30:45,000
Leo 4 bytes

750
00:30:45,000 --> 00:30:47,000
Y luego le digo todos los que has leído ahora

751
00:30:47,000 --> 00:30:49,000
Estos 4 por 8 bits

752
00:30:49,000 --> 00:30:51,000
Que tengo

753
00:30:51,000 --> 00:30:53,000
Pues interpretándolo como un entero

754
00:30:53,000 --> 00:30:55,000
Con un cast

755
00:30:55,000 --> 00:30:57,000
Se puede hacer

756
00:30:57,000 --> 00:30:59,000
Pero es un poco engordoso

757
00:30:59,000 --> 00:31:01,000
¿Sí?

758
00:31:01,000 --> 00:31:03,000
Ahora, si yo no tengo datos

759
00:31:03,000 --> 00:31:05,000
Reales en el

760
00:31:05,000 --> 00:31:07,000
¿Sabes?

761
00:31:07,000 --> 00:31:09,000
No tengo datos que son

762
00:31:09,000 --> 00:31:11,000
Tipos primitivos, objetos

763
00:31:11,000 --> 00:31:13,000
O algo por el estilo

764
00:31:13,000 --> 00:31:15,000
Dentro del fichero

765
00:31:15,000 --> 00:31:17,000
Si no, por ejemplo, tengo un fichero ejecutable

766
00:31:17,000 --> 00:31:19,000
Fichero ejecutable es un fichero

767
00:31:19,000 --> 00:31:21,000
Que se ha ejecutado

768
00:31:21,000 --> 00:31:23,000
Y dentro hay unos y ceros

769
00:31:23,000 --> 00:31:25,000
Que los interpreta el procesador

770
00:31:25,000 --> 00:31:27,000
El procesador es capaz de interpretar esos unos y ceros

771
00:31:27,000 --> 00:31:29,000
Pero yo no, yo como ser humano

772
00:31:29,000 --> 00:31:31,000
No sé qué son

773
00:31:31,000 --> 00:31:33,000
Y tengo que copiar ese fichero, por ejemplo

774
00:31:33,000 --> 00:31:35,000
Al leerlo

775
00:31:35,000 --> 00:31:37,000
No lo puedo leer como enteros

776
00:31:37,000 --> 00:31:39,000
Lo puedo leer como objetos

777
00:31:39,000 --> 00:31:41,000
Lo tengo que leer

778
00:31:41,000 --> 00:31:43,000
Como bytes

779
00:31:43,000 --> 00:31:45,000
Entonces, por ejemplo, si yo quiero

780
00:31:45,000 --> 00:31:47,000
Copiar un fichero

781
00:31:47,000 --> 00:31:49,000
Y que sea cualquier fichero

782
00:31:49,000 --> 00:31:51,000
Lo voy a leer así

783
00:31:51,000 --> 00:31:53,000
Porque me da igual

784
00:31:53,000 --> 00:31:55,000
Que sea un fichero de texto, que sea una imagen

785
00:31:55,000 --> 00:31:57,000
Que sea un fichero exe

786
00:31:57,000 --> 00:31:59,000
Que sea un fichero de audio

787
00:31:59,000 --> 00:32:01,000
Voy a copiar los bytes que están escritos aquí

788
00:32:01,000 --> 00:32:03,000
Y los copio en otro trozo de memoria

789
00:32:03,000 --> 00:32:05,000
Ya está

790
00:32:05,000 --> 00:32:07,000
Si yo empezara

791
00:32:07,000 --> 00:32:09,000
Estos a interpretarlos como otra cosa

792
00:32:09,000 --> 00:32:11,000
Pues entonces podría tener problemas

793
00:32:11,000 --> 00:32:13,000
Porque si intento leer

794
00:32:13,000 --> 00:32:15,000
Letras en un fichero audio

795
00:32:17,000 --> 00:32:19,000
No funciona

796
00:32:19,000 --> 00:32:21,000
¿Habéis abierto alguna vez

797
00:32:21,000 --> 00:32:23,000
Un fichero doc

798
00:32:23,000 --> 00:32:25,000
Con glocknotes?

799
00:32:29,000 --> 00:32:31,000
Probadlo

800
00:32:31,000 --> 00:32:33,000
Recibo

801
00:32:33,000 --> 00:32:35,000
Los datos

802
00:32:35,000 --> 00:32:37,000
Del fichero doc

803
00:32:37,000 --> 00:32:39,000
No lo interpreto como

804
00:32:39,000 --> 00:32:41,000
Lo interpretaría Word

805
00:32:41,000 --> 00:32:43,000
Sino lo interpreto como carácter a carácter

806
00:32:43,000 --> 00:32:45,000
Y me salen cosas raras

807
00:32:49,000 --> 00:32:51,000
Esto es una forma

808
00:32:51,000 --> 00:32:53,000
De leer un flujo

809
00:32:53,000 --> 00:32:55,000
De información que son sólo bits

810
00:32:55,000 --> 00:32:57,000
Voy leyendo bit a bit o byte a byte

811
00:32:57,000 --> 00:32:59,000
¿Qué pasa?

812
00:33:01,000 --> 00:33:03,000
¿Qué pasa si yo sé

813
00:33:03,000 --> 00:33:05,000
Que me estoy conectando

814
00:33:05,000 --> 00:33:07,000
Quiero tener un flujo de información

815
00:33:07,000 --> 00:33:09,000
Pero con un fichero que es de texto

816
00:33:09,000 --> 00:33:11,000
Sé que el fichero es de texto

817
00:33:11,000 --> 00:33:13,000
Es un fichero lleno de carácter

818
00:33:13,000 --> 00:33:15,000
¿Tengo de verdad

819
00:33:15,000 --> 00:33:17,000
Que molestarme a leer

820
00:33:17,000 --> 00:33:19,000
Bit por bit

821
00:33:19,000 --> 00:33:21,000
Y una vez leído estos bits

822
00:33:21,000 --> 00:33:23,000
Convertirlos a una letra

823
00:33:23,000 --> 00:33:25,000
Leo 8 bits

824
00:33:25,000 --> 00:33:27,000
¿Este qué es?

825
00:33:27,000 --> 00:33:29,000
La F

826
00:33:29,000 --> 00:33:31,000
África

827
00:33:33,000 --> 00:33:35,000
Pues no

828
00:33:35,000 --> 00:33:37,000
Hay una forma de decir

829
00:33:37,000 --> 00:33:39,000
En vez de estar tan a bajo nivel

830
00:33:39,000 --> 00:33:41,000
Subo un poquito de nivel

831
00:33:41,000 --> 00:33:43,000
Y miro un input stream

832
00:33:43,000 --> 00:33:45,000
Reader

833
00:33:45,000 --> 00:33:47,000
Cuando tengo reader

834
00:33:47,000 --> 00:33:49,000
Estoy trabajando con carácter

835
00:33:51,000 --> 00:33:53,000
Este señor de aquí

836
00:33:53,000 --> 00:33:55,000
Tiene métodos especiales

837
00:33:55,000 --> 00:33:57,000
Para leer directamente carácteres

838
00:34:01,000 --> 00:34:03,000
Entonces

839
00:34:03,000 --> 00:34:05,000
En vez de decir

840
00:34:05,000 --> 00:34:07,000
Lea algo y me llegará un array de bytes

841
00:34:07,000 --> 00:34:09,000
Por ejemplo

842
00:34:09,000 --> 00:34:11,000
Ahora puedo decirle

843
00:34:11,000 --> 00:34:13,000
Lea algo y me llegue un array de carácteres

844
00:34:15,000 --> 00:34:17,000
Stream

845
00:34:17,000 --> 00:34:19,000
¿Sí?

846
00:34:19,000 --> 00:34:21,000
Entonces

847
00:34:21,000 --> 00:34:23,000
¿Tengo un fichero de texto?

848
00:34:23,000 --> 00:34:25,000
¿Estoy trabajando con fichero de texto?

849
00:34:25,000 --> 00:34:27,000
Reader

850
00:34:27,000 --> 00:34:29,000
Me da algunos métodos que input stream

851
00:34:29,000 --> 00:34:31,000
No tiene

852
00:34:31,000 --> 00:34:33,000
Que me permiten trabajar directamente con carácter

853
00:34:33,000 --> 00:34:35,000
Trabajar con strings

854
00:34:35,000 --> 00:34:37,000
Mientras que input stream

855
00:34:37,000 --> 00:34:39,000
No, input stream solo tiene los métodos

856
00:34:39,000 --> 00:34:41,000
Relacionados con leer bytes

857
00:34:41,000 --> 00:34:43,000
¿Entiende la diferencia?

858
00:34:43,000 --> 00:34:45,000
Por debajo es lo mismo

859
00:34:45,000 --> 00:34:47,000
Esto por debajo

860
00:34:47,000 --> 00:34:49,000
Solo que hacen automático

861
00:34:49,000 --> 00:34:51,000
La interpretación

862
00:34:53,000 --> 00:34:55,000
Dentro de este mundo

863
00:34:55,000 --> 00:34:57,000
De aquí

864
00:34:57,000 --> 00:34:59,000
Existen los señores

865
00:34:59,000 --> 00:35:01,000
File input stream y file reader

866
00:35:01,000 --> 00:35:03,000
Que son los canales

867
00:35:03,000 --> 00:35:05,000
Los flujos de información

868
00:35:05,000 --> 00:35:07,000
Adaptados

869
00:35:07,000 --> 00:35:09,000
A poder leer desde un fichero

870
00:35:09,000 --> 00:35:11,000
¿Sí?

871
00:35:11,000 --> 00:35:13,000
Hemos dicho que estos

872
00:35:13,000 --> 00:35:15,000
Podría ser

873
00:35:15,000 --> 00:35:17,000
Que es una comunicación en red

874
00:35:17,000 --> 00:35:19,000
A través de un socket

875
00:35:19,000 --> 00:35:21,000
O podría ser leer de teclado

876
00:35:21,000 --> 00:35:23,000
O podría ser escribir en pantalla

877
00:35:23,000 --> 00:35:25,000
Bueno, escribir no

878
00:35:25,000 --> 00:35:27,000
Pero recibir datos

879
00:35:27,000 --> 00:35:29,000
Desde cualquier tipo de cosa

880
00:35:29,000 --> 00:35:31,000
¿Vale?

881
00:35:31,000 --> 00:35:33,000
Este de aquí está especializado en

882
00:35:33,000 --> 00:35:35,000
No, lo estás haciendo sobre un fichero

883
00:35:35,000 --> 00:35:37,000
Nosotros cuando trabajaremos

884
00:35:37,000 --> 00:35:39,000
Usaremos estos

885
00:35:39,000 --> 00:35:41,000
Estos si estoy leyendo

886
00:35:41,000 --> 00:35:43,000
Un fichero que es por ejemplo una imagen

887
00:35:43,000 --> 00:35:45,000
Esto si estoy leyendo

888
00:35:45,000 --> 00:35:47,000
Un fichero que es de texto

889
00:35:49,000 --> 00:35:51,000
¿Dudas?

890
00:35:55,000 --> 00:35:57,000
Si procedo en

891
00:35:57,000 --> 00:35:59,000
La abstracción

892
00:35:59,000 --> 00:36:01,000
Puedo llegar hasta mi amigo

893
00:36:01,000 --> 00:36:03,000
El buffer reader

894
00:36:03,000 --> 00:36:05,000
¿Vale?

895
00:36:05,000 --> 00:36:07,000
Es como un reader

896
00:36:07,000 --> 00:36:09,000
Que pero añade además

897
00:36:09,000 --> 00:36:11,000
Un buffer

898
00:36:11,000 --> 00:36:13,000
¿Qué es un buffer?

899
00:36:15,000 --> 00:36:17,000
Buffer es como una memoria temporal

900
00:36:17,000 --> 00:36:19,000
Que se va llenando

901
00:36:19,000 --> 00:36:21,000
¿Sabéis cuando metéis Netflix

902
00:36:21,000 --> 00:36:23,000
Le dais al play y veis un numerito

903
00:36:23,000 --> 00:36:25,000
Que aumenta hasta el 99%

904
00:36:25,000 --> 00:36:27,000
Y luego empieza la película?

905
00:36:27,000 --> 00:36:29,000
Eso es un buffer

906
00:36:29,000 --> 00:36:31,000
Me estoy guardando un trozo de película

907
00:36:31,000 --> 00:36:33,000
Para que si luego hay un poquito de problemas

908
00:36:33,000 --> 00:36:35,000
No se te bloque la película

909
00:36:35,000 --> 00:36:37,000
Cada vez que hay un problema de conexión

910
00:36:37,000 --> 00:36:39,000
Sino que tú tengas un margen

911
00:36:39,000 --> 00:36:41,000
Para que siga la película

912
00:36:41,000 --> 00:36:43,000
Y luego funcione otra vez internet

913
00:36:43,000 --> 00:36:45,000
Y siempre tengo un trozo

914
00:36:45,000 --> 00:36:47,000
De posibilidad de leer

915
00:36:47,000 --> 00:36:49,000
¿Vale?

916
00:36:49,000 --> 00:36:51,000
Eso es un buffer

917
00:36:51,000 --> 00:36:53,000
Es una memoria temporal

918
00:36:53,000 --> 00:36:55,000
Porque en cuanto se ha leído la puedo librar

919
00:36:55,000 --> 00:36:57,000
Que puedo utilizar

920
00:36:57,000 --> 00:36:59,000
Para que en vez de leer

921
00:36:59,000 --> 00:37:01,000
Los datos directamente

922
00:37:01,000 --> 00:37:03,000
Que llegan en los procesos

923
00:37:03,000 --> 00:37:05,000
No, los datos llegan

924
00:37:05,000 --> 00:37:07,000
Los guardo por algún lado

925
00:37:07,000 --> 00:37:09,000
Y cuando ya tienen determinadas características

926
00:37:09,000 --> 00:37:11,000
Pues los proceso

927
00:37:13,000 --> 00:37:15,000
¿Para qué sirve?

928
00:37:15,000 --> 00:37:17,000
Pues esto por ejemplo me permite leer

929
00:37:17,000 --> 00:37:19,000
Una línea entera

930
00:37:19,000 --> 00:37:21,000
Esto lee a bits

931
00:37:21,000 --> 00:37:23,000
Bytes

932
00:37:23,000 --> 00:37:25,000
Y luego los tengo interpretados

933
00:37:25,000 --> 00:37:27,000
Esto lee caracteres

934
00:37:27,000 --> 00:37:29,000
Es decir que puedo leer letra por letra

935
00:37:29,000 --> 00:37:31,000
Ver donde acaba una frase aquí

936
00:37:31,000 --> 00:37:33,000
Debería estar leyendo

937
00:37:33,000 --> 00:37:35,000
Letra, letra, letra, letra

938
00:37:35,000 --> 00:37:37,000
Hasta que encuentro un punto

939
00:37:37,000 --> 00:37:39,000
Cuando encuentro un punto

940
00:37:39,000 --> 00:37:41,000
Asumo A

941
00:37:41,000 --> 00:37:43,000
En realidad cuando encuentro un retorno de carro

942
00:37:43,000 --> 00:37:45,000
Un intro

943
00:37:45,000 --> 00:37:47,000
Un enter

944
00:37:47,000 --> 00:37:49,000
Entonces cuando encuentro ese carácter especial

945
00:37:49,000 --> 00:37:51,000
Que es un enter

946
00:37:51,000 --> 00:37:53,000
Diría aquí ha acabado una frase

947
00:37:53,000 --> 00:37:55,000
Este señor de aquí lo que permite es

948
00:37:55,000 --> 00:37:57,000
No leer solo un carácter

949
00:37:57,000 --> 00:37:59,000
Empieza a leer carácter

950
00:37:59,000 --> 00:38:01,000
Cuando llegas a un momento

951
00:38:01,000 --> 00:38:03,000
Que has leído suficiente carácter

952
00:38:03,000 --> 00:38:05,000
Y encuentras un retorno de carro

953
00:38:05,000 --> 00:38:07,000
Pues esta es una línea y devuelve directamente

954
00:38:07,000 --> 00:38:09,000
Un string que es toda la línea

955
00:38:11,000 --> 00:38:13,000
¿Eh?

956
00:38:13,000 --> 00:38:15,000
Y si quieres

957
00:38:15,000 --> 00:38:17,000
O sea que

958
00:38:17,000 --> 00:38:19,000
Sustancialmente todo esto son lo mismo

959
00:38:19,000 --> 00:38:21,000
Leen desde una fuente

960
00:38:21,000 --> 00:38:23,000
¿Vale?

961
00:38:23,000 --> 00:38:25,000
Pero desde más cerca al binario

962
00:38:25,000 --> 00:38:27,000
Hacia abstracciones más altas

963
00:38:27,000 --> 00:38:29,000
¿Vale?

964
00:38:29,000 --> 00:38:31,000
Este de aquí en particular

965
00:38:31,000 --> 00:38:33,000
Si lo asociáis al método 1

966
00:38:37,000 --> 00:38:39,000
Cuando vosotros guardáis

967
00:38:39,000 --> 00:38:41,000
Los archivos

968
00:38:41,000 --> 00:38:43,000
Los objetos

969
00:38:43,000 --> 00:38:45,000
Guardáis cada objeto en una línea

970
00:38:45,000 --> 00:38:47,000
Toda la información relacionada con el mismo objeto

971
00:38:47,000 --> 00:38:49,000
En la misma línea

972
00:38:49,000 --> 00:38:51,000
Y luego ponéis un buffered reader

973
00:38:51,000 --> 00:38:53,000
Que lee línea por línea

974
00:38:53,000 --> 00:38:55,000
Viendo objeto por objeto

975
00:38:55,000 --> 00:38:57,000
Entonces me leo una línea

976
00:38:57,000 --> 00:38:59,000
Que es un objeto y con esto hago el objeto

977
00:38:59,000 --> 00:39:01,000
Me leo otra línea

978
00:39:01,000 --> 00:39:03,000
Y con esto hago el segundo objeto

979
00:39:03,000 --> 00:39:05,000
Leo otra línea

980
00:39:05,000 --> 00:39:07,000
Por ejemplo

981
00:39:07,000 --> 00:39:09,000
¿Dudas?

982
00:39:09,000 --> 00:39:11,000
Si soy un programa de

983
00:39:11,000 --> 00:39:13,000
Procesamiento de texto

984
00:39:13,000 --> 00:39:15,000
Que tiene que buscar una palabra

985
00:39:15,000 --> 00:39:17,000
Dentro de un texto muy largo

986
00:39:17,000 --> 00:39:19,000
Pues lo que puedo hacer es

987
00:39:19,000 --> 00:39:21,000
Leérmelo línea por línea

988
00:39:21,000 --> 00:39:23,000
Una línea del texto

989
00:39:23,000 --> 00:39:25,000
Y busca aquí la palabra

990
00:39:25,000 --> 00:39:27,000
Otra línea del texto

991
00:39:27,000 --> 00:39:29,000
Y además, cuando te tengo que decir

992
00:39:29,000 --> 00:39:31,000
Si he encontrado la palabra

993
00:39:31,000 --> 00:39:33,000
Te puedo decir, mira, la he encontrado

994
00:39:33,000 --> 00:39:35,000
Y está en la línea 3

995
00:39:35,000 --> 00:39:37,000
Cada vez que busco una línea

996
00:39:37,000 --> 00:39:39,000
Sé en qué línea está

997
00:39:39,000 --> 00:39:41,000
¿Dudas?

998
00:39:41,000 --> 00:39:43,000
¿Si?

999
00:39:43,000 --> 00:39:45,000
Esto es sólo presentación de la

1000
00:39:47,000 --> 00:39:49,000
De las clases

1001
00:39:49,000 --> 00:39:51,000
Después las usamos

1002
00:39:51,000 --> 00:39:53,000
Hacemos ejemplos

1003
00:39:57,000 --> 00:39:59,000
Aquí lo que hago es

1004
00:39:59,000 --> 00:40:01,000
Utilizar FileReader

1005
00:40:01,000 --> 00:40:03,000
Y BufferedReader

1006
00:40:03,000 --> 00:40:05,000
Para leer algo en un fichero

1007
00:40:05,000 --> 00:40:07,000
Entonces

1008
00:40:07,000 --> 00:40:09,000
Me creo un señor

1009
00:40:09,000 --> 00:40:11,000
FileReader a nul

1010
00:40:11,000 --> 00:40:13,000
Y un BufferedReader a nul

1011
00:40:13,000 --> 00:40:15,000
FR es mi FileReader

1012
00:40:15,000 --> 00:40:17,000
BR es mi BufferedReader

1013
00:40:17,000 --> 00:40:19,000
Tengo un nuevo FileReader

1014
00:40:19,000 --> 00:40:21,000
Con la ruta del archivo

1015
00:40:21,000 --> 00:40:23,000
Aquí debería poner

1016
00:40:23,000 --> 00:40:25,000
C dos puntos barra mi carpeta

1017
00:40:25,000 --> 00:40:27,000
Barra texto punto text

1018
00:40:27,000 --> 00:40:29,000
Por ejemplo

1019
00:40:29,000 --> 00:40:31,000
¿Si?

1020
00:40:31,000 --> 00:40:33,000
Mejor podría haber creado

1021
00:40:33,000 --> 00:40:35,000
Antes un File

1022
00:40:35,000 --> 00:40:37,000
Mi fichero es igual a

1023
00:40:37,000 --> 00:40:39,000
NewFile con la ruta

1024
00:40:39,000 --> 00:40:41,000
Y ahora aquí utilizar

1025
00:40:41,000 --> 00:40:43,000
Mi fichero

1026
00:40:43,000 --> 00:40:45,000
O podría utilizar

1027
00:40:45,000 --> 00:40:47,000
Uno de los

1028
00:40:47,000 --> 00:40:49,000
Componentes que seguramente

1029
00:40:49,000 --> 00:40:51,000
Habéis mirado en la

1030
00:40:51,000 --> 00:40:53,000
Parte gráfica que es el

1031
00:40:53,000 --> 00:40:55,000
FileChooser

1032
00:40:55,000 --> 00:40:57,000
Cuando lo pincháis se abre la clásica ventanita

1033
00:40:57,000 --> 00:40:59,000
Esa que te permite elegir un fichero

1034
00:40:59,000 --> 00:41:01,000
Con eso

1035
00:41:01,000 --> 00:41:03,000
Elegir el fichero y luego ponerlo

1036
00:41:03,000 --> 00:41:05,000
Aquí para ir a leer

1037
00:41:09,000 --> 00:41:11,000
Fijaos que creo un nuevo BufferedReader

1038
00:41:11,000 --> 00:41:13,000
Y le pongo dentro este

1039
00:41:13,000 --> 00:41:15,000
FileReader

1040
00:41:15,000 --> 00:41:17,000
Es el concepto que

1041
00:41:17,000 --> 00:41:19,000
Esto es como que se va

1042
00:41:19,000 --> 00:41:21,000
Encapsulando

1043
00:41:21,000 --> 00:41:23,000
En clases que hacen

1044
00:41:23,000 --> 00:41:25,000
Más cosas

1045
00:41:25,000 --> 00:41:27,000
Lo que ya tengo

1046
00:41:27,000 --> 00:41:29,000
He creado un FileReader

1047
00:41:29,000 --> 00:41:31,000
Este FR tendrá un conjunto de métodos

1048
00:41:31,000 --> 00:41:33,000
Como por ejemplo

1049
00:41:33,000 --> 00:41:35,000
Leerme un byte, leerme un carácter

1050
00:41:35,000 --> 00:41:37,000
O cosas por el estilo

1051
00:41:37,000 --> 00:41:39,000
Este

1052
00:41:39,000 --> 00:41:41,000
Stream

1053
00:41:41,000 --> 00:41:43,000
Esta información

1054
00:41:43,000 --> 00:41:45,000
Lo paso como parámetro a un BufferedReader

1055
00:41:45,000 --> 00:41:47,000
¿Qué me hará?

1056
00:41:47,000 --> 00:41:49,000
Me añadirá una memoria temporal

1057
00:41:49,000 --> 00:41:51,000
A la posibilidad de leer

1058
00:41:51,000 --> 00:41:53,000
Carácter por carácter

1059
00:41:53,000 --> 00:41:55,000
Y entonces ahora BR me ofrecerá

1060
00:41:55,000 --> 00:41:57,000
Más funcionalidades

1061
00:41:57,000 --> 00:41:59,000
Me ofrecerá

1062
00:41:59,000 --> 00:42:01,000
Lo mismo que hace un FR

1063
00:42:01,000 --> 00:42:03,000
Más algunos métodos que FR no tenía

1064
00:42:03,000 --> 00:42:05,000
Como por ejemplo leerte una línea entera de golpe

1065
00:42:05,000 --> 00:42:07,000
Cosa que

1066
00:42:07,000 --> 00:42:09,000
Esto no podría hacer

1067
00:42:10,000 --> 00:42:12,000
Por ejemplo

1068
00:42:12,000 --> 00:42:14,000
Me creo un StringLinea

1069
00:42:14,000 --> 00:42:16,000
Y digo que mientras

1070
00:42:16,000 --> 00:42:18,000
Linea es igual a

1071
00:42:18,000 --> 00:42:20,000
BR.readline

1072
00:42:20,000 --> 00:42:22,000
¿Qué hace BR.readline?

1073
00:42:24,000 --> 00:42:26,000
Lee una línea

1074
00:42:26,000 --> 00:42:28,000
Me la pasa

1075
00:42:28,000 --> 00:42:30,000
Dentro de linea

1076
00:42:30,000 --> 00:42:32,000
Y si esto ha pasado

1077
00:42:32,000 --> 00:42:34,000
Y ha funcionado

1078
00:42:34,000 --> 00:42:36,000
Pues entonces no se hará nada

1079
00:42:37,000 --> 00:42:39,000
¿Ok?

1080
00:42:39,000 --> 00:42:41,000
Si esta operación devuelve null

1081
00:42:41,000 --> 00:42:43,000
Quiere decir que ha acabado el fichero

1082
00:42:47,000 --> 00:42:49,000
Entonces si esta operación de aquí

1083
00:42:49,000 --> 00:42:51,000
Funciona

1084
00:42:51,000 --> 00:42:53,000
Y esto no es null lo que ha puesto aquí dentro

1085
00:42:53,000 --> 00:42:55,000
Pues entonces lo que hago es

1086
00:42:55,000 --> 00:42:57,000
Procesar la línea

1087
00:42:57,000 --> 00:42:59,000
Hacer lo que tenga que hacer con esta línea

1088
00:42:59,000 --> 00:43:01,000
Si la quiero imprimir por pantalla

1089
00:43:01,000 --> 00:43:03,000
Si quisiera crear un objeto a partir de aquí

1090
00:43:03,000 --> 00:43:05,000
Pues aquí crearía el objeto

1091
00:43:05,000 --> 00:43:07,000
Separaría todos los componentes

1092
00:43:07,000 --> 00:43:09,000
Que están en esta línea que he leído

1093
00:43:09,000 --> 00:43:11,000
De los objetos

1094
00:43:11,000 --> 00:43:13,000
Crearía el objeto y lo añadiría a una lista

1095
00:43:13,000 --> 00:43:15,000
O lo sé, hago lo que tengo que hacer

1096
00:43:15,000 --> 00:43:17,000
Con lo que he leído desde el fichero

1097
00:43:17,000 --> 00:43:19,000
En este caso lo escribe

1098
00:43:19,000 --> 00:43:21,000
Teniendo en cuenta que puede haber excepciones

1099
00:43:21,000 --> 00:43:23,000
Podéis ir a mirar

1100
00:43:23,000 --> 00:43:25,000
Que tipo de excepciones lanzan

1101
00:43:25,000 --> 00:43:27,000
Estas operaciones de aquí

1102
00:43:27,000 --> 00:43:29,000
Fijaos que el tráiler es aquí

1103
00:43:29,000 --> 00:43:31,000
Muchas de estas son

1104
00:43:31,000 --> 00:43:33,000
IOException

1105
00:43:33,000 --> 00:43:35,000
Pero puede ser

1106
00:43:35,000 --> 00:43:37,000
FileNotFoundException

1107
00:43:37,000 --> 00:43:39,000
Si yo intento acceder a un fichero que no existe

1108
00:43:39,000 --> 00:43:41,000
Os vais a mirar en el API

1109
00:43:41,000 --> 00:43:43,000
Y podéis ver todas las excepciones

1110
00:43:43,000 --> 00:43:45,000
Os recuerdo que las excepciones

1111
00:43:45,000 --> 00:43:47,000
Las hemos visto

1112
00:43:47,000 --> 00:43:49,000
Y este tipo de forma

1113
00:43:49,000 --> 00:43:51,000
De manejar las excepciones

1114
00:43:51,000 --> 00:43:53,000
Es pésimo

1115
00:43:53,000 --> 00:43:55,000
Porque no sé que ha pasado

1116
00:43:55,000 --> 00:43:57,000
Si pasa algo explota

1117
00:43:57,000 --> 00:43:59,000
Dime que ha pasado

1118
00:43:59,000 --> 00:44:01,000
Oye el fichero que has seleccionado no existe

1119
00:44:01,000 --> 00:44:03,000
Dime, oye mira, he intentado abrir

1120
00:44:03,000 --> 00:44:05,000
Pero no lo he conseguido

1121
00:44:05,000 --> 00:44:07,000
Dime algo, no me digas

1122
00:44:07,000 --> 00:44:09,000
Boom

1123
00:44:09,000 --> 00:44:11,000
Aquí hay una cosa

1124
00:44:11,000 --> 00:44:13,000
Finally

1125
00:44:13,000 --> 00:44:15,000
Cuando he utilizado todo esto

1126
00:44:15,000 --> 00:44:17,000
Porque fijaos que este es un while

1127
00:44:17,000 --> 00:44:19,000
Que mientras recibo cosas la escribo

1128
00:44:19,000 --> 00:44:21,000
Cuando esto me da null

1129
00:44:21,000 --> 00:44:23,000
Y entonces he acabado, salgo del while

1130
00:44:23,000 --> 00:44:25,000
Y al final

1131
00:44:25,000 --> 00:44:27,000
Tanto si ha explotado

1132
00:44:27,000 --> 00:44:29,000
Como si ha acabado el fichero

1133
00:44:29,000 --> 00:44:31,000
Lo que hago es

1134
00:44:31,000 --> 00:44:33,000
Si esto y esto

1135
00:44:33,000 --> 00:44:35,000
Si esto no es null

1136
00:44:35,000 --> 00:44:37,000
O sea si FR

1137
00:44:37,000 --> 00:44:39,000
Cuando lo he creado

1138
00:44:39,000 --> 00:44:41,000
Era algo y por lo tanto existe como objeto

1139
00:44:41,000 --> 00:44:43,000
Pues entonces cierralo

1140
00:44:45,000 --> 00:44:47,000
Si cuando he hecho esto

1141
00:44:47,000 --> 00:44:49,000
Ha explotado o no ha funcionado

1142
00:44:49,000 --> 00:44:51,000
Y por lo tanto FR se ha quedado null

1143
00:44:51,000 --> 00:44:53,000
Pues no lo hago, no he abierto el fichero

1144
00:44:53,000 --> 00:44:55,000
No lo cierro

1145
00:44:55,000 --> 00:44:57,000
¿Qué quiere decir cerrar el fichero?

1146
00:44:57,000 --> 00:44:59,000
Cuando yo creo un file reader

1147
00:44:59,000 --> 00:45:01,000
O un buffer reader

1148
00:45:01,000 --> 00:45:03,000
Lo que estoy haciendo es poner un tubo

1149
00:45:03,000 --> 00:45:05,000
Desde el fichero

1150
00:45:05,000 --> 00:45:07,000
Hasta mi programa

1151
00:45:07,000 --> 00:45:09,000
Y empiezo a pillar desde allí información

1152
00:45:09,000 --> 00:45:11,000
Cuando ya no lo quiero usar más

1153
00:45:11,000 --> 00:45:13,000
La cosa que debería hacer

1154
00:45:13,000 --> 00:45:15,000
Es quitar el tubo

1155
00:45:15,000 --> 00:45:17,000
Cerrar el fichero

1156
00:45:17,000 --> 00:45:19,000
Ya no lo estoy utilizando

1157
00:45:19,000 --> 00:45:21,000
Y entonces ya tengo esto

1158
00:45:21,000 --> 00:45:23,000
Sustancialmente quito todos los recursos

1159
00:45:23,000 --> 00:45:25,000
Que estos dos señores

1160
00:45:25,000 --> 00:45:27,000
Estos dos señores

1161
00:45:27,000 --> 00:45:29,000
Habían guardado por algún lado

1162
00:45:29,000 --> 00:45:31,000
Diciendo oye mira

1163
00:45:31,000 --> 00:45:33,000
Me han abierto un stream

1164
00:45:33,000 --> 00:45:35,000
Tengo que estar pendiente de recibir datos

1165
00:45:35,000 --> 00:45:37,000
Si me piden los datos

1166
00:45:37,000 --> 00:45:39,000
Lo tengo que pasar

1167
00:45:39,000 --> 00:45:41,000
Lo tengo que poner en una memoria

1168
00:45:41,000 --> 00:45:43,000
O hacer algo

1169
00:45:43,000 --> 00:45:45,000
Pues todos estos recursos que estaban a disposición de mi programa

1170
00:45:45,000 --> 00:45:47,000
Pues libéralos

1171
00:45:47,000 --> 00:45:49,000
Porque he acabado de mirar el fichero

1172
00:45:49,000 --> 00:45:51,000
Lo puedo cerrar

1173
00:45:51,000 --> 00:45:53,000
¿Qué hace este programa?

1174
00:45:55,000 --> 00:45:57,000
Escribir en pata y un fichero

1175
00:45:57,000 --> 00:45:59,000
Tengo un fichero de texto

1176
00:45:59,000 --> 00:46:01,000
Y esto lo escribo en pata

1177
00:46:01,000 --> 00:46:03,000
¿Sí?

1178
00:46:03,000 --> 00:46:05,000
¿Cómo se escribe?

1179
00:46:05,000 --> 00:46:07,000
Pues en vez de los readers

1180
00:46:07,000 --> 00:46:09,000
Hay los writers

1181
00:46:09,000 --> 00:46:11,000
¿Cómo se escribe?

1182
00:46:11,000 --> 00:46:13,000
Pues en vez de los readers

1183
00:46:13,000 --> 00:46:15,000
Hay los writers

1184
00:46:15,000 --> 00:46:17,000
¿Cómo se escribe?

1185
00:46:17,000 --> 00:46:19,000
Pues en vez de los readers

1186
00:46:19,000 --> 00:46:21,000
Hay los writers

1187
00:46:21,000 --> 00:46:23,000
¿Cómo se escribe?

1188
00:46:23,000 --> 00:46:25,000
Hay los writers

1189
00:46:25,000 --> 00:46:27,000
¿Vale?

1190
00:46:27,000 --> 00:46:29,000
Donde hay un input stream

1191
00:46:29,000 --> 00:46:31,000
Hay un output stream

1192
00:46:31,000 --> 00:46:33,000
Donde hay un input stream reader

1193
00:46:33,000 --> 00:46:35,000
Hay un output stream writer

1194
00:46:37,000 --> 00:46:39,000
Donde hay un file reader

1195
00:46:39,000 --> 00:46:41,000
Hay un file writer

1196
00:46:41,000 --> 00:46:43,000
¿Vale?

1197
00:46:43,000 --> 00:46:45,000
Todos los readers, input y cosas por el estilo

1198
00:46:45,000 --> 00:46:47,000
Me darán operaciones de leer

1199
00:46:47,000 --> 00:46:49,000
Todos los writers

1200
00:46:49,000 --> 00:46:51,000
Output y cosas por el estilo

1201
00:46:51,000 --> 00:46:53,000
Me darán operaciones para escribir

1202
00:46:53,000 --> 00:46:55,000
Para mandar datos

1203
00:46:55,000 --> 00:46:57,000
Desde mi programa hacia el fichero

1204
00:46:57,000 --> 00:46:59,000
¿Sí?

1205
00:46:59,000 --> 00:47:01,000
Por ejemplo aquí

1206
00:47:01,000 --> 00:47:03,000
Tengo este file writer

1207
00:47:03,000 --> 00:47:05,000
Este print writer

1208
00:47:05,000 --> 00:47:07,000
Alguno de vosotros os sonará

1209
00:47:07,000 --> 00:47:09,000
System.out

1210
00:47:11,000 --> 00:47:13,000
¿Vale?

1211
00:47:13,000 --> 00:47:15,000
Como vosotros

1212
00:47:15,000 --> 00:47:17,000
Sois buenos alumnos

1213
00:47:17,000 --> 00:47:19,000
Y sabéis que

1214
00:47:19,000 --> 00:47:21,000
System empieza por S

1215
00:47:21,000 --> 00:47:23,000
Y habéis ido a mirar en el

1216
00:47:23,000 --> 00:47:25,000
Apis que es

1217
00:47:25,000 --> 00:47:27,000
Y que tipo tiene

1218
00:47:27,000 --> 00:47:29,000
Este System.out

1219
00:47:29,000 --> 00:47:31,000
Ahora os sonará

1220
00:47:35,000 --> 00:47:37,000
Entonces

1221
00:47:37,000 --> 00:47:39,000
Creo un fichero file writer

1222
00:47:39,000 --> 00:47:41,000
Con la ruta del fichero

1223
00:47:41,000 --> 00:47:43,000
Repito que la foto la podía poner

1224
00:47:43,000 --> 00:47:45,000
Cuidado que aquí hay una cosa

1225
00:47:45,000 --> 00:47:47,000
Si pones la ruta

1226
00:47:47,000 --> 00:47:49,000
Y luego aquí coma true

1227
00:47:49,000 --> 00:47:51,000
Creo que esto no te

1228
00:47:51,000 --> 00:47:53,000
Sobrescribe el fichero

1229
00:47:53,000 --> 00:47:55,000
Sino te lo añade al final

1230
00:47:55,000 --> 00:47:57,000
Pero habría que ver nada

1231
00:47:57,000 --> 00:47:59,000
No me acuerdo bien

1232
00:47:59,000 --> 00:48:01,000
Y este file writer

1233
00:48:01,000 --> 00:48:03,000
Lo encrusto dentro

1234
00:48:03,000 --> 00:48:05,000
Lo paso como parámetro

1235
00:48:05,000 --> 00:48:07,000
Que es la versión del buffer

1236
00:48:07,000 --> 00:48:09,000
En un cierto sentido pero en escritura

1237
00:48:09,000 --> 00:48:11,000
Lo que me permite escribir

1238
00:48:11,000 --> 00:48:13,000
Una string de golpe

1239
00:48:13,000 --> 00:48:15,000
Entonces

1240
00:48:15,000 --> 00:48:17,000
For int y bla bla bla

1241
00:48:17,000 --> 00:48:19,000
10 veces

1242
00:48:19,000 --> 00:48:21,000
pv.println

1243
00:48:21,000 --> 00:48:23,000
¿Os suena de algo?

1244
00:48:23,000 --> 00:48:25,000
Linea mas i

1245
00:48:25,000 --> 00:48:27,000
¿Vale?

1246
00:48:27,000 --> 00:48:29,000
Si hay una excepción explota

1247
00:48:29,000 --> 00:48:31,000
Y al final cierrame el fichero

1248
00:48:35,000 --> 00:48:37,000
¿Qué hace este programa?

1249
00:48:37,000 --> 00:48:39,000
Escribe linea 1, 0

1250
00:48:39,000 --> 00:48:41,000
Linea 1, 0

1251
00:48:41,000 --> 00:48:43,000
Lo guardo en un fichero de texto

1252
00:48:43,000 --> 00:48:45,000
Dice esto guardado en un fichero de texto

1253
00:48:45,000 --> 00:48:47,000
¿Vale?

1254
00:48:47,000 --> 00:48:49,000
Fijaos que al usar el print writer

1255
00:48:49,000 --> 00:48:51,000
Puedo escribir una linea

1256
00:48:51,000 --> 00:48:53,000
println

1257
00:48:53,000 --> 00:48:55,000
Me permite escribir

1258
00:48:55,000 --> 00:48:57,000
Linea el numerito

1259
00:48:57,000 --> 00:48:59,000
Y dar un retorno de carro

1260
00:48:59,000 --> 00:49:01,000
Si pusiera solo print

1261
00:49:01,000 --> 00:49:03,000
Me lo escribiría todo en la misma linea

1262
00:49:03,000 --> 00:49:05,000
Parecido a

1263
00:49:05,000 --> 00:49:07,000
Ahora

1264
00:49:07,000 --> 00:49:09,000
Cuando vosotros usáis system.out

1265
00:49:09,000 --> 00:49:11,000
¿Está conectado a un fichero?

1266
00:49:15,000 --> 00:49:17,000
System.out.println

1267
00:49:17,000 --> 00:49:19,000
No, aquí está conectado

1268
00:49:19,000 --> 00:49:21,000
Al sistema

1269
00:49:21,000 --> 00:49:23,000
A la salida de mi sistema

1270
00:49:23,000 --> 00:49:25,000
Que normalmente es la consola

1271
00:49:25,000 --> 00:49:27,000
¿Vale?

1272
00:49:27,000 --> 00:49:29,000
Cuando yo escribo algo

1273
00:49:29,000 --> 00:49:31,000
Me lo escribe en esta parte de consola

1274
00:49:31,000 --> 00:49:33,000
Por defecto

1275
00:49:33,000 --> 00:49:35,000
Cuando yo arranco un programa

1276
00:49:35,000 --> 00:49:37,000
El systemin es el teclado

1277
00:49:37,000 --> 00:49:39,000
Systemout es la consola

1278
00:49:39,000 --> 00:49:41,000
Y ahora un tercero

1279
00:49:41,000 --> 00:49:43,000
Systemer

1280
00:49:43,000 --> 00:49:45,000
Que es la consola pero en rojo

1281
00:49:45,000 --> 00:49:47,000
Ahí es donde escribiría

1282
00:49:47,000 --> 00:49:49,000
Información sobre los errores

1283
00:49:49,000 --> 00:49:51,000
Si explota un error, en vez de hacer

1284
00:49:51,000 --> 00:49:53,000
System.out.println

1285
00:49:53,000 --> 00:49:55,000
Arroga a que ha pasado algo raro

1286
00:49:55,000 --> 00:49:57,000
Sería system.er

1287
00:49:57,000 --> 00:49:59,000
.println

1288
00:49:59,000 --> 00:50:01,000
Error, err

1289
00:50:01,000 --> 00:50:03,000
¿Vale?

1290
00:50:03,000 --> 00:50:05,000
Creo que viene ahora

1291
00:50:07,000 --> 00:50:09,000
Lectura y escritura de un archivo binario

1292
00:50:09,000 --> 00:50:11,000
¿Vale?

1293
00:50:11,000 --> 00:50:13,000
Voy a leer

1294
00:50:13,000 --> 00:50:15,000
Por ejemplo copiar un fichero

1295
00:50:15,000 --> 00:50:17,000
Voy a leer de un fichero

1296
00:50:17,000 --> 00:50:19,000
Es binario, esto no es de texto

1297
00:50:19,000 --> 00:50:21,000
Y lo que he leído

1298
00:50:21,000 --> 00:50:23,000
Lo escribo en otro fichero

1299
00:50:25,000 --> 00:50:27,000
Tengo un file input stream

1300
00:50:27,000 --> 00:50:29,000
Ahora no tengo reader y writer

1301
00:50:29,000 --> 00:50:31,000
Porque estoy leyendo

1302
00:50:31,000 --> 00:50:33,000
Quiero leer byte a byte

1303
00:50:33,000 --> 00:50:35,000
Es un fichero binario, no es un fichero de texto

1304
00:50:35,000 --> 00:50:37,000
Puede ser una imagen

1305
00:50:37,000 --> 00:50:39,000
Puede ser un ejecutable

1306
00:50:39,000 --> 00:50:41,000
Y creo

1307
00:50:41,000 --> 00:50:43,000
Un nuevo file input stream

1308
00:50:43,000 --> 00:50:45,000
Con la ruta del fichero original

1309
00:50:45,000 --> 00:50:47,000
Luego pillo un buffer

1310
00:50:47,000 --> 00:50:49,000
De input stream

1311
00:50:49,000 --> 00:50:51,000
No un buffer de reader

1312
00:50:51,000 --> 00:50:53,000
Y

1313
00:50:53,000 --> 00:50:55,000
Le paso este de aquí

1314
00:50:55,000 --> 00:50:57,000
¿Qué es esto? Es un input stream con un buffer

1315
00:50:57,000 --> 00:50:59,000
Me permite leer en vez de byte a byte

1316
00:50:59,000 --> 00:51:01,000
Un trozo de byte

1317
00:51:01,000 --> 00:51:03,000
Me dará métodos que en vez de leer

1318
00:51:03,000 --> 00:51:05,000
Leer un byte me dirá leer mucho

1319
00:51:05,000 --> 00:51:07,000
¿Vale?

1320
00:51:07,000 --> 00:51:09,000
Luego tengo un file output stream

1321
00:51:09,000 --> 00:51:11,000
¿Vale?

1322
00:51:11,000 --> 00:51:13,000
Que le pongo el fichero copia

1323
00:51:13,000 --> 00:51:15,000
Entonces esto y esto

1324
00:51:15,000 --> 00:51:17,000
Son distintos

1325
00:51:17,000 --> 00:51:19,000
Esto será c2.micarpeta

1326
00:51:19,000 --> 00:51:21,000
Original.exe

1327
00:51:21,000 --> 00:51:23,000
Y este de aquí será

1328
00:51:23,000 --> 00:51:25,000
c2.micarpeta

1329
00:51:25,000 --> 00:51:27,000
Barra

1330
00:51:27,000 --> 00:51:29,000
Destino.exe

1331
00:51:29,000 --> 00:51:31,000
¿Vale?

1332
00:51:31,000 --> 00:51:33,000
Y un buffer de output stream

1333
00:51:33,000 --> 00:51:35,000
¿Sí?

1334
00:51:35,000 --> 00:51:37,000
Al que le paso este de aquí

1335
00:51:37,000 --> 00:51:39,000
Aquí estoy creando sustancialmente

1336
00:51:39,000 --> 00:51:41,000
Mis dos canales de entradas

1337
00:51:41,000 --> 00:51:43,000
De entrada y salida

1338
00:51:43,000 --> 00:51:45,000
Este que lee desde el fichero original

1339
00:51:45,000 --> 00:51:47,000
Y este que escribe en el fichero destino

1340
00:51:49,000 --> 00:51:51,000
¿Sí?

1341
00:51:51,000 --> 00:51:53,000
Vale

1342
00:51:53,000 --> 00:51:55,000
Pillo un array

1343
00:51:55,000 --> 00:51:57,000
De bytes

1344
00:51:57,000 --> 00:51:59,000
¿Vale? Con mil bytes dentro

1345
00:51:59,000 --> 00:52:01,000
Tendré una memoria, un bloque

1346
00:52:01,000 --> 00:52:03,000
De mil bytes

1347
00:52:03,000 --> 00:52:05,000
Lo rellenaré leyendo de aquí

1348
00:52:05,000 --> 00:52:07,000
De aquí

1349
00:52:07,000 --> 00:52:09,000
Y lo que he rellenado allí

1350
00:52:09,000 --> 00:52:11,000
Lo escribiré

1351
00:52:13,000 --> 00:52:15,000
Entonces vamos a ver como se hace

1352
00:52:15,000 --> 00:52:17,000
int leidos es igual a

1353
00:52:17,000 --> 00:52:19,000
bis.read

1354
00:52:19,000 --> 00:52:21,000
De array

1355
00:52:21,000 --> 00:52:23,000
La read, la operación read de leer

1356
00:52:23,000 --> 00:52:25,000
¿Vale?

1357
00:52:25,000 --> 00:52:27,000
Que hay varias read

1358
00:52:27,000 --> 00:52:29,000
Dependiendo de lo que pongo aquí

1359
00:52:29,000 --> 00:52:31,000
Hace una cosa u otra

1360
00:52:31,000 --> 00:52:33,000
Pero en general, si yo le pongo un array

1361
00:52:33,000 --> 00:52:35,000
Un cierto número de posiciones

1362
00:52:35,000 --> 00:52:37,000
Un array de bytes

1363
00:52:37,000 --> 00:52:39,000
Lo que hace el resultado de esta operación

1364
00:52:39,000 --> 00:52:41,000
Es que me pone dentro de este array

1365
00:52:41,000 --> 00:52:43,000
Lo que ha leído

1366
00:52:43,000 --> 00:52:45,000
Byte por byte

1367
00:52:45,000 --> 00:52:47,000
O sea que si hay mil bytes en el

1368
00:52:47,000 --> 00:52:49,000
En el fichero

1369
00:52:49,000 --> 00:52:51,000
Pues me leerá mil bytes

1370
00:52:51,000 --> 00:52:53,000
Hasta mil bytes

1371
00:52:53,000 --> 00:52:55,000
Si hay menos me leerá menos

1372
00:52:55,000 --> 00:52:57,000
Y aquí me dice cuantos has leído

1373
00:52:59,000 --> 00:53:01,000
Si el array tiene

1374
00:53:01,000 --> 00:53:03,000
1200 bytes, la primera vez que

1375
00:53:03,000 --> 00:53:05,000
Uso esto, aquí me verá mil

1376
00:53:05,000 --> 00:53:07,000
Porque ha leído mil bytes

1377
00:53:07,000 --> 00:53:09,000
Si el array

1378
00:53:09,000 --> 00:53:11,000
Si el fichero tiene 300 bytes

1379
00:53:11,000 --> 00:53:13,000
Solo, pues aquí me pondrá 300

1380
00:53:13,000 --> 00:53:15,000
Entonces si yo sé que de estos mil

1381
00:53:15,000 --> 00:53:17,000
Bytes, los primeros 300

1382
00:53:17,000 --> 00:53:19,000
Tienen sentido porque acabo de leerlos

1383
00:53:19,000 --> 00:53:21,000
Y son el fichero que he leído

1384
00:53:21,000 --> 00:53:23,000
Y los otros 700 no tienen sentido porque

1385
00:53:23,000 --> 00:53:25,000
A lo mejor son de una lectura anterior

1386
00:53:25,000 --> 00:53:27,000
Pero no es lo que he leído ahora

1387
00:53:27,000 --> 00:53:29,000
Ahora he leído solo 300

1388
00:53:31,000 --> 00:53:33,000
¿Si?

1389
00:53:33,000 --> 00:53:35,000
Y digo, mientras

1390
00:53:35,000 --> 00:53:37,000
Leídos es mayor que 0

1391
00:53:37,000 --> 00:53:39,000
¿Vale? O sea que

1392
00:53:39,000 --> 00:53:41,000
Mientras tengo cosas que he leído

1393
00:53:41,000 --> 00:53:43,000
Lo que voy a escribir es escribir

1394
00:53:43,000 --> 00:53:45,000
El

1395
00:53:47,000 --> 00:53:49,000
Lo que hay en el array

1396
00:53:49,000 --> 00:53:51,000
Leyendo desde 0

1397
00:53:51,000 --> 00:53:53,000
Desde el array 0

1398
00:53:53,000 --> 00:53:55,000
Hasta el número leídos

1399
00:53:55,000 --> 00:53:57,000
¿Vale?

1400
00:53:57,000 --> 00:53:59,000
Y leer otra vez el array

1401
00:54:01,000 --> 00:54:03,000
Substantialmente lo que hago es

1402
00:54:03,000 --> 00:54:05,000
Leo algo y lo escribo

1403
00:54:05,000 --> 00:54:07,000
Leo algo y lo escribo

1404
00:54:07,000 --> 00:54:09,000
Leo algo y lo escribo

1405
00:54:09,000 --> 00:54:11,000
Leo algo y lo escribo

1406
00:54:11,000 --> 00:54:13,000
Lo que he leído lo escribo

1407
00:54:13,000 --> 00:54:15,000
Ese último leído es igual a

1408
00:54:15,000 --> 00:54:17,000
BIS.READ

1409
00:54:17,000 --> 00:54:19,000
Si ya he leído un cacho pues seguiré leyendo el siguiente

1410
00:54:19,000 --> 00:54:21,000
¿Vale?

1411
00:54:21,000 --> 00:54:23,000
Como yo tengo este stream

1412
00:54:23,000 --> 00:54:25,000
El stream se acuerda

1413
00:54:25,000 --> 00:54:27,000
De donde ha llegado

1414
00:54:27,000 --> 00:54:29,000
Si yo leo la primera vez me lee esto

1415
00:54:29,000 --> 00:54:31,000
Si leo otra vez

1416
00:54:31,000 --> 00:54:33,000
Empieza desde aquí a leer

1417
00:54:33,000 --> 00:54:35,000
Ahora, si yo cerrara este BIS

1418
00:54:35,000 --> 00:54:37,000
Y lo vuelvo a abrir

1419
00:54:37,000 --> 00:54:39,000
Pues entonces es como si hubiese empezado

1420
00:54:39,000 --> 00:54:41,000
Desde el principio otra vez a leer el fichero

1421
00:54:43,000 --> 00:54:45,000
¿Vale?

1422
00:54:45,000 --> 00:54:47,000
Y entonces

1423
00:54:47,000 --> 00:54:49,000
¿Para qué sirve esto?

1424
00:54:49,000 --> 00:54:51,000
¿Qué me quiere decir esta cosa aquí?

1425
00:54:53,000 --> 00:54:55,000
Mientras haya leído algo

1426
00:54:55,000 --> 00:54:57,000
Si yo hago la read

1427
00:54:57,000 --> 00:54:59,000
Y me devuelve 0

1428
00:54:59,000 --> 00:55:01,000
Es que he acabado

1429
00:55:01,000 --> 00:55:03,000
O no hay bytes en el fichero

1430
00:55:03,000 --> 00:55:05,000
O que he acabado el fichero

1431
00:55:05,000 --> 00:55:07,000
He leído, he leído, he leído

1432
00:55:07,000 --> 00:55:09,000
Ahora no he leído nada

1433
00:55:09,000 --> 00:55:11,000
Pues quiere decir que no tienes nada que escribir

1434
00:55:11,000 --> 00:55:13,000
Pues sale

1435
00:55:13,000 --> 00:55:15,000
Cierro BIS

1436
00:55:15,000 --> 00:55:17,000
Cierro BOS

1437
00:55:17,000 --> 00:55:19,000
Y salgo

1438
00:55:21,000 --> 00:55:23,000
En mi experiencia

1439
00:55:23,000 --> 00:55:25,000
Pasaréis el resto de vuestra existencia

1440
00:55:25,000 --> 00:55:27,000
Llamando estas cosas

1441
00:55:27,000 --> 00:55:29,000
FIS, BIS, FOS y BOS

1442
00:55:29,000 --> 00:55:31,000
¿Vale?

1443
00:55:31,000 --> 00:55:33,000
Ahora, estaría bien que le hicierais

1444
00:55:33,000 --> 00:55:35,000
Algo de semántica

1445
00:55:35,000 --> 00:55:37,000
A estos nombres

1446
00:55:37,000 --> 00:55:39,000
Como estos son ejercicios sin semántica

1447
00:55:39,000 --> 00:55:41,000
Pues tampoco

1448
00:55:41,000 --> 00:55:43,000
Esto podría ser origen

1449
00:55:43,000 --> 00:55:45,000
De este destino

1450
00:55:45,000 --> 00:55:47,000
Para que luego entendáis mejor

1451
00:55:47,000 --> 00:55:49,000
La diferencia entre FIS, FOS, BOS y FIS

1452
00:55:49,000 --> 00:55:51,000
Si, porque si no es un poco malo

1453
00:55:51,000 --> 00:55:53,000
Una cosa

1454
00:55:53,000 --> 00:55:55,000
¿Por qué no funciona en el Default Package?

1455
00:55:55,000 --> 00:55:57,000
¿Por qué no funciona en él?

1456
00:55:57,000 --> 00:55:59,000
De hecho eso

1457
00:55:59,000 --> 00:56:01,000
Sale el de leer archivos en el Default Package

1458
00:56:01,000 --> 00:56:03,000
Y en uno con otro nombre

1459
00:56:03,000 --> 00:56:05,000
En el Default no funciona

1460
00:56:05,000 --> 00:56:07,000
En este fichero

1461
00:56:07,000 --> 00:56:09,000
No lo sé

1462
00:56:09,000 --> 00:56:11,000
Debería funcionar

1463
00:56:11,000 --> 00:56:13,000
¿Has importado?

1464
00:56:19,000 --> 00:56:21,000
No lo sé

1465
00:56:21,000 --> 00:56:23,000
No me resulta

1466
00:56:23,000 --> 00:56:25,000
Que no tenga que funcionar

1467
00:56:25,000 --> 00:56:27,000
Pues a lo mejor

1468
00:56:27,000 --> 00:56:29,000
No lo sé

1469
00:56:29,000 --> 00:56:31,000
¿Por qué lo has hecho mal?

1470
00:56:31,000 --> 00:56:33,000
¿Cómo guardar el atributo

1471
00:56:33,000 --> 00:56:35,000
De un objeto?

1472
00:56:35,000 --> 00:56:37,000
Hagamos una

1473
00:56:37,000 --> 00:56:39,000
Pausa