1
00:00:00,500 --> 00:00:07,879
Voy a acabar esta clase, por lo tanto, si habláis, me estáis dando la autorización a que grabe vuestra voz.

2
00:00:08,679 --> 00:00:15,259
Vale, entonces, hasta ahora hemos visto cómo escribir un fichero de texto, escribir un fichero binario, ¿vale?

3
00:00:15,800 --> 00:00:22,199
Hemos empezado a mirar la posibilidad de guardar objetos y la primera opción que hemos tenido es,

4
00:00:22,199 --> 00:00:31,120
oye, mira, mi objeto lo represento como una cadena de texto, como un string, y lo guardo en un fichero de texto.

5
00:00:31,339 --> 00:00:37,060
Cuando lo voy a leer, pillo ese fichero de texto, lo reinterpreto según el formato que había elegido,

6
00:00:37,439 --> 00:00:39,960
y a partir de allí me recreo el objeto, ¿vale?

7
00:00:40,939 --> 00:00:48,079
Hemos visto también, en el ejemplo que hemos hecho en clase, que esta materialización-desmaterialización de los objetos,

8
00:00:48,079 --> 00:00:57,579
o sea, de cómo los creo, cómo los deshago, cómo los guardo, pues se va complicando, sobre todo cuando aumento las referencias a otros objetos.

9
00:00:57,820 --> 00:01:08,879
O sea, cuando mi objeto tiene como atributos alguna variable cuyo tipo es otros objetos, pues allí se puede complicar.

10
00:01:08,879 --> 00:01:18,000
Se complica todavía más cuando tengo objetos bidireccionales, entre comillas, o sea, un alumno que tiene materias y las materias que tiene una lista de alumnos.

11
00:01:18,079 --> 00:01:35,500
Pues puede ser algún problema por ahí. Habría que hacer varios pasos, dejar la primera vez que intento crear, por ejemplo, las materias, dejar esa parte de alumnos vacía, luego crear todos los alumnos con sus materias y luego volver a rellenar las materias y cosas así.

12
00:01:35,500 --> 00:01:41,620
De esta forma es un trabajo complejo y que hoy en día no se hace, ¿vale?

13
00:01:43,920 --> 00:01:49,099
La empresa nunca suspirará de hacerlo de esta forma, ¿vale?

14
00:01:49,099 --> 00:01:55,900
Nos viene bien a nosotros porque es un mecanismo de razonar, de razonamiento, que está bien para nosotros

15
00:01:55,900 --> 00:02:01,959
y porque tenemos que aprender a escribir y leer los ficheros y esto nos viene bien para leer los ficheros.

16
00:02:02,159 --> 00:02:03,840
¿Cómo se hace entonces en la realidad?

17
00:02:03,840 --> 00:02:21,300
En realidad hay varias soluciones, ¿vale? Desde la serialización RAW, que es la que vemos ahora, a la serialización textual, es decir, guardar los ficheros en un formato XML o JSON o lo que sea.

18
00:02:21,300 --> 00:02:29,439
Normalmente hay librerías, hay dependencias que yo puedo poner en mi proyecto para que tenga

19
00:02:29,439 --> 00:02:35,900
sustancialmente un elemento que me diga, oye mira, guárdame este fichero, guárdame este objeto en un fichero

20
00:02:35,900 --> 00:02:41,580
y él lo interprete como él quiere, él lo ponga ahí como un XML o como un JSON, ¿vale?

21
00:02:41,960 --> 00:02:47,360
Con las ventajas que puede tener XML o JSON, o sea que son interpretables por el ser humano.

22
00:02:47,360 --> 00:02:49,360
si yo escribo un fichero xml

23
00:02:49,360 --> 00:02:51,360
luego lo puedo abrir y ver

24
00:02:51,360 --> 00:02:53,360
que está escrito allí dentro hasta modificar

25
00:02:53,360 --> 00:02:54,719
si yo quisiera, ¿vale?

26
00:02:55,000 --> 00:02:57,379
Pero con las desventajas de xml

27
00:02:57,379 --> 00:02:59,159
y json, muchas veces son

28
00:02:59,159 --> 00:03:00,340
lentos porque

29
00:03:00,340 --> 00:03:03,580
tienes que procesar un fichero de texto

30
00:03:03,580 --> 00:03:03,919
al final

31
00:03:03,919 --> 00:03:07,139
La solución

