1
00:00:00,000 --> 00:00:03,560
ayer habíamos terminado diciendo

2
00:00:03,560 --> 00:00:04,980
que

3
00:00:04,980 --> 00:00:07,700
en Java siempre hay una jerarquía

4
00:00:07,700 --> 00:00:09,019
una jerarquía de herencia

5
00:00:09,019 --> 00:00:11,320
aunque nosotros no la hagamos específicamente

6
00:00:11,320 --> 00:00:13,080
aquí en este ejercicio

7
00:00:13,080 --> 00:00:15,120
si habíamos hecho una jerarquía específica

8
00:00:15,120 --> 00:00:16,580
que era animal

9
00:00:16,580 --> 00:00:19,160
y de animal heredan ave, perro

10
00:00:19,160 --> 00:00:19,960
y pez

11
00:00:19,960 --> 00:00:25,320
pero aunque no hagamos ninguna jerarquía

12
00:00:25,320 --> 00:00:26,800
siempre hay una implícita

13
00:00:26,800 --> 00:00:29,039
porque existe una clase object

14
00:00:29,039 --> 00:00:31,379
una clase object que nos la aporta

15
00:00:31,379 --> 00:00:32,799
la máquina virtual

16
00:00:32,799 --> 00:00:34,659
junto con otras mil

17
00:00:34,659 --> 00:00:37,259
string, scanner, buffer,

18
00:00:37,379 --> 00:00:38,439
reader, bla bla bla

19
00:00:38,439 --> 00:00:41,439
pues existe una clase object

20
00:00:41,439 --> 00:00:42,920
con muy poquitas cosas

21
00:00:42,920 --> 00:00:45,340
de la que todas las clases

22
00:00:45,340 --> 00:00:47,259
heredan si es que

23
00:00:47,259 --> 00:00:49,420
no especificamos que hereden de alguna otra

24
00:00:49,420 --> 00:00:51,179
entonces este sería

25
00:00:51,179 --> 00:00:51,960
el caso de animal

26
00:00:51,960 --> 00:00:54,739
esta clase no hereda de ninguna

27
00:00:54,739 --> 00:00:56,820
pero no es

28
00:00:56,820 --> 00:00:57,560
eh

29
00:00:57,560 --> 00:01:01,039
la parte alta de la jerarquía

30
00:01:01,039 --> 00:01:02,480
no, porque no heredar de ninguna

31
00:01:02,480 --> 00:01:04,060
significa que en realidad

32
00:01:04,060 --> 00:01:06,320
es como si hiciéramos esto

33
00:01:06,320 --> 00:01:09,180
como si heredara de object

34
00:01:09,180 --> 00:01:10,299
vale

35
00:01:10,299 --> 00:01:11,680
entonces no heredar de

36
00:01:11,680 --> 00:01:13,240
no poner nada

37
00:01:13,240 --> 00:01:15,540
es lo mismo que poner esto

38
00:01:15,540 --> 00:01:17,159
entonces todas las clases

39
00:01:17,159 --> 00:01:18,719
todas las clases que hagamos

40
00:01:18,719 --> 00:01:19,960
heredan

41
00:01:19,960 --> 00:01:22,700
de verdad que rabia lo de no tener rotulador

42
00:01:22,700 --> 00:01:23,140
porque

43
00:01:23,140 --> 00:01:25,700
a ver si me compro uno una vez

44
00:01:25,700 --> 00:01:27,020
vale

45
00:01:27,020 --> 00:01:27,540
entonces todas las clases que hagamos

46
00:01:27,540 --> 00:01:28,580
todas las clases en realidad

47
00:01:28,580 --> 00:01:41,719
todas heredan de esta

48
00:01:41,719 --> 00:01:42,719
todas

49
00:01:42,719 --> 00:01:45,140
si no se pone nada

50
00:01:45,140 --> 00:01:47,760
entonces en nuestro ejemplo pues teníamos animal

51
00:01:47,760 --> 00:01:49,080
que

52
00:01:57,540 --> 00:01:59,540
hereda de object

53
00:01:59,540 --> 00:02:01,540
animal hereda de object

54
00:02:01,540 --> 00:02:03,540
porque al no haber puesto

55
00:02:03,540 --> 00:02:05,540
que hereda de ninguna

56
00:02:05,540 --> 00:02:06,540
es como haber puesto esto

57
00:02:06,540 --> 00:02:07,540
hereda de object

58
00:02:07,540 --> 00:02:09,540
entonces ya sabemos lo que significa heredar

59
00:02:09,540 --> 00:02:11,540
heredar significa

60
00:02:11,540 --> 00:02:13,540
que todo lo que haya en object

61
00:02:13,540 --> 00:02:15,540
es como si estuviera aquí también escrito

62
00:02:15,540 --> 00:02:17,540
tanto propiedades como métodos

63
00:02:17,540 --> 00:02:18,540
todo

64
00:02:18,540 --> 00:02:20,540
exceptuando los constructores

65
00:02:20,540 --> 00:02:23,540
los constructores hay que hacerlos específicamente

66
00:02:23,540 --> 00:02:25,540
y ya vimos ayer como

67
00:02:25,540 --> 00:02:26,580
la forma habitual de hacer un proyecto es hacer una propiedad y hacer un objeto

68
00:02:26,580 --> 00:02:28,580
la forma habitual de hacer un constructor en una subclase

69
00:02:28,580 --> 00:02:30,580
suele ser apoyándose

70
00:02:30,580 --> 00:02:32,580
en constructores

71
00:02:32,580 --> 00:02:34,580
que ya hay hechos en la superior

72
00:02:34,580 --> 00:02:36,580
llamándolos con super etcétera

73
00:02:36,580 --> 00:02:38,580
vale entonces animal vale dar todo lo de object que es muy poca cosa

74
00:02:38,580 --> 00:02:40,580
y luego además nosotros

75
00:02:40,580 --> 00:02:42,580
en nuestra aplicación habíamos hecho

76
00:02:42,580 --> 00:02:44,580
pues una clase

77
00:02:44,580 --> 00:02:46,580
ave, perro

78
00:02:46,580 --> 00:02:48,580
de todo y

79
00:02:56,580 --> 00:02:58,580
pues esa clase ave

80
00:02:58,580 --> 00:03:00,580
heredaba de animal

81
00:03:04,580 --> 00:03:06,580
y también teníamos

82
00:03:20,580 --> 00:03:22,580
la clase perro

83
00:03:22,580 --> 00:03:24,580
hereda de animal y así todas

84
00:03:24,580 --> 00:03:26,580
entonces

85
00:03:26,580 --> 00:03:28,580
niveles de jerarquía

86
00:03:28,580 --> 00:03:30,580
puede haber

87
00:03:30,580 --> 00:03:32,580
hasta el infinito

88
00:03:32,580 --> 00:03:34,580
lo que pasa es que hombre

89
00:03:34,580 --> 00:03:36,580
la idea es que cuando uno hace un diseño de clases

90
00:03:36,580 --> 00:03:38,580
sirva para ayudar

91
00:03:38,580 --> 00:03:40,580
para representar la situación

92
00:03:40,580 --> 00:03:42,580
que quiere gestionar y para hacer una especie

93
00:03:42,580 --> 00:03:44,580
pues de pintura

94
00:03:44,580 --> 00:03:46,580
de foto de ella que sea útil

95
00:03:46,580 --> 00:03:48,580
entonces si una jerarquía ya es demasiado grande

96
00:03:48,580 --> 00:03:50,580
seguramente ese diseño que hemos hecho

97
00:03:50,580 --> 00:03:52,580
pues ya empieza a ser confuso

98
00:03:52,580 --> 00:03:54,580
porque que pasa en una jerarquía? ave

99
00:03:54,580 --> 00:03:56,580
ave va a tener

100
00:03:56,580 --> 00:03:58,580
lo que hemos escrito en ella específicamente

101
00:03:58,580 --> 00:04:00,580
eso está claro pero además ave va a tener

102
00:04:00,580 --> 00:04:02,580
aunque nosotros no lo veamos va a tener todo lo que hay en animal

103
00:04:02,580 --> 00:04:04,580
salvo los constructores

104
00:04:04,580 --> 00:04:06,580
pero es que además

105
00:04:06,580 --> 00:04:08,580
ave va a tener todo lo que hay en object

106
00:04:08,580 --> 00:04:10,580
porque lo hereda a través de animal

107
00:04:10,580 --> 00:04:12,580
lo hereda entonces ave va a tener

108
00:04:12,580 --> 00:04:14,580
todo lo que hay en animal excepto constructores

109
00:04:14,580 --> 00:04:16,580
y todo lo que hay en object excepto constructores

110
00:04:16,580 --> 00:04:18,580
entonces si la jerarquía ya empezamos

111
00:04:18,580 --> 00:04:20,580
a hacerla demasiado grande y hacemos clases

112
00:04:20,580 --> 00:04:22,580
que hereden y a su vez que hereden

113
00:04:22,580 --> 00:04:24,580
el lío de clases que se nos queda

114
00:04:24,579 --> 00:04:26,579
pues es muy confuso porque llega un momento

115
00:04:26,579 --> 00:04:28,579
en que ya no sabemos lo que hay dentro de esta clase

116
00:04:28,579 --> 00:04:30,579
tiene tantas cosas que podemos perder

117
00:04:30,579 --> 00:04:32,579
un poquito el control

118
00:04:32,579 --> 00:04:34,579
entonces como todas las herramientas

119
00:04:34,579 --> 00:04:36,579
como todas

120
00:04:36,579 --> 00:04:38,579
hay que usarlas de manera que ayude

121
00:04:38,579 --> 00:04:40,579
que hagan aplicaciones claras

122
00:04:40,579 --> 00:04:42,579
que representen lo que queremos

123
00:04:42,579 --> 00:04:44,579
entonces en la realidad rara vez

124
00:04:44,579 --> 00:04:46,579
hay situaciones que exijan una jerarquía

125
00:04:46,579 --> 00:04:48,579
demasiado profunda

126
00:04:48,579 --> 00:04:50,579
rara vez vale

127
00:04:50,579 --> 00:04:52,579
lo normal es que con dos niveles ya

128
00:04:52,579 --> 00:04:54,579
representen todo lo que queremos

129
00:04:54,579 --> 00:04:56,579
porque más allá de dos niveles se va a complicar

130
00:04:56,579 --> 00:04:58,579
entonces

131
00:04:58,579 --> 00:05:00,579
no olvidemos que todas las clases

132
00:05:00,579 --> 00:05:02,579
de Java heredan de object

133
00:05:02,579 --> 00:05:04,579
todas las que hagamos

134
00:05:04,579 --> 00:05:06,579
si es que no ponemos nada y luego además

135
00:05:06,579 --> 00:05:08,579
de cada una de esas clases

136
00:05:08,579 --> 00:05:10,579
si queremos pues pueden heredar otras

137
00:05:10,579 --> 00:05:12,579
y así vamos haciendo un arbolito

138
00:05:12,579 --> 00:05:14,579
de clases

139
00:05:14,579 --> 00:05:16,579
que

140
00:05:16,579 --> 00:05:18,579
como ya hemos dicho otras veces

141
00:05:18,579 --> 00:05:20,579
se queda un poco pobre

142
00:05:20,579 --> 00:05:22,579
porque

143
00:05:22,579 --> 00:05:24,579
las clases solo pueden heredar de una

144
00:05:24,579 --> 00:05:26,579
solo puede heredar de una

145
00:05:26,579 --> 00:05:28,579
a lo mejor aquí podría haber

146
00:05:28,579 --> 00:05:30,579
otra clase que fuera mamífero

147
00:05:30,579 --> 00:05:32,579
otra clase que fuera mamífero

148
00:05:32,579 --> 00:05:34,579
porque esta aplicación nuestra

149
00:05:34,579 --> 00:05:36,579
pues trabaja con conceptos relacionados con animales

150
00:05:36,579 --> 00:05:38,579
con conceptos relacionados con mamíferos

151
00:05:38,579 --> 00:05:40,579
con lo que sea

152
00:05:40,579 --> 00:05:42,579
bueno en este caso parece que mamífero podría heredar de animal

153
00:05:42,579 --> 00:05:44,579
pero bueno imaginaos que tenemos aquí una clase mamífero

154
00:05:44,579 --> 00:05:46,579
que

155
00:05:46,579 --> 00:05:48,579
va por libre

156
00:05:48,579 --> 00:05:50,579
entonces a lo mejor tendría sentido hacer

157
00:05:50,579 --> 00:05:52,579
que perro

158
00:05:52,579 --> 00:05:54,579
cogiera todo lo de animal

159
00:05:54,579 --> 00:05:56,579
que perro cogiera todo lo de mamífero

160
00:05:56,579 --> 00:05:58,579
porque tiene

161
00:05:58,579 --> 00:06:00,579
la doble personalidad

162
00:06:00,579 --> 00:06:02,579
pues no se puede hay que elegir

163
00:06:02,579 --> 00:06:04,579
o heredo de uno o heredo de otro

164
00:06:04,579 --> 00:06:06,579
entonces eso

165
00:06:06,579 --> 00:06:08,579
nos resta posibilidades

