1
00:00:00,050 --> 00:00:07,929
Vale, a ver, entonces, con lo que hemos visto de herencia hasta ahora, ya sabemos que las clases Java de una aplicación

2
00:00:07,929 --> 00:00:16,149
pueden relacionarse con relaciones de herencia construyendo una jerarquía, ¿vale?

3
00:00:16,710 --> 00:00:24,609
La idea no es que en los diseños aparezcan jerarquías complejas, porque ya se pierde un poquito la perspectiva del asunto,

4
00:00:24,609 --> 00:00:31,690
pero sí que haya relaciones de herencia entre clases puntualmente, sí que facilita bastante las cosas.

5
00:00:32,149 --> 00:00:37,729
En cualquier caso, como la herencia en Java como tal es simple, es lo que se llama herencia simple,

6
00:00:38,390 --> 00:00:46,070
¿y qué significa simple? Que cada clase sólo puede heredar de otra, sólo, o sea, esto no existe, esto no se puede dar,

7
00:00:46,890 --> 00:00:53,149
cada clase sólo puede heredar de otra, pues la estructura que tenemos siempre son árboles de este tipo.

8
00:00:54,609 --> 00:01:18,310
Vale, y de hecho tanto es así que si yo tengo una clase cualquiera, una clase cualquiera, si no pongo que herede, por ejemplo, imaginaos que tenéis una aplicación con tres clases que no están relacionadas entre sí, esta es una clase C1, clase C2, clase C3, cliente, producto, pedido, no tienen relaciones de herencia entre sí, ¿vale?

9
00:01:18,310 --> 00:01:41,540
Bueno, pues las clases que no tienen ninguna superclase, que no tienen ninguna, Java supone que por defecto heredan de otra clase que existe, que ahora la abriremos y la veremos, que ya existe, que está hecha, que se llama Objeto.

10
00:01:41,540 --> 00:01:45,659
Entonces, todas las clases

11
00:01:45,659 --> 00:01:47,319
Si no heredan de ninguna

12
00:01:47,319 --> 00:01:48,980
Es decir, si aquí no hay un

13
00:01:48,980 --> 00:01:50,400
Extents de lo que sea

14
00:01:50,400 --> 00:01:53,620
Si no heredan de ninguna, heredan por defecto

15
00:01:53,620 --> 00:01:54,439
De esta clase

16
00:01:54,439 --> 00:01:57,040
Que ya existe, es una clase pequeñita

17
00:01:57,040 --> 00:01:58,980
Que en realidad tiene muy poca cosa dentro

18
00:01:58,980 --> 00:02:00,700
Pero si yo tengo

19
00:02:00,700 --> 00:02:02,719
Estas tres clases en mi aplicación

20
00:02:02,719 --> 00:02:04,400
Las tres

21
00:02:04,400 --> 00:02:06,480
Heredan de object sí o sí

22
00:02:06,480 --> 00:02:09,500
Y luego otra cosa es que además haga más clases

23
00:02:09,500 --> 00:02:10,599
Que hereden de estas

24
00:02:10,599 --> 00:02:13,039
Bueno, pues si las he hecho

25
00:02:13,039 --> 00:02:17,909
ya tengo el arbolito

26
00:02:17,909 --> 00:02:18,889
ya tengo el árbol

27
00:02:18,889 --> 00:02:21,770
siempre, siempre hay un

28
00:02:21,770 --> 00:02:23,909
nodo único raíz de todo

29
00:02:23,909 --> 00:02:26,030
siempre, que es la clase

30
00:02:26,030 --> 00:02:27,930
object, siempre es el nodo

31
00:02:27,930 --> 00:02:29,169
único raíz de cualquier

32
00:02:29,169 --> 00:02:31,810
estructura de clases y todas

33
00:02:31,810 --> 00:02:33,810
aquellas que no tengan un extens

34
00:02:33,810 --> 00:02:36,090
específico, todas las que no lo tengan

35
00:02:36,090 --> 00:02:36,849
heredan de object

36
00:02:36,849 --> 00:02:40,050
entonces object es una clase que se puede

37
00:02:40,050 --> 00:02:41,990
instanciar, lo que pasa es que tiene muy

38
00:02:41,990 --> 00:02:42,669
poco dentro

39
00:02:42,669 --> 00:02:45,250
uno puede hacer un new object

40
00:02:45,250 --> 00:02:49,050
e instanciar

41
00:02:49,050 --> 00:02:50,530
una clase object

42
00:02:50,530 --> 00:02:53,330
esto se puede hacer

43
00:02:53,330 --> 00:02:55,050
entonces estamos instanciando un objeto

44
00:02:55,050 --> 00:02:56,770
de esta clase que ya existe en Java

45
00:02:56,770 --> 00:02:59,009
que está en toda la librería

46
00:02:59,009 --> 00:03:00,210
que nos ofrece la JRE

47
00:03:00,210 --> 00:03:02,629
pero que tipo de objeto es este

48
00:03:02,629 --> 00:03:04,610
es un objeto muy básico

49
00:03:04,610 --> 00:03:06,830
que no tiene espacio

50
00:03:06,830 --> 00:03:08,210
para nada dentro en realidad

51
00:03:08,210 --> 00:03:10,610
pero representa la idea de objeto

52
00:03:10,610 --> 00:03:12,150
esa idea la representa

53
00:03:12,150 --> 00:03:14,710
porque es una referencia

54
00:03:14,710 --> 00:03:16,169
o es una referencia

55
00:03:16,169 --> 00:03:18,050
que me apuntaría a un espacio en memoria

56
00:03:18,050 --> 00:03:20,289
entonces bueno

57
00:03:20,289 --> 00:03:21,930
le da cierta semántica

58
00:03:21,930 --> 00:03:23,550
cierto significado a todo esto

59
00:03:23,550 --> 00:03:24,849
porque cualquier cosa

60
00:03:24,849 --> 00:03:27,189
al heredar de object es como decir

61
00:03:27,189 --> 00:03:29,189
cualquier cosa es un objeto en realidad

62
00:03:29,189 --> 00:03:31,090
¿vale?

63
00:03:32,129 --> 00:03:33,490
entonces ¿de qué nos sirve?

64
00:03:33,949 --> 00:03:35,270
además ¿de qué nos sirve?

65
00:03:35,770 --> 00:03:38,530
que todas las clases hereden de object

66
00:03:38,530 --> 00:03:40,069
bueno porque object

67
00:03:40,069 --> 00:03:41,550
nos ofrece unos métodos

68
00:03:41,550 --> 00:03:43,069
Que ahora los veremos

69
00:03:43,069 --> 00:03:45,930
Que nosotros ya podríamos usarlos tal cual

70
00:03:45,930 --> 00:03:46,469
Si queremos

71
00:03:46,469 --> 00:03:49,810
Es decir, cuando nosotros hacemos una clase nuestra

72
00:03:49,810 --> 00:03:52,370
Clase 1

73
00:03:52,370 --> 00:03:53,250
Sin más

74
00:03:53,250 --> 00:03:55,909
Una clase normal, sin ningún extensa aquí

75
00:03:55,909 --> 00:03:56,870
Sin ninguno

76
00:03:56,870 --> 00:03:59,509
En realidad esta clase ya tiene muchas cosas

77
00:03:59,509 --> 00:04:01,830
Aunque aquí esté vacío, aunque aquí no haya nada

78
00:04:01,830 --> 00:04:03,610
Ya tiene muchas cosas

79
00:04:03,610 --> 00:04:05,430
Porque esto

80
00:04:05,430 --> 00:04:06,689
Implícitamente

81
00:04:06,689 --> 00:04:09,270
Hereda de object

82
00:04:09,270 --> 00:04:10,389
Aunque no esté puesto

83
00:04:10,389 --> 00:04:13,310
implícitamente hereda, aunque no esté puesto

84
00:04:13,310 --> 00:04:14,990
entonces una clase que hagamos

85
00:04:14,990 --> 00:04:17,029
con llavecitas y sin más

86
00:04:17,029 --> 00:04:18,769
ya tiene cosas dentro

87
00:04:18,769 --> 00:04:20,209
aunque nosotros no lo veamos

88
00:04:20,209 --> 00:04:22,910
¿y qué tiene dentro? lo que tiene object

89
00:04:22,910 --> 00:04:24,470
que son algunos métodos

90
00:04:24,470 --> 00:04:26,689
de los cuales el que nos puede sonar ahora

91
00:04:26,689 --> 00:04:28,569
y que más nos importa

92
00:04:28,569 --> 00:04:30,709
es el método toString

93
00:04:30,709 --> 00:04:34,680
ahora lo vemos

94
00:04:34,680 --> 00:04:36,120
entonces

95
00:04:36,120 --> 00:04:38,240
todos los objetos

96
00:04:38,240 --> 00:04:41,399
pueden llamar a toString, aunque no lo hayamos puesto

97
00:04:41,399 --> 00:04:42,199
aquí, ¿por qué?

98
00:04:42,860 --> 00:04:44,259
Porque lo han heredado de object.

99
00:04:45,220 --> 00:04:48,079
Lo que pasa es que la versión del toString heredado

100
00:04:48,079 --> 00:04:50,060
es una versión que te pone nada.

101
00:04:50,439 --> 00:04:51,240
Una cosa muy fea.

102
00:04:51,240 --> 00:04:54,240
Por eso lo que solemos hacer es sobrescribirlo.

103
00:04:54,500 --> 00:04:55,019
El heredado.

104
00:04:55,660 --> 00:04:55,819
¿Vale?

105
00:04:56,439 --> 00:04:58,480
Y como toString algún método más.

106
00:05:00,079 --> 00:05:02,240
Entonces, si lo...

107
00:05:03,300 --> 00:05:04,560
Vemos aquí.

108
00:05:07,220 --> 00:05:07,459
Ahora.

109
00:05:10,980 --> 00:05:21,620
Por ejemplo,

110
00:05:21,620 --> 00:05:23,819
En nuestra clase está

111
00:05:23,819 --> 00:05:25,500
A ver

112
00:05:25,500 --> 00:05:28,019
Voy a abrir herencia ejemplos

113
00:05:28,019 --> 00:05:29,879
Por ejemplo

114
00:05:29,879 --> 00:05:31,420
Teníamos aquí el cliente normal

115
00:05:31,420 --> 00:05:35,639
Cliente yo no he puesto

116
00:05:35,639 --> 00:05:36,600
Que herede de nadie

117
00:05:36,600 --> 00:05:39,240
Entonces no ponerlo

118
00:05:39,240 --> 00:05:42,040
Es equivalente a todos los efectos

119
00:05:42,040 --> 00:05:42,899
Equivalente

120
00:05:42,899 --> 00:05:45,060
A poner esto

121
00:05:45,060 --> 00:05:48,269
¿Vale?

122
00:05:49,370 --> 00:05:51,430
Es decir, cualquier cosa

123
00:05:51,430 --> 00:05:52,750
Hereda de object

124
00:05:52,750 --> 00:05:55,149
Si es que no hereda de ninguna otra

125
00:05:55,149 --> 00:05:56,970
que a su vez heredará de object

126
00:05:56,970 --> 00:05:58,250
si es que no le da ninguna otra

127
00:05:58,250 --> 00:06:01,569
entonces esto está siempre por defecto

128
00:06:01,569 --> 00:06:02,889
no tenemos que ponerlo

129
00:06:02,889 --> 00:06:04,069
está siempre por defecto

130
00:06:04,069 --> 00:06:05,370
entonces al heredar de object

131
00:06:05,370 --> 00:06:07,389
ya esta clase se llena

132
00:06:07,389 --> 00:06:09,629
de las cosas que tiene object

133
00:06:09,629 --> 00:06:12,870
además de las que le hagamos específicamente

134
00:06:12,870 --> 00:06:14,750
¿y qué cosas tiene object?

135
00:06:14,829 --> 00:06:15,970
vamos a buscar esta clase

136
00:06:15,970 --> 00:06:18,569
porque nosotros cuando

137
00:06:18,569 --> 00:06:20,930
hacemos un proyecto

138
00:06:20,930 --> 00:06:23,389
aparte de las clases nuestras

139
00:06:23,389 --> 00:06:25,589
ya hay un montón más de clases hechas

140
00:06:25,589 --> 00:06:26,449
que podemos usar

141
00:06:26,449 --> 00:06:28,870
que son las que están aquí

142
00:06:28,870 --> 00:06:33,029
¿veis? o sea este es mi proyecto

143
00:06:33,029 --> 00:06:36,649
mi proyecto de aquí

144
00:06:36,649 --> 00:06:38,649
el de herencia ejemplos, vale

145
00:06:38,649 --> 00:06:40,310
mi proyecto tendrá

146
00:06:40,310 --> 00:06:42,029
las clases

147
00:06:42,029 --> 00:06:43,810
que yo he hecho

148
00:06:43,810 --> 00:06:47,089
que son estas, estas tres porque las he hecho yo