32
00:03:07,139 --> 00:03:09,159
más práctica, más

33
00:03:09,159 --> 00:03:11,240
avanzada sería utilizar

34
00:03:11,240 --> 00:03:13,080
una base de datos con un

35
00:03:13,080 --> 00:03:15,400
object relational mapping

36
00:03:15,400 --> 00:03:17,099
¿vale? Pero esto

37
00:03:17,099 --> 00:03:24,900
en años futuros en segundo posiblemente veréis algo de estas cosas aquí vale aquí donde llegaremos

38
00:03:24,900 --> 00:03:31,740
nosotros es si tenemos el tiempo a ver un poquito de conexión a una base de datos vale pero no la

39
00:03:31,740 --> 00:03:37,919
parte de OR simplemente tengo una base de datos necesito datos de esta base de datos pues se lo

40
00:03:37,919 --> 00:03:45,479
pido y me da los datos como si hiciera solamente hacer una query SQL y los datos en vez de tenerlos

41
00:03:45,479 --> 00:03:53,939
en la consola de mi sgbd pues lo tengo dentro del programa definido como una lista de récords

42
00:03:53,939 --> 00:04:05,060
que puedo ir a mirar vale entonces nosotros hoy vemos la serialización raw si objetos serializables

43
00:04:05,060 --> 00:04:11,699
vale para que un objeto sea serializable tiene que implementar la clase serializable

44
00:04:11,699 --> 00:04:21,860
Sostancialmente, no sé cuánto esto sea correcto desde una perspectiva de purismo, de informática,

45
00:04:22,060 --> 00:04:37,000
pero pensarlo como yo puedo pillar un objeto y describirlo como una serie de ceros y unos.

46
00:04:37,000 --> 00:04:42,000
si mi objeto puede hacer esto

47
00:04:42,000 --> 00:04:46,139
o sea, implementa la clase serializable, entonces yo le estoy diciendo

48
00:04:46,139 --> 00:04:49,899
oye mira, tú puedes transformar este objeto en una secuencia

49
00:04:49,899 --> 00:04:54,339
de ceros y unos, estos ceros y unos los puedo disparar

50
00:04:54,339 --> 00:04:58,180
en uno de los canales de comunicaciones que tengo, como por ejemplo

51
00:04:58,180 --> 00:05:01,980
un output streamer o un input streamer

52
00:05:01,980 --> 00:05:05,680
o un file reader o lo que sea, ¿vale? y como

53
00:05:05,680 --> 00:05:09,819
este objeto, al fin y al cabo todo en informática

54
00:05:09,819 --> 00:05:14,160
son una tira de ceros y unos, si yo puedo escribir estos ceros y unos

55
00:05:14,160 --> 00:05:18,139
en un fichero y guardarlos allí, es sustancialmente

56
00:05:18,139 --> 00:05:21,860
guardado el objeto, y si luego estos mismos ceros y unos

57
00:05:21,860 --> 00:05:26,220
los vuelvo a leer al revés, pues sustancialmente estoy importando

58
00:05:26,220 --> 00:05:30,420
otra vez lo que estaba escrito en mi memoria RAM cuando había creado ese objeto.

59
00:05:31,680 --> 00:05:34,279
Claramente es más complejo de así, hay que

60
00:05:34,279 --> 00:05:38,779
ver si este objeto como atributos tiene otros objetos pues entonces que hago

61
00:05:38,779 --> 00:05:45,079
posiblemente todo un objeto que sea serializable puede contener como

62
00:05:45,079 --> 00:05:49,220
atributos sólo otros objetos que sean serializable porque si no tengo un

63
00:05:49,220 --> 00:05:53,660
problema tengo dentro un objeto que no puedo serializar no puedo

64
00:05:53,660 --> 00:05:59,779
escribir en un fichero o leer de un fichero pues sería un problema escribir

65
00:05:59,779 --> 00:06:10,819
todo el objeto que he creado. Esto, cuando y si en un futuro veréis la parte de comunicación con

66
00:06:10,819 --> 00:06:17,160
Socket, que sirve para que dos procesos o dos programas en ordenadores distintos comuniquen

67
00:06:17,160 --> 00:06:23,660
entre ellos, pues vuelve a ser lo mismo. Yo puedo pasar un objeto de un lado a otro serializándolo

68
00:06:23,660 --> 00:06:30,060
y pasándolo por un canal de este estilo, en vez de escribirlo en un fichero, en un tubo que