166
00:06:08,579 --> 00:06:10,579
para diseñar nuestras clases

167
00:06:10,579 --> 00:06:12,579
sería más bonito

168
00:06:12,579 --> 00:06:14,579
que una clase pudiera

169
00:06:14,579 --> 00:06:16,579
cogerlo de varias a través de la herencia

170
00:06:16,579 --> 00:06:18,579
pues no puede

171
00:06:18,579 --> 00:06:20,579
entonces como no puede y efectivamente

172
00:06:20,579 --> 00:06:22,579
eso es una limitación un poco fea

173
00:06:22,579 --> 00:06:24,579
un poco fea porque no tiene sentido en la vida real

174
00:06:24,579 --> 00:06:26,579
uno puede tener doble personalidad

175
00:06:26,579 --> 00:06:28,579
y triple y lo que quiera

176
00:06:28,579 --> 00:06:30,579
pues como es una limitación un poco fea

177
00:06:30,579 --> 00:06:32,579
pues entonces se hace

178
00:06:32,579 --> 00:06:34,579
otra cosa más que es lo siguiente

179
00:06:34,579 --> 00:06:36,579
que veremos vale

180
00:06:36,579 --> 00:06:38,579
que son las interfaces y su implementación

181
00:06:38,579 --> 00:06:40,579
pero eso es lo siguiente que veremos

182
00:06:40,579 --> 00:06:42,579
son la misma idea que la herencia

183
00:06:42,579 --> 00:06:44,579
pero incluye unos pequeños matices nada más

184
00:06:44,579 --> 00:06:46,579
bueno pues entonces

185
00:06:46,579 --> 00:06:48,579
como todas heredan de object

186
00:06:48,579 --> 00:06:50,579
que es lo que nos quedamos diciendo ayer

187
00:06:50,579 --> 00:06:52,579
todas tienen cosas ahí

188
00:06:52,579 --> 00:06:54,579
que no estamos viendo

189
00:06:54,579 --> 00:06:56,579
y en particular

190
00:06:56,579 --> 00:06:58,579
hay dos métodos

191
00:06:58,579 --> 00:07:00,579
que toda clase tiene

192
00:07:00,579 --> 00:07:02,579
por el hecho de heredar de object

193
00:07:02,579 --> 00:07:04,579
que sí que son muy útiles

194
00:07:04,579 --> 00:07:06,579
y que se usan continuamente

195
00:07:06,579 --> 00:07:08,579
y que no los hemos programado nosotros

196
00:07:08,579 --> 00:07:10,579
los estamos usando sin haberlos programado

197
00:07:10,579 --> 00:07:12,579
y los está heredando de object

198
00:07:12,579 --> 00:07:14,579
vale vamos a ver eso

199
00:07:14,579 --> 00:07:16,579
y ya dejaríamos medio cerrado

200
00:07:16,579 --> 00:07:18,579
lo de la herencia

201
00:07:18,579 --> 00:07:20,579
vale

202
00:07:20,579 --> 00:07:22,579
bueno pues entonces

203
00:07:22,579 --> 00:07:24,579
vamos a hacernos otra clase

204
00:07:24,579 --> 00:07:26,579
para no volver a

205
00:07:26,579 --> 00:07:28,579
tocar esta ya

206
00:07:28,579 --> 00:07:30,579
habíamos dejado que esta era abstracta

207
00:07:30,579 --> 00:07:32,579
porque tenía un método

208
00:07:32,579 --> 00:07:34,579
que habíamos decidido que fuera abstracto

209
00:07:34,579 --> 00:07:36,579
porque este método

210
00:07:36,579 --> 00:07:38,579
realizar acción del animal

211
00:07:38,579 --> 00:07:40,579
no podíamos definirlo en este punto

212
00:07:40,579 --> 00:07:42,579
en la clase animal no podíamos definirlo

213
00:07:42,579 --> 00:07:44,579
realizar acción del animal

214
00:07:44,579 --> 00:07:46,579
que acción depende

215
00:07:46,579 --> 00:07:48,579
que acción realiza el animal no lo sé

216
00:07:48,579 --> 00:07:50,579
entonces como aquí habíamos decidido

217
00:07:50,579 --> 00:07:52,579
que este método

218
00:07:52,579 --> 00:07:54,579
no podíamos todavía definirlo

219
00:07:54,579 --> 00:07:56,579
entonces pegaba

220
00:07:56,579 --> 00:07:58,579
quedaba más bonito si lo hacíamos abstracto

221
00:07:58,579 --> 00:08:00,579
en lugar de dejarle un cuerpo vacío

222
00:08:00,579 --> 00:08:02,579
y entonces la clase se convertía en abstracta

223
00:08:02,579 --> 00:08:04,579
y ya veíamos las implicaciones que teníamos

224
00:08:04,579 --> 00:08:06,579
que todo lo que heredara de una clase abstracta

225
00:08:06,579 --> 00:08:08,579
estaba obligada

226
00:08:08,579 --> 00:08:10,579
a darle cuerpo a este método

227
00:08:10,579 --> 00:08:12,579
entonces vamos a hacer otra clase

228
00:08:12,579 --> 00:08:14,579
para ver estos métodos que os digo de object

229
00:08:14,579 --> 00:08:16,579
y así no retocamos por enésima vez esta

230
00:08:16,579 --> 00:08:18,579
bueno

231
00:08:18,579 --> 00:08:20,579
pues vamos a hacernos otro animalillo

232
00:08:20,579 --> 00:08:22,579
por ahí

233
00:08:22,579 --> 00:08:24,579
otra clase

234
00:08:24,579 --> 00:08:28,579
no pero que no herede de animal

235
00:08:28,579 --> 00:08:30,579
otra clase cualquiera

236
00:08:32,579 --> 00:08:34,579
clase cuidador yo que sé

237
00:08:34,579 --> 00:08:36,579
por poner algo

238
00:08:38,579 --> 00:08:40,579
vale

239
00:08:40,579 --> 00:08:42,579
cuidador no hereda de animal

240
00:08:42,579 --> 00:08:44,579
un cuidador en la mayoría de los casos

241
00:08:44,579 --> 00:08:46,579
no es un animal

242
00:08:46,579 --> 00:08:48,579
entonces es otra entidad

243
00:08:48,579 --> 00:08:50,579
de mi aplicación esta de animales

244
00:08:50,579 --> 00:08:52,579
de zoológico de lo que sea

245
00:08:52,579 --> 00:08:54,579
es otra entidad cualquiera que hago aparte

246
00:08:54,580 --> 00:08:56,580
vale

247
00:08:56,580 --> 00:08:58,580
esta no la hago heredar de ninguna

248
00:08:58,580 --> 00:09:00,580
no la hago heredar de ninguna

249
00:09:00,580 --> 00:09:02,580
si no la hago heredar de ninguna

250
00:09:02,580 --> 00:09:04,580
significa

251
00:09:04,580 --> 00:09:06,580
que entonces

252
00:09:06,580 --> 00:09:08,580
tiene una herencia implícita

253
00:09:08,580 --> 00:09:10,580
que es de la clase object

254
00:09:10,580 --> 00:09:12,580
vale que es de la clase object

255
00:09:12,580 --> 00:09:14,580
y la clase object

256
00:09:14,580 --> 00:09:16,580
para tenerla aquí al ladito abierta

257
00:09:20,580 --> 00:09:22,580
pues vamos a

258
00:09:22,580 --> 00:09:30,580
a ver

259
00:09:30,580 --> 00:09:32,580
recordad que

260
00:09:32,580 --> 00:09:34,580
aquí la JRE

261
00:09:34,580 --> 00:09:36,580
tiene tropecientos mil paquetes

262
00:09:36,580 --> 00:09:38,580
con tropecientos mil

263
00:09:38,580 --> 00:09:40,580
clases pero tropecientos

264
00:09:44,580 --> 00:09:46,580
por ejemplo tiene aquí en el paquete

265
00:09:46,580 --> 00:09:48,580
java lang en este

266
00:09:48,580 --> 00:09:50,580
tiene tropecientas mil cosas

267
00:09:50,580 --> 00:09:52,580
aquí

268
00:09:52,580 --> 00:09:54,580
bueno pues yo en particular

269
00:09:56,580 --> 00:09:58,580
lógicamente las que tiene

270
00:09:58,580 --> 00:10:00,580
la máquina virtual son las compiladas

271
00:10:00,580 --> 00:10:02,580
las punto clas

272
00:10:02,580 --> 00:10:04,580
porque son las que la máquina virtual

273
00:10:04,580 --> 00:10:06,580
necesita

274
00:10:06,580 --> 00:10:08,580
a ver Moisés te traigo otra vez con Adrián

275
00:10:08,580 --> 00:10:10,580
o traigo

276
00:10:10,580 --> 00:10:12,580
a María me da lo mismo

277
00:10:12,580 --> 00:10:14,580
digo yo

278
00:10:14,580 --> 00:10:16,580
vale aquí está el punto clas

279
00:10:16,580 --> 00:10:18,580
porque el punto clas es la que la máquina virtual

280
00:10:18,580 --> 00:10:20,580
necesita obviamente

281
00:10:20,580 --> 00:10:22,580
pero están

282
00:10:22,580 --> 00:10:24,580
incorporados el Eclipse me incorpora

283
00:10:24,580 --> 00:10:26,580
los fuentes para que yo me facilite

284
00:10:26,580 --> 00:10:28,580
el desarrollo me lo facilite

285
00:10:28,580 --> 00:10:30,580
entonces si yo pincho aquí

286
00:10:30,580 --> 00:10:32,580
no es que se me abra el punto clas porque el punto clas

287
00:10:32,580 --> 00:10:34,580
estaría en un idioma que yo no entiendo

288
00:10:34,580 --> 00:10:36,580
no se me abre el punto clas que es el compilado

289
00:10:36,580 --> 00:10:38,580
lo que hace el Eclipse es buscar

290
00:10:38,580 --> 00:10:40,580
el código fuente que generó ese clas

291
00:10:40,580 --> 00:10:42,580
y me abre ese código fuente

292
00:10:42,580 --> 00:10:44,580
vale pero realmente los ficheros

293
00:10:44,580 --> 00:10:46,580
que están en la máquina virtual que son los que tienen que estar

294
00:10:46,580 --> 00:10:48,580
porque son los que necesita

295
00:10:48,580 --> 00:10:50,580
luego para la ejecución

296
00:10:50,580 --> 00:10:52,580
son los clas obviamente pero bueno

297
00:10:52,580 --> 00:10:54,580
el Eclipse afortunadamente

298
00:10:54,580 --> 00:10:56,580
las últimas versiones desde hace ya tiempo

299
00:10:56,580 --> 00:10:58,580
me incorporan el fuente

300
00:10:58,580 --> 00:11:00,580
entonces si pincháis en cualquiera de ellas

301
00:11:00,580 --> 00:11:02,580
se van a buscar el fuente y te lo abren

302
00:11:02,580 --> 00:11:04,580
entonces en particular

303
00:11:04,580 --> 00:11:06,580
esta

304
00:11:06,580 --> 00:11:08,580
vale vamos a

305
00:11:10,580 --> 00:11:12,580
abrir object

306
00:11:12,580 --> 00:11:14,580
vale

307
00:11:16,580 --> 00:11:18,580
entonces repito

308
00:11:18,580 --> 00:11:20,580
aunque aquí ponga object punto clas

309
00:11:20,580 --> 00:11:22,580
esto no es

310
00:11:22,580 --> 00:11:24,580
object punto clas

311
00:11:24,580 --> 00:11:26,580
object punto clas es un código ya compilado

312
00:11:26,580 --> 00:11:28,580
el bytecode de toda la vida que decíamos

313
00:11:28,580 --> 00:11:30,580
un código que no podíamos nunca jamás

314
00:11:30,580 --> 00:11:32,580
ver en un fichero de texto

315
00:11:32,580 --> 00:11:34,580
nunca jamás podríamos porque no es código fuente

316
00:11:34,580 --> 00:11:36,580
pero ese

317
00:11:36,580 --> 00:11:38,580
punto clas se corresponde

318
00:11:38,580 --> 00:11:40,580
con este código fuente

319
00:11:40,580 --> 00:11:42,580
que está aquí

320
00:11:42,580 --> 00:11:44,580
y en este código fuente hay un montón de cosas

321
00:11:44,580 --> 00:11:46,580
que está heredando

322
00:11:46,580 --> 00:11:48,580
la aplicación

323
00:11:48,580 --> 00:11:50,580
por ejemplo

324
00:11:50,580 --> 00:11:52,580
hay un constructor vacío

325
00:11:52,580 --> 00:11:54,580
hay un constructor vacío

326
00:11:54,580 --> 00:11:56,580
entonces cuando nosotros en cuidador

327
00:11:56,580 --> 00:11:58,580
imaginaos que generamos un constructor

328
00:11:58,580 --> 00:12:00,580
sin parámetros

329
00:12:00,580 --> 00:12:02,580
con el Eclipse

330
00:12:02,580 --> 00:12:04,580
que hacíamos esto

331
00:12:04,580 --> 00:12:06,580
genero un constructor

332
00:12:08,580 --> 00:12:10,580
entonces como no tiene campos