149
00:06:47,089 --> 00:06:49,110
pero es que además de estas clases

150
00:06:49,110 --> 00:06:51,529
tiene todas las que están

151
00:06:51,529 --> 00:06:52,730
en estos hard

152
00:06:52,730 --> 00:06:54,670
de aquí

153
00:06:54,670 --> 00:06:58,389
En estos paquetes

154
00:06:58,389 --> 00:07:01,350
¿Vale? Esto es como si se hiciera

155
00:07:01,350 --> 00:07:03,170
Un agregar

156
00:07:03,170 --> 00:07:04,649
JAR externo

157
00:07:04,649 --> 00:07:06,829
Como lo hicimos nosotros para la clase teclado

158
00:07:06,829 --> 00:07:09,250
Pues en realidad cuando se crea un proyecto

159
00:07:09,250 --> 00:07:11,470
Es como si se agregaran tropecientos mil

160
00:07:11,470 --> 00:07:12,430
JAR externos

161
00:07:12,430 --> 00:07:14,750
Que están aquí en la máquina virtual

162
00:07:14,750 --> 00:07:15,430
Que están aquí

163
00:07:15,430 --> 00:07:17,170
En la JRE

164
00:07:17,170 --> 00:07:20,769
¿Vale? Es decir, cuando uno tiene

165
00:07:20,769 --> 00:07:22,290
Instalado en su ordenador

166
00:07:22,290 --> 00:07:24,370
La máquina virtual de Java

167
00:07:24,370 --> 00:07:26,350
No hablo del JDK

168
00:07:26,350 --> 00:07:28,490
con el que tú desarrollas, escribes código

169
00:07:28,490 --> 00:07:30,430
y compilas, no hablo de eso

170
00:07:30,430 --> 00:07:32,670
ni de Eclipse, cuando tú tienes

171
00:07:32,670 --> 00:07:34,170
la máquina virtual de Java

172
00:07:34,170 --> 00:07:36,569
que es la que es capaz de ejecutar

173
00:07:36,569 --> 00:07:38,529
código Java, la máquina virtual de Java

174
00:07:38,529 --> 00:07:40,670
además del propio

175
00:07:40,670 --> 00:07:42,410
proceso que se lanza

176
00:07:42,410 --> 00:07:44,509
para ejecutar el código Java, además de eso

177
00:07:44,509 --> 00:07:46,810
tienes un montón de clases

178
00:07:46,810 --> 00:07:48,829
que cualquier aplicación necesita

179
00:07:48,829 --> 00:07:50,490
y que por tanto no las hacemos

180
00:07:50,490 --> 00:07:52,389
nosotros, vale

181
00:07:52,389 --> 00:07:54,529
como la clase System.out que es una clase

182
00:07:54,529 --> 00:07:56,029
que llama al método println

183
00:07:56,029 --> 00:07:57,829
la clase scanner

184
00:07:57,829 --> 00:07:59,509
que cualquier la necesita

185
00:07:59,509 --> 00:08:00,709
o sea, estamos usando

186
00:08:00,709 --> 00:08:02,250
en cualquier aplicación nuestra

187
00:08:02,250 --> 00:08:04,529
usamos un montón de clases

188
00:08:04,529 --> 00:08:05,370
que no hemos hecho

189
00:08:05,370 --> 00:08:06,689
nosotros y todo el mundo

190
00:08:06,689 --> 00:08:08,110
¿vale?

191
00:08:08,149 --> 00:08:09,290
como ejemplo, repito

192
00:08:09,290 --> 00:08:10,230
veamos, scanner

193
00:08:10,230 --> 00:08:11,449
entonces

194
00:08:11,449 --> 00:08:13,990
cuando yo doy mi aplicación

195
00:08:13,990 --> 00:08:14,730
a cualquiera

196
00:08:14,730 --> 00:08:16,850
ese cualquiera lo ejecuta

197
00:08:16,850 --> 00:08:17,629
en su máquina virtual

198
00:08:17,629 --> 00:08:18,250
y le funciona

199
00:08:18,250 --> 00:08:18,709
¿por qué?

200
00:08:19,170 --> 00:08:20,430
porque la máquina virtual

201
00:08:20,430 --> 00:08:22,689
entrega esas clases

202
00:08:22,689 --> 00:08:24,449
que mi aplicación usa

203
00:08:24,449 --> 00:08:25,230
que son comunes

204
00:08:25,230 --> 00:08:25,949
para todo el mundo

205
00:08:25,949 --> 00:08:28,769
Bueno, pues esas clases están aquí

206
00:08:28,769 --> 00:08:30,889
¿Vale? Esas clases

207
00:08:30,889 --> 00:08:32,669
Están aquí, no las he hecho yo

208
00:08:32,669 --> 00:08:34,389
Están aquí metidas en mi ordenador

209
00:08:34,389 --> 00:08:36,929
Y el Eclipse las agrega

210
00:08:36,929 --> 00:08:38,750
Como Hards exactamente

211
00:08:38,750 --> 00:08:40,710
Igual que nosotros agregamos nuestro Hard

212
00:08:40,710 --> 00:08:41,970
Teclado cuando hicimos la prueba

213
00:08:41,970 --> 00:08:44,450
Pues cuando hacemos un proyecto Eclipse

214
00:08:44,450 --> 00:08:46,169
Él automáticamente

215
00:08:46,169 --> 00:08:48,669
Agrega todos estos

216
00:08:48,669 --> 00:08:50,470
Hards que tienen todos estos paquetes

217
00:08:50,470 --> 00:08:51,809
¿Veis? Esto es un Hard

218
00:08:51,809 --> 00:08:54,529
Este botecito de aquí es un Hard

219
00:08:54,529 --> 00:08:55,970
Que tiene todos esos paquetes dentro

220
00:08:55,970 --> 00:08:58,049
Y así tengo para aburrir

221
00:08:58,049 --> 00:08:59,690
Tengo la leche

222
00:08:59,690 --> 00:09:01,570
¿Vale?

223
00:09:03,370 --> 00:09:04,669
Todo esto de aquí

224
00:09:04,669 --> 00:09:08,059
Que cuelga de

225
00:09:08,059 --> 00:09:10,159
Aquí, todos son hard

226
00:09:10,159 --> 00:09:12,159
Todo, todo, que están en mi

227
00:09:12,159 --> 00:09:14,159
Ordenador, y dentro de esos

228
00:09:14,159 --> 00:09:16,159
Hard tengo clases, que son las

229
00:09:16,159 --> 00:09:17,940
Que se supone que usamos todos

230
00:09:17,940 --> 00:09:19,720
Básicas para programar

231
00:09:19,720 --> 00:09:21,399
Que no las tenemos que hacer

232
00:09:21,399 --> 00:09:23,659
Porque ya las da la máquina virtual

233
00:09:23,659 --> 00:09:24,559
¿Vale?

234
00:09:24,559 --> 00:09:26,879
Bueno, pues en todos estos hard

235
00:09:26,879 --> 00:09:28,940
Que dentro tienen un montón de paquetes con clases

236
00:09:28,940 --> 00:09:31,480
Repito, tenemos escáner, tenemos de todo

237
00:09:31,480 --> 00:09:33,200
Entre ellas tenemos la clase

238
00:09:33,200 --> 00:09:34,299
Object, ¿vale?

239
00:09:34,679 --> 00:09:36,919
Por ejemplo, la clase object si la buscamos

240
00:09:36,919 --> 00:09:38,820
A mano, la clase object

241
00:09:38,820 --> 00:09:40,299
Estará

242
00:09:40,299 --> 00:09:43,100
En java lang casi seguro

243
00:09:43,100 --> 00:09:49,720
Aquí, object, ¿vale?

244
00:09:50,259 --> 00:09:51,879
O sea, esta es la clase object

245
00:09:51,879 --> 00:09:53,980
De la que hereda cualquier

246
00:09:53,980 --> 00:09:56,179
Clase que yo no le ponga específicamente

247
00:09:56,179 --> 00:09:56,919
Una super clase

248
00:09:56,919 --> 00:10:05,139
Y ahora esta clase si la abrimos para ver qué es lo que entrega el resto del mundo, pues entrega muy poca cosa, ¿vale?

249
00:10:06,639 --> 00:10:20,799
Entrega un constructor sin parámetros que nos hereda, pero que podemos utilizar nosotros con super sin parámetros, que en realidad explícitamente se asume que se pone, aunque no lo pongamos nosotros.

250
00:10:20,799 --> 00:10:23,220
entrega este método

251
00:10:23,220 --> 00:10:25,460
que ahora mismo nos sería relativamente complicado

252
00:10:25,460 --> 00:10:27,720
entender, en segundo lo entenderemos

253
00:10:27,720 --> 00:10:29,220
¿vale? porque implica

254
00:10:29,220 --> 00:10:30,740
genéricos y demás rollos

255
00:10:30,740 --> 00:10:33,700
entrega este

256
00:10:33,700 --> 00:10:35,820
que este sí que vamos a

257
00:10:35,820 --> 00:10:37,419
explicar por qué es interesante

258
00:10:37,419 --> 00:10:39,679
que esté aquí, porque está relacionado

259
00:10:39,679 --> 00:10:41,220
con los códigos de hash de las

260
00:10:41,220 --> 00:10:42,299
estructuras

261
00:10:42,299 --> 00:10:45,480
el hash set, que es así que las tenemos que ver

262
00:10:45,480 --> 00:10:45,779
claro

263
00:10:45,779 --> 00:10:50,899
¿Qué más métodos entrega?

264
00:10:51,100 --> 00:10:51,799
Lo que es native

265
00:10:51,799 --> 00:10:52,419
¿Eh?

266
00:10:53,080 --> 00:10:53,620
Nativo

267
00:10:53,620 --> 00:10:59,870
Que tira del software de tu equipo

268
00:10:59,870 --> 00:11:01,210
Para generar el código hash

269
00:11:01,210 --> 00:11:02,809
El código nativo en general

270
00:11:02,809 --> 00:11:05,850
Es código que necesita ejecutar

271
00:11:05,850 --> 00:11:08,029
Código máquina de tu sistema operativo

272
00:11:08,029 --> 00:11:08,710
¿Vale?

273
00:11:08,730 --> 00:11:10,730
Que no es independiente de tu sistema operativo

274
00:11:10,730 --> 00:11:12,070
Sería el nativo

275
00:11:12,070 --> 00:11:13,070
El que trae tu sistema operativo

276
00:11:13,070 --> 00:11:13,350
Entonces

277
00:11:13,350 --> 00:11:15,769
Eso significa que tiene que hacer una llamada

278
00:11:15,769 --> 00:11:17,990
a tu sistema operativo

279
00:11:17,990 --> 00:11:19,909
para ejecutar código propio de tu equipo

280
00:11:19,909 --> 00:11:21,269
en este caso para generar ese

281
00:11:21,269 --> 00:11:23,070
hash, ese código de hash

282
00:11:23,070 --> 00:11:26,090
el código

283
00:11:26,090 --> 00:11:27,909
no nativo es el código que está

284
00:11:27,909 --> 00:11:29,769
hecho en un lenguaje de programación que es independiente

285
00:11:29,769 --> 00:11:31,429
de la máquina, que no tiene que llamar a

286
00:11:31,429 --> 00:11:33,450
funciones propias de la máquina

287
00:11:33,450 --> 00:11:34,289
más o menos

288
00:11:34,289 --> 00:11:37,049
¿Para hacer un método de pillar

289
00:11:37,049 --> 00:11:38,090
MIT o así?

290
00:11:38,730 --> 00:11:39,529
¿Utilizaría el MIT?

291
00:11:41,250 --> 00:11:42,330
Si hiciera un método

292
00:11:42,330 --> 00:11:45,889
A ver, es la idea

293
00:11:45,889 --> 00:11:47,350
En este ejemplo que me pones exactamente

294
00:11:47,350 --> 00:11:49,669
No creo, porque lo harías

295
00:11:49,669 --> 00:11:51,269
A través de otra cosa, de un socket

296
00:11:51,269 --> 00:11:53,289
Pero bueno, más o menos es la idea

297
00:11:53,289 --> 00:11:55,850
Quédate con que código nativo

298
00:11:55,850 --> 00:11:57,610
Es lo que está hecho

299
00:11:57,610 --> 00:11:59,090
Específicamente para tu máquina

300
00:11:59,090 --> 00:12:01,090
Y el no nativo

301
00:12:01,090 --> 00:12:02,830
Quédate más o menos con esa idea

302
00:12:02,830 --> 00:12:04,529
Vale

303
00:12:04,529 --> 00:12:06,070
Entonces

304
00:12:06,070 --> 00:12:07,970
¿Qué ofrece?

305
00:12:09,750 --> 00:12:10,450
Bueno, el equals

306
00:12:10,450 --> 00:12:15,960
vamos a clonar

307
00:12:15,960 --> 00:12:18,120
no nos interesa por ahora, estábamos buscando