69
00:06:30,060 --> 00:06:36,800
un file reader o un output stream o lo que sea, que en vez que al otro lado

70
00:06:36,800 --> 00:06:41,480
haber un fichero, entonces lo que escribo allí dentro acaba en este fichero, pues al otro

71
00:06:41,480 --> 00:06:45,560
lado tengo otro programa que está allí con un input stream, entonces lo que escribo por un lado

72
00:06:45,560 --> 00:06:53,779
lo lee el otro. Claramente, cuando yo paso un objeto de este estilo, no es el mismo objeto.

73
00:06:53,779 --> 00:06:58,879
Si tengo dos ordenadores, serán dos objetos distintos. Entonces, si luego modifico un

74
00:06:58,879 --> 00:07:05,860
objeto en uno de los ordenadores, el otro ordenador no ve afectado ese objeto. Es una copia, no es una

75
00:07:05,860 --> 00:07:16,040
referencia. Aún así, es realmente complejo esto de la señalización de cómo poner los

76
00:07:16,040 --> 00:07:21,160
oficieros y cosas por el estilo, de cómo poner los datos tanto del oficiero como del otro lado,

77
00:07:21,160 --> 00:07:29,800
y la otra máquina hace lo que puede para mantener las referencias y cosas así. Pero si vosotros os

78
00:07:29,800 --> 00:07:41,360
os empeñáis, posiblemente conseguís destruir lo que es la consistencia de datos de JavaScript.

79
00:07:41,360 --> 00:07:48,339
Repito que esto se usaba, era una forma de guardar los datos, pero hoy en día no es

80
00:07:48,339 --> 00:07:51,540
la forma más propia.

81
00:07:51,540 --> 00:07:56,720
Aún así, os introduzco al concepto de serialización que sí sigue siendo necesario para poder

82
00:07:56,720 --> 00:08:04,879
escribir ficheros donde sea, o mandarlos. Entonces, hemos dicho que el objeto que tengo

83
00:08:04,879 --> 00:08:12,439
que utilizar tiene que ser implementar la interfaz serialized. Estos atributos han de ser de tipo

84
00:08:12,439 --> 00:08:20,180
simple, o sea de tipo primitivo, o otros objetos serialized. Para escribir un objeto en disco,

85
00:08:20,180 --> 00:08:21,399
ahora tengo

86
00:08:21,399 --> 00:08:24,100
object output stream

87
00:08:24,100 --> 00:08:26,060
¿vale? entonces es un

88
00:08:26,060 --> 00:08:27,579
output stream que

89
00:08:27,579 --> 00:08:29,980
es

90
00:08:29,980 --> 00:08:31,819
aumentado, es mejorado

91
00:08:31,819 --> 00:08:33,899
para la gestión de objetos

92
00:08:33,899 --> 00:08:35,740
¿vale? entonces por ejemplo

93
00:08:35,740 --> 00:08:38,299
aquí tengo, como antes hacía como un buffer

94
00:08:38,299 --> 00:08:39,919
de lo que sea, pues ahora tengo

95
00:08:39,919 --> 00:08:41,559
un object output stream

96
00:08:41,559 --> 00:08:44,259
que tiene dentro un file output stream del fichero

97
00:08:44,259 --> 00:08:46,500
que yo quiera, donde quiero escribir

98
00:08:46,500 --> 00:08:48,539
¿vale? para escribir un objeto

99
00:08:48,539 --> 00:08:49,860
tengo una

100
00:08:49,860 --> 00:08:58,980
un método que es WriteObject. Entonces WriteObject de un objeto serializable pues me permite escribir

101
00:08:58,980 --> 00:09:10,740
esto en Fichero. ¿Con qué formato? No tengo idea, no quiero saberlo. Quiero que sea la Java

102
00:09:10,740 --> 00:09:16,679
Virtual Machine que se encargue de guardarlo y si hay alguna referencia que se encargue ella,

103
00:09:16,679 --> 00:09:23,000
si hay algún problema que se encargue ahí. Está claro que tiene su limitación. Para leerlo pues tengo

104
00:09:23,000 --> 00:09:32,500
un object inputStream, se crea así, y tengo un readObject. Tened en cuenta que cuando leo un

105
00:09:32,500 --> 00:09:43,159
objeto pues leo un objeto y luego también tendré que ver qué pasa. Si lo he podido leer, si lo que he leído es null, si...