333
00:12:10,580 --> 00:12:12,580
no me deja

334
00:12:12,580 --> 00:12:14,580
no tengo opción de

335
00:12:14,580 --> 00:12:16,580
generarlo de otra manera

336
00:12:16,580 --> 00:12:18,580
si así

337
00:12:18,580 --> 00:12:20,580
vale

338
00:12:20,580 --> 00:12:22,580
cuando generamos el constructor

339
00:12:22,580 --> 00:12:24,580
nosotros directamente con el Eclipse

340
00:12:24,580 --> 00:12:26,580
recordáis que nos aparecía siempre esto

341
00:12:26,580 --> 00:12:28,580
en la primera línea y yo decía

342
00:12:28,580 --> 00:12:30,580
esto que este o no este

343
00:12:30,580 --> 00:12:32,580
es que da exactamente igual

344
00:12:32,580 --> 00:12:34,580
ahora ya entendemos que da exactamente igual

345
00:12:34,580 --> 00:12:36,580
porque que hace esta llamada

346
00:12:36,580 --> 00:12:38,580
llama al constructor de la clase padre

347
00:12:38,580 --> 00:12:40,580
el constructor de la clase

348
00:12:40,580 --> 00:12:42,580
padre cual es

349
00:12:42,580 --> 00:12:44,580
es decir llama al constructor

350
00:12:44,580 --> 00:12:46,580
sin parámetros de la clase padre

351
00:12:46,580 --> 00:12:48,580
que es este

352
00:12:48,580 --> 00:12:50,580
y este constructor que hace nada vacío

353
00:12:50,580 --> 00:12:52,580
por eso ese super

354
00:12:52,580 --> 00:12:54,580
que nos ponía

355
00:12:54,580 --> 00:12:56,580
entre que este y no este nada

356
00:12:56,580 --> 00:12:58,580
no hace absolutamente nada

357
00:12:58,580 --> 00:13:00,580
vale y por eso lo quitábamos

358
00:13:00,580 --> 00:13:02,580
bueno

359
00:13:02,580 --> 00:13:04,580
pues entonces

360
00:13:04,580 --> 00:13:06,580
la clase object tiene ese constructor

361
00:13:06,580 --> 00:13:08,580
que no hace nada

362
00:13:08,580 --> 00:13:10,580
y tiene otras cosas de las cuales dos

363
00:13:10,580 --> 00:13:12,580
si que nos interesan

364
00:13:12,580 --> 00:13:14,580
bueno pues vamos a

365
00:13:14,580 --> 00:13:16,580
a verlo

366
00:13:16,580 --> 00:13:18,580
vamos a ponerle propiedades al cuidador

367
00:13:18,580 --> 00:13:20,580
para poder hacer algo

368
00:13:20,580 --> 00:13:22,580
a ver le ponemos

369
00:13:22,580 --> 00:13:24,580
que el cuidador va a tener

370
00:13:24,580 --> 00:13:26,580
un código

371
00:13:30,580 --> 00:13:32,580
y va a tener un nombre

372
00:13:34,580 --> 00:13:36,580
para no perder

373
00:13:36,580 --> 00:13:38,580
mucho tiempo en propiedades

374
00:13:40,580 --> 00:13:42,580
va a tener

375
00:13:42,580 --> 00:13:44,580
un código y un nombre

376
00:13:44,580 --> 00:13:46,580
entonces en condiciones normales pues siempre hacemos

377
00:13:46,580 --> 00:13:48,580
en las entidades siempre hacemos

378
00:13:48,580 --> 00:13:50,580
constructor con y sin parámetros

379
00:13:50,580 --> 00:13:52,580
y luego getter y setter

380
00:13:52,580 --> 00:13:54,580
vale pues es lo que

381
00:13:54,580 --> 00:13:56,580
vamos a hacer aquí

382
00:13:56,580 --> 00:13:58,580
constructor

383
00:14:00,580 --> 00:14:02,580
con parámetros

384
00:14:04,580 --> 00:14:06,580
y get y set

385
00:14:16,580 --> 00:14:18,580
pues nada

386
00:14:18,580 --> 00:14:20,580
esta es mi entidad normal y corriente

387
00:14:20,580 --> 00:14:22,580
propiedades, constructor

388
00:14:22,580 --> 00:14:24,580
y get y setter

389
00:14:24,580 --> 00:14:26,580
no hereda de nadie

390
00:14:26,580 --> 00:14:28,580
osea no he puesto ningún extens

391
00:14:28,580 --> 00:14:30,580
luego hereda de hoy

392
00:14:30,580 --> 00:14:32,580
vale vamos ahora en un main a hacer cosas con cuidadores

393
00:14:32,580 --> 00:14:34,580
en un main a hacer cosas con cuidadores

394
00:14:38,580 --> 00:14:40,580
pues venga

395
00:14:40,580 --> 00:14:42,580
nos vamos a

396
00:14:44,580 --> 00:14:46,580
a nuestro main

397
00:14:50,580 --> 00:14:52,580
en el que hacíamos las pruebas estas

398
00:14:52,580 --> 00:14:54,580
con los animales

399
00:14:54,580 --> 00:14:56,580
hicimos todas las pruebas

400
00:14:56,580 --> 00:14:58,580
para verle el polimorfismo como funcionaba

401
00:14:58,580 --> 00:15:00,580
etc etc

402
00:15:00,580 --> 00:15:02,580
y para que nos servía

403
00:15:02,580 --> 00:15:04,580
vale

404
00:15:04,580 --> 00:15:06,580
y

405
00:15:06,580 --> 00:15:08,580
vamos a añadir este main

406
00:15:08,580 --> 00:15:10,580
algunas cositas

407
00:15:10,580 --> 00:15:12,580
con el cuidador

408
00:15:12,580 --> 00:15:14,580
le voy a poner aquí

409
00:15:14,580 --> 00:15:16,580
para

410
00:15:16,580 --> 00:15:18,580
indicar que ya estamos

411
00:15:18,580 --> 00:15:20,580
vale vamos a hacer algunas cositas con el cuidador bueno pues vamos a

412
00:15:20,580 --> 00:15:22,580
crear dos cuidadores

413
00:15:22,580 --> 00:15:24,580
por ejemplo dos cuidadores

414
00:15:24,580 --> 00:15:26,580
distintos

415
00:15:28,580 --> 00:15:30,580
un cuidador c1

416
00:15:32,580 --> 00:15:34,580
que sea un cuidador de código 1

417
00:15:34,580 --> 00:15:36,580
y nombre

418
00:15:36,580 --> 00:15:38,580
pues este

419
00:15:38,580 --> 00:15:40,580
ala

420
00:15:40,580 --> 00:15:42,580
ya tenemos un cuidador creado

421
00:15:46,580 --> 00:15:48,580
y ahora vamos a hacer otro

422
00:15:50,580 --> 00:16:08,580
vale tenemos dos cuidadores

423
00:16:08,580 --> 00:16:10,580
con estos cuidadores yo ahora

424
00:16:10,580 --> 00:16:12,580
no puedo hacer nada en realidad

425
00:16:12,580 --> 00:16:14,580
ahora mismo no puedo hacer nada con ellos

426
00:16:14,580 --> 00:16:16,580
porque la clase cuidador

427
00:16:16,580 --> 00:16:18,580
es que no tiene nada

428
00:16:18,580 --> 00:16:20,580
no le he puesto ningún método como para que haga cosas

429
00:16:20,580 --> 00:16:22,580
pues añadirle no se que

430
00:16:22,580 --> 00:16:24,580
asignarle animales

431
00:16:24,580 --> 00:16:26,580
no tiene nada este cuidador no tiene nada

432
00:16:26,580 --> 00:16:28,580
vale

433
00:16:28,580 --> 00:16:30,580
pero por el hecho de

434
00:16:30,580 --> 00:16:32,580
heredar de object

435
00:16:32,580 --> 00:16:34,580
tiene métodos de la clase object que puede usar

436
00:16:34,580 --> 00:16:36,580
y que de hecho usamos

437
00:16:36,580 --> 00:16:38,580
continuamente y que tenemos que entender

438
00:16:38,580 --> 00:16:40,580
muy bien como están funcionando

439
00:16:40,580 --> 00:16:42,580
porque los usamos continuamente

440
00:16:42,580 --> 00:16:44,580
y me refiero en particular a equals

441
00:16:44,580 --> 00:16:46,580
y a toString

442
00:16:46,580 --> 00:16:48,580
vale a equals y a toString

443
00:16:48,580 --> 00:16:50,580
vale vamos con el primer

444
00:16:50,580 --> 00:16:52,580
de ellos

445
00:16:52,580 --> 00:16:54,580
nos vamos a nuestro main

446
00:16:56,580 --> 00:16:58,580
y vamos a poner aquí

447
00:17:00,580 --> 00:17:02,580
la clase cuidador

448
00:17:02,580 --> 00:17:04,579
hereda

449
00:17:04,579 --> 00:17:06,579
el método

450
00:17:08,579 --> 00:17:10,579
toString

451
00:17:10,579 --> 00:17:12,579
de la clase object

452
00:17:14,579 --> 00:17:16,579
lo hereda

453
00:17:16,579 --> 00:17:18,579
yo no tengo ningún toString metido aquí en cuidador

454
00:17:18,579 --> 00:17:20,579
no tengo ninguno

455
00:17:20,579 --> 00:17:22,579
pero sin embargo

456
00:17:22,579 --> 00:17:24,579
pero sin embargo

457
00:17:24,579 --> 00:17:26,579
yo si que puedo aquí

458
00:17:26,579 --> 00:17:28,579
hacer que el objeto

459
00:17:28,579 --> 00:17:30,579
c1

460
00:17:30,579 --> 00:17:32,579
llame al método toString

461
00:17:32,579 --> 00:17:34,579
puedo perfectamente

462
00:17:34,579 --> 00:17:36,579
c1 está llamando al método toString

463
00:17:36,579 --> 00:17:38,579
pero este método

464
00:17:38,579 --> 00:17:40,579
yo no lo he hecho en la clase cuidador

465
00:17:40,579 --> 00:17:42,579
no lo he hecho

466
00:17:42,579 --> 00:17:44,579
pero lo puede llamar porque toString es un método

467
00:17:44,579 --> 00:17:46,579
que está en object

468
00:17:46,579 --> 00:17:48,579
todos los métodos y propiedades salvo constructores

469
00:17:48,579 --> 00:17:50,579
de una superclase

470
00:17:50,579 --> 00:17:52,579
se heredan en la subclase

471
00:17:52,579 --> 00:17:54,579
bueno pues toString es tan obvio

472
00:17:54,579 --> 00:17:56,579
ahora la pregunta sería

473
00:17:56,579 --> 00:17:58,579
y para que me sirve ese método

474
00:17:58,579 --> 00:18:00,579
tiene sentido que yo lo use alguna vez

475
00:18:00,579 --> 00:18:02,579
hombre pues si

476
00:18:02,579 --> 00:18:04,579
pues es un método que si que se usa

477
00:18:04,579 --> 00:18:06,579
a menudo

478
00:18:06,579 --> 00:18:08,579
para que hemos convenido todos

479
00:18:08,579 --> 00:18:10,579
para que convenimos todos

480
00:18:10,579 --> 00:18:12,579
los que

481
00:18:12,579 --> 00:18:14,579
el programa manejaba

482
00:18:14,579 --> 00:18:16,579
para que se use

483
00:18:16,579 --> 00:18:18,579
bueno pues para dar información sobre él

484
00:18:18,579 --> 00:18:20,579
esa es la idea de este método

485
00:18:20,579 --> 00:18:22,579
dar información sobre este objeto

486
00:18:22,579 --> 00:18:24,579
recordad que c1

487
00:18:24,579 --> 00:18:26,579
en realidad es una dirección de memoria

488
00:18:26,579 --> 00:18:28,579
eso es lo que es

489
00:18:28,579 --> 00:18:30,579
es una dirección de memoria

490
00:18:30,579 --> 00:18:32,579
que apunta a un espacio donde ya están las propiedades de c1

491
00:18:32,579 --> 00:18:34,579
en este caso código y nombre

492
00:18:34,579 --> 00:18:36,579
entonces

493
00:18:36,579 --> 00:18:38,579
si yo quiero información sobre ese objeto

494
00:18:38,579 --> 00:18:40,579
pues podría yo construirla

495
00:18:40,579 --> 00:18:42,579
accediendo a c1 punto código

496
00:18:42,579 --> 00:18:44,579
c1 punto nombre

497
00:18:44,579 --> 00:18:46,579
y mostrarlo todo

498
00:18:46,579 --> 00:18:48,579
vale

499
00:18:48,579 --> 00:18:50,579
podríamos hacer eso

500
00:18:50,579 --> 00:18:52,579
pero se ha llegado

501
00:18:52,579 --> 00:18:54,579
de alguna manera al convenio

502
00:18:54,579 --> 00:18:56,579
que este método toString

503
00:18:56,579 --> 00:18:58,579
lo que haga sea

504
00:18:58,579 --> 00:19:00,579
devolver un string

505
00:19:00,579 --> 00:19:02,579
con información sobre el objeto al que

506
00:19:02,579 --> 00:19:04,579
apunta c1