308
00:12:18,120 --> 00:12:19,139
el toString, este

309
00:12:19,139 --> 00:12:22,080
¿qué ofrece? ofrece un método

310
00:12:22,080 --> 00:12:24,159
toString, eso es lo que

311
00:12:24,159 --> 00:12:26,000
ofrece object, ofrece

312
00:12:26,000 --> 00:12:27,799
un método toString, pero

313
00:12:27,799 --> 00:12:29,960
el método toString lo que te devuelve

314
00:12:29,960 --> 00:12:31,279
es un

315
00:12:31,279 --> 00:12:34,019
getClaseName que os digo ahora

316
00:12:34,019 --> 00:12:35,940
porque este método no lo podemos entender todavía

317
00:12:35,940 --> 00:12:37,580
que te da el nombre de la clase

318
00:12:37,580 --> 00:12:39,799
una arroba y luego

319
00:12:39,799 --> 00:12:42,059
después de la arroba te ofrece

320
00:12:42,059 --> 00:12:43,139
un numerito entero

321
00:12:43,139 --> 00:12:46,019
sacado del código hash

322
00:12:46,019 --> 00:12:48,000
o sea un toString que en realidad

323
00:12:48,000 --> 00:12:49,700
no te da ninguna información sobre el objeto

324
00:12:49,700 --> 00:12:52,240
no te dice nada interesante este toString

325
00:12:52,240 --> 00:12:54,480
entonces yo podría

326
00:12:54,480 --> 00:12:56,220
utilizar este toString directamente

327
00:12:56,220 --> 00:12:58,659
desde cliente si es que no tengo uno específico

328
00:12:58,659 --> 00:13:00,440
aquí por ejemplo en cliente

329
00:13:00,440 --> 00:13:02,240
no tengo ningún

330
00:13:02,240 --> 00:13:04,379
toString, pero yo puedo usar

331
00:13:04,379 --> 00:13:06,240
la llamada toString si me da la gana

332
00:13:06,240 --> 00:13:07,639
porque la ha heredado de object

333
00:13:07,639 --> 00:13:09,799
entonces vamos a hacernos un

334
00:13:09,799 --> 00:13:12,080
main aparte solamente para

335
00:13:12,080 --> 00:13:14,159
pruebas con esta cosita

336
00:13:14,159 --> 00:13:14,679
de object

337
00:13:14,679 --> 00:13:22,129
porque otras clases lo van a necesitar

338
00:13:22,129 --> 00:13:22,490
entonces

339
00:13:22,490 --> 00:13:25,970
alguna versión tiene que tener, ahora volvemos con eso

340
00:13:25,970 --> 00:13:27,889
vale, entonces

341
00:13:27,889 --> 00:13:32,029
me voy a hacer aquí un main2

342
00:13:32,029 --> 00:13:32,610
cualquiera

343
00:13:32,610 --> 00:13:35,669
entonces yo me voy a instanciar aquí

344
00:13:35,669 --> 00:13:36,690
un objeto cliente

345
00:13:36,690 --> 00:13:42,809
un objeto cliente c

346
00:13:42,809 --> 00:13:44,429
igual a new

347
00:13:44,429 --> 00:13:47,129
cliente, vale

348
00:13:47,129 --> 00:13:49,470
Como está en otro paquete, pues tengo que hacer el import

349
00:13:49,470 --> 00:13:51,509
O poner el nombre completo

350
00:13:51,509 --> 00:13:53,149
A elección

351
00:13:53,149 --> 00:13:54,889
Vale, ahora

352
00:13:54,889 --> 00:13:57,529
Cliente, tal y como yo lo he hecho

353
00:13:57,529 --> 00:13:58,789
Este stents como

354
00:13:58,789 --> 00:14:01,370
Lo quito porque que esté y que no esté

355
00:14:01,370 --> 00:14:01,889
Es lo mismo

356
00:14:01,889 --> 00:14:05,330
Esta clase cliente no tiene

357
00:14:05,330 --> 00:14:07,190
Ningún método toString, no lo tiene

358
00:14:07,190 --> 00:14:08,429
Yo no se lo he hecho, no lo tiene

359
00:14:08,429 --> 00:14:11,450
Pero como lo hereda de object

360
00:14:11,450 --> 00:14:12,830
Que object sí que lo tiene

361
00:14:12,830 --> 00:14:15,090
Pues lógicamente c

362
00:14:15,090 --> 00:14:16,289
Puede llamar a toString

363
00:14:16,289 --> 00:14:18,330
Y no pasa nada

364
00:14:18,330 --> 00:14:21,149
Voy a mostrar

365
00:14:21,149 --> 00:14:23,330
Aquí el resultado de tu string

366
00:14:23,330 --> 00:14:25,210
Lo hago en una línea separada

367
00:14:25,210 --> 00:14:26,309
Para que se vea más claro

368
00:14:26,309 --> 00:14:28,789
Y ahora puedo mostrar aquí

369
00:14:28,789 --> 00:14:35,139
Vale, entonces, ¿por qué me hayan dejado

370
00:14:35,139 --> 00:14:36,460
Llamar a un método tu string

371
00:14:36,460 --> 00:14:38,820
Si cliente, cliente

372
00:14:38,820 --> 00:14:39,740
No tiene ese método?

373
00:14:40,299 --> 00:14:42,840
Porque cliente hereda de object

374
00:14:42,840 --> 00:14:44,299
Y object lo tiene

375
00:14:44,299 --> 00:14:46,899
Pero claro, object tiene una versión de tu string

376
00:14:46,899 --> 00:14:48,019
Que

377
00:14:48,019 --> 00:14:50,899
Que lógicamente

378
00:14:50,899 --> 00:14:52,500
No sabe nada del objeto

379
00:14:52,500 --> 00:14:54,960
Tiene una versión de toString muy random

380
00:14:54,960 --> 00:14:57,159
Y además random nunca mejor dicho

381
00:14:57,159 --> 00:14:58,740
Porque el hashCode

382
00:14:58,740 --> 00:15:01,139
Utiliza una semilla aleatoria además

383
00:15:01,139 --> 00:15:02,539
Así que

384
00:15:02,539 --> 00:15:04,899
Entonces si yo ejecuto este main2

385
00:15:04,899 --> 00:15:15,360
Pues me saca esto

386
00:15:15,360 --> 00:15:17,159
Que esto es la salida

387
00:15:17,159 --> 00:15:18,379
Del toString de object

388
00:15:18,379 --> 00:15:20,539
El nombre de la clase

389
00:15:20,539 --> 00:15:23,059
Una arrobita y un número random

390
00:15:23,059 --> 00:15:25,559
Porque eso es lo que tiene el toString de object

391
00:15:25,559 --> 00:15:27,120
el nombre de la clase

392
00:15:27,120 --> 00:15:28,840
una arrobita

393
00:15:28,840 --> 00:15:30,740
y un número aquí random

394
00:15:30,740 --> 00:15:33,080
pues esto es lo que me saca

395
00:15:33,080 --> 00:15:35,620
claro, nosotros

396
00:15:35,620 --> 00:15:36,879
nos gusta este toString

397
00:15:36,879 --> 00:15:39,440
pues no nos gusta, entonces por eso

398
00:15:39,440 --> 00:15:40,620
lo que solemos hacer es

399
00:15:40,620 --> 00:15:43,559
sobreescribirlo en la clase cliente

400
00:15:43,559 --> 00:15:45,200
entonces

401
00:15:45,200 --> 00:15:46,960
nosotros podemos hacer toString

402
00:15:46,960 --> 00:15:49,480
que además este por ser un método

403
00:15:49,480 --> 00:15:51,519
importante nos lo hacía solo el Eclipse

404
00:15:51,519 --> 00:15:52,179
si queremos

405
00:15:52,179 --> 00:15:57,840
y ala, ya tengo el toString

406
00:15:57,840 --> 00:16:00,279
sobrescrito. Y como veis

407
00:16:00,279 --> 00:16:02,120
el Eclipse, como le gusta que

408
00:16:02,120 --> 00:16:04,200
programemos bien, me ha

409
00:16:04,200 --> 00:16:05,559
metido la anotación overwrite

410
00:16:05,559 --> 00:16:07,220
para

411
00:16:07,220 --> 00:16:10,059
permitirme validar que eso es un

412
00:16:10,059 --> 00:16:11,960
método sobrescrito. ¿Qué es

413
00:16:11,960 --> 00:16:14,240
obligatoria la anotación? No es obligatoria

414
00:16:14,240 --> 00:16:16,159
la anotación. La anotación me

415
00:16:16,159 --> 00:16:18,080
vale como aviso de que es un

416
00:16:18,080 --> 00:16:20,059
método sobrescrito de la superclase.

417
00:16:20,679 --> 00:16:21,639
No es obligatoria.

418
00:16:22,299 --> 00:16:23,960
Pero es muy buena práctica

419
00:16:23,960 --> 00:16:25,759
por lo que dijimos el miércoles.

420
00:16:26,700 --> 00:16:27,120
Esto no.

421
00:16:27,840 --> 00:16:30,559
mantener la

422
00:16:30,559 --> 00:16:32,159
anotación

423
00:16:32,159 --> 00:16:34,419
porque así

424
00:16:34,419 --> 00:16:36,679
si yo me equivoco y se me va aquí el dedo

425
00:16:36,679 --> 00:16:38,639
y se me va el dedo

426
00:16:38,639 --> 00:16:39,559
ahí y me equivoco

427
00:16:39,559 --> 00:16:41,779
el que exista la anotación

428
00:16:41,779 --> 00:16:43,620
hace que el compilador diga

429
00:16:43,620 --> 00:16:46,799
cuidado que este método es imposible

430
00:16:46,799 --> 00:16:48,720
que sea sobrescrito porque no existe

431
00:16:48,720 --> 00:16:49,799
arriba, no existe

432
00:16:49,799 --> 00:16:52,720
si yo no tuviera puesta la anotación

433
00:16:52,720 --> 00:16:56,019
traga con todo

434
00:16:56,019 --> 00:16:58,240
ah, que haces un método tu string, jijir

435
00:16:58,240 --> 00:16:59,679
vale, pues toString jiji

436
00:16:59,679 --> 00:17:02,200
pero no queremos hacer un método

437
00:17:02,200 --> 00:17:04,279
toString jiji, sino que queremos sobreescribir

438
00:17:04,279 --> 00:17:04,740
el de arriba

439
00:17:04,740 --> 00:17:08,519
entonces, por eso, si nuestra intención

440
00:17:08,519 --> 00:17:09,539
es sobreescribir

441
00:17:09,539 --> 00:17:11,380
mantengamos la anotación

442
00:17:11,380 --> 00:17:13,759
si nuestra intención es sobreescribir

443
00:17:13,759 --> 00:17:16,480
vale, entonces ahora

444
00:17:16,480 --> 00:17:20,299
respondiendo a tu pregunta

445
00:17:20,299 --> 00:17:22,519
¿y por qué

446
00:17:22,519 --> 00:17:24,259
object te ofrece ya un toString?

447
00:17:24,660 --> 00:17:26,779
¿qué sentido tiene que te ofrezca un toString?

448
00:17:26,779 --> 00:17:29,680
si lo que te ofrece es un código

449
00:17:29,680 --> 00:17:31,859
tan feo que tú lo vas a

450
00:17:31,859 --> 00:17:32,940
tener que sobreescribir

451
00:17:32,940 --> 00:17:35,140
bueno, porque

452
00:17:35,140 --> 00:17:37,519
el método toString es un método

453
00:17:37,519 --> 00:17:39,420
que llaman muchísimas clases

454
00:17:39,420 --> 00:17:43,099
de Java para hacer cosas

455
00:17:43,099 --> 00:17:45,460
por ejemplo, la clase System.out

456
00:17:45,460 --> 00:17:48,890
la clase System.out

457
00:17:48,890 --> 00:17:50,269
cuando le pasamos un objeto

458
00:17:50,269 --> 00:17:52,150
si yo le paso c

459
00:17:52,150 --> 00:17:53,849
yo le paso un objeto

460
00:17:53,849 --> 00:17:56,369
pues este es un ejemplo

461
00:17:56,369 --> 00:17:58,309
en el cual System.out

462
00:17:58,309 --> 00:17:58,869
¿qué hace?

463
00:17:59,849 --> 00:18:01,930
si entráramos en el código de System.out

464
00:18:01,930 --> 00:18:03,710
que este es el método estático

465
00:18:03,710 --> 00:18:06,529
println de la clase System.out

466
00:18:06,529 --> 00:18:07,769
ahora ya podemos entender esto

467
00:18:07,769 --> 00:18:10,269
es la llamada al método println de esta clase

468
00:18:10,269 --> 00:18:11,730
que tiene este nombre raro porque es especial

469
00:18:11,730 --> 00:18:12,250
pero bueno

470
00:18:12,250 --> 00:18:15,710
entonces, si entramos en el código de este método