106
00:09:46,679 --> 00:09:55,679
Una vez que tenga este objeto, pues puedo intentar castearlo al tipo correcto de este objeto, ¿vale?

107
00:09:55,679 --> 00:09:57,679
Pero, cuidado.

108
00:09:57,679 --> 00:10:02,679
También se suele utilizar la serialización para transmitir objetos en red, ¿vale?

109
00:10:02,679 --> 00:10:11,679
Y, en ambos casos, la JavaScript gestiona el formato de los datos del objeto u objetos serializados, ¿vale?

110
00:10:11,679 --> 00:10:18,580
Si yo le digo, guárdame este objeto en el fichero, luego es ella que se encarga de todo.

111
00:10:20,580 --> 00:10:22,200
Inconvenientes de la serialización.

112
00:10:22,639 --> 00:10:24,759
¿Qué puedo encontrarme por ahí?

113
00:10:25,320 --> 00:10:34,639
La clase OutputStreamer no funciona bien del todo cuando intentamos reutilizar una misma referencia para serializar objetos diferentes.

114
00:10:34,639 --> 00:10:41,500
Si yo tengo la referencia, el objeto X, y lo guardo.

115
00:10:41,679 --> 00:10:47,379
Luego modifico cosas e intento guardarlo otra vez, a veces se guía.

116
00:10:48,519 --> 00:10:56,580
Esto es basado sobre todo por el hecho que se intenta optimizar estas cosas.

117
00:10:57,600 --> 00:11:01,700
Entonces hay veces que si yo ya he hecho una escritura de un fichero,

118
00:11:02,039 --> 00:11:05,059
en un fichero de un objeto, y tú me dices vuelve a escribirlo,

119
00:11:05,440 --> 00:11:08,179
pues yo no te lo reescribo porque asumo que ya lo he escrito,

120
00:11:08,279 --> 00:11:09,340
porque lo tengo que escribir otra vez.

121
00:11:09,340 --> 00:11:11,659
entonces

122
00:11:11,659 --> 00:11:13,899
muchas veces para poder

123
00:11:13,899 --> 00:11:16,000
lograr esto tengo que

124
00:11:16,000 --> 00:11:16,840
cerrar

125
00:11:16,840 --> 00:11:20,340
todos los canales de comunicación que tenía

126
00:11:20,340 --> 00:11:22,419
volver a abrirlos

127
00:11:22,419 --> 00:11:24,179
y entonces él no se acuerda que

128
00:11:24,179 --> 00:11:26,200
antes lo había guardado otra vez y volver

129
00:11:26,200 --> 00:11:26,879
a guardarlo

130
00:11:26,879 --> 00:11:30,080
lo que hace engorrosas algunas

131
00:11:30,080 --> 00:11:31,980
opciones porque a veces

132
00:11:31,980 --> 00:11:34,019
para hacer esto pues tengo que reescribir

133
00:11:34,019 --> 00:11:35,980
el bloque de datos enteros

134
00:11:35,980 --> 00:11:37,600
en vez de modificar una cosa pequeña

135
00:11:37,600 --> 00:11:41,620
también cuando output stream escribe

136
00:11:41,620 --> 00:11:43,820
usa una cabecera

137
00:11:43,820 --> 00:11:45,639
¿vale? entonces

138
00:11:45,639 --> 00:11:47,259
escribe en el fichero

139
00:11:47,259 --> 00:11:49,159
no escribe directamente

140
00:11:49,159 --> 00:11:51,940
los objetos, antes pone una cabecera

141
00:11:51,940 --> 00:11:53,039
pone con una introducción

142
00:11:53,039 --> 00:11:55,720
y luego pone los objetos que tú has dicho que guardas

143
00:11:55,720 --> 00:11:58,080
¿vale? si ahora tú vienes

144
00:11:58,080 --> 00:11:59,700
y en vez de crear un objeto

145
00:11:59,700 --> 00:12:00,960
nuevo desde cero

146
00:12:00,960 --> 00:12:03,799
tú dices añádeme más objetos

147
00:12:03,799 --> 00:12:06,039
al añadir más objetos

148
00:12:06,039 --> 00:12:08,919
como hemos hecho en el ejemplo nuestro

149
00:12:08,919 --> 00:12:11,559
de append, de añadirlo al final del fichero