507
00:19:04,579 --> 00:19:06,579
es el convenio al que se llega

508
00:19:06,579 --> 00:19:08,579
que este método sea

509
00:19:08,579 --> 00:19:10,579
el que devuelve un string

510
00:19:10,579 --> 00:19:12,579
con valor de retorno, devuelve un string

511
00:19:12,579 --> 00:19:14,579
con información sobre ese objeto

512
00:19:14,579 --> 00:19:16,579
entonces como devuelve con valor de retorno

513
00:19:16,579 --> 00:19:18,579
un string

514
00:19:18,579 --> 00:19:20,579
de hecho si nos vamos aquí a ver el toString

515
00:19:20,579 --> 00:19:22,579
efectivamente devuelve un string

516
00:19:22,579 --> 00:19:24,579
ese es el toString de object

517
00:19:24,579 --> 00:19:26,579
el que estamos heredando

518
00:19:26,579 --> 00:19:28,579
esto ahora no lo diréis

519
00:19:28,579 --> 00:19:30,579
el toString de object como devuelve un string

520
00:19:30,579 --> 00:19:32,579
pues hombre si quiero yo ver

521
00:19:32,579 --> 00:19:34,579
el efecto

522
00:19:34,579 --> 00:19:36,579
de la llamada

523
00:19:36,579 --> 00:19:38,579
pues hombre

524
00:19:38,579 --> 00:19:40,579
voy a pasárselo a un system.out para mostrarlo

525
00:19:40,579 --> 00:19:42,579
sino no lo voy a poder mostrar

526
00:19:46,579 --> 00:19:52,579
vale pues para eso se conviene

527
00:19:52,579 --> 00:19:54,579
para eso se ha convenido que se use toString

528
00:19:54,579 --> 00:19:56,579
para que devuelva un string

529
00:19:56,579 --> 00:19:58,579
con información de c1

530
00:19:58,579 --> 00:20:00,579
pero claro yo aquí

531
00:20:00,579 --> 00:20:02,579
no es sobre escrito

532
00:20:02,579 --> 00:20:04,579
el método toString en cuidador

533
00:20:04,579 --> 00:20:06,579
no lo es sobre escrito

534
00:20:06,579 --> 00:20:08,579
entonces está tirando del que está en object

535
00:20:08,579 --> 00:20:10,579
está tirando del que está en object

536
00:20:10,579 --> 00:20:12,579
no lo es sobre escrito

537
00:20:12,579 --> 00:20:14,579
y el método que está en object

538
00:20:14,579 --> 00:20:16,579
es un método genérico

539
00:20:16,579 --> 00:20:18,579
que lo que te muestra es una basurilla

540
00:20:18,579 --> 00:20:20,579
el método toString de object

541
00:20:20,579 --> 00:20:22,579
te devuelve

542
00:20:22,579 --> 00:20:24,579
el nombre de la clase

543
00:20:24,579 --> 00:20:26,579
porque getClash te da el nombre de la clase

544
00:20:26,579 --> 00:20:28,579
todo esto

545
00:20:28,579 --> 00:20:30,579
el nombre de la clase

546
00:20:30,579 --> 00:20:32,579
un arroba

547
00:20:32,579 --> 00:20:34,579
y luego un código

548
00:20:34,579 --> 00:20:36,579
un código hash

549
00:20:36,579 --> 00:20:38,579
que ya veremos cuando veamos conjuntos

550
00:20:38,579 --> 00:20:40,579
y tablas hash

551
00:20:40,579 --> 00:20:42,579
que es un código hash

552
00:20:42,579 --> 00:20:44,579
es un código

553
00:20:44,579 --> 00:20:46,579
asociado

554
00:20:46,579 --> 00:20:48,579
si, pero que normalmente tiene un uso

555
00:20:48,579 --> 00:20:50,579
que es tratar de

556
00:20:50,579 --> 00:20:52,579
me sale clasterizar

557
00:20:52,579 --> 00:20:54,579
pero no

558
00:20:54,579 --> 00:20:56,579
se usa para encriptar

559
00:20:56,579 --> 00:20:58,579
es uno de los usos de los códigos hash

560
00:20:58,579 --> 00:21:00,579
pero en general es cuando tienes una diversidad

561
00:21:00,579 --> 00:21:02,579
de objetos muy grande

562
00:21:02,579 --> 00:21:04,579
y los quieres identificar fácilmente

563
00:21:04,579 --> 00:21:06,579
pues les asocias efectivamente un identificador

564
00:21:06,579 --> 00:21:08,579
y ese identificador es el código hash

565
00:21:08,579 --> 00:21:10,579
pero claro

566
00:21:10,579 --> 00:21:12,579
si la idea de ese código hash

567
00:21:12,579 --> 00:21:14,579
es que

568
00:21:14,579 --> 00:21:16,579
te reduzca

569
00:21:16,579 --> 00:21:18,579
la variabilidad de toda esa bolsa de cosas

570
00:21:18,579 --> 00:21:20,579
entonces hay varios objetos

571
00:21:20,579 --> 00:21:22,579
que te pueden llegar al mismo código hash

572
00:21:22,579 --> 00:21:24,579
bueno, ya volveremos sobre ello

573
00:21:24,579 --> 00:21:26,579
pero si, en resumen

574
00:21:26,579 --> 00:21:28,579
el código hash es normalmente una forma sencilla

575
00:21:28,579 --> 00:21:30,579
de identificar a cualquier cosa

576
00:21:30,579 --> 00:21:32,579
en nuestro caso a un objeto

577
00:21:32,579 --> 00:21:34,579
pero puede ser a cualquier cosa

578
00:21:34,579 --> 00:21:36,579
es una forma sencilla de identificar a cualquier cosa

579
00:21:36,579 --> 00:21:38,579
que luego tiene muchos usos

580
00:21:38,579 --> 00:21:40,579
lo tiene en encriptación

581
00:21:40,579 --> 00:21:42,579
lo tiene en almacenamiento

582
00:21:42,579 --> 00:21:44,579
lo tiene en muchas partes

583
00:21:44,579 --> 00:21:46,579
pero en general es un número para identificar una cosa

584
00:21:46,579 --> 00:21:48,579
y luego en función de como lo generes

585
00:21:48,579 --> 00:21:50,579
las reglas de generación

586
00:21:50,579 --> 00:21:52,579
que pueden ser muchas

587
00:21:52,579 --> 00:21:54,579
lo puedes usar para unas cosas o para otras

588
00:21:54,579 --> 00:21:56,579
pero por definición es

589
00:21:56,579 --> 00:21:58,579
un numerito para identificar una cosa

590
00:21:58,579 --> 00:22:00,579
bueno, pues a lo que vamos

591
00:22:00,579 --> 00:22:02,579
el toString este

592
00:22:02,579 --> 00:22:04,579
de object dice, pues yo que sé

593
00:22:04,579 --> 00:22:06,579
yo aquí que hago, un object

594
00:22:06,579 --> 00:22:08,579
pues te doy el nombre de la clase

595
00:22:08,579 --> 00:22:10,579
un arroba y te doy un identificador

596
00:22:10,579 --> 00:22:12,579
un identificador que genero

597
00:22:12,579 --> 00:22:14,579
según una regla

598
00:22:14,579 --> 00:22:16,579
que ahora tiene muy básica

599
00:22:16,579 --> 00:22:18,579
porque es que ni siquiera la tenemos

600
00:22:18,579 --> 00:22:20,579
una regla que tiene muy básica

601
00:22:20,579 --> 00:22:22,579
¿eso nos vale para algo?

602
00:22:22,579 --> 00:22:24,579
pues vaya descripción del objeto más fea

603
00:22:24,579 --> 00:22:26,579
o sea si esa nos gusta

604
00:22:26,579 --> 00:22:28,579
pues venga vamos a ver efectivamente que nos sale

605
00:22:36,579 --> 00:22:38,579
pues esta es

606
00:22:38,579 --> 00:22:40,579
la salida del toString

607
00:22:40,579 --> 00:22:42,579
de object

608
00:22:42,579 --> 00:22:44,579
el nombre de la clase efectivamente

609
00:22:44,579 --> 00:22:46,579
como veis

610
00:22:46,579 --> 00:22:48,579
el nombre de la clase es todo

611
00:22:48,579 --> 00:22:50,579
no os miento, el nombre de la clase no es esto

612
00:22:50,579 --> 00:22:52,579
el nombre de la clase es todo con el paquete

613
00:22:52,579 --> 00:22:54,579
el nombre de la clase un arrobita

614
00:22:54,579 --> 00:22:56,579
y la traducción a código esadecimal

615
00:22:56,579 --> 00:22:58,579
del identificador de hash

616
00:22:58,579 --> 00:23:00,579
hombre pues como salida del método toString

617
00:23:00,579 --> 00:23:02,579
vaya mierda de descripción

618
00:23:02,579 --> 00:23:04,579
de cuidador

619
00:23:04,579 --> 00:23:06,579
no nos vale para nada

620
00:23:06,579 --> 00:23:08,579
entonces ¿qué se suele hacer?

621
00:23:08,579 --> 00:23:10,579
se suele sobreescribir en cada clase

622
00:23:10,579 --> 00:23:12,579
el método toString de object

623
00:23:12,579 --> 00:23:14,579
y es una de las cosas que se suele hacer

624
00:23:14,579 --> 00:23:16,579
por sistema

625
00:23:16,579 --> 00:23:18,579
igual que los constructores

626
00:23:18,579 --> 00:23:20,579
los get y los set

627
00:23:20,579 --> 00:23:22,579
pues igual que los constructores

628
00:23:22,579 --> 00:23:24,579
los get y los set

629
00:23:24,579 --> 00:23:26,579
digamos que en plan churro

630
00:23:26,579 --> 00:23:28,579
como todo de carrerilla

631
00:23:28,579 --> 00:23:30,579
también se sobreescribe toString

632
00:23:30,579 --> 00:23:32,579
para que cada clase de la explicación

633
00:23:32,579 --> 00:23:34,579
que le apetece dar

634
00:23:34,579 --> 00:23:36,579
y no de la de object

635
00:23:36,579 --> 00:23:38,579
que es una basurilla de explicación

636
00:23:38,579 --> 00:23:40,579
entonces

637
00:23:40,579 --> 00:23:42,579
¿cómo sobreescribiríamos toString?

638
00:23:42,579 --> 00:23:44,579
pues para sobreescribir un método

639
00:23:44,579 --> 00:23:46,579
porque hay que respetar la cabecera

640
00:23:46,579 --> 00:23:48,579
tal cual

641
00:23:48,579 --> 00:23:50,579
este es el que yo quiero sobreescribir

642
00:23:50,579 --> 00:23:52,579
de object

643
00:23:52,579 --> 00:23:54,579
pues venga lo voy a sobreescribir aquí

644
00:23:56,579 --> 00:23:58,579
y aquí ya

645
00:23:58,579 --> 00:24:00,579
pongo la descripción que a mi me de la gana

646
00:24:00,579 --> 00:24:02,579
y la descripción que a mi me de la gana

647
00:24:02,579 --> 00:24:04,579
puede ser

648
00:24:06,579 --> 00:24:08,579
código

649
00:24:08,579 --> 00:24:10,579
y lo concateno

650
00:24:10,579 --> 00:24:12,579
con el código que sea

651
00:24:12,579 --> 00:24:14,579
más

652
00:24:14,579 --> 00:24:16,579
nombre

653
00:24:16,579 --> 00:24:18,579
y lo concateno

654
00:24:18,579 --> 00:24:20,579
con el nombre del cuidador

655
00:24:20,579 --> 00:24:22,579
por ejemplo

656
00:24:22,579 --> 00:24:24,579
me puede dar a mi la gana

657
00:24:24,579 --> 00:24:26,579
que este sea el toString

658
00:24:26,579 --> 00:24:28,579
de cuidador

659
00:24:28,579 --> 00:24:30,579
vale este lo describe

660
00:24:30,579 --> 00:24:32,579
pues entonces ahora ya

661
00:24:32,579 --> 00:24:34,579
he pisado

662
00:24:34,579 --> 00:24:36,579
a ver uno de los dos

663
00:24:36,579 --> 00:24:38,579
no es eso uno de los dos

664
00:24:38,579 --> 00:24:40,579
que elija venga

665
00:24:40,579 --> 00:24:42,579
no de verdad

666
00:24:42,579 --> 00:24:44,579
te lo juro lo siento

667
00:24:44,579 --> 00:24:46,579
de verdad es que lo he dicho

668
00:24:46,579 --> 00:24:48,579
me pone muy nerviosa

669
00:24:48,579 --> 00:24:50,579
y si es contigo en todo el brazo

670
00:24:50,579 --> 00:24:52,579
lo siento

671
00:24:52,579 --> 00:24:54,579
y es que además aunque no te lo parezca

672
00:24:54,579 --> 00:24:56,579
soy yo la que te lo deduco

673
00:24:56,579 --> 00:24:58,579
venga quien elige

674
00:25:04,579 --> 00:25:06,579
y aparte que

675
00:25:06,579 --> 00:25:08,579
es estupendo que te explique las cosas

676
00:25:08,579 --> 00:25:10,579
pero fuera de horario