471
00:18:15,710 --> 00:18:16,829
veremos que lo que hace es

472
00:18:16,829 --> 00:18:18,230
coge esto que hay aquí

473
00:18:18,230 --> 00:18:21,329
si es una variable primitiva la muestra tal cual

474
00:18:21,329 --> 00:18:23,109
si es una variable objeto

475
00:18:23,109 --> 00:18:24,349
llama a tu string

476
00:18:24,349 --> 00:18:26,950
entonces, hombre

477
00:18:26,950 --> 00:18:29,490
vamos a meter un mecanismo

478
00:18:29,490 --> 00:18:31,210
para asegurarnos de que todo el mundo

479
00:18:31,210 --> 00:18:32,250
del mundo mundial

480
00:18:32,250 --> 00:18:35,250
haga la clase que haga, la va a hacer con un

481
00:18:35,250 --> 00:18:37,650
tuestrin, vamos a asegurarnos

482
00:18:37,650 --> 00:18:39,130
porque el tuestrin lo va a llamar

483
00:18:39,130 --> 00:18:40,630
mucha gente, entonces es una

484
00:18:40,630 --> 00:18:42,769
herramienta, es una

485
00:18:42,769 --> 00:18:45,170
forma de asegurarnos de que todo

486
00:18:45,170 --> 00:18:47,250
el mundo va a incluir el tuestrin en sus clases

487
00:18:47,250 --> 00:18:49,109
pues la forma de asegurarnos

488
00:18:49,109 --> 00:18:51,390
de que todo el mundo va a incluir un tuestrin en sus clases

489
00:18:51,390 --> 00:18:52,690
aunque tú no lo pongas

490
00:18:52,690 --> 00:18:55,069
es ponerlo en object y decir, a mí me da igual

491
00:18:55,069 --> 00:18:57,250
cómo programe la gente, sé que cualquier objeto

492
00:18:57,250 --> 00:18:59,109
del mundo, cualquiera va a tener

493
00:18:59,109 --> 00:19:01,069
tu stream. Otra cosa es que lo tenga

494
00:19:01,069 --> 00:19:03,130
con código feo, pero lo va a tener.

495
00:19:04,130 --> 00:19:04,529
¿Vale?

496
00:19:05,529 --> 00:19:07,009
Ok, o sea, es un método

497
00:19:07,009 --> 00:19:07,529
tan usado.

498
00:19:08,730 --> 00:19:11,029
Claro, que ya desde la

499
00:19:11,029 --> 00:19:12,910
superclase lo entregas

500
00:19:12,910 --> 00:19:14,930
para que todos lo tengan en la versión

501
00:19:14,930 --> 00:19:16,809
básica que puede hacer Object, que es nada.

502
00:19:17,869 --> 00:19:19,130
Pero al menos no te va a

503
00:19:19,130 --> 00:19:19,609
dar error

504
00:19:19,609 --> 00:19:23,210
en el desarrollo, porque todo el mundo

505
00:19:23,210 --> 00:19:23,890
tiene ese método.

506
00:19:25,069 --> 00:19:28,390
La idea es acomodar ciertos patrones de diseño que todos

507
00:19:28,390 --> 00:19:28,769
sigamos.

508
00:19:28,910 --> 00:19:30,890
Pues, todos son toString porque lo llamamos todos.

509
00:19:31,049 --> 00:19:32,650
Pues, entonces, en object, ¿vale?

510
00:19:40,759 --> 00:19:44,059
Entonces, si yo no tengo aquí este método,

511
00:19:45,240 --> 00:19:48,819
no tengo el toString en cliente, no lo tengo,

512
00:19:49,640 --> 00:19:50,759
aquí no hay ningún problema.

513
00:19:51,900 --> 00:19:55,019
Este va a seguir llamando al toString.

514
00:19:55,559 --> 00:19:56,859
System.out va a llamar a toString.

515
00:19:57,160 --> 00:19:58,500
Ningún problema porque lo tiene.

516
00:19:58,500 --> 00:20:00,400
Pero me muestra

517
00:20:00,400 --> 00:20:03,019
Pues esta cosa rara

518
00:20:03,019 --> 00:20:05,039
¿Vale? Porque ha llamado al toString de object

519
00:20:05,039 --> 00:20:07,660
Pero si yo sí que tuviera

520
00:20:07,660 --> 00:20:11,960
Un toString sobrescrito en cliente

521
00:20:11,960 --> 00:20:13,859
Ahora este código main

522
00:20:13,859 --> 00:20:16,680
Pues ya me hace algo más bonito

523
00:20:16,680 --> 00:20:18,140
¿Vale?

524
00:20:35,519 --> 00:20:38,680
Claro, en este caso sería un error ya de compilación de partida

525
00:20:38,680 --> 00:20:39,920
Porque te diría

526
00:20:39,920 --> 00:20:41,420
Oye, que cliente no tiene toString

527
00:20:41,420 --> 00:20:43,339
Aquí el compilador no te puede decir eso

528
00:20:43,339 --> 00:20:44,500
porque te dice, a ver,

529
00:20:45,200 --> 00:20:47,200
C es cliente, pero también es object.

530
00:20:47,480 --> 00:20:49,640
Con lo cual, tú no lo tienes, pero está heredado.

531
00:20:49,779 --> 00:20:50,839
O sea, sí que lo tienes en realidad.

532
00:20:51,000 --> 00:20:52,200
Sí que lo tienes, aunque no lo veas.

533
00:20:59,079 --> 00:21:00,480
Y también hay otro método,

534
00:21:00,579 --> 00:21:02,960
es el segundo con el que nos...

535
00:21:02,960 --> 00:21:04,440
El único, segundo y último,

536
00:21:04,519 --> 00:21:06,119
en el que por ahora nos metemos de object,

537
00:21:06,920 --> 00:21:08,740
que es este de aquí que acabamos de ver

538
00:21:08,740 --> 00:21:10,920
que nos ha gustado

539
00:21:10,920 --> 00:21:12,839
porque lo usamos todo el rato en realidad.

540
00:21:14,220 --> 00:21:14,579
Este.

541
00:21:16,900 --> 00:21:18,039
El equals nos suena,

542
00:21:18,039 --> 00:21:20,279
que sí, es un método que estamos usando

543
00:21:20,279 --> 00:21:22,339
a menudo, pero nunca jamás

544
00:21:22,339 --> 00:21:24,420
hemos nosotros programado

545
00:21:24,420 --> 00:21:24,920
un equals

546
00:21:24,920 --> 00:21:28,500
¿vale? claro, no lo hemos programado

547
00:21:28,500 --> 00:21:29,819
porque lo heredamos de object

548
00:21:29,819 --> 00:21:30,759
entonces

549
00:21:30,759 --> 00:21:33,559
a ver, esto es importante

550
00:21:33,559 --> 00:21:34,920
vamos a intentar

551
00:21:34,920 --> 00:21:38,079
ir despacio y entenderlo

552
00:21:38,079 --> 00:21:40,380
¿vale? venga, vamos a ponerlo aquí

553
00:21:40,380 --> 00:21:46,380
bueno, pues

554
00:21:46,380 --> 00:21:48,319
la igualdad de objetos

555
00:21:48,319 --> 00:21:50,839
sigue los mismos criterios

556
00:21:50,839 --> 00:21:51,960
que la igualdad de

557
00:21:51,960 --> 00:21:53,640
Cadenas string

558
00:21:53,640 --> 00:21:55,440
Que ya la vimos en su momento

559
00:21:55,440 --> 00:21:57,079
Porque los string son cadenas

560
00:21:57,079 --> 00:21:58,640
Entonces recordad

561
00:21:58,640 --> 00:22:00,559
Recordáis que nosotros decíamos

562
00:22:00,559 --> 00:22:03,420
Pues yo tengo una cadena

563
00:22:03,420 --> 00:22:08,240
String S1

564
00:22:08,240 --> 00:22:11,160
Igual a hola

565
00:22:11,160 --> 00:22:11,559
¿Vale?

566
00:22:12,299 --> 00:22:13,420
Tengo

567
00:22:13,420 --> 00:22:15,980
String S2

568
00:22:15,980 --> 00:22:17,720
Igual a

569
00:22:17,720 --> 00:22:19,119
Adiós

570
00:22:19,119 --> 00:22:19,519
¿Vale?

571
00:22:20,220 --> 00:22:21,380
Entonces

572
00:22:21,380 --> 00:22:24,059
Ahora si muestro aquí

573
00:22:24,059 --> 00:22:27,720
Igual

574
00:22:27,720 --> 00:22:31,980
Para comparar cadenas

575
00:22:31,980 --> 00:22:35,000
Las comparamos así, ¿verdad?

576
00:22:36,220 --> 00:22:36,900
Las comparamos

577
00:22:36,900 --> 00:22:38,660
S1 igual a S2, perdón

578
00:22:38,660 --> 00:22:41,299
Las comparamos así

579
00:22:41,299 --> 00:22:43,059
Entonces, esto me dará

580
00:22:43,059 --> 00:22:47,279
False, ¿vale?

581
00:22:49,140 --> 00:22:49,859
Ahora

582
00:22:49,859 --> 00:22:53,660
Voy a cambiar a S2

583
00:22:53,660 --> 00:22:55,200
Y le voy a poner a hola

584
00:22:58,799 --> 00:23:12,480
Y ahora, uy, ahora esto me dará true, ¿verdad?

585
00:23:14,140 --> 00:23:14,660
Vale.

586
00:23:15,559 --> 00:23:17,779
Y así es como comparamos cadenas, ¿verdad?

587
00:23:20,200 --> 00:23:28,650
Porque si las comparáramos así, ¿vale?

588
00:23:33,039 --> 00:23:38,720
Es que él usa un buffer, es que estaba buscando un ejemplo en el que hasta 1024 cadenas,

589
00:23:39,680 --> 00:23:43,519
él cuando ve dos cadenas iguales las pone bajo la misma referencia.

590
00:23:43,900 --> 00:23:46,839
Pero eso solo aplica en los casos en los que no lo estás pasando como parámetro.

591
00:23:46,839 --> 00:23:49,220
entonces, vamos a instanciarlas

592
00:23:49,220 --> 00:23:51,119
las cadenas bien para que esto no ocurra

593
00:23:51,119 --> 00:23:53,480
vale

594
00:23:53,480 --> 00:23:56,539
vale, entonces

595
00:23:56,539 --> 00:24:01,539
a ver

596
00:24:01,539 --> 00:24:09,869
vale, entonces

597
00:24:09,869 --> 00:24:11,809
lo que he retocado aquí

598
00:24:11,809 --> 00:24:13,329
lo que he retocado aquí

599
00:24:13,329 --> 00:24:15,009
es la forma real

600
00:24:15,009 --> 00:24:17,710
lo que hace Java en la forma real

601
00:24:17,710 --> 00:24:20,309
en la cual uno instancia un objeto

602
00:24:20,309 --> 00:24:21,930
lo que pasa es que Java nos permite

603
00:24:21,930 --> 00:24:22,809
lógicamente

604
00:24:22,809 --> 00:24:24,829
nos permite

605
00:24:24,829 --> 00:24:26,930
esto

606
00:24:26,930 --> 00:24:31,099
esto de aquí

607
00:24:31,099 --> 00:24:31,940
por comodidad

608
00:24:31,940 --> 00:24:32,700
como los string

609
00:24:32,700 --> 00:24:33,900
los usamos tantísimo

610
00:24:33,900 --> 00:24:35,099
pues java

611
00:24:35,099 --> 00:24:35,859
nos permite

612
00:24:35,859 --> 00:24:37,019
el atajo

613
00:24:37,019 --> 00:24:38,500
de instanciar

614
00:24:38,500 --> 00:24:39,079
un objeto

615
00:24:39,079 --> 00:24:40,059
de la clase string

616
00:24:40,059 --> 00:24:41,420
de instanciarlo

617
00:24:41,420 --> 00:24:42,380
poniendo ahí

618
00:24:42,380 --> 00:24:42,720
lo que sea

619
00:24:42,720 --> 00:24:43,319
con comillas

620
00:24:43,319 --> 00:24:43,839
¿vale?

621
00:24:44,420 --> 00:24:45,720
nos permite este atajo

622
00:24:45,720 --> 00:24:46,440
pero realmente

623
00:24:46,440 --> 00:24:47,240
lo que está haciendo

624
00:24:47,240 --> 00:24:48,099
es instanciar

625
00:24:48,099 --> 00:24:48,599
un objeto

626
00:24:48,599 --> 00:24:49,559
de la clase string

627
00:24:49,559 --> 00:24:51,420
entonces lo que realmente

628
00:24:51,420 --> 00:24:51,920
está haciendo

629
00:24:51,920 --> 00:24:52,380
es esto

630
00:24:52,380 --> 00:24:54,000
entonces yo lo puedo hacer

631
00:24:54,000 --> 00:24:54,940
específicamente

632
00:24:54,940 --> 00:24:55,599
si quiero