150
00:12:11,559 --> 00:12:13,860
él vuelve a escribir la cabecera

151
00:12:13,860 --> 00:12:17,879
entonces encontramos un fichero

152
00:12:17,879 --> 00:12:20,259
que tiene una cabecera, luego unos objetos

153
00:12:20,259 --> 00:12:22,700
otra vez una cabecera, otra vez unos objetos

154
00:12:22,700 --> 00:12:26,159
y esto cuando lo va a leer no lo interpreta bien

155
00:12:26,159 --> 00:12:30,059
porque no se esperan dos cabeceras

156
00:12:30,059 --> 00:12:32,360
entonces aquí hay

157
00:12:32,360 --> 00:12:34,740
o que reescribir el fichero entero siempre

158
00:12:34,740 --> 00:12:36,879
o si quiero añadir las cosas

159
00:12:36,879 --> 00:12:38,720
al final, pues tengo que

160
00:12:38,720 --> 00:12:39,879
toquetear otro método

161
00:12:39,879 --> 00:12:43,019
y hacer algunas cosas avanzadas.

162
00:12:44,080 --> 00:12:44,200
¿Vale?

163
00:12:44,620 --> 00:12:45,759
Intentaremos hacerlo.

164
00:12:47,000 --> 00:12:48,700
Por estas razones, es mejor

165
00:12:48,700 --> 00:12:50,059
no utilizar ficheros

166
00:12:50,059 --> 00:12:52,440
ni civilización con métodos de persistencia.

167
00:12:52,779 --> 00:12:53,519
Sí, no uno de ellos.

168
00:12:55,019 --> 00:12:55,700
¿Vale?

169
00:12:56,019 --> 00:12:58,299
¿Por qué entonces no hacemos eso directamente?

170
00:12:59,159 --> 00:13:01,039
Porque lleva un mogollón

171
00:13:01,039 --> 00:13:01,720
de tiempo

172
00:13:01,720 --> 00:13:06,899
aparte saber la parte teórica

173
00:13:06,899 --> 00:13:10,080
que necesitamos saber, pero luego también habría

174
00:13:10,080 --> 00:13:12,759
que desplegar una base de datos, hacer que funcione

175
00:13:12,759 --> 00:13:16,120
crearse la base de datos, crear un ORM, configurar

176
00:13:16,120 --> 00:13:18,559
el ORM y eso se vuelve un poco

177
00:13:18,559 --> 00:13:21,899
complejo y digamos que para el nivel

178
00:13:21,899 --> 00:13:24,740
que estáis vosotros y para lo que es programación

179
00:13:24,740 --> 00:13:28,120
tampoco es tan útil, o sea, vosotros estáis a un nivel muy bajo

180
00:13:28,120 --> 00:13:31,259
de aprender a programar, ¿vale? Entonces las cosas avanzadas

181
00:13:31,259 --> 00:13:38,480
la veréis el próximo año, cuando hayáis aprendido, habréis pasado este curso, sepáis programar,

182
00:13:38,820 --> 00:13:46,440
y entonces, sobre la base de programación, pues los profesores de segundos os harán ver cosas bastante más avanzadas.

183
00:13:47,759 --> 00:13:48,820
¿Dudas? Hasta aquí.

184
00:13:51,000 --> 00:13:57,740
Entonces, aquí viene, este de aquí es otro ejemplo de lectura de texto sin báceres reader, ¿vale?

185
00:13:57,740 --> 00:14:07,320
Esto es solo un FileWriter, perdón, esta es una escritura sin nada más, es solo utilizando FileWriter, veis que escribe un string, ¿vale?

186
00:14:07,740 --> 00:14:13,799
Este es otro ejemplo de lectura de texto sin utilizar el BufferedReader, ¿vale?

187
00:14:13,840 --> 00:14:19,620
Va utilizando read, ¿vale? Utilizando sustantivamente carácter por carácter.

188
00:14:19,620 --> 00:14:28,740
Estos son ficheros binarios de escribir un fichero binario utilizando FileOutputStream

189
00:14:28,740 --> 00:14:34,440
y escribiendo cosas, este de aquí es un fichero binario de lectura, ¿vale?

190
00:14:34,440 --> 00:14:37,860
Entonces lo tenéis allí en los ejemplos, lo podéis mirar.

191
00:14:38,700 --> 00:14:40,980
Lo que nos interesa es esto, ¿vale?