677
00:25:14,579 --> 00:25:16,579
vale

678
00:25:16,579 --> 00:25:18,579
vale

679
00:25:18,579 --> 00:25:20,579
vale

680
00:25:20,579 --> 00:25:22,579
vale

681
00:25:42,579 --> 00:25:44,579
vale

682
00:27:14,579 --> 00:27:16,579
, si nos hemos equivocado

683
00:27:16,579 --> 00:27:18,579
y aquí hemos puesto

684
00:27:18,579 --> 00:27:20,579
en lugar de toString

685
00:27:20,579 --> 00:27:22,579
pues lo hemos llamado de otra manera

686
00:27:22,579 --> 00:27:24,579
y lo hemos llamado así

687
00:27:24,579 --> 00:27:26,579
pues vale estupendo

688
00:27:26,579 --> 00:27:28,579
habremos hecho otro método

689
00:27:28,579 --> 00:27:30,579
habremos hecho otro

690
00:27:30,579 --> 00:27:32,579
pero no estará sobre escribiendo

691
00:27:32,579 --> 00:27:34,579
el toString de object

692
00:27:34,579 --> 00:27:36,579
el que tiene aquí su mayúscula

693
00:27:36,579 --> 00:27:38,579
y el resto del mundo cuando busque nuestra descripción

694
00:27:38,579 --> 00:27:40,579
la va a buscar con el nombre estándar

695
00:27:40,579 --> 00:27:42,579
con el nombre bueno que es el tu con la s mayúscula

696
00:27:42,579 --> 00:27:44,579
entonces tenemos que adaptarnos a eso

697
00:27:44,579 --> 00:27:46,579
y de hecho

698
00:27:46,579 --> 00:27:48,579
es tan importante

699
00:27:48,579 --> 00:27:50,579
que existe una cosa que se llama

700
00:27:50,579 --> 00:27:52,579
anotaciones

701
00:27:52,579 --> 00:27:54,579
para verificar muchas cosas en general

702
00:27:54,579 --> 00:27:56,579
y una de ellas es para verificar

703
00:27:56,579 --> 00:27:58,579
que este método realmente

704
00:27:58,579 --> 00:28:00,579
sobreescribe el de arriba

705
00:28:00,579 --> 00:28:02,579
o es uno que me he inventado

706
00:28:02,579 --> 00:28:04,579
y esa anotación ahora si es el momento de meterla

707
00:28:04,579 --> 00:28:06,579
es esta

708
00:28:10,579 --> 00:28:12,579
arroba

709
00:28:12,579 --> 00:28:14,579
overwrite

710
00:28:14,579 --> 00:28:18,579
que es una anotación en general en java

711
00:28:18,579 --> 00:28:20,579
una anotación en general

712
00:28:20,579 --> 00:28:22,579
es algo que empieza

713
00:28:22,579 --> 00:28:24,579
con la arroba

714
00:28:24,579 --> 00:28:26,579
y tiene un término

715
00:28:26,579 --> 00:28:28,579
que existe una sintaxis

716
00:28:28,579 --> 00:28:30,579
no es comentario

717
00:28:30,579 --> 00:28:32,579
porque los comentarios es algo

718
00:28:32,579 --> 00:28:34,579
que para java no existen

719
00:28:34,579 --> 00:28:36,579
los comentarios son para nosotros

720
00:28:36,579 --> 00:28:38,579
para el programador que está leyendo el código

721
00:28:38,579 --> 00:28:40,579
para java no existen

722
00:28:40,579 --> 00:28:42,579
entonces no es comentario

723
00:28:42,579 --> 00:28:44,579
pero tampoco es código

724
00:28:44,579 --> 00:28:46,579
que se ejecute

725
00:28:46,579 --> 00:28:48,579
es información sobre el código

726
00:28:48,579 --> 00:28:50,579
que la máquina virtual

727
00:28:50,579 --> 00:28:52,579
si tiene en cuenta

728
00:28:52,579 --> 00:28:54,579
eso es en general el concepto de anotación

729
00:28:54,579 --> 00:28:56,579
entonces configura partes del código

730
00:28:56,579 --> 00:28:58,579
y hace muchas cosas

731
00:28:58,579 --> 00:29:00,579
ahora mismo este año no vamos a tener la necesidad

732
00:29:00,579 --> 00:29:02,579
de incorporar anotaciones en nuestros códigos

733
00:29:02,579 --> 00:29:04,579
pero en segundo continuamente

734
00:29:04,579 --> 00:29:06,579
habrá que incorporar anotaciones

735
00:29:06,579 --> 00:29:08,579
para identificar bien esos códigos

736
00:29:08,579 --> 00:29:10,579
bueno pues esta si es importante ahora

737
00:29:10,579 --> 00:29:12,579
ya que la metamos

738
00:29:12,579 --> 00:29:14,579
¿qué significa?

739
00:29:14,579 --> 00:29:16,579
ojo que el método que viene después

740
00:29:16,579 --> 00:29:18,579
sobre escribe uno de la clase

741
00:29:18,579 --> 00:29:20,579
de la que heredas

742
00:29:20,579 --> 00:29:22,579
¿no? de hecho

743
00:29:22,579 --> 00:29:24,579
te lo está diciendo sobre escritura

744
00:29:24,579 --> 00:29:26,579
te lo está diciendo

745
00:29:26,579 --> 00:29:28,579
ojo que este método sobre escribe el de arriba

746
00:29:28,579 --> 00:29:30,579
entonces no es obligatoria

747
00:29:30,579 --> 00:29:32,579
podemos ponerla o no podemos ponerla

748
00:29:32,579 --> 00:29:34,579
yo puedo no ponerla

749
00:29:36,579 --> 00:29:38,579
puedo no ponerla

750
00:29:38,579 --> 00:29:40,579
y simplemente

751
00:29:40,579 --> 00:29:42,579
el hecho de que esta cabecera

752
00:29:42,579 --> 00:29:44,579
sea idéntica calcada

753
00:29:44,579 --> 00:29:46,579
a la cabecera de object

754
00:29:46,579 --> 00:29:48,579
a esta

755
00:29:48,579 --> 00:29:50,579
el hecho de que sea calcada

756
00:29:50,579 --> 00:29:52,579
ya eso implica que está sobre escribiendo

757
00:29:52,579 --> 00:29:54,579
ya eso implica

758
00:29:54,579 --> 00:29:56,579
que está sobre escribiendo

759
00:29:56,579 --> 00:29:58,579
no hace falta ponerla

760
00:29:58,579 --> 00:30:00,579
pero ponerla es útil

761
00:30:00,579 --> 00:30:02,579
¿por qué?

762
00:30:02,579 --> 00:30:04,579
si yo la pongo en todos los métodos

763
00:30:04,579 --> 00:30:06,579
que quiero que mi intención es que sean sobre escritos

764
00:30:06,579 --> 00:30:08,579
la pongo y luego resulta que me equivoco

765
00:30:08,579 --> 00:30:10,579
y lo escribo mal

766
00:30:10,579 --> 00:30:12,579
automáticamente

767
00:30:12,579 --> 00:30:14,579
el compilador va a detectar que hay un problema

768
00:30:14,579 --> 00:30:16,579
te dice uy me dices que este sobre escrito

769
00:30:16,579 --> 00:30:18,579
pues yo no lo conozco

770
00:30:18,579 --> 00:30:20,579
en la clase padre no está

771
00:30:20,579 --> 00:30:22,579
algo falla

772
00:30:22,579 --> 00:30:24,579
entonces es muy útil ponerla

773
00:30:24,579 --> 00:30:26,579
porque te avisa no vaya a ser que te hayas equivocado

774
00:30:26,579 --> 00:30:28,579
a la hora de poner la cabecera

775
00:30:28,579 --> 00:30:30,579
y no estés sobre escribiendo sino que estás haciendo otro

776
00:30:30,579 --> 00:30:32,579
no estás haciendo otro distinto

777
00:30:32,579 --> 00:30:34,579
entonces te permite detectar eso

778
00:30:34,579 --> 00:30:36,579
por eso es útil

779
00:30:36,579 --> 00:30:38,579
esta anotación

780
00:30:38,579 --> 00:30:40,579
¿vale?

781
00:30:40,579 --> 00:30:42,579
si yo tengo una anotación puesta

782
00:30:42,579 --> 00:30:44,579
y lo escribo mal

783
00:30:44,579 --> 00:30:46,579
a lo mejor me creo que estoy sobre escribiendo

784
00:30:46,579 --> 00:30:48,579
el método toString

785
00:30:48,579 --> 00:30:50,579
y no lo estás sobre escribiendo

786
00:30:50,579 --> 00:30:52,579
estás haciendo otro distinto

787
00:30:52,579 --> 00:30:54,579
y entonces ya vas a tener los dos coexistiendo

788
00:30:54,579 --> 00:30:56,579
heredado de object que no ves

789
00:30:56,579 --> 00:30:58,579
y el nuevo que has hecho

790
00:30:58,579 --> 00:31:00,579
y eso es un problema

791
00:31:00,579 --> 00:31:02,579
porque el resto de clases van a estar llamando al heredado que no ves

792
00:31:02,579 --> 00:31:04,579
este es como si no existiera

793
00:31:04,579 --> 00:31:06,579
¿vale?

794
00:31:06,579 --> 00:31:08,579
pues la utilidad de la anotación es esa

795
00:31:08,579 --> 00:31:10,579
¿vale?

796
00:31:10,579 --> 00:31:12,579
vale pues entonces

797
00:31:12,579 --> 00:31:14,579
si yo sobre escribo toString y decido así

798
00:31:14,579 --> 00:31:16,579
pues hala estupendo

799
00:31:16,579 --> 00:31:18,579
ahora yo cuando en mi main

800
00:31:18,579 --> 00:31:20,579
haga un system.out.println de c1

801
00:31:20,579 --> 00:31:22,579
en lugar de salirme esa cosa rara

802
00:31:22,579 --> 00:31:24,579
me llamará

803
00:31:24,579 --> 00:31:26,579
me llamará al toString de c1

804
00:31:26,579 --> 00:31:28,579
y ya no llamará al toString de object

805
00:31:28,579 --> 00:31:30,579
llamará al suyo propio que ha sobre escrito

806
00:31:30,579 --> 00:31:32,579
y entonces ahora ya si

807
00:31:32,579 --> 00:31:34,579
que nos saldrá algo pues más bonito

808
00:31:34,579 --> 00:31:36,579
¿vale?

809
00:31:36,579 --> 00:31:38,579
nos saldrá la descripción

810
00:31:38,579 --> 00:31:40,579
anda ahora si que me salen las tildes

811
00:31:40,579 --> 00:31:42,579
ah bueno es que siempre me han salido aquí

812
00:31:42,579 --> 00:31:44,579
bueno da igual

813
00:31:44,579 --> 00:31:46,579
entonces nos da una descripción más bonita

814
00:31:46,579 --> 00:31:48,579
¿vale?

815
00:31:48,579 --> 00:31:50,579
bueno pues entonces el método toString es un método

816
00:31:50,579 --> 00:31:52,579
que vais a ver continuamente

817
00:31:52,579 --> 00:31:54,579
que se incorpora en las entidades

818
00:31:54,579 --> 00:31:56,579
porque ofrece

819
00:31:56,579 --> 00:31:58,579
ofrece una

820
00:31:58,579 --> 00:32:00,579
manera de

821
00:32:00,579 --> 00:32:02,579
obtener una descripción mediante texto

822
00:32:02,579 --> 00:32:04,579
de un objeto mediante texto

823
00:32:04,579 --> 00:32:06,579
y a ese método toString

824
00:32:06,579 --> 00:32:08,579
puede que recurran

825
00:32:08,579 --> 00:32:10,579
hay muchas clases por ahí

826
00:32:10,579 --> 00:32:12,579
puede que recurran

827
00:32:12,579 --> 00:32:14,579
entonces vamos a sobre escribirlo bien

828
00:32:14,579 --> 00:32:16,579
vamos a sobre escribirlo

829
00:32:16,579 --> 00:32:18,579
y así esas clases que recurran a él

830
00:32:18,579 --> 00:32:20,579
no van a tirar del de object del heredado

831
00:32:20,579 --> 00:32:22,579
que saca una información muy extraña

832
00:32:22,579 --> 00:32:24,579
¿vale?

833
00:32:28,579 --> 00:32:30,579
bueno tanto es así lo de la utilidad de toString

834
00:32:30,579 --> 00:32:32,579
que de hecho

835
00:32:32,579 --> 00:32:34,579
el propio clipse

836
00:32:34,579 --> 00:32:36,579
me ofrece generarlo automáticamente

837
00:32:36,579 --> 00:32:38,579
voy a comentar

838
00:32:38,579 --> 00:32:40,579
el nuestro

839
00:32:40,579 --> 00:32:42,579
voy a comentar este

840
00:32:42,579 --> 00:32:44,579
¿vale? entonces

841
00:32:44,579 --> 00:32:46,579
si nos vamos de nuevo al

842
00:32:46,579 --> 00:32:48,579
botón derecho para ver lo que me ofrece

843
00:32:48,579 --> 00:32:50,579
la pestaña source este