633
00:24:55,599 --> 00:24:56,180
lo puedo hacer

634
00:24:56,180 --> 00:24:56,940
específicamente

635
00:24:56,940 --> 00:24:59,460
¿Vale? Con esto estoy instanciando

636
00:24:59,460 --> 00:25:00,880
Un objeto de la clase string

637
00:25:00,880 --> 00:25:03,000
Y al constructor de string

638
00:25:03,000 --> 00:25:05,299
Ya le paso la propiedad

639
00:25:05,299 --> 00:25:07,000
De ese objeto que es esto

640
00:25:07,000 --> 00:25:08,880
Y en mi instanción string con ese valor de

641
00:25:08,880 --> 00:25:11,119
¿Vale? Pero repito

642
00:25:11,119 --> 00:25:13,180
Esto es lo que se abrevia

643
00:25:13,180 --> 00:25:14,200
Si yo hago así

644
00:25:14,200 --> 00:25:16,779
O se abrevia

645
00:25:16,779 --> 00:25:18,119
Si yo hago así ¿Vale?

646
00:25:20,140 --> 00:25:22,480
Por eso normalmente lo hacemos abreviado

647
00:25:22,480 --> 00:25:23,799
No usamos todo esto

648
00:25:23,799 --> 00:25:26,460
Lo que pasa es que yo lo voy a hacer específicamente

649
00:25:26,460 --> 00:25:29,680
Para que se escape de un buffer

650
00:25:29,680 --> 00:25:30,660
Y lo veamos más claro

651
00:25:30,660 --> 00:25:35,420
A ver, dejadme probar un segundito

652
00:25:35,420 --> 00:25:37,480
Vale, ahora ya sé

653
00:25:37,480 --> 00:25:39,420
Vale, entonces

654
00:25:39,420 --> 00:25:43,599
Yo tengo aquí mis dos cadenas

655
00:25:43,599 --> 00:25:46,039
Está claro que aquí me va a dar

656
00:25:46,039 --> 00:25:47,619
S1 equals S2

657
00:25:47,619 --> 00:25:48,440
Falso

658
00:25:48,440 --> 00:25:50,940
Perdón

659
00:25:50,940 --> 00:25:53,579
Vale, tengo estas dos cadenas

660
00:25:53,579 --> 00:25:55,039
Hola y adiós

661
00:25:55,039 --> 00:25:56,720
Me da falso, lógicamente

662
00:25:56,720 --> 00:25:58,839
Ahora, S2

663
00:25:58,839 --> 00:26:01,119
Le asigno hola

664
00:26:01,119 --> 00:26:02,880
Le cambio su valor, le asigno hola

665
00:26:02,880 --> 00:26:04,880
A este objeto S2 que yo tengo aquí instanciado

666
00:26:04,880 --> 00:26:05,740
Le asigno hola

667
00:26:05,740 --> 00:26:08,740
Voy a compararlos ahora, S1 con S2

668
00:26:08,740 --> 00:26:10,619
¿Vale?

669
00:26:10,619 --> 00:26:12,900
Y voy a compararlos de estas dos maneras

670
00:26:12,900 --> 00:26:13,980
De la buena

671
00:26:13,980 --> 00:26:15,519
Con el equals

672
00:26:15,519 --> 00:26:17,799
Y de la mala que uno podría hacer

673
00:26:17,799 --> 00:26:18,880
Si escribe muy rápido

674
00:26:18,880 --> 00:26:21,160
Y mete la pata

675
00:26:21,160 --> 00:26:24,720
Que es S1 es igual a S2

676
00:26:24,720 --> 00:26:27,319
bueno, pues si ejecutamos esto

677
00:26:27,319 --> 00:26:29,740
lógicamente

678
00:26:29,740 --> 00:26:30,799
de la manera buena

679
00:26:30,799 --> 00:26:33,480
me ha salido true, porque aquí

680
00:26:33,480 --> 00:26:35,759
¿qué está comparando? el equals compara

681
00:26:35,759 --> 00:26:37,420
que el contenido que tiene

682
00:26:37,420 --> 00:26:39,519
S1 sea igual que

683
00:26:39,519 --> 00:26:41,160
el contenido que tiene S2

684
00:26:41,160 --> 00:26:43,799
¿pero qué comparamos con esto?

685
00:26:43,960 --> 00:26:45,559
la dirección de memoria

686
00:26:45,559 --> 00:26:47,700
en la que está la cadena S1 es igual

687
00:26:47,700 --> 00:26:49,759
que la dirección de memoria en la que está la cadena S2

688
00:26:49,759 --> 00:26:52,039
no, S1 es un objeto

689
00:26:52,039 --> 00:26:54,000
y S2 es otro objeto

690
00:26:54,000 --> 00:26:57,559
entonces esto es

691
00:26:57,559 --> 00:26:59,500
falso, porque son dos objetos distintos

692
00:26:59,500 --> 00:27:01,480
otra cosa es que su contenido

693
00:27:01,480 --> 00:27:03,579
sea el mismo, su contenido

694
00:27:03,579 --> 00:27:05,140
lo es, porque

695
00:27:05,140 --> 00:27:07,259
lo que mira es el contenido

696
00:27:07,259 --> 00:27:09,539
esto es lo que hemos visto

697
00:27:09,539 --> 00:27:11,359
con string, con lo que hemos

698
00:27:11,359 --> 00:27:13,339
dicho de toda la vida

699
00:27:13,339 --> 00:27:15,539
pues con cualquier otro

700
00:27:15,539 --> 00:27:16,480
objeto sería igual

701
00:27:16,480 --> 00:27:19,559
entonces, vámonos ahora a nuestro cliente

702
00:27:20,279 --> 00:27:21,420
resulta que mi

703
00:27:21,420 --> 00:27:22,200
aplicación

704
00:27:22,200 --> 00:27:39,960
Pues, normalmente a las aplicaciones les ponemos un criterio de igualdad entre entidades, ¿vale? Es decir, una clave primaria. El concepto de clave primaria en las bases de datos es natural porque lo usáis y es imprescindible, no es imprescindible, pero recomendable.

705
00:27:39,960 --> 00:27:43,000
El concepto de clave primaria como tal

706
00:27:43,000 --> 00:27:45,000
En los lenguajes de programación no está

707
00:27:45,000 --> 00:27:47,359
Pero es una idea que yo tengo que poner

708
00:27:47,359 --> 00:27:49,140
Desde fuera, de alguna manera

709
00:27:49,140 --> 00:27:50,839
Por ejemplo, aquí

710
00:27:50,839 --> 00:27:53,680
Sería lo normal asumir

711
00:27:53,680 --> 00:27:55,980
Que dos clientes del mismo NIF

712
00:27:55,980 --> 00:27:56,839
Son el mismo

713
00:27:56,839 --> 00:27:59,140
Tendría sentido, ¿vale?

714
00:27:59,220 --> 00:28:01,240
Por significado real de mi aplicación

715
00:28:01,240 --> 00:28:02,880
Todo por significado, no es que Java

716
00:28:02,880 --> 00:28:04,660
Me obligue

717
00:28:04,660 --> 00:28:07,019
Tendría sentido, ¿vale?

718
00:28:07,519 --> 00:28:09,299
No tendría sentido pensar

719
00:28:09,299 --> 00:28:11,500
que dos clientes con el mismo nombre son el mismo.

720
00:28:11,660 --> 00:28:12,539
No, se pueden llamar igual.

721
00:28:13,799 --> 00:28:15,420
Pero que dos clientes con el mismo

722
00:28:15,420 --> 00:28:16,819
NIF son el mismo, sí.

723
00:28:18,019 --> 00:28:19,539
Lo que pasa es que puede ser que el cliente

724
00:28:19,539 --> 00:28:20,819
a lo mejor se haya registrado

725
00:28:20,819 --> 00:28:23,319
dos veces con nombres

726
00:28:23,319 --> 00:28:25,380
distintos y podría

727
00:28:25,380 --> 00:28:27,359
haber dos objetos con el

728
00:28:27,359 --> 00:28:29,579
mismo NIF y nombres distintos.

729
00:28:31,160 --> 00:28:31,339
Entonces,

730
00:28:31,460 --> 00:28:33,460
hombre, sería interesante que mi aplicación

731
00:28:33,460 --> 00:28:34,380
de alguna manera

732
00:28:34,380 --> 00:28:37,319
fuera capaz de ver si un

733
00:28:37,319 --> 00:28:39,019
objeto es el mismo que el otro,

734
00:28:39,019 --> 00:28:41,380
es igual que el otro, porque si lo es

735
00:28:41,380 --> 00:28:43,119
yo interpreto ya que es una dúplica

736
00:28:43,119 --> 00:28:44,599
ignoro uno o lo que sea

737
00:28:44,599 --> 00:28:46,880
vale, pues entonces

738
00:28:46,880 --> 00:28:49,000
desde el momento en que yo

739
00:28:49,000 --> 00:28:51,400
asumo un criterio

740
00:28:51,400 --> 00:28:52,180
de igualdad

741
00:28:52,180 --> 00:28:54,920
en mis entidades

742
00:28:54,920 --> 00:28:57,180
lo tengo que reflejar de alguna manera

743
00:28:57,180 --> 00:28:59,160
porque si no, ¿cómo sé

744
00:28:59,160 --> 00:29:00,420
si un objeto es igual a otro?

745
00:29:01,160 --> 00:29:03,259
por ejemplo, vamos a hacer aquí en mi main2

746
00:29:03,259 --> 00:29:05,140
vamos a hacer

747
00:29:05,140 --> 00:29:09,039
dos clientes

748
00:29:09,039 --> 00:29:13,819
Igualdad de objetos

749
00:29:13,819 --> 00:29:16,200
Vamos a hacernos aquí dos clientes

750
00:29:16,200 --> 00:29:18,920
Entonces aquí aparece un cliente porque uno se ha registrado

751
00:29:18,920 --> 00:29:21,599
Cliente C1 se ha registrado

752
00:29:21,599 --> 00:29:26,420
Y este cliente C1 se ha registrado

753
00:29:26,420 --> 00:29:28,160
Con el nombre

754
00:29:28,160 --> 00:29:34,990
Se ha registrado, pues con el nombre Luis

755
00:29:34,990 --> 00:29:40,670
Y este cliente C1 se ha registrado

756
00:29:40,670 --> 00:29:42,430
Con el NIF

757
00:29:42,430 --> 00:29:46,039
1, 2, 3, 4

758
00:29:46,039 --> 00:29:49,740
ahora esta aplicación

759
00:29:49,740 --> 00:29:51,099
que es una aplicación distribuida

760
00:29:51,099 --> 00:29:53,960
que se ejecuta en cualquier momento

761
00:29:53,960 --> 00:29:54,839
pues

762
00:29:54,839 --> 00:29:57,700
ha permitido

763
00:29:57,700 --> 00:29:59,740
lo que fuera, pues que haya otro cliente

764
00:29:59,740 --> 00:30:00,819
en la aplicación C2

765
00:30:00,819 --> 00:30:02,740
que resulta que es el mismo

766
00:30:02,740 --> 00:30:09,339
entonces este cliente C2

767
00:30:09,339 --> 00:30:11,880
pues se ha registrado con nombre

768
00:30:11,880 --> 00:30:14,880
Luisito

769
00:30:14,880 --> 00:30:16,660
pues porque

770
00:30:16,660 --> 00:30:18,259
se registró hace muchos años

771
00:30:18,259 --> 00:30:19,259
entonces se llamaba Luisito

772
00:30:19,259 --> 00:30:21,839
pero es Luis

773
00:30:21,839 --> 00:30:23,099
que ha crecido

774
00:30:23,099 --> 00:30:28,619
bueno, pues en la aplicación se puede dar esta situación

775
00:30:28,619 --> 00:30:30,599
se puede dar que yo tenga

776
00:30:30,599 --> 00:30:32,500
dos objetos instanciados

777
00:30:32,500 --> 00:30:35,839
pero a nivel de

778
00:30:35,839 --> 00:30:38,059
interpretación real de lo que está ocurriendo ahí

779
00:30:38,059 --> 00:30:39,440
a nivel de lo que está pasando

780
00:30:39,440 --> 00:30:42,059
se refieren a la misma

781
00:30:42,059 --> 00:30:43,819
persona, a la misma persona

782
00:30:43,819 --> 00:30:45,779
pero son dos objetos distintos, está claro

783
00:30:45,779 --> 00:30:48,200
entonces yo tengo que de alguna manera

784
00:30:48,200 --> 00:30:49,759
pues habilitar

785
00:30:49,759 --> 00:30:51,839
poner la posibilidad de distinguirse

786
00:30:51,839 --> 00:30:55,980
si un objeto se corresponde al mismo cliente que el otro.

787
00:30:56,160 --> 00:30:59,220
Si un objeto y el otro, estas son dúplicas en realidad,

788
00:30:59,380 --> 00:31:00,460
aunque sean objetos distintos.