192
00:14:41,399 --> 00:14:46,279
Es ficheros binarios donde utilizo ObjectsOutputStream.

193
00:14:46,279 --> 00:14:54,799
Sustantialmente esto es voy a escribir un objeto en un fichero, pero recuerda que cuando yo escribo

194
00:14:54,799 --> 00:15:03,179
un objeto en un fichero, este fichero no es un fichero de texto, si lo abro no entiendo lo que

195
00:15:03,179 --> 00:15:09,379
está escribiendo, es un código, es binario que entenderá la Javascript Machine a la hora de

196
00:15:09,379 --> 00:15:19,629
importar otra vez a la hora de materializar otra vez esto entiende vale entonces por ejemplo aquí

197
00:15:19,629 --> 00:15:25,409
tengo un file output stream la base es siempre la misma el file output stream se conecta a este

198
00:15:25,409 --> 00:15:31,190
fichero de aquí que tengo por aquí pues lo que tengo ahora es también un object output stream

199
00:15:31,190 --> 00:15:38,549
el object output stream pilla el file output stream que está conectado con el fichero y luego tengo

200
00:15:38,549 --> 00:15:46,309
varios métodos como WriteBoolean, WriteDouble, WriteCharge, WriteInt, Write2tf. En particular

201
00:15:46,309 --> 00:15:52,429
a nosotros nos interesa el método WriteObject, que me pide un objeto y me escribe un objeto.

202
00:15:52,429 --> 00:15:59,090
Pero puedo usar este, el ObjectOutputStream también para escribir un tipo booleano, o

203
00:15:59,090 --> 00:16:06,590
sea un tipo primitivo, usando el método correcto. Desde la perspectiva de layer, misma cosa,

204
00:16:06,590 --> 00:16:08,750
inputStream, objectInputStream

205
00:16:08,750 --> 00:16:10,429
con esto de aquí los conecto

206
00:16:10,429 --> 00:16:12,509
de esta forma y luego puedo

207
00:16:12,509 --> 00:16:14,409
leer varias cosas. En particular

208
00:16:14,409 --> 00:16:16,190
puedo leer el

209
00:16:16,190 --> 00:16:18,429
readObject que lee un

210
00:16:18,429 --> 00:16:18,809
objeto.

211
00:16:22,470 --> 00:16:24,129
Esto es una clase

212
00:16:24,129 --> 00:16:25,850
¿vale? Para que sea

213
00:16:25,850 --> 00:16:27,850
serializable tiene que implementarse en el

214
00:16:27,850 --> 00:16:30,110
IceBall. Si no pongo implementarse en el IceBall

215
00:16:30,110 --> 00:16:31,970
no funciona. Es que aquí tiene

216
00:16:31,970 --> 00:16:34,149
sus cosas. Ahora cuando la voy a escribir

217
00:16:34,149 --> 00:16:35,730
pues me escribirá esta

218
00:16:35,730 --> 00:16:36,190
sin forma.

219
00:16:36,190 --> 00:16:43,190
Tengo aquí, por ejemplo, varias personas y lo que está haciendo aquí es BrightObject.

220
00:16:43,190 --> 00:16:50,049
Está claro que este es un ejemplo básico. Si tuviera esto sería mejor tenerlo en una lista,

221
00:16:50,049 --> 00:16:56,129
recorrer la lista y escribir los objetos en la lista. O un array o lo que sea.

222
00:16:56,129 --> 00:17:07,450
Lectura, pues me pongo aquí y hago muchas veces, mientras haya sustancialmente bits

223
00:17:07,450 --> 00:17:15,250
para leer en lo que estoy leyendo, que es un FileInputStream, pues entonces me creo

224
00:17:15,250 --> 00:17:24,930
una nueva persona y esta persona, bueno, esto en realidad podría evitarlo, la leo con ReadObject.

225
00:17:24,930 --> 00:17:33,690
fijaos que obj.readObject me daría un objeto y entonces lo casteo a la persona asumiendo

226
00:17:33,690 --> 00:17:44,380
que sepa que es una persona. Y a este punto la tengo. Y ya está. Aquí viene un poco

227
00:17:44,380 --> 00:17:51,900
de jerarquía de clases de qué deriva de quién, qué opciones hay, cosas por el estilo.

228
00:17:51,900 --> 00:18:00,240
que pasaréis el fin de semana mirando la diferencia entre estas varias clases porque sé que os encanta