844
00:32:50,579 --> 00:32:52,579
pues una de las cosas que ofrece es

845
00:32:52,579 --> 00:32:54,579
genera automáticamente un toString

846
00:32:54,579 --> 00:32:56,579
genera uno

847
00:32:56,579 --> 00:32:58,579
le damos

848
00:32:58,579 --> 00:33:00,579
y te dice a ver

849
00:33:00,579 --> 00:33:02,579
¿qué campus quieres que se incluya en la descripción?

850
00:33:02,579 --> 00:33:04,579
pues quiero que se incluya

851
00:33:04,579 --> 00:33:06,579
código y nombre solamente

852
00:33:06,579 --> 00:33:08,579
métodos ninguno porque te genera automáticamente

853
00:33:08,580 --> 00:33:10,580
unas descripciones muy extrañas

854
00:33:10,580 --> 00:33:12,580
vale pues ya está

855
00:33:12,580 --> 00:33:14,580
te lo crea

856
00:33:14,580 --> 00:33:16,580
te dice venga ¿te gusta este toString?

857
00:33:16,580 --> 00:33:18,580
que te devuelve este texto tan chulo

858
00:33:18,580 --> 00:33:20,580
pues si y te pone el override

859
00:33:20,580 --> 00:33:22,580
claro y te lo deja ya muy bien

860
00:33:22,580 --> 00:33:24,580
¿te gusta este toString?

861
00:33:24,580 --> 00:33:26,580
bueno pues puede ser

862
00:33:26,580 --> 00:33:28,580
vamos a volver a probar en nuestro main

863
00:33:28,580 --> 00:33:30,580
a ver si nos gusta

864
00:33:30,580 --> 00:33:32,580
pues este

865
00:33:32,580 --> 00:33:34,580
este es el toString que te genera el clipse

866
00:33:34,580 --> 00:33:36,580
bueno

867
00:33:36,580 --> 00:33:38,580
pues es cómodo

868
00:33:38,580 --> 00:33:40,580
vale entonces es una buena práctica

869
00:33:40,580 --> 00:33:42,580
que todas nuestras clases tengan toString

870
00:33:42,580 --> 00:33:44,580
porque nunca sabemos cuando alguien

871
00:33:44,580 --> 00:33:46,580
va a llamarlo

872
00:33:46,580 --> 00:33:48,580
entonces para ofrecerle un arroba

873
00:33:48,580 --> 00:33:50,580
un código hash o no se que

874
00:33:50,580 --> 00:33:52,580
pues para eso le ofrecemos un mensajito

875
00:33:52,580 --> 00:33:54,580
un poco más

876
00:33:54,580 --> 00:33:56,580
más bonito

877
00:33:58,580 --> 00:34:00,580
vale pues esto en cuanto al toString

878
00:34:00,580 --> 00:34:02,580
de nuevo nos está sirviendo para ver

879
00:34:02,580 --> 00:34:04,580
un ejemplo de

880
00:34:04,580 --> 00:34:06,580
Mario

881
00:34:06,580 --> 00:34:08,579
sobrescritura de métodos

882
00:34:08,579 --> 00:34:10,579
vale

883
00:34:10,579 --> 00:34:12,579
y recordad

884
00:34:12,579 --> 00:34:14,579
que la sobrescritura

885
00:34:14,579 --> 00:34:16,579
implica automáticamente

886
00:34:16,579 --> 00:34:18,579
un polimorfismo el método toString

887
00:34:18,579 --> 00:34:20,579
es el más polimorfo del mundo

888
00:34:20,579 --> 00:34:22,579
si al toString lo llama un objeto cuidador

889
00:34:22,579 --> 00:34:24,579
mostrará la descripción del cuidador

890
00:34:24,579 --> 00:34:26,579
pero si al toString lo llama un objeto

891
00:34:26,579 --> 00:34:28,579
no se que mostrará al toString de ese objeto

892
00:34:28,579 --> 00:34:30,579
vale que eso era el polimorfismo

893
00:34:30,579 --> 00:34:32,579
dependiendo del objeto

894
00:34:32,579 --> 00:34:34,579
que lo llame ese método con

895
00:34:34,579 --> 00:34:36,579
ese mismo nombre hace cosas distintas

896
00:34:40,579 --> 00:34:42,579
bueno pues hala eso en cuanto al toString

897
00:34:42,579 --> 00:34:44,579
y el segundo

898
00:34:44,579 --> 00:34:46,579
que nos interesa heredado de

899
00:34:46,579 --> 00:34:48,579
object que se usa continuamente

900
00:34:48,579 --> 00:34:50,579
segundo que nos interesa

901
00:34:50,579 --> 00:34:52,579
y que cuando veamos las colecciones

902
00:34:52,579 --> 00:34:54,579
es imprescindible

903
00:34:54,579 --> 00:34:56,579
manejarlo con soltura

904
00:34:56,579 --> 00:34:58,579
el equals

905
00:34:58,579 --> 00:35:00,579
vale pues entonces yo aquí ahora

906
00:35:00,579 --> 00:35:02,579
en cuidador tengo los get los set

907
00:35:02,579 --> 00:35:04,579
y el toString

908
00:35:04,579 --> 00:35:06,579
son los que tengo

909
00:35:06,579 --> 00:35:08,579
la versión que queráis

910
00:35:08,579 --> 00:35:10,579
la que genera el eclipse la nuestra la que queráis

911
00:35:10,579 --> 00:35:12,579
vale

912
00:35:12,579 --> 00:35:14,579
y ya no tengo más

913
00:35:14,579 --> 00:35:16,579
pero efectivamente en mi main

914
00:35:16,579 --> 00:35:18,579
yo si puedo seguir llamando a métodos

915
00:35:18,579 --> 00:35:20,579
que yo no he hecho

916
00:35:20,579 --> 00:35:22,579
porque los he heredado con toString

917
00:35:22,579 --> 00:35:24,579
por ejemplo hay un método que hemos usado

918
00:35:24,579 --> 00:35:26,579
con la clase string sin entenderlo

919
00:35:26,579 --> 00:35:28,579
en realidad

920
00:35:28,579 --> 00:35:30,579
que es el método equals

921
00:35:30,579 --> 00:35:32,579
vale

922
00:35:32,579 --> 00:35:34,579
el método equals

923
00:35:36,579 --> 00:35:38,579
es un método

924
00:35:38,579 --> 00:35:40,579
que hasta ahora lo hemos

925
00:35:40,579 --> 00:35:42,579
usado asociado

926
00:35:42,579 --> 00:35:44,579
a un objeto string

927
00:35:44,579 --> 00:35:46,579
y pasándole como parámetro otro

928
00:35:46,579 --> 00:35:48,579
objeto string

929
00:35:48,579 --> 00:35:50,579
pero eso no significa que solamente

930
00:35:50,579 --> 00:35:52,579
los objetos

931
00:35:52,579 --> 00:35:54,579
string puedan llamar a equals

932
00:35:54,579 --> 00:35:56,579
a equals lo puede llamar cualquier objeto

933
00:35:56,579 --> 00:35:58,579
del mundo cualquiera

934
00:35:58,579 --> 00:36:00,579
y porque lo puede llamar cualquier objeto del mundo

935
00:36:00,579 --> 00:36:02,579
pues porque

936
00:36:02,579 --> 00:36:04,579
equals está en la clase object

937
00:36:04,579 --> 00:36:06,579
es este

938
00:36:06,579 --> 00:36:08,579
está en la clase object

939
00:36:08,579 --> 00:36:10,579
vale

940
00:36:10,579 --> 00:36:12,579
y el método equals de la clase object

941
00:36:12,579 --> 00:36:14,579
te dice tu pasame

942
00:36:14,579 --> 00:36:16,579
cualquier cosa que sea un object

943
00:36:16,579 --> 00:36:18,579
y de nuevo

944
00:36:18,579 --> 00:36:20,579
ya sabemos que en una referencia

945
00:36:20,579 --> 00:36:22,579
caben objetos de esa clase

946
00:36:22,579 --> 00:36:24,579
y de todas las herederas

947
00:36:24,579 --> 00:36:26,579
entonces como todas las clases que uno dejaba

948
00:36:26,579 --> 00:36:28,579
todas cualquiera todas van a heredar de object

949
00:36:28,579 --> 00:36:30,579
en última instancia todas

950
00:36:30,579 --> 00:36:32,579
pues a equals se le puede pasar

951
00:36:32,579 --> 00:36:34,579
cualquier tipo de objeto cualquiera

952
00:36:34,579 --> 00:36:36,579
a equals se le puede pasar cualquier objeto

953
00:36:36,579 --> 00:36:38,579
cualquiera

954
00:36:38,579 --> 00:36:40,579
vale y que devuelve el método

955
00:36:40,579 --> 00:36:42,579
equals de object

956
00:36:42,579 --> 00:36:44,579
un boolean

957
00:36:44,579 --> 00:36:46,579
vale un boolean

958
00:36:46,579 --> 00:36:48,579
entonces y que hace este método

959
00:36:48,579 --> 00:36:50,579
equals en object que hace este método

960
00:36:50,579 --> 00:36:52,579
equals te devuelve true

961
00:36:52,579 --> 00:36:54,579
si la dirección

962
00:36:54,579 --> 00:36:56,579
de memoria de este objeto

963
00:36:56,579 --> 00:36:58,579
es la misma dirección de memoria

964
00:36:58,579 --> 00:37:00,579
del objeto que llame al método

965
00:37:00,579 --> 00:37:02,579
eso es lo que te devuelve

966
00:37:02,579 --> 00:37:04,579
el equals de object

967
00:37:04,579 --> 00:37:06,579
nos interesa esa versión de equals

968
00:37:06,579 --> 00:37:08,579
nos interesa esa versión de equals

969
00:37:08,579 --> 00:37:10,579
puede que nos interese

970
00:37:10,579 --> 00:37:12,579
puede que no normalmente no

971
00:37:12,579 --> 00:37:14,579
porque no tiene mucho sentido

972
00:37:14,579 --> 00:37:16,579
realista y práctico

973
00:37:16,579 --> 00:37:18,579
vamos a verlo

974
00:37:18,579 --> 00:37:20,579
a ver entendemos que al haber aquí un doble igual

975
00:37:20,579 --> 00:37:22,579
esto significa el contenido

976
00:37:22,579 --> 00:37:24,579
de este variable objeto

977
00:37:24,579 --> 00:37:26,579
y el contenido del variable objeto

978
00:37:26,579 --> 00:37:28,579
es la dirección de memoria eso lo tenemos clarísimo

979
00:37:28,579 --> 00:37:30,579
y esto significa el contenido

980
00:37:30,579 --> 00:37:32,579
de esta variable no a lo que apunta

981
00:37:32,579 --> 00:37:34,579
el contenido es su dirección

982
00:37:34,579 --> 00:37:36,579
entonces el método equals

983
00:37:36,579 --> 00:37:38,579
de object va a devolver true

984
00:37:38,579 --> 00:37:40,579
si las dos direcciones de memoria

985
00:37:40,579 --> 00:37:42,579
del que llama equals

986
00:37:42,579 --> 00:37:44,579
y el pasado son la misma idéntica

987
00:37:44,579 --> 00:37:46,579
y va a devolver el false si no

988
00:37:46,579 --> 00:37:48,579
vale

989
00:37:48,579 --> 00:37:50,579
lo tenemos claro que eso es lo que hace

990
00:37:50,579 --> 00:37:52,579
el método equals tal cual

991
00:37:52,579 --> 00:37:54,579
bueno pues entonces

992
00:37:54,579 --> 00:37:56,579
con eso si yo llamo

993
00:37:56,579 --> 00:37:58,579
equals

994
00:38:02,579 --> 00:38:12,579
si yo llamo al método equals

995
00:38:12,579 --> 00:38:14,579
de object lo llama el objeto c1

996
00:38:14,579 --> 00:38:16,579
y le paso como parámetro

997
00:38:16,579 --> 00:38:18,579
c2

998
00:38:18,579 --> 00:38:20,579
que va a hacer el if o el else

999
00:38:22,579 --> 00:38:24,579
el if o el else

1000
00:38:24,579 --> 00:38:26,579
el else porque c1 es un objeto

1001
00:38:26,579 --> 00:38:28,579
apuntado por su dirección de memoria

1002
00:38:28,579 --> 00:38:30,579
y c2 es otro

1003
00:38:30,579 --> 00:38:32,579
eso está claro ¿no?

1004
00:38:32,579 --> 00:38:38,579
vale

1005
00:38:38,579 --> 00:38:40,579
si yo tengo aquí

1006
00:38:44,579 --> 00:38:46,579
c1 pues nada

1007
00:38:46,579 --> 00:38:48,579
c1

1008
00:38:48,579 --> 00:38:50,579
es

1009
00:38:52,579 --> 00:38:54,579
c1 es en realidad

1010
00:38:54,579 --> 00:38:56,579
la dirección de memoria

1011
00:38:56,579 --> 00:38:58,579
de un espacio

1012
00:38:58,579 --> 00:39:00,579
en memoria

1013
00:39:00,579 --> 00:39:02,579
para contener ya las propiedades de código

1014
00:39:02,579 --> 00:39:04,579
vale y c2 que es