789
00:31:01,380 --> 00:31:02,759
Tengo que tener alguna manera de decir,

790
00:31:02,819 --> 00:31:04,779
oye, este no será una dúplica,

791
00:31:04,859 --> 00:31:07,119
porque si es una dúplica voy a eliminar uno de los dos,

792
00:31:07,240 --> 00:31:09,839
porque si no voy a tener aquí una raíz de clientes,

793
00:31:09,839 --> 00:31:13,279
cuando a lo mejor cuatro son el mismo,

794
00:31:13,680 --> 00:31:15,660
otros cinco son el mismo, me va a funcionar mal.

795
00:31:15,980 --> 00:31:17,680
Cuando agrego un pedido, ¿a quién se lo agrego?

796
00:31:17,720 --> 00:31:19,039
Si tengo varios NIF juntos.

797
00:31:19,039 --> 00:31:22,240
entonces debería poner de alguna manera

798
00:31:22,240 --> 00:31:23,619
una forma de detectar

799
00:31:23,619 --> 00:31:25,980
si diferentes instancias

800
00:31:25,980 --> 00:31:27,799
son el mismo

801
00:31:27,799 --> 00:31:28,720
la misma persona

802
00:31:28,720 --> 00:31:31,380
son duplicados que no quiero, que me sobran

803
00:31:31,380 --> 00:31:32,920
pues ¿cómo?

804
00:31:33,460 --> 00:31:34,660
pues ahora mismo

805
00:31:34,660 --> 00:31:36,759
tal y como lo tenemos

806
00:31:36,759 --> 00:31:40,099
si mi criterio de igualdad es cliente

807
00:31:40,099 --> 00:31:41,119
tendría que hacerlo

808
00:31:41,119 --> 00:31:42,920
haciendo la propiedad

809
00:31:42,920 --> 00:31:46,339
si c2.getNive

810
00:31:46,339 --> 00:31:49,990
vale, vamos a ponerlo aquí

811
00:31:49,990 --> 00:31:56,369
Ver si los

812
00:31:56,369 --> 00:31:58,710
Dos objetos

813
00:31:58,710 --> 00:32:03,369
Son el mismo

814
00:32:03,369 --> 00:32:05,430
Cliente

815
00:32:05,430 --> 00:32:07,109
Vale

816
00:32:07,109 --> 00:32:09,109
Antes de ponerlo como lo tendríamos que hacer

817
00:32:09,109 --> 00:32:10,730
Lógicamente

818
00:32:10,730 --> 00:32:11,730
Uno

819
00:32:11,730 --> 00:32:14,269
Jamás lo compararía así

820
00:32:14,269 --> 00:32:26,210
Así no los compararía porque esto

821
00:32:26,210 --> 00:32:28,009
Le va a dar

822
00:32:28,009 --> 00:32:29,849
Lógicamente que no son el mismo

823
00:32:29,849 --> 00:32:34,119
Porque ahí compara

824
00:32:34,119 --> 00:32:38,930
Aquí compara la dirección de memoria

825
00:32:38,930 --> 00:32:40,190
De la que cuelga cada objeto

826
00:32:40,190 --> 00:32:42,589
Son dos objetos distintos colgando

827
00:32:42,589 --> 00:32:44,430
Direcciones de memoria distintas

828
00:32:44,430 --> 00:32:47,009
Lo que pasa es que el nif es igual, uno es copia del otro

829
00:32:47,009 --> 00:32:48,950
Pero son dos objetos distintos

830
00:32:48,950 --> 00:32:50,509
Colgando direcciones de memoria distintas

831
00:32:50,509 --> 00:32:52,509
Entonces, si yo

832
00:32:52,509 --> 00:32:54,829
Hago esto, me va a decir que

833
00:32:54,829 --> 00:32:56,730
No son el mismo, ¿verdad?

834
00:32:59,670 --> 00:33:00,650
No son el mismo

835
00:33:00,650 --> 00:33:03,390
Vale, entonces yo podría decir

836
00:33:03,390 --> 00:33:05,390
Oye, voy a hacer el truco

837
00:33:05,390 --> 00:33:07,450
Del string, voy a hacerlo

838
00:33:07,450 --> 00:33:08,809
Con el equals

839
00:33:08,809 --> 00:33:11,170
Vale, entonces yo

840
00:33:11,170 --> 00:33:12,609
Vamos a hacer otro intento

841
00:33:12,609 --> 00:33:14,609
En lugar de comparar así

842
00:33:14,609 --> 00:33:17,170
Vamos a comparar

843
00:33:17,170 --> 00:33:19,430
Que ya tenemos la pista de que con las cadenas

844
00:33:19,430 --> 00:33:21,369
Esto no funciona, pues las direcciones de memoria

845
00:33:21,369 --> 00:33:26,200
Vamos a comparar así

846
00:33:26,200 --> 00:33:28,779
¿Vale?

847
00:33:30,869 --> 00:33:33,289
Y ahora, la pregunta que haríais sería

848
00:33:33,289 --> 00:33:35,329
¿Podemos completar esto

849
00:33:35,329 --> 00:33:35,970
O preferís parar?

850
00:33:37,630 --> 00:33:38,650
¿Eh? ¿Qué habéis dicho?

851
00:33:40,950 --> 00:33:41,430
¿Sigo?

852
00:33:42,009 --> 00:33:42,869
Vale, pues nada

853
00:33:42,869 --> 00:33:44,329
5 minutos, o por ahí

854
00:33:44,329 --> 00:33:47,230
Bueno, siempre digo 5 y luego son 6, pero...

855
00:33:47,230 --> 00:33:50,250
Vale, entonces, primera pregunta que os hacéis.

856
00:33:50,730 --> 00:33:54,970
Decís, pero bueno, ¿cómo que C1.equals?

857
00:33:55,109 --> 00:33:59,269
¿Desde cuándo he hecho yo en mi clase cliente un método

858
00:33:59,269 --> 00:33:59,609
equals?

859
00:33:59,789 --> 00:34:01,750
¿Cómo es que eso puede llamar a un método equals?

860
00:34:02,589 --> 00:34:05,009
Vamos a ver si es que yo tengo en mi clase cliente un método

861
00:34:05,009 --> 00:34:05,410
equals.

862
00:34:06,150 --> 00:34:08,030
No tengo un método equals en ningún sitio.

863
00:34:08,250 --> 00:34:10,670
¿Cómo puede ser que este llame a un método equals?

864
00:34:11,449 --> 00:34:14,670
Claro, pero ya sabemos que cliente hereda de object

865
00:34:14,670 --> 00:34:18,409
y object tiene un método equals, que es este.

866
00:34:20,090 --> 00:34:21,989
Pero este método equals nos vale.

867
00:34:22,449 --> 00:34:24,789
Pues si miramos cómo está hecho, tampoco nos vale.

868
00:34:25,170 --> 00:34:27,829
Porque este método equals lo que hace es el doble igual.

869
00:34:28,269 --> 00:34:31,469
Comparar la dirección de memoria del que llama al método

870
00:34:31,469 --> 00:34:34,269
con la propia dirección de memoria del pasado.

871
00:34:35,190 --> 00:34:36,329
Es decir, hace lo mismo.

872
00:34:36,809 --> 00:34:37,690
Hace el doble igual.

873
00:34:37,869 --> 00:34:40,530
Con lo cual no he ganado nada llamando al equals.

874
00:34:40,670 --> 00:34:48,510
No he ganado nada, porque lo que hace el equals de object es coger la dirección de C1 y hacer doble igual con la de C2.

875
00:34:48,829 --> 00:34:57,750
Esto, coger C1 y hacer doble igual con C2, con lo cual no he ganado nada, llamando al equals de object.

876
00:34:58,469 --> 00:35:01,389
Y de hecho, si lo ejecuto, me va a seguir diciendo que no son el mismo.

877
00:35:02,750 --> 00:35:06,789
Claro, pero es que lo que ocurre es que a mí el equals de object no me interesa.

878
00:35:06,789 --> 00:35:09,369
yo quiero sobreescribir el equals

879
00:35:09,369 --> 00:35:11,869
para que refleje realmente

880
00:35:11,869 --> 00:35:13,750
si el objeto es el mismo o no

881
00:35:13,750 --> 00:35:15,550
entonces nosotros

882
00:35:15,550 --> 00:35:17,670
sobreescribimos el método equals

883
00:35:17,670 --> 00:35:19,989
de object con nuestra condición de igualdad

884
00:35:19,989 --> 00:35:22,190
con la que nos interese a nosotros por aplicación

885
00:35:22,190 --> 00:35:23,030
la que nos dé la gana

886
00:35:23,030 --> 00:35:25,550
entonces, ¿qué hacemos aquí?

887
00:35:25,630 --> 00:35:27,190
vamos a sobreescribir el equals

888
00:35:27,190 --> 00:35:28,949
igual que hemos sobreescrito el toString

889
00:35:28,949 --> 00:35:31,190
vamos a sobreescribir el equals

890
00:35:31,190 --> 00:35:33,769
cliente

891
00:35:33,769 --> 00:35:35,010
equals

892
00:35:35,010 --> 00:35:38,550
cliente C

893
00:35:38,550 --> 00:35:39,409
por ejemplo

894
00:35:39,409 --> 00:35:40,949
y ahora

895
00:35:40,949 --> 00:35:44,889
y que me devuelve

896
00:35:44,889 --> 00:35:45,449
boolean

897
00:35:45,449 --> 00:35:47,250
vale

898
00:35:47,250 --> 00:35:51,199
y voy a poner aquí un override

899
00:35:51,199 --> 00:35:53,139
para asegurarme

900
00:35:53,139 --> 00:35:55,219
a ver si he puesto bien la cabecera

901
00:35:55,219 --> 00:35:56,360
vale

902
00:35:56,360 --> 00:35:59,539
he puesto aquí, perdón

903
00:35:59,539 --> 00:36:01,480
esto, vale

904
00:36:01,480 --> 00:36:03,980
public me devuelve un boolean

905
00:36:03,980 --> 00:36:05,980
el método equal recibe un objeto cliente

906
00:36:06,559 --> 00:36:07,860
entonces

907
00:36:07,860 --> 00:36:10,199
¿qué me va a devolver? pues

908
00:36:10,199 --> 00:36:11,719
si

909
00:36:11,719 --> 00:36:14,079
dis

910
00:36:14,079 --> 00:36:15,960
el objeto que llama al método

911
00:36:15,960 --> 00:36:16,760
punto nif

912
00:36:16,760 --> 00:36:19,960
resulta que es como es un string

913
00:36:19,960 --> 00:36:21,400
resulta que es igual

914
00:36:21,400 --> 00:36:23,840
esto es un string

915
00:36:23,840 --> 00:36:25,860
¿vale? recordad que los strings se comparan con

916
00:36:25,860 --> 00:36:26,300
equals

917
00:36:26,300 --> 00:36:30,079
es igual que c punto nif

918
00:36:30,079 --> 00:36:31,760
pues entonces

919
00:36:31,760 --> 00:36:32,500
ya retúntru

920
00:36:32,500 --> 00:36:34,960
que mi equals me devuelva true

921
00:36:34,960 --> 00:36:36,920
y si no

922
00:36:36,920 --> 00:36:38,019
Else

923
00:36:38,019 --> 00:36:40,519
Return false

924
00:36:40,519 --> 00:36:42,159
¿Vale?

925
00:36:42,820 --> 00:36:43,780
Entonces

926
00:36:43,780 --> 00:36:50,539
A ver que no he escrito

927
00:36:50,539 --> 00:36:52,820
Bien la cabecera

928
00:36:52,820 --> 00:37:06,530
Object

929
00:37:06,530 --> 00:37:07,989
Y ahora, ¿vale?

930
00:37:08,050 --> 00:37:11,010
Porque la cabecera no estaba idéntica

931
00:37:11,010 --> 00:37:12,869
¿Vale? Ahora he puesto la cabecera

932
00:37:12,869 --> 00:37:14,630
Idéntica para que sea sobrescrito

933
00:37:14,630 --> 00:37:15,690
¿Vale?

934
00:37:15,690 --> 00:37:17,349
He puesto la cabecera

935
00:37:17,349 --> 00:37:18,650
Perdón, idéntica

936
00:37:18,650 --> 00:37:20,809
la cabecera está idéntica

937
00:37:20,809 --> 00:37:22,670
pero lo único

938
00:37:22,670 --> 00:37:24,010
es que ahora me falta hacer el casting

939
00:37:24,010 --> 00:37:26,269
para que la cabecera sea idéntica

940
00:37:26,269 --> 00:37:28,289
el parámetro que paso

941
00:37:28,289 --> 00:37:29,949
lo tengo que poner como si fuera object

942
00:37:29,949 --> 00:37:31,650
para que la cabecera sea idéntica

943
00:37:31,650 --> 00:37:34,550
pero yo sé que el que voy a pasar