1015
00:39:08,579 --> 00:39:10,579
c2 es

1016
00:39:16,579 --> 00:39:18,579
otra dirección de memoria

1017
00:39:18,579 --> 00:39:20,579
otra distinta

1018
00:39:22,579 --> 00:39:24,579
que está ahí para contener las propiedades

1019
00:39:24,579 --> 00:39:26,579
de otro objeto

1020
00:39:26,579 --> 00:39:28,579
esto es lo que tenemos

1021
00:39:28,579 --> 00:39:30,579
luego c1 no es igual a c2

1022
00:39:30,579 --> 00:39:32,579
está claro c1 es una dirección de memoria

1023
00:39:32,579 --> 00:39:34,579
una dirección que lleva aquí

1024
00:39:34,579 --> 00:39:36,579
y c2 es una dirección que lleva aquí

1025
00:39:36,579 --> 00:39:38,579
c1 es igual a c2

1026
00:39:38,579 --> 00:39:40,579
vale

1027
00:39:40,579 --> 00:39:42,579
pues vamos a comprobarlo

1028
00:39:42,579 --> 00:39:44,579
entonces si ejecutamos esto

1029
00:39:48,579 --> 00:39:50,579
pues me dice que distintos

1030
00:39:50,579 --> 00:39:52,579
vale

1031
00:39:52,579 --> 00:39:54,579
vale y nosotros podríamos tirar

1032
00:39:54,579 --> 00:39:56,579
con ese sentido de equals

1033
00:39:56,579 --> 00:39:58,579
pero ese sentido de equals

1034
00:39:58,579 --> 00:40:00,579
no es el sentido real

1035
00:40:00,579 --> 00:40:02,579
en una aplicación

1036
00:40:02,579 --> 00:40:04,579
en una aplicación

1037
00:40:04,579 --> 00:40:06,579
para que las cosas tengan sentido

1038
00:40:06,579 --> 00:40:08,579
el criterio de igualdad no es ese

1039
00:40:08,579 --> 00:40:10,579
el criterio de igualdad siempre es

1040
00:40:10,579 --> 00:40:12,579
que las claves primarias sean la misma

1041
00:40:12,579 --> 00:40:14,579
por ejemplo si yo tengo dos personas

1042
00:40:14,579 --> 00:40:16,579
y las dos tienen el mismo nif

1043
00:40:16,579 --> 00:40:18,579
para mi aplicación

1044
00:40:18,579 --> 00:40:20,579
tienen que ser iguales

1045
00:40:20,579 --> 00:40:22,579
porque si no pierde el sentido la aplicación

1046
00:40:22,579 --> 00:40:24,579
no

1047
00:40:24,579 --> 00:40:26,579
si tengo

1048
00:40:26,579 --> 00:40:28,579
osea cada entidad

1049
00:40:28,579 --> 00:40:30,579
tendrá su código primario su clave principal

1050
00:40:30,579 --> 00:40:32,579
si estoy trabajando con clientes

1051
00:40:32,579 --> 00:40:34,579
cada cliente tiene un código

1052
00:40:34,579 --> 00:40:36,579
o con pedidos y cada pedido tiene un código

1053
00:40:36,579 --> 00:40:38,579
o con facturas que ahí se ve más claro

1054
00:40:38,579 --> 00:40:40,579
cada factura tiene un número de factura

1055
00:40:40,579 --> 00:40:42,579
entonces si mi aplicación ve

1056
00:40:42,579 --> 00:40:44,579
dos facturas que tienen

1057
00:40:44,579 --> 00:40:46,579
el mismo número de factura

1058
00:40:46,579 --> 00:40:48,579
a todos los efectos

1059
00:40:48,579 --> 00:40:50,579
para la aplicación tienen que ser la misma

1060
00:40:50,579 --> 00:40:52,579
porque si no pierde su sentido

1061
00:40:52,579 --> 00:40:54,579
entonces para que las aplicaciones sean coherentes

1062
00:40:54,579 --> 00:40:56,579
objetos

1063
00:40:56,579 --> 00:40:58,579
que tienen la misma clave primaria

1064
00:40:58,579 --> 00:41:00,579
que tienen el mismo identificador único

1065
00:41:00,579 --> 00:41:02,579
tienen que ser el mismo

1066
00:41:02,579 --> 00:41:04,579
tienen que ser el mismo

1067
00:41:04,579 --> 00:41:06,579
lo que pasa es que a lo mejor han aparecido duplicados

1068
00:41:06,579 --> 00:41:08,579
o lo que sea

1069
00:41:08,579 --> 00:41:10,579
pero los efectos de trabajo tienen que ser considerados

1070
00:41:10,579 --> 00:41:12,579
como el mismo y como iguales

1071
00:41:12,579 --> 00:41:14,579
luego el criterio de igualdad real

1072
00:41:14,579 --> 00:41:16,579
que es el que tiene que reproducir la aplicación

1073
00:41:16,579 --> 00:41:18,579
el real

1074
00:41:18,579 --> 00:41:20,579
no es este

1075
00:41:20,579 --> 00:41:22,579
no es que estén en posiciones de memoria distintas

1076
00:41:22,579 --> 00:41:24,579
ese no es el criterio de igualdad real

1077
00:41:24,579 --> 00:41:26,579
y operativo

1078
00:41:26,579 --> 00:41:28,579
el criterio de igualdad

1079
00:41:28,579 --> 00:41:30,579
tiene que ser

1080
00:41:30,579 --> 00:41:32,579
el mismo

1081
00:41:32,579 --> 00:41:34,579
entonces a lo mejor físicamente en memoria

1082
00:41:34,579 --> 00:41:36,579
tengo ahí esas dos referencias

1083
00:41:36,579 --> 00:41:38,579
porque las he generado dos veces

1084
00:41:38,579 --> 00:41:40,579
pero son la misma cosa

1085
00:41:40,579 --> 00:41:42,579
y las tengo que tratar igual

1086
00:41:42,579 --> 00:41:44,579
entonces el ver que son iguales

1087
00:41:44,579 --> 00:41:46,579
me permitiría a lo mejor olvidarme de uno

1088
00:41:46,579 --> 00:41:48,579
y empezar a trabajar con el otro

1089
00:41:48,579 --> 00:41:50,579
entonces el criterio de igualdad real en la vida

1090
00:41:50,579 --> 00:41:52,579
y por tanto en la aplicación

1091
00:41:52,579 --> 00:41:54,579
es que lo que identifica de forma única

1092
00:41:54,579 --> 00:41:56,579
a dos objetos

1093
00:41:56,579 --> 00:41:58,579
es igual, es el mismo, es el criterio real

1094
00:41:58,579 --> 00:42:00,579
este no tiene ninguna utilidad

1095
00:42:00,579 --> 00:42:02,579
bueno pues entonces

1096
00:42:02,579 --> 00:42:04,579
que es lo que tenemos que hacer

1097
00:42:04,579 --> 00:42:06,579
sobre escribir el equals

1098
00:42:06,579 --> 00:42:08,579
en nuestras clases para decir

1099
00:42:08,579 --> 00:42:10,579
oye si hay otro objeto

1100
00:42:10,579 --> 00:42:12,579
con este mismo código

1101
00:42:12,579 --> 00:42:14,579
o con este mismo nif

1102
00:42:14,579 --> 00:42:16,579
o con este mismo lo que sea

1103
00:42:16,579 --> 00:42:18,579
entonces es el mismo

1104
00:42:18,579 --> 00:42:20,579
aunque este alojado en posiciones de memoria distintas

1105
00:42:20,579 --> 00:42:22,579
ese es el uso

1106
00:42:22,579 --> 00:42:24,579
que tendría sentido

1107
00:42:24,579 --> 00:42:26,579
entonces

1108
00:42:26,579 --> 00:42:28,579
de hecho

1109
00:42:28,579 --> 00:42:30,579
el eclipse te ofrece

1110
00:42:30,579 --> 00:42:32,579
la posibilidad de sobre escribir el método equals

1111
00:42:32,579 --> 00:42:34,579
sobre escribirlo

1112
00:42:34,579 --> 00:42:36,579
pero vamos no hace falta que usemos el eclipse

1113
00:42:36,579 --> 00:42:38,579
para todo

1114
00:42:38,579 --> 00:42:40,579
podríamos sobre escribirlo nosotros

1115
00:42:40,579 --> 00:42:42,579
y hacer esto

1116
00:42:42,579 --> 00:42:44,579
lo voy a sobre escribir

1117
00:42:44,579 --> 00:42:46,579
en cuidador

1118
00:42:46,579 --> 00:42:48,579
voy a asegurarme

1119
00:42:48,579 --> 00:42:50,579
de que he puesto bien la

1120
00:42:50,579 --> 00:42:52,579
el este

1121
00:42:52,579 --> 00:42:54,579
poniendo el override

1122
00:42:54,579 --> 00:42:56,579
bueno vamos a hacerlo primero

1123
00:42:56,579 --> 00:42:58,579
porque si no me va a aparecer en rojo todo el rato

1124
00:42:58,579 --> 00:43:00,579
vale pues aquí uno ya tiene que decidir

1125
00:43:00,579 --> 00:43:02,579
acorde al sentido de su aplicación

1126
00:43:02,579 --> 00:43:04,579
recordad que una aplicación tiene que reproducir

1127
00:43:04,579 --> 00:43:06,579
lo que está pasando

1128
00:43:06,579 --> 00:43:08,579
tiene que pensar a ver para mi

1129
00:43:08,579 --> 00:43:10,579
que va a hacer que un cuidador sea igual a otro

1130
00:43:10,579 --> 00:43:12,579
que sean el mismo

1131
00:43:12,579 --> 00:43:14,579
que va a hacer que sean el mismo

1132
00:43:14,579 --> 00:43:16,579
pues miraría uno su modelo su descripción

1133
00:43:20,579 --> 00:43:22,579
y según el modelo de datos

1134
00:43:22,579 --> 00:43:24,579
el análisis que ha hecho todo lo que ha estudiado

1135
00:43:24,579 --> 00:43:26,579
diría hombre

1136
00:43:26,579 --> 00:43:28,579
pues dos cuidadores con el mismo código son el mismo

1137
00:43:28,579 --> 00:43:30,579
mi aplicación tiene que tratar

1138
00:43:30,579 --> 00:43:32,579
igual tiene que considerar que son lo mismo

1139
00:43:32,579 --> 00:43:34,579
que son el mismo

1140
00:43:34,579 --> 00:43:36,579
dos cuidadores con el mismo código

1141
00:43:36,579 --> 00:43:38,579
mi modelo de datos mi realidad no concibe

1142
00:43:38,579 --> 00:43:40,579
que en misológico haya dos cuidadores con código

1143
00:43:40,579 --> 00:43:42,579
distinto no lo concibe

1144
00:43:42,579 --> 00:43:44,579
los cuidadores

1145
00:43:44,579 --> 00:43:46,579
distintos códigos distintos

1146
00:43:46,579 --> 00:43:48,579
pues entonces tendría sentido

1147
00:43:48,579 --> 00:43:50,579
hacer un equals que te devuelva true

1148
00:43:50,579 --> 00:43:52,579
si los códigos del que llama el método

1149
00:43:52,579 --> 00:43:54,579
y el parámetro son iguales

1150
00:43:54,579 --> 00:43:56,579
y false en caso contrario

1151
00:43:56,579 --> 00:43:58,579
recordad que todo lo que programamos

1152
00:43:58,579 --> 00:44:00,579
todo lo que declaramos en las clases todo lo que hacemos

1153
00:44:00,579 --> 00:44:02,579
tiene que reproducir

1154
00:44:02,579 --> 00:44:04,579
la situación real

1155
00:44:04,579 --> 00:44:06,579
tiene que estar al servicio

1156
00:44:06,579 --> 00:44:08,579
de esa situación

1157
00:44:08,579 --> 00:44:10,579
bueno pues aquí podríamos hacer nuestro object

1158
00:44:10,579 --> 00:44:12,579
que fuera venga vamos a ver

1159
00:44:12,579 --> 00:44:14,579
vamos a hacerlo largo o sea escrito en varias

1160
00:44:14,579 --> 00:44:16,579
líneas para no liarnos

1161
00:44:16,579 --> 00:44:18,579
pues vamos a hacer un

1162
00:44:20,579 --> 00:44:22,579
bueno no que igual así os es más claro

1163
00:44:22,579 --> 00:44:24,579
pues venga vamos a hacer si

1164
00:44:24,579 --> 00:44:26,579
si

1165
00:44:26,579 --> 00:44:28,579
la propiedad código del

1166
00:44:28,579 --> 00:44:30,579
objeto que llame al equals

1167
00:44:30,579 --> 00:44:32,579
que es un entero con lo cual lo puedo

1168
00:44:32,579 --> 00:44:34,579
es igual

1169
00:44:34,579 --> 00:44:36,579
que la propiedad código del objeto

1170
00:44:36,579 --> 00:44:38,579
que le paso por parámetro

1171
00:44:40,579 --> 00:44:42,579
vale aquí nos viene de nuevo

1172
00:44:42,579 --> 00:44:44,579
objeto

1173
00:44:44,579 --> 00:44:46,579
está declarado como object