944
00:37:34,550 --> 00:37:36,309
es un objeto cliente

945
00:37:36,309 --> 00:37:38,690
cuando lo llame lo sé que es un objeto cliente

946
00:37:38,690 --> 00:37:40,630
luego para poder acceder

947
00:37:40,630 --> 00:37:42,849
a nif, porque esto de nuevo es herencia

948
00:37:42,849 --> 00:37:44,530
el compilador me dice

949
00:37:44,530 --> 00:37:45,889
a ver parámetro c

950
00:37:45,889 --> 00:37:48,190
parámetro c es de clase object

951
00:37:48,190 --> 00:37:50,030
En la clase object

952
00:37:50,030 --> 00:37:51,829
No hay ningún nif que yo sepa

953
00:37:51,829 --> 00:37:53,989
Con lo cual no te dejo

954
00:37:53,989 --> 00:37:55,389
Que hacíamos

955
00:37:55,389 --> 00:37:57,289
Le poníamos el casting a object

956
00:37:57,289 --> 00:37:58,110
¿Verdad?

957
00:37:59,469 --> 00:38:01,289
Perdón, el casting a cliente

958
00:38:01,289 --> 00:38:10,340
Ay, jolines, cliente

959
00:38:10,340 --> 00:38:15,849
Cliente de C

960
00:38:15,849 --> 00:38:19,159
Y ahora

961
00:38:19,159 --> 00:38:24,420
Esto lo paso a

962
00:38:24,420 --> 00:38:25,659
Cliente C

963
00:38:25,659 --> 00:38:26,639
Punto

964
00:38:26,639 --> 00:38:33,079
Ahora, ahora lo

965
00:38:33,079 --> 00:38:39,760
Vale, ya está

966
00:38:39,760 --> 00:39:02,300
Vale, a ver, repasamos por partes. Yo quiero sobreescribir el método equals de object para que realmente me compare, me devuelva true si los objetos son iguales o falsos y no, pero según el criterio de igualdad mío que yo quiera, no según el de dirección de memoria que es el que tiene object.

967
00:39:02,300 --> 00:39:04,880
¿Vale? Ese no me gusta

968
00:39:04,880 --> 00:39:07,039
Quiero que me devuelva true

969
00:39:07,039 --> 00:39:08,760
Si pasa lo que yo quiero

970
00:39:08,760 --> 00:39:10,260
Y false si no

971
00:39:10,260 --> 00:39:11,800
Hasta ahí está claro, ¿no?

972
00:39:11,900 --> 00:39:13,099
Entonces lo sobrescribo

973
00:39:13,099 --> 00:39:16,820
Y sobrescribirlo implica respetar su cabecera tal cual

974
00:39:16,820 --> 00:39:18,440
Vale, ahí se queda sobrescrito

975
00:39:18,440 --> 00:39:19,639
Ahora

976
00:39:19,639 --> 00:39:22,000
¿Cuándo quiero yo que devuelva true?

977
00:39:22,619 --> 00:39:25,039
Cuando el need del objeto que llama el método

978
00:39:25,039 --> 00:39:25,599
Que es this

979
00:39:25,599 --> 00:39:29,219
Sea igual que el need del objeto parámetro

980
00:39:29,219 --> 00:39:31,099
Ahí es cuando quiero que devuelva true

981
00:39:31,099 --> 00:39:32,280
Y false si no

982
00:39:32,280 --> 00:39:35,280
vale, pues si this.nif

983
00:39:35,280 --> 00:39:36,460
es igual

984
00:39:36,460 --> 00:39:38,980
este es el equals de la clase string

985
00:39:38,980 --> 00:39:41,400
es igual que el nif

986
00:39:41,400 --> 00:39:42,059
de este

987
00:39:42,059 --> 00:39:45,440
pero claro, esto es lo mismo de la herencia

988
00:39:45,440 --> 00:39:46,199
que ya hemos visto

989
00:39:46,199 --> 00:39:49,179
como cliente

990
00:39:49,179 --> 00:39:50,320
hereda de object

991
00:39:50,320 --> 00:39:53,599
yo aquí le puedo pasar, le he pasado un cliente

992
00:39:53,599 --> 00:39:55,639
y no pasa nada, porque recordad

993
00:39:55,639 --> 00:39:56,940
que en una superclase

994
00:39:56,940 --> 00:39:59,559
puede caer una instancia de una subclase

995
00:39:59,559 --> 00:40:01,500
entonces c2, lo que yo le paso

996
00:40:01,500 --> 00:40:03,380
aquí es cliente que es subclase

997
00:40:03,380 --> 00:40:05,699
pero él cabe perfectamente

998
00:40:05,699 --> 00:40:06,559
ningún problema

999
00:40:06,559 --> 00:40:09,099
en meterlo en un object

1000
00:40:09,099 --> 00:40:10,900
porque object es superclase

1001
00:40:10,900 --> 00:40:12,599
luego casa perfectamente

1002
00:40:12,599 --> 00:40:15,820
pero claro, el compilador, cuando yo haga c.nir

1003
00:40:15,820 --> 00:40:17,280
el compilador me dice

1004
00:40:17,280 --> 00:40:19,559
perdona, yo miro como estás

1005
00:40:19,559 --> 00:40:21,420
declarado, aunque luego te instancies

1006
00:40:21,420 --> 00:40:23,960
como cliente y te pases aquí como cliente

1007
00:40:23,960 --> 00:40:25,500
yo miro que estás

1008
00:40:25,500 --> 00:40:27,480
declarado como object y aquí en object

1009
00:40:27,480 --> 00:40:28,820
que yo sepa no hay ningún nir

1010
00:40:28,820 --> 00:40:31,079
¿cómo solucionábamos eso?

1011
00:40:31,500 --> 00:40:33,739
hacíamos el casting a la subclase

1012
00:40:33,739 --> 00:40:34,920
y ya está

1013
00:40:34,920 --> 00:40:37,800
¿vale? es decir, yo sé

1014
00:40:37,800 --> 00:40:40,000
que C, cuando este método realmente

1015
00:40:40,000 --> 00:40:41,579
se ha invocado desde el main

1016
00:40:41,579 --> 00:40:43,039
se ha invocado

1017
00:40:43,039 --> 00:40:46,239
sé que le voy a pasar un objeto cliente

1018
00:40:46,239 --> 00:40:47,760
que perfectamente

1019
00:40:47,760 --> 00:40:49,179
cabe en esta referencia

1020
00:40:49,179 --> 00:40:52,179
entonces, me puedo permitir

1021
00:40:52,179 --> 00:40:53,840
hacerle un casting

1022
00:40:53,840 --> 00:40:55,519
a cliente y ahora

1023
00:40:55,519 --> 00:40:57,260
en el casting del compilador

1024
00:40:57,260 --> 00:40:59,519
ya si me deja coger las propiedades de cliente

1025
00:41:00,460 --> 00:41:01,320
ya si me deja

1026
00:41:01,320 --> 00:41:03,019
¿vale? que es lo que habíamos hablado

1027
00:41:03,019 --> 00:41:05,480
bueno, pues ya tengo un equals

1028
00:41:05,480 --> 00:41:07,000
que se adapta a lo que yo quiero

1029
00:41:07,000 --> 00:41:08,340
me devuelve true

1030
00:41:08,340 --> 00:41:10,579
si el objeto que llama al método

1031
00:41:10,579 --> 00:41:12,880
tiene el mismo need que el objeto parámetro

1032
00:41:12,880 --> 00:41:15,280
y false signo, ahora ya tengo el equals

1033
00:41:15,280 --> 00:41:15,639
bueno

1034
00:41:15,639 --> 00:41:19,139
con lo cual, ahora ya mi main

1035
00:41:19,139 --> 00:41:21,139
esto ya sí que va a funcionar

1036
00:41:21,139 --> 00:41:23,300
estos dos son objetos distintos

1037
00:41:23,300 --> 00:41:25,480
el nombre distinto

1038
00:41:25,480 --> 00:41:27,579
luego se registró, puso nombres distintos

1039
00:41:27,579 --> 00:41:29,519
pero son el mismo, son una

1040
00:41:29,519 --> 00:41:30,059
dúplica

1041
00:41:30,059 --> 00:41:32,760
entonces, ahora yo ya

1042
00:41:32,760 --> 00:41:33,780
lo voy a ver con esto

1043
00:41:33,780 --> 00:41:36,219
cuando yo ejecute esto

1044
00:41:36,219 --> 00:41:39,559
ahora efectivamente

1045
00:41:39,559 --> 00:41:42,039
me dice la aplicación, los objetos

1046
00:41:42,039 --> 00:41:43,579
son el mismo, son lo mismo

1047
00:41:43,579 --> 00:41:46,159
es el mismo cliente, porque c1

1048
00:41:46,159 --> 00:41:47,019
es igual a c2

1049
00:41:47,019 --> 00:41:56,820
porque para que este método sea sobrescrito

1050
00:41:56,820 --> 00:41:58,539
tiene que tener la cabecera

1051
00:41:58,539 --> 00:42:00,559
tal cual, y la cabecera

1052
00:42:00,559 --> 00:42:02,400
en object es esta

1053
00:42:02,400 --> 00:42:04,019
vale

1054
00:42:04,019 --> 00:42:07,619
claro

1055
00:42:07,619 --> 00:42:13,909
¿vale? entonces el equals

1056
00:42:13,909 --> 00:42:15,889
de hecho es un método

1057
00:42:15,889 --> 00:42:17,789
tan imprescindible

1058
00:42:17,789 --> 00:42:19,789
en general, ponerlo en nuestras clases

1059
00:42:19,789 --> 00:42:21,849
para dar ese significado

1060
00:42:21,849 --> 00:42:23,769
de cuando algo es igual, es una dúplica

1061
00:42:23,769 --> 00:42:25,690
de otra cosa, aunque sean objetos distintos

1062
00:42:25,690 --> 00:42:26,789
que

1063
00:42:26,789 --> 00:42:29,650
como el toString, el eclipse te lo genera

1064
00:42:29,650 --> 00:42:30,530
solo si te da la gana

1065
00:42:30,530 --> 00:42:33,530
por ejemplo, voy a dejar

1066
00:42:33,530 --> 00:42:35,130
este comentado que es nuestra versión

1067
00:42:35,130 --> 00:42:37,769
y digo, yo estoy ya

1068
00:42:37,769 --> 00:42:39,610
en plan piloto automático

1069
00:42:39,610 --> 00:42:41,050
y digo, a ver, cliente

1070
00:42:41,050 --> 00:42:44,070
cliente en mi diseño, mi aplicación

1071
00:42:44,070 --> 00:42:45,909
me está diciendo que clientes

1072
00:42:45,909 --> 00:42:47,789
con NIF iguales son el mismo porque es clave

1073
00:42:47,789 --> 00:42:49,889
primaria, pues como NIF es clave

1074
00:42:49,889 --> 00:42:51,789
primaria no puede haber dos clientes

1075
00:42:51,789 --> 00:42:53,829
con el mismo

1076
00:42:53,829 --> 00:42:55,769
NIF, pues me voy a hacer ya un equals

1077
00:42:55,769 --> 00:42:57,869
para que la aplicación tenga claro cuando

1078
00:42:57,869 --> 00:42:59,769
un objeto es el mismo que el otro, cuando son

1079
00:42:59,769 --> 00:43:01,309
dúplicas, aunque sean objetos distintos

1080
00:43:01,309 --> 00:43:03,550
pues o lo hago a mano como lo he hecho ahora

1081
00:43:03,550 --> 00:43:05,829
o cualquier entorno te permite generarlo

1082
00:43:05,829 --> 00:43:07,889
directamente, veis aquí botón derecho

1083
00:43:07,889 --> 00:43:10,429
te pone

1084
00:43:10,429 --> 00:43:11,329
generar hashcode

1085
00:43:11,329 --> 00:43:11,829
en equals

1086
00:43:11,829 --> 00:43:14,050
igual que hemos generado

1087
00:43:14,050 --> 00:43:14,590
automáticamente

1088
00:43:14,590 --> 00:43:15,530
los getter y setter

1089
00:43:15,530 --> 00:43:16,170
el toString

1090
00:43:16,170 --> 00:43:17,469
pues le marcamos

1091
00:43:17,469 --> 00:43:18,289
hashcode en equals

1092
00:43:18,289 --> 00:43:18,929
y te dice

1093
00:43:18,929 --> 00:43:22,130
¿cuáles son las

1094
00:43:22,130 --> 00:43:23,130
propiedades

1095
00:43:23,130 --> 00:43:24,530
que definen

1096
00:43:24,530 --> 00:43:25,269
que un objeto

1097
00:43:25,269 --> 00:43:25,909
sea igual a otro?

1098
00:43:25,949 --> 00:43:26,489
en nuestro caso

1099
00:43:26,489 --> 00:43:26,789
nif

1100
00:43:26,789 --> 00:43:27,989
pues dejamos marcada