1174
00:44:46,579 --> 00:44:48,579
no tiene

1175
00:44:48,579 --> 00:44:50,579
una propiedad código verdad no la tiene

1176
00:44:50,579 --> 00:44:52,579
el compilador no me va a

1177
00:44:52,579 --> 00:44:54,579
decir dejar poner aquí

1178
00:44:54,579 --> 00:44:56,579
objeto punto código

1179
00:44:56,579 --> 00:44:58,579
porque yo querría

1180
00:44:58,579 --> 00:45:00,579
poner esto si los códigos

1181
00:45:00,579 --> 00:45:02,579
son iguales entonces

1182
00:45:02,579 --> 00:45:04,579
return true

1183
00:45:04,579 --> 00:45:06,579
else

1184
00:45:06,579 --> 00:45:08,579
return

1185
00:45:08,579 --> 00:45:10,579
false este sería la

1186
00:45:10,579 --> 00:45:12,579
idea de mi equals verdad sería esta

1187
00:45:14,579 --> 00:45:16,579
esta sería la idea de mi equals

1188
00:45:16,579 --> 00:45:18,579
si los códigos del que llama el método

1189
00:45:18,579 --> 00:45:20,579
y el pasado por parámetros son iguales

1190
00:45:20,579 --> 00:45:22,579
los códigos devuelve true

1191
00:45:22,579 --> 00:45:24,579
para indicar que esos objetos son el mismo

1192
00:45:26,579 --> 00:45:28,579
si no devuelve false

1193
00:45:28,579 --> 00:45:30,579
pero bueno no podemos ponerlo así no

1194
00:45:30,579 --> 00:45:32,579
por el mismo problema que nos surgió ayer

1195
00:45:32,579 --> 00:45:34,579
etcétera etcétera

1196
00:45:34,579 --> 00:45:36,579
porque obj está declarado como la clase

1197
00:45:36,579 --> 00:45:38,579
genérica object

1198
00:45:38,579 --> 00:45:40,579
por tanto el compilador no ve en esa clase

1199
00:45:40,579 --> 00:45:42,579
genérica code

1200
00:45:42,579 --> 00:45:44,579
que solución podemos poner

1201
00:45:44,579 --> 00:45:48,579
para eso

1202
00:45:48,579 --> 00:45:50,579
hacer un

1203
00:45:50,579 --> 00:45:52,579
hacer un casting efectivamente yo sé que lo que

1204
00:45:52,579 --> 00:45:54,579
le voy a pasar es un objeto cuidador

1205
00:45:54,579 --> 00:45:56,579
sé que le voy a pasar un cuidador pero voy a

1206
00:45:56,579 --> 00:45:58,579
comparar un cuidador con otro

1207
00:45:58,579 --> 00:46:00,579
tranquilidad

1208
00:46:00,579 --> 00:46:02,579
te haces un casting

1209
00:46:04,579 --> 00:46:06,579
de este

1210
00:46:06,579 --> 00:46:08,579
objeto de aquí

1211
00:46:08,579 --> 00:46:10,579
te haces un casting a cuidador

1212
00:46:10,579 --> 00:46:12,579
y listo

1213
00:46:12,579 --> 00:46:14,579
ala

1214
00:46:14,579 --> 00:46:16,579
ya tenemos un equals ya con sentido real

1215
00:46:16,579 --> 00:46:18,579
con sentido práctico

1216
00:46:18,579 --> 00:46:20,579
si además somos ya

1217
00:46:20,579 --> 00:46:22,579
perfectos

1218
00:46:22,579 --> 00:46:24,579
vamos a

1219
00:46:24,579 --> 00:46:26,579
anotarlo con overwrite

1220
00:46:26,579 --> 00:46:28,579
para asegurar

1221
00:46:28,579 --> 00:46:30,579
de que hemos escrito

1222
00:46:30,579 --> 00:46:32,579
bien la cabecera no vaya a ser que estemos

1223
00:46:32,579 --> 00:46:34,579
haciendo otro método que no es el equals

1224
00:46:34,579 --> 00:46:36,579
estándar que se usa

1225
00:46:36,579 --> 00:46:38,579
siempre sino otro añadido que nos hemos

1226
00:46:38,579 --> 00:46:40,579
inventado porque se nos ha olvidado

1227
00:46:40,579 --> 00:46:42,579
porque hemos puesto dos s en vez de una

1228
00:46:42,579 --> 00:46:44,579
si encima nos acordamos de poner el overwrite

1229
00:46:44,579 --> 00:46:46,579
estupendo

1230
00:46:46,579 --> 00:46:48,579
así sabemos que estamos sobre escribiendo

1231
00:46:48,579 --> 00:46:50,579
el de object

1232
00:46:50,579 --> 00:46:52,579
porque pueden venir otras clases por ahí

1233
00:46:52,579 --> 00:46:54,579
que quieran hacer igualdades entre cuidadores

1234
00:46:54,579 --> 00:46:56,579
y van a llamar al equals de

1235
00:46:56,579 --> 00:46:58,579
en su nombre real

1236
00:46:58,579 --> 00:47:00,579
van a llamar al equals de su nombre real

1237
00:47:00,579 --> 00:47:02,579
entonces vamos a sobre escribirlo

1238
00:47:02,579 --> 00:47:04,579
con su nombre real

1239
00:47:06,579 --> 00:47:08,579
vale pues entonces con el

1240
00:47:08,579 --> 00:47:10,579
equals sobre escrito

1241
00:47:10,579 --> 00:47:12,579
ahora ya si que nos pasaría

1242
00:47:12,579 --> 00:47:14,579
vamos a por ejemplo

1243
00:47:14,579 --> 00:47:16,579
vamos a

1244
00:47:16,579 --> 00:47:18,579
cambiar esto

1245
00:47:18,579 --> 00:47:20,579
y ya ejecutamos esto

1246
00:47:20,579 --> 00:47:22,579
y ya si que paramos

1247
00:47:22,579 --> 00:47:24,579
voy a quitar para que lo veamos

1248
00:47:24,579 --> 00:47:26,579
primero nuestra sobre escritura

1249
00:47:26,579 --> 00:47:28,579
de esta de aquí

1250
00:47:28,579 --> 00:47:30,579
entonces resulta que mi aplicación

1251
00:47:30,579 --> 00:47:32,579
tiene

1252
00:47:32,579 --> 00:47:34,579
dos cuidadores

1253
00:47:34,579 --> 00:47:36,579
ha introducido

1254
00:47:36,579 --> 00:47:38,579
donde estamos el main

1255
00:47:38,579 --> 00:47:40,579
ha introducido cuidadores

1256
00:47:40,579 --> 00:47:42,579
y

1257
00:47:42,579 --> 00:47:44,579
se le da a lo mejor

1258
00:47:44,579 --> 00:47:46,579
esta situación

1259
00:47:46,579 --> 00:47:48,579
pues que en una parte

1260
00:47:48,579 --> 00:47:50,579
un gestor lo introdujo

1261
00:47:50,579 --> 00:47:52,579
con el nombre de luis y el otro

1262
00:47:52,579 --> 00:47:54,579
le puso el nombre completo luis maria

1263
00:47:54,579 --> 00:47:56,579
pero en realidad son el mismo

1264
00:47:56,579 --> 00:47:58,579
son el mismo cuidador

1265
00:47:58,579 --> 00:48:00,579
y cuando hay que subir el sueldo

1266
00:48:00,579 --> 00:48:02,579
hay que subírselo a ese único

1267
00:48:02,579 --> 00:48:04,579
no hay dos cuidadores

1268
00:48:04,579 --> 00:48:06,579
hay uno que tiene su código uno

1269
00:48:06,579 --> 00:48:08,579
lo que pasa es que en la aplicación

1270
00:48:08,579 --> 00:48:10,579
por la razón que sea

1271
00:48:10,579 --> 00:48:12,579
pueden haberse instanciado dos objetos distintos

1272
00:48:12,579 --> 00:48:14,579
pero son el mismo cuidador

1273
00:48:14,579 --> 00:48:16,579
y a efectos del resto de funcionalidades

1274
00:48:16,579 --> 00:48:18,579
pues hay que trabajar con el único cuidador

1275
00:48:18,579 --> 00:48:20,579
que haya

1276
00:48:20,579 --> 00:48:22,579
entonces sin haber sobre escrito

1277
00:48:22,579 --> 00:48:24,579
el método equals

1278
00:48:24,579 --> 00:48:26,579
ejecutando esto

1279
00:48:26,579 --> 00:48:28,579
nos va a decir distintos ¿verdad?

1280
00:48:28,579 --> 00:48:30,579
nos va a decir distintos

1281
00:48:30,579 --> 00:48:32,579
y esto no tiene sentido

1282
00:48:32,579 --> 00:48:34,579
no tiene sentido

1283
00:48:34,579 --> 00:48:36,579
en el contexto de nuestra aplicación

1284
00:48:36,579 --> 00:48:38,579
no lo tiene

1285
00:48:38,579 --> 00:48:40,579
pero una vez que hayamos sobre escrito

1286
00:48:40,579 --> 00:48:42,579
el equals

1287
00:48:42,579 --> 00:48:44,579
según el sentido de nuestra aplicación

1288
00:48:44,579 --> 00:48:46,579
y el sentido es que

1289
00:48:46,579 --> 00:48:48,579
códigos iguales, cuidadores iguales

1290
00:48:48,579 --> 00:48:50,579
que todo esto viene

1291
00:48:50,579 --> 00:48:52,579
de haber hecho un buen análisis

1292
00:48:52,579 --> 00:48:54,579
claro, de ahí la importancia de los análisis

1293
00:48:54,579 --> 00:48:56,579
de entender la situación

1294
00:48:56,579 --> 00:48:58,579
de entender la aplicación

1295
00:48:58,579 --> 00:49:00,579
si hemos hecho un buen análisis

1296
00:49:00,579 --> 00:49:02,579
hemos llegado a la conclusión

1297
00:49:02,579 --> 00:49:04,579
es que en mi aplicación

1298
00:49:04,579 --> 00:49:06,579
los cuidadores tienen que tener códigos distintos

1299
00:49:06,579 --> 00:49:08,579
pues si yo después de haber hecho ese buen análisis

1300
00:49:08,579 --> 00:49:10,579
he llegado a que esa conclusión es así

1301
00:49:10,579 --> 00:49:12,579
pues entonces habré sobre escrito un equals así

1302
00:49:12,579 --> 00:49:14,579
y ahora ya cuando ejecutemos este main

1303
00:49:14,579 --> 00:49:16,579
pues lógicamente

1304
00:49:16,579 --> 00:49:18,579
ahora ya me va a decir que son iguales

1305
00:49:20,579 --> 00:49:22,579
me va a decir que los cuidadores son el mismo

1306
00:49:22,579 --> 00:49:24,579
y lo son

1307
00:49:24,579 --> 00:49:26,579
que son dos objetos distintos

1308
00:49:26,579 --> 00:49:28,579
con dos objetos distintos

1309
00:49:28,579 --> 00:49:30,579
me refiero

1310
00:49:30,579 --> 00:49:32,579
está este y está este otro

1311
00:49:32,579 --> 00:49:34,579
apuntado por ediciones distintas

1312
00:49:34,579 --> 00:49:36,579
pues sí, porque eventualmente la aplicación ha generado dos instancias

1313
00:49:36,579 --> 00:49:38,579
pero lo que importa

1314
00:49:38,579 --> 00:49:40,579
es el funcionamiento de la aplicación

1315
00:49:40,579 --> 00:49:42,579
¿vale?

1316
00:49:42,579 --> 00:49:44,579
y para que ese funcionamiento sea coherente

1317
00:49:44,579 --> 00:49:46,579
y consistente

1318
00:49:46,579 --> 00:49:48,579
pues hombre, tengo yo que incluir los criterios de igualdad

1319
00:49:48,579 --> 00:49:50,579
para poder usarlos cuando hagan falta

1320
00:49:50,579 --> 00:49:52,579
tengo que incluirlos

1321
00:49:52,579 --> 00:49:54,579
y aquí efectivamente estos dos cuidadores

1322
00:49:54,579 --> 00:49:56,579
pues según mi criterio de igualdad

1323
00:49:56,579 --> 00:49:58,579
son el mismo

1324
00:50:00,579 --> 00:50:02,579
y sobre escribir este método

1325
00:50:02,579 --> 00:50:04,579
es de vital importancia

1326
00:50:04,579 --> 00:50:06,579
para que luego todas las colecciones

1327
00:50:06,579 --> 00:50:08,579
todas las clases que nos van a usar

1328
00:50:08,579 --> 00:50:10,579
funcionen bien y tengan sentido lo que hacen

1329
00:50:10,579 --> 00:50:12,579
porque si no van a hacer cosas

1330
00:50:12,579 --> 00:50:14,579
sin errores

1331
00:50:14,579 --> 00:50:16,579
pero no van a tener sentido

1332
00:50:16,579 --> 00:50:18,579
¿vale?

1333
00:50:18,579 --> 00:50:20,579
bueno, ahora sí que vamos a parar aquí un momentito

1334
00:50:20,579 --> 00:50:22,579
se hace muy largo esto