1101
00:43:27,989 --> 00:43:28,949
nif solamente

1102
00:43:28,949 --> 00:43:30,769
podría ser

1103
00:43:30,769 --> 00:43:31,090
que yo

1104
00:43:31,090 --> 00:43:31,829
que para mí

1105
00:43:31,829 --> 00:43:32,269
dos objetos

1106
00:43:32,269 --> 00:43:32,989
son iguales

1107
00:43:32,989 --> 00:43:33,309
solo

1108
00:43:33,309 --> 00:43:34,829
si nif

1109
00:43:34,829 --> 00:43:35,550
y nombre

1110
00:43:35,550 --> 00:43:36,230
son iguales

1111
00:43:36,230 --> 00:43:36,530
los dos

1112
00:43:36,530 --> 00:43:37,130
podría ser

1113
00:43:37,130 --> 00:43:39,570
eso ya depende del análisis

1114
00:43:39,570 --> 00:43:41,110
que yo he hecho de mi aplicación, en este caso

1115
00:43:41,110 --> 00:43:43,369
solo depende del nif, marco solo

1116
00:43:43,369 --> 00:43:45,230
nif y generar

1117
00:43:45,230 --> 00:43:46,550
vale

1118
00:43:46,550 --> 00:43:51,949
y él me ha

1119
00:43:51,949 --> 00:43:54,070
generado aquí

1120
00:43:54,070 --> 00:43:55,489
este equals

1121
00:43:55,489 --> 00:43:57,849
y me gea el hashcode

1122
00:43:57,849 --> 00:43:59,550
obligatoriamente que lo podemos dejar

1123
00:43:59,550 --> 00:44:01,429
pero ahora mismo es que no lo usamos

1124
00:44:01,429 --> 00:44:03,030
entonces lo podemos dejar

1125
00:44:03,030 --> 00:44:05,889
el hashcode es un paso B

1126
00:44:05,889 --> 00:44:08,030
de igualdad cuando usas conjuntos

1127
00:44:08,030 --> 00:44:09,150
pero bueno, eso ya lo veremos

1128
00:44:09,150 --> 00:44:11,389
Si no usas conjuntos, no lo necesitas.

1129
00:44:12,710 --> 00:44:14,590
Vale, entonces nos ha generado un equals

1130
00:44:14,590 --> 00:44:17,150
un poquito más completito que el nuestro.

1131
00:44:18,949 --> 00:44:20,230
En realidad hacen lo mismo, pero bueno,

1132
00:44:20,730 --> 00:44:21,829
como te dice.

1133
00:44:22,409 --> 00:44:24,929
A ver, si la dirección de memoria del que llama

1134
00:44:24,929 --> 00:44:27,150
es igual que la dirección de memoria,

1135
00:44:27,150 --> 00:44:28,730
ahí es evidente que van a ser,

1136
00:44:28,949 --> 00:44:29,690
que tiene el mismo nid.

1137
00:44:29,869 --> 00:44:30,610
Ahí es evidente.

1138
00:44:31,469 --> 00:44:32,630
Pues entonces te devuelve true.

1139
00:44:33,269 --> 00:44:33,449
Vale.

1140
00:44:34,070 --> 00:44:35,570
¿Qué más hace este equals generado?

1141
00:44:36,250 --> 00:44:38,650
Si el objeto que le pasas como parámetro

1142
00:44:38,650 --> 00:44:41,050
es nul, es evidente

1143
00:44:41,050 --> 00:44:42,610
que es imposible que sea igual que este.

1144
00:44:43,630 --> 00:44:44,869
Con lo cual, retúrfalse.

1145
00:44:45,929 --> 00:44:46,829
Porque el que llama

1146
00:44:46,829 --> 00:44:48,090
al método no podría ser nul.

1147
00:44:48,550 --> 00:44:49,670
¿Por qué no puede ser nul?

1148
00:44:52,769 --> 00:44:54,190
Porque si...

1149
00:44:54,190 --> 00:44:56,389
Claro, si un objeto nul...

1150
00:44:56,389 --> 00:44:58,489
Tú llamas c1 punto...

1151
00:44:58,489 --> 00:45:00,489
No, es que

1152
00:45:00,489 --> 00:45:02,730
no serían iguales. Es que nunca jamás

1153
00:45:02,730 --> 00:45:04,550
llegarías ahí. Imagínate que c1 es nul.

1154
00:45:05,070 --> 00:45:05,949
Yo ahora hago esto.

1155
00:45:06,969 --> 00:45:08,190
c1 es igual a nul.

1156
00:45:08,650 --> 00:45:11,650
Y trato de ejecutar este código, que puedo ejecutarlo.

1157
00:45:14,099 --> 00:45:15,920
Me sale un null pointer exception,

1158
00:45:16,380 --> 00:45:19,099
porque yo no puedo ejecutar desde un,

1159
00:45:19,320 --> 00:45:20,840
con lo cual jamás llegaría al equals.

1160
00:45:22,119 --> 00:45:22,480
¿Vale?

1161
00:45:23,579 --> 00:45:25,880
Entonces, y ya de verdad que terminamos.

1162
00:45:28,960 --> 00:45:31,199
Ya, es que son 6 minutos cuánticos.

1163
00:45:31,699 --> 00:45:32,639
Entonces, no son lo mismo.

1164
00:45:37,230 --> 00:45:38,030
¿Dónde estamos?

1165
00:45:38,130 --> 00:45:39,849
En el equals que ha generado, que estaba dónde.

1166
00:45:40,590 --> 00:45:41,409
Ah, que no estoy ahí.

1167
00:45:41,550 --> 00:45:41,789
Aquí.

1168
00:45:41,849 --> 00:45:44,130
vale, entonces este

1169
00:45:44,130 --> 00:45:46,070
equals, si los dos

1170
00:45:46,070 --> 00:45:48,010
objetos son la misma dirección de memoria

1171
00:45:48,010 --> 00:45:50,030
es decir, uno está encima del otro, es evidente

1172
00:45:50,030 --> 00:45:52,170
que retunsa, si el segundo

1173
00:45:52,170 --> 00:45:54,110
es null, es evidente

1174
00:45:54,110 --> 00:45:56,110
que no son iguales, porque el primero no puede ser

1175
00:45:56,110 --> 00:45:57,389
null, porque no habríamos llegado ahí

1176
00:45:57,389 --> 00:46:00,150
no puede ser null, vale, ahora

1177
00:46:00,150 --> 00:46:01,530
esto lo que te dice es

1178
00:46:01,530 --> 00:46:04,090
si la clase a la que pertenece

1179
00:46:04,090 --> 00:46:06,210
el primero es diferente de la clase

1180
00:46:06,210 --> 00:46:07,550
a la que pertenece el segundo

1181
00:46:07,550 --> 00:46:09,389
es decir, yo le paso

1182
00:46:09,389 --> 00:46:12,010
un cliente y aquí le paso un pedido

1183
00:46:12,010 --> 00:46:13,610
que podría porque cabe en object

1184
00:46:13,610 --> 00:46:15,309
él ya directamente

1185
00:46:15,309 --> 00:46:17,650
te devuelve que es falso, es imposible

1186
00:46:17,650 --> 00:46:19,809
que dos objetos sean iguales y son de diferente clase

1187
00:46:19,809 --> 00:46:21,989
vale, entonces este es

1188
00:46:21,989 --> 00:46:23,969
un método que te devuelve, ya veremos

1189
00:46:23,969 --> 00:46:25,929
más adelante, la clase a la que pertenece

1190
00:46:25,929 --> 00:46:27,570
si no es la misma clase

1191
00:46:27,570 --> 00:46:29,710
directamente retú un falso

1192
00:46:29,710 --> 00:46:31,929
y ahora ya, si has pasado todo

1193
00:46:31,929 --> 00:46:33,809
el cribado, ahora ya te hace

1194
00:46:33,809 --> 00:46:35,869
el casting famoso, te hace el

1195
00:46:35,869 --> 00:46:37,849
casting y ahora ya sí te

1196
00:46:37,849 --> 00:46:39,469
devuelve, si este

1197
00:46:39,469 --> 00:46:41,730
es igual que el otro, te devuelve true

1198
00:46:41,730 --> 00:46:42,769
y si no te devuelve false

1199
00:46:42,769 --> 00:46:45,550
es decir, hace lo mismo

1200
00:46:45,550 --> 00:46:47,210
que el nuestro, pero bueno

1201
00:46:47,210 --> 00:46:49,590
te contempla más casos, te contempla si este

1202
00:46:49,590 --> 00:46:51,030
es null, que tenemos comparado

1203
00:46:51,030 --> 00:46:53,710
luego, este es

1204
00:46:53,710 --> 00:46:55,789
otro ejemplo de método sobrescrito de object

1205
00:46:55,789 --> 00:46:57,489
que normalmente

1206
00:46:57,489 --> 00:46:59,909
lo ponemos para darle un poco de significado

1207
00:46:59,909 --> 00:47:01,429
a la aplicación, para darle

1208
00:47:01,429 --> 00:47:03,210
significado de que un objeto es igual a otro

1209
00:47:03,210 --> 00:47:04,730
y la clase string

1210
00:47:04,730 --> 00:47:07,489
tiene su propio método equals que ella

1211
00:47:07,489 --> 00:47:09,530
sobrescribe, cuando usamos el

1212
00:47:09,530 --> 00:47:11,510
equals de string, no usamos el de object

1213
00:47:11,510 --> 00:47:13,730
usamos el que la propia clase

1214
00:47:13,730 --> 00:47:15,710
string ha sobrescrito, que mira

1215
00:47:15,710 --> 00:47:17,849
a ver si cada carácter es igual que el del otro

1216
00:47:17,849 --> 00:47:19,289
¿vale?

1217
00:47:20,050 --> 00:47:20,489
si

1218
00:47:20,489 --> 00:47:25,219
si mira, si entramos en la clase

1219
00:47:25,219 --> 00:47:27,280
string, que es

1220
00:47:27,280 --> 00:47:29,440
esta clase string, pues la clase string

1221
00:47:29,440 --> 00:47:31,519
tiene su propio toString sobrescrito

1222
00:47:31,519 --> 00:47:37,449
su propio toString

1223
00:47:37,449 --> 00:47:39,429
sobrescrito, que a ver si

1224
00:47:39,429 --> 00:47:41,869
lo encontramos rápido, esos son los constructores

1225
00:47:41,869 --> 00:47:51,110
bueno, aquí no hay un buscar

1226
00:47:51,110 --> 00:47:55,860
toString

1227
00:47:55,860 --> 00:47:59,150
vale, pero más

1228
00:47:59,150 --> 00:48:03,320
¿cómo avanzo aquí?

1229
00:48:03,820 --> 00:48:04,699
así aquí

1230
00:48:04,699 --> 00:48:18,429
ah, no, perdón

1231
00:48:18,429 --> 00:48:19,650
que estaba hablando del equals

1232
00:48:19,650 --> 00:48:22,030
perdón, el que quiero localizar es el equals

1233
00:48:22,030 --> 00:48:23,309
tiene su propio equals

1234
00:48:23,309 --> 00:48:26,610
su propio equals

1235
00:48:26,610 --> 00:48:33,760
¿veis? la clase string

1236
00:48:33,760 --> 00:48:35,420
que es esta clase

1237
00:48:35,420 --> 00:48:37,079
que la acabo de abrir, la clase string

1238
00:48:37,079 --> 00:48:39,579
tiene su propio

1239
00:48:39,579 --> 00:48:41,039
equals que sobrescribe

1240
00:48:41,039 --> 00:48:43,579
de la de object, porque cuando yo

1241
00:48:43,579 --> 00:48:45,519
comparo dos strings no quiero comparar con

1242
00:48:45,519 --> 00:48:47,579
su dirección de memoria, quiero

1243
00:48:47,579 --> 00:48:49,719
comparar si los char que tiene uno dentro

1244
00:48:49,719 --> 00:48:51,519
son los char que tiene otro, puesto

1245
00:48:51,519 --> 00:48:53,380
de este código que te hace

1246
00:48:53,380 --> 00:48:55,400
el equals de tu string

1247
00:48:55,400 --> 00:48:57,500
te vale para meterse en el string

1248
00:48:57,500 --> 00:48:59,460
para ver si los caracteres son iguales

1249
00:48:59,460 --> 00:49:00,980
los del que llama el método

1250
00:49:00,980 --> 00:49:03,139
que el string que tú le pases, etc

1251
00:49:03,139 --> 00:49:05,099
tiene su propio equals

1252
00:49:05,099 --> 00:49:07,239
¿vale? porque el equals

1253
00:49:07,239 --> 00:49:09,199
de object no vale para nada, vale para comparar direcciones

1254
00:49:09,199 --> 00:49:09,980
de memoria solo

1255
00:49:09,980 --> 00:49:11,780
¿vale?

1256
00:49:12,900 --> 00:49:14,320
y ahora sí que me callo