1
00:00:00,000 --> 00:00:04,400
bueno pues esto del equals

2
00:00:04,400 --> 00:00:06,700
efectivamente tiene tanta

3
00:00:06,700 --> 00:00:09,019
implicación práctica

4
00:00:09,019 --> 00:00:11,140
tiene tanta trascendencia que de nuevo

5
00:00:11,140 --> 00:00:12,820
el eclipse y

6
00:00:12,820 --> 00:00:14,380
casi cualquier otro entorno de desarrollo

7
00:00:14,380 --> 00:00:17,199
me deja generarlo de forma automática

8
00:00:17,199 --> 00:00:18,920
y me ahorro escribirlo todo

9
00:00:18,920 --> 00:00:21,240
pero cuidado porque estamos

10
00:00:21,240 --> 00:00:22,960
utilizando muchísimo

11
00:00:22,960 --> 00:00:24,420
esos recursos de vagos

12
00:00:24,420 --> 00:00:26,339
y hay que tener cuidado

13
00:00:26,339 --> 00:00:28,839
de que se usen cuando realmente se sabe

14
00:00:28,839 --> 00:00:30,420
lo que uno quiere hacer

15
00:00:30,420 --> 00:00:32,240
entonces voy a comentar mi versión

16
00:00:32,240 --> 00:00:34,980
y a ver que genera

17
00:00:34,980 --> 00:00:35,460
el eclipse

18
00:00:35,460 --> 00:00:39,219
aquí de nuevo en source

19
00:00:39,219 --> 00:00:40,939
pues uno tiene uno que pone

20
00:00:40,939 --> 00:00:43,120
generar hashcode and equals

21
00:00:43,120 --> 00:00:46,159
no deja por separado

22
00:00:46,159 --> 00:00:47,200
hashcode and equals

23
00:00:47,200 --> 00:00:48,980
entonces el te dice

24
00:00:48,980 --> 00:00:50,879
lo que te saca aquí es a ver

25
00:00:50,879 --> 00:00:54,340
cual es el campo que marca tu igualdad

26
00:00:54,340 --> 00:00:56,719
entonces tu seleccionas

27
00:00:56,719 --> 00:00:57,659
el código

28
00:00:57,660 --> 00:01:00,040
con que los códigos de dos cuidadores

29
00:01:00,040 --> 00:01:01,980
sean iguales pues eso para mi es la igualdad

30
00:01:01,980 --> 00:01:03,920
podría ser que no, podría ser no

31
00:01:03,920 --> 00:01:05,159
en mi aplicación

32
00:01:05,159 --> 00:01:08,300
dos cuidadores sean iguales

33
00:01:08,300 --> 00:01:10,439
si son iguales tanto el código como el nombre

34
00:01:10,439 --> 00:01:11,060
depende

35
00:01:11,060 --> 00:01:14,280
estas conclusiones derivarán del análisis que hayamos

36
00:01:14,280 --> 00:01:15,580
hecho y del estudio que hayamos hecho

37
00:01:15,580 --> 00:01:18,040
con el cliente de la aplicación con el que nos

38
00:01:18,040 --> 00:01:20,180
explica con habremos estudiado la situación

39
00:01:20,180 --> 00:01:22,320
al detalle todas las casuísticas que se pueden

40
00:01:22,320 --> 00:01:24,520
dar pues después de haber estudiado

41
00:01:24,520 --> 00:01:26,140
todos los requisitos

42
00:01:26,140 --> 00:01:27,240
al dedillo de nuestra aplicación

43
00:01:27,659 --> 00:01:29,979
y situación

44
00:01:29,979 --> 00:01:33,420
podemos responder a estas cosas claro

45
00:01:33,420 --> 00:01:36,840
entonces en nuestro caso a lo mejor la respuesta podría ser no no en mi caso

46
00:01:36,840 --> 00:01:39,780
el código lo identifica de forma única

47
00:01:39,780 --> 00:01:43,500
si el nombre es diferente es que se han hecho dos instancias porque uno se

48
00:01:43,500 --> 00:01:45,759
llamó luis pepito y el otro luis

49
00:01:45,759 --> 00:01:48,780
pero se refieren al mismo se refieren al mismo cuidado

50
00:01:48,780 --> 00:01:52,140
bueno pues eso repito estas preguntas se tienen que resolver después de que uno

51
00:01:52,140 --> 00:01:53,400
haya estudiado bien

52
00:01:53,400 --> 00:01:57,199
su caso concreto bueno pues si en nuestro caso hemos decidido que el

53
00:01:57,200 --> 00:02:03,579
código es lo que marca la unicidad es decir que es la clave primaria

54
00:02:03,579 --> 00:02:09,360
pues marcamos solamente código venga general y cual saber cómo lo generas y

55
00:02:09,360 --> 00:02:12,699
él me genera dos meje al jasco que ahora mismo no nos hace falta

56
00:02:12,699 --> 00:02:17,500
pero va a ser fundamental más adelante también para mí me nos hace falta fuera

57
00:02:17,500 --> 00:02:24,680
y nos genera un eequals como veis nos hace un equals un pelín más sofisticado

58
00:02:24,680 --> 00:02:26,580
un pelín más sofisticado

59
00:02:27,200 --> 00:02:29,620
¿Vale? Pero lo podemos entender perfectamente.

60
00:02:31,040 --> 00:02:34,640
Él nos dice, a ver, si las direcciones de memoria son la misma,

61
00:02:35,740 --> 00:02:36,880
ahí es que no hay más que mirar.

62
00:02:37,280 --> 00:02:39,500
Obviamente es que los códigos van a ser el mismo.

63
00:02:40,020 --> 00:02:43,200
Si las direcciones de memoria son la misma, es que están apuntando al mismo lado.

64
00:02:43,860 --> 00:02:45,920
Entonces ahí está claro, el igual tiene que devolver true.

65
00:02:46,200 --> 00:02:48,760
¿No hay otra? ¿Cómo no van a ser iguales los códigos

66
00:02:48,760 --> 00:02:51,320
si las direcciones están apuntando al mismo sitio?

67
00:02:51,800 --> 00:02:53,900
Ahí devuelve true. ¿Vale?

68
00:02:53,900 --> 00:02:59,740
Luego te dice, a ver, si el objeto que le pasas es null,

69
00:03:01,260 --> 00:03:06,159
entonces ya sé que es falso, que no puede ser igual que el otro.

70
00:03:07,800 --> 00:03:09,159
¿Por qué no puede ser igual que el otro?

71
00:03:09,259 --> 00:03:11,640
Porque me podríais decir, anda, y si el otro es null, son iguales.

72
00:03:12,259 --> 00:03:14,680
¿Por qué no puede ser igual que el otro?

73
00:03:17,400 --> 00:03:21,219
Porque es imposible que el que llama al método sea null.

74
00:03:21,219 --> 00:03:23,780
Es imposible, porque un null no puede.

75
00:03:23,780 --> 00:03:29,640
Si yo hago c1.equals y c1 es null,

76
00:03:29,819 --> 00:03:31,640
es que ni entraría jamás al método.

77
00:03:31,800 --> 00:03:34,340
No entraría, porque la máquina virtual me diría

78
00:03:34,340 --> 00:03:36,240
e null pointer exception, ni entra.

79
00:03:37,099 --> 00:03:40,699
Con lo cual, si he llegado a este punto, es porque he entrado en el método

80
00:03:40,699 --> 00:03:43,780
o lo que es lo mismo, porque el objeto que lo llamo no es null.

81
00:03:44,400 --> 00:03:47,379
Porque es que si no, no habría entrado, me habría salido un null pointer exception.

82
00:03:48,039 --> 00:03:51,360
Entonces, si he llegado aquí, es porque el que le llamo no era null.

83
00:03:51,740 --> 00:03:53,560
Con lo cual, si este sí lo es,

84
00:03:53,780 --> 00:03:56,620
pues es que son distintos, obviamente, pues falsos.

85
00:03:57,180 --> 00:04:01,340
Vale, ya tenemos dos casos que entendemos.

86
00:04:01,939 --> 00:04:06,439
Ahora, este es un método, también de object,

87
00:04:06,920 --> 00:04:12,420
que te devuelve la clase, o sea, un identificador, una cosa interna,

88
00:04:13,219 --> 00:04:15,340
de la clase del objeto.

89
00:04:16,720 --> 00:04:19,500
Ahora mismo, no hace falta que nos metamos en complicaciones en él,

90
00:04:19,500 --> 00:04:23,540
simplemente, como está en object, lo puede llamar cualquier objeto.

91
00:04:23,780 --> 00:04:28,820
Y te devuelve, empaquetado de una manera extraña,

92
00:04:28,900 --> 00:04:30,000
codificado de una manera extraña,

93
00:04:30,760 --> 00:04:34,740
cuál es el nombre de la clase a la que pertenece ese objeto,

94
00:04:34,800 --> 00:04:35,640
el nombre de la clase.

95
00:04:36,480 --> 00:04:38,220
Vale, pero no te lo devuelve en string, en string no.

96
00:04:38,680 --> 00:04:40,240
Lo devuelve en otro formato.

97
00:04:40,860 --> 00:04:42,480
Vale, pues entonces, este te dice, a ver,

98
00:04:43,060 --> 00:04:45,100
si la clase a la que pertenece dis,

99
00:04:45,620 --> 00:04:47,440
porque esto es como si hubiera aquí un dis, ¿verdad?

100
00:04:49,160 --> 00:04:51,920
Porque cuando tenemos una llamada a un método al que nadie lo llama,

101
00:04:51,920 --> 00:04:53,760
es como si fuera esto.

102
00:04:53,780 --> 00:04:55,280
A lo mejor así lo veis más claro.

103
00:04:56,020 --> 00:05:00,780
Pues si la clase del objeto que llama al equals es diferente de esta clase,

104
00:05:01,620 --> 00:05:03,280
de nuevo, puedo devolver false,

105
00:05:03,660 --> 00:05:06,620
porque es que no tiene sentido decir que los cuidadores son iguales,

106
00:05:07,360 --> 00:05:10,180
si este objeto no es cuidador, o este no lo es,

107
00:05:10,180 --> 00:05:11,720
o sea, que no pertenece a la misma clase.

108
00:05:12,640 --> 00:05:14,460
Entonces, si no pertenece a la misma clase,

109
00:05:15,040 --> 00:05:17,640
también puedo concluir que imposible que sean iguales.

110
00:05:17,640 --> 00:05:21,220
Es que ni pertenecen a la misma clase, luego imposible que sean iguales, false.

111
00:05:22,160 --> 00:05:22,660
Vale.

112
00:05:22,660 --> 00:05:23,600
Entonces, si hemos llegado a este punto,

113
00:05:23,600 --> 00:05:29,040
es porque ni ha salido por aquí, ni ha salido por aquí, ni ha salido por aquí.

114
00:05:29,740 --> 00:05:31,740
Con lo cual, si hemos llegado a este punto es

115
00:05:32,540 --> 00:05:35,580
porque este objeto obj no solo no es null,

116
00:05:36,160 --> 00:05:39,760
sino que su clase es la misma que la que el que llama al método,

117
00:05:40,439 --> 00:05:40,939
que es la misma.

118
00:05:41,939 --> 00:05:43,240
Porque si no, habría salido por aquí.

119
00:05:43,980 --> 00:05:45,780
Pues como ya sabemos que es la misma,

120
00:05:46,720 --> 00:05:49,939
pues hace el casting sin ningún problema,

121
00:05:50,340 --> 00:05:52,240
lo hace sin problema porque sabe

122
00:05:52,620 --> 00:05:53,439
que la clase

123
00:05:53,439 --> 00:05:56,939
de obj es la misma que la clase del objeto disk, que es cuidador.

124
00:05:57,939 --> 00:06:00,519
Lo sabe, entonces hace el casting sin ningún problema,

125
00:06:01,040 --> 00:06:04,259
lo convierte en este y ahora ya te devuelve

126
00:06:06,819 --> 00:06:09,000
true si los códigos son iguales.

127
00:06:09,659 --> 00:06:12,720
Vale, y es como si hubiera un disk, es lo mismo.

128
00:06:16,300 --> 00:06:19,980
Te devuelve true si los códigos son iguales y falsos y son diferentes.

129
00:06:20,560 --> 00:06:22,199
Entonces, es una versión un poquito más completa,

130
00:06:22,199 --> 00:06:22,800
es una versión más completa.

131
00:06:22,800 --> 00:06:23,399
Es una versión más completa.

132
00:06:23,400 --> 00:06:30,360
Nosotros en el nuestro de arriba no habíamos distinguido si éste era null,

133
00:06:30,360 --> 00:06:32,020
si la clase era distinta.

134
00:06:32,380 --> 00:06:36,220
Nos habíamos lanzado a hacer el casting directamente confiando en que el que llamara

135
00:06:36,220 --> 00:06:40,900
equal siempre lo iba a llamar pasándole un objeto cuidador distinto de null.

136
00:06:41,400 --> 00:06:43,900
Entonces, si le pasa siempre un objeto cuidador distinto de null,

137
00:06:44,200 --> 00:06:45,720
este equal funciona perfectamente.

138
00:06:46,620 --> 00:06:51,980
El equals que teje en el eclipse es un poquito más completo porque considera todos los casos.

139
00:06:51,980 --> 00:06:53,020
Que tú le pases un objeto cuidador distinto de null,

140
00:06:53,019 --> 00:06:53,719
que tú le pases un null,

141
00:06:54,339 --> 00:06:56,560
que le pases un objeto de otra clase distinta,

142
00:06:56,699 --> 00:06:57,419
que no es cuidador,

143
00:06:57,519 --> 00:07:00,680
te considera todos los casos.

144
00:07:01,519 --> 00:07:02,519
Pero en última instancia,

145
00:07:02,719 --> 00:07:04,240
si tú le pasas un objeto cuidador,

146
00:07:04,319 --> 00:07:06,519
te devuelve true si los códigos son iguales

147
00:07:06,519 --> 00:07:07,839
y falses y no,

148
00:07:07,899 --> 00:07:08,620
que es de lo que se trata.

149
00:07:09,180 --> 00:07:10,740
Que el equal se devuelva true o falsa.

150
00:07:12,120 --> 00:07:12,319
¿Vale?

151
00:07:13,899 --> 00:07:15,500
Bueno, pues entonces, de nuevo,

152
00:07:16,519 --> 00:07:17,180
en general,

153
00:07:17,560 --> 00:07:20,680
cuando uno tiene sus entidades ya definidas en una aplicación,

154
00:07:20,979 --> 00:07:22,899
client de factura, no sé qué, no sé cuántos,

155
00:07:23,019 --> 00:07:25,439
pues lo habitual es que en ellas se incluyan

156
00:07:25,439 --> 00:07:27,339
los constructores, por supuesto,

157
00:07:27,680 --> 00:07:29,659
los get y los set para acceder a las propiedades,

158
00:07:30,579 --> 00:07:33,759
el toString por si alguien lo usa alguna vez

159
00:07:33,759 --> 00:07:36,039
para mostrar una descripción,

160
00:07:36,240 --> 00:07:37,979
como el system.out.println, por ejemplo,

161
00:07:38,180 --> 00:07:39,419
que ya hemos visto que lo usa,

162
00:07:40,879 --> 00:07:46,319
y el equals para recoger la condición de igualdad entre objetos,

163
00:07:46,680 --> 00:07:47,639
para recogerla.

164
00:07:49,039 --> 00:07:50,839
Habrá aplicaciones en las cuales

165
00:07:50,839 --> 00:07:52,839
que la igualdad entre objetos no está recogida,

166
00:07:53,019 --> 00:07:53,899
no importa,

167
00:07:54,599 --> 00:07:56,019
porque no hay ninguna funcionalidad

168
00:07:56,019 --> 00:07:57,319
que tenga en ningún momento

169
00:07:57,319 --> 00:07:59,379
que distinguir si los objetos son iguales o no.

170
00:08:00,000 --> 00:08:00,680
Pero es muy raro.

171
00:08:01,060 --> 00:08:02,819
Es muy raro que una aplicación,

172
00:08:03,000 --> 00:08:04,599
según se va ampliando en funcionalidad,

173
00:08:04,699 --> 00:08:05,939
no necesite alguna vez

174
00:08:05,939 --> 00:08:07,799
ver si los objetos son iguales.

175
00:08:07,819 --> 00:08:09,240
Es muy raro que no lo necesite.

176
00:08:09,859 --> 00:08:11,560
Entonces, por defecto,

177
00:08:12,079 --> 00:08:14,259
lo natural es que se incluya en las clases de entidades

178
00:08:14,259 --> 00:08:16,639
también una sobrescritura del equals.

179
00:08:17,459 --> 00:08:18,819
Una sobrescritura del equals.

180
00:08:19,240 --> 00:08:20,719
¿Y para qué esta sobrescritura?

181
00:08:20,719 --> 00:08:22,439
Para que la sobrescritura sea correcta,

182
00:08:22,439 --> 00:08:24,939
pues tengo yo que entender bien mi aplicación

183
00:08:24,939 --> 00:08:27,639
y entender qué hace que dos objetos sean iguales.

184
00:08:27,639 --> 00:08:28,939
Qué es lo que hace.

185
00:08:28,939 --> 00:08:30,939
Si es el código, si es el código y el nombre,

186
00:08:30,939 --> 00:08:31,939
si es no sé qué.

187
00:08:31,939 --> 00:08:32,940
Y todo eso, de nuevo,

188
00:08:32,940 --> 00:08:35,440
pues deriva de que yo entienda bien mi aplicación,

189
00:08:35,440 --> 00:08:36,440
lo que tengo que hacer,

190
00:08:36,440 --> 00:08:38,440
cómo tiene que funcionar, etcétera, etcétera.

191
00:08:42,440 --> 00:08:45,440
Vale, luego es importante que entendáis bien todo esto,

192
00:08:45,440 --> 00:08:46,940
porque ahora ya no se trata de

193
00:08:46,940 --> 00:08:49,940
hago un programa, me funciona o no me funciona.

194
00:08:49,940 --> 00:08:51,940
Programar no va de eso.

195
00:08:52,440 --> 00:08:54,440
A ver, va, pues bueno, programas pequeñitos

196
00:08:54,440 --> 00:08:55,940
que uno hace en plan divertimento.

197
00:08:56,440 --> 00:08:57,940
Pues hacer factoriales, hacer no sé qué.

198
00:08:57,940 --> 00:08:59,940
Vale, ahí sí va, me funciona o no me funciona.

199
00:09:00,940 --> 00:09:02,940
Pero en general va de desarrollar aplicaciones

200
00:09:02,940 --> 00:09:04,940
que funcionar, pues te van a funcionar.

201
00:09:04,940 --> 00:09:06,940
Tú haces un código, lo despliegas en un servidor

202
00:09:06,940 --> 00:09:07,940
y te hace cosas.

203
00:09:08,940 --> 00:09:11,440
Pero esa aplicación puede ser una caca o no.

204
00:09:12,440 --> 00:09:13,940
Funcionando igualmente.

205
00:09:13,940 --> 00:09:15,440
Y que sea una caca o no.

206
00:09:15,940 --> 00:09:19,940
Es decir, que lo que me saque,

207
00:09:19,940 --> 00:09:22,440
pues sea realmente utilizable, tenga sentido.

208
00:09:22,440 --> 00:09:24,440
Yo lo pueda luego ampliar.

209
00:09:24,440 --> 00:09:26,440
Pues va a depender de tener mucho control

210
00:09:26,440 --> 00:09:27,440
de todas estas cosas.

211
00:09:27,440 --> 00:09:29,440
Esto ya no es me está funcionando o no me está funcionando.

212
00:09:29,440 --> 00:09:31,440
Esto es, esto está bien hecho,

213
00:09:31,440 --> 00:09:33,440
según los criterios de desarrollo.

214
00:09:33,440 --> 00:09:36,440
Esto es usable, esto es reutilizable.

215
00:09:36,440 --> 00:09:39,440
Esto es ampliable, que lo que se suele llamar es escalable.

216
00:09:39,440 --> 00:09:42,440
O sea, yo puedo escalar y añadir otra funcionalidad fácilmente.

217
00:09:42,440 --> 00:09:48,440
Esto le meta todos los casos de prueba que le meto.

218
00:09:48,440 --> 00:09:50,440
Lo que me saca tiene sentido.

219
00:09:50,440 --> 00:09:52,440
O a veces me saca cosas que, uh, qué raro.

220
00:09:52,440 --> 00:09:53,440
¿Y cómo me saca esto?

221
00:09:53,440 --> 00:09:54,440
Pues te saca esto,

222
00:09:54,440 --> 00:09:56,440
pero no te das cuenta de que aquí no es sobre escrito este método.

223
00:09:56,440 --> 00:09:59,440
Entonces te está tirando de otra cosa y tú no lo sabes.

224
00:09:59,440 --> 00:10:03,440
Pero es importante que todo esto lo tengáis controlado.

225
00:10:03,440 --> 00:10:06,440
Porque no es algo que se vea en, uy, me funciona o no me funciona.

226
00:10:06,440 --> 00:10:07,440
No se ve así.

227
00:10:08,440 --> 00:10:12,440
Entonces es difícil detectar por qué algo no funciona

228
00:10:12,440 --> 00:10:14,440
si esto no está controlado.

229
00:10:14,440 --> 00:10:15,440
¿Vale?

230
00:10:19,440 --> 00:10:20,440
¿Eh?

231
00:10:21,440 --> 00:10:22,440
¿Qué has dicho?

232
00:10:22,440 --> 00:10:24,440
¿Qué es prueba de examen?

233
00:10:24,440 --> 00:10:26,440
¿Qué es prueba de examen dices?

234
00:10:26,440 --> 00:10:28,440
A ver, es muy difícil, es muy complicado.

235
00:10:28,440 --> 00:10:31,440
En un examen de dos, tres horas, obviamente,

236
00:10:31,440 --> 00:10:39,440
pues va a hacer algo que ponga en, que meta en cuestión de todas estas cosas.

237
00:10:39,440 --> 00:10:46,440
Pero, pero aquí se trata de aprobar por un lado y luego de vuestro futuro.

238
00:10:46,440 --> 00:10:49,440
O sea, aprobar solamente no vale.

239
00:10:49,440 --> 00:10:51,440
Aprobar solo no vale.

240
00:10:52,440 --> 00:10:56,440
Es aprobar y además haber sacado todo el aprobé.

241
00:10:56,440 --> 00:10:57,440
Porque es que es imposible.

242
00:10:57,440 --> 00:11:00,440
No podemos examinar de todo lo que van a esperar de vos,

243
00:11:00,440 --> 00:11:02,440
de todas las destrezas que van a esperar de vosotros.

244
00:11:02,440 --> 00:11:04,440
Es que no se puede, no se puede examinar.

245
00:11:04,440 --> 00:11:06,440
No podemos poner una aplicación en la que estéis dos semanas

246
00:11:06,440 --> 00:11:09,440
y la traigáis por razones obvias, pero la podéis copiar.

247
00:11:09,440 --> 00:11:10,440
¿Vale?

248
00:11:10,440 --> 00:11:13,440
Entonces, aprobar, hombre, es condición necesaria.

249
00:11:14,440 --> 00:11:18,440
Pero para que a uno le vaya bien y no acabe en la calle rápidamente,

250
00:11:18,440 --> 00:11:20,440
pues además tiene que aprovechar

251
00:11:20,440 --> 00:11:23,440
todo lo que pueda estos dos años,

252
00:11:23,440 --> 00:11:25,440
pues para coger, empaparse de todo lo que vea

253
00:11:25,440 --> 00:11:27,440
y de todas las solturas que,

254
00:11:27,440 --> 00:11:29,440
y de todo lo que de alguna manera os decimos

255
00:11:29,440 --> 00:11:31,440
y vosotros mismos vais indagando por ahí.

256
00:11:32,440 --> 00:11:34,440
Bueno, pues entonces.

257
00:11:35,440 --> 00:11:36,440
¿Del equals?

258
00:11:37,440 --> 00:11:38,440
¿Alguna duda?

259
00:11:40,440 --> 00:11:43,440
El equals en realidad ya lo hemos venido usando.

260
00:11:43,440 --> 00:11:45,440
Lo hemos venido usando con el famoso stream.

261
00:11:45,440 --> 00:11:47,440
Con el famoso stream.

262
00:11:48,440 --> 00:11:49,440
¿Verdad?

263
00:11:50,440 --> 00:11:51,440
¿Qué ocurría?

264
00:11:52,440 --> 00:11:56,440
Y ya con esto de verdad que me callo por ahora.

265
00:11:59,440 --> 00:12:01,440
¿Qué ocurría con el stream?

266
00:12:01,440 --> 00:12:02,440
Vamos a ver.

267
00:12:02,440 --> 00:12:03,440
Vamos a poner aquí.

268
00:12:05,440 --> 00:12:06,440
Sí.

269
00:12:09,440 --> 00:12:10,440
Voy a ponerlo aquí.

270
00:12:16,440 --> 00:12:18,440
Ejemplos de equals.

271
00:12:19,440 --> 00:12:23,440
Con stream.

272
00:12:25,440 --> 00:12:26,440
En mi main.

273
00:12:26,440 --> 00:12:27,440
¿Vale?

274
00:12:27,440 --> 00:12:28,440
Porque luego este proyecto

275
00:12:28,440 --> 00:12:30,440
lo subo entero pisando el que había.

276
00:12:30,440 --> 00:12:32,440
Bueno, para que tengáis ahí.

277
00:12:39,440 --> 00:12:40,440
Vale.

278
00:12:40,440 --> 00:12:41,440
¿Qué hemos hecho nosotros?

279
00:12:41,440 --> 00:12:44,440
¿El equals hasta ahora nosotros para qué lo habíamos usado?

280
00:12:44,440 --> 00:12:46,440
Exclusivamente para esto.

281
00:12:46,440 --> 00:12:48,440
Nosotros a lo mejor hacíamos un objeto stream S1.

282
00:12:48,440 --> 00:12:50,440
Imaginaos que le damos un valor.

283
00:12:50,440 --> 00:12:51,440
Pues ya está.

284
00:12:51,440 --> 00:12:52,440
Hola.

285
00:12:52,440 --> 00:12:53,440
Hala.

286
00:12:53,440 --> 00:12:54,440
Tengo yo aquí mi stream S1.

287
00:12:54,440 --> 00:12:55,440
Y ahora pues tenemos otro stream por ahí.

288
00:12:55,440 --> 00:12:56,440
Stream S2.

289
00:12:56,440 --> 00:12:57,440
Hala.

290
00:12:57,440 --> 00:12:58,440
Hala.

291
00:12:58,440 --> 00:12:59,440
Hala.

292
00:12:59,440 --> 00:13:00,440
Hala.

293
00:13:00,440 --> 00:13:01,440
Hala.

294
00:13:01,440 --> 00:13:02,440
Hala.

295
00:13:02,440 --> 00:13:03,440
Hala.

296
00:13:03,440 --> 00:13:04,440
Hala.

297
00:13:04,440 --> 00:13:05,440
Hala.

298
00:13:05,440 --> 00:13:06,440
Hala.

299
00:13:06,440 --> 00:13:07,440
Hala.

300
00:13:07,440 --> 00:13:08,440
Hala.

301
00:13:08,440 --> 00:13:09,440
Hala.

302
00:13:09,440 --> 00:13:10,440
Hala.

303
00:13:10,440 --> 00:13:11,440
Hala.

304
00:13:11,440 --> 00:13:12,440
Hala.

305
00:13:12,440 --> 00:13:13,440
Hala.

306
00:13:13,440 --> 00:13:14,440
Hala.

307
00:13:14,440 --> 00:13:15,440
Hala.

308
00:13:15,440 --> 00:13:16,440
Hala.

309
00:13:16,440 --> 00:13:17,440
Hala.

310
00:13:17,440 --> 00:13:18,440
Hala.

311
00:13:18,440 --> 00:13:19,440
Hala.

312
00:13:19,440 --> 00:13:20,440
Entonces esta es la clase de stream.

313
00:13:20,440 --> 00:13:22,440
Es una clase que ya está hecha en la máquina virtual.

314
00:13:22,440 --> 00:13:23,440
No la hemos hecho nosotros.

315
00:13:23,440 --> 00:13:30,440
Y ahora que ya entendemos los objetos ya en detalle, podemos ver algunas cosas que hemos

316
00:13:30,440 --> 00:13:34,440
estado usando de ella un poco así, con las buenas, que no salen muy bien.

317
00:13:34,440 --> 00:13:36,440
Por ejemplo, esto es muy raro.

318
00:13:36,440 --> 00:13:41,440
Si S1 es un objeto, desde cuando un objeto se puede instanciar sin un new.

319
00:13:41,440 --> 00:13:42,440
Desde nunca.

320
00:13:42,440 --> 00:13:43,440
¿No?

321
00:13:43,440 --> 00:13:46,440
Siempre hemos dicho que S1 tiene una variable objeto.

322
00:13:46,440 --> 00:13:48,760
declarada como objeto

323
00:13:48,760 --> 00:13:49,700
y ese 1 lo es

324
00:13:49,700 --> 00:13:51,600
para habilitar el espacio

325
00:13:51,600 --> 00:13:52,480
hay que hacerlo con new

326
00:13:52,480 --> 00:13:53,360
no hay otra

327
00:13:53,360 --> 00:13:55,220
y eso es verdad

328
00:13:55,220 --> 00:13:57,580
lo que pasa es que la clase string está hecha

329
00:13:57,580 --> 00:13:59,280
de tal manera que la programó

330
00:13:59,280 --> 00:14:01,080
la programó para permitir este truco

331
00:14:01,080 --> 00:14:03,000
y ese es un truco

332
00:14:03,000 --> 00:14:06,620
que nos evita tener que hacer esto

333
00:14:06,620 --> 00:14:09,040
que es llamar específicamente

334
00:14:09,040 --> 00:14:10,180
al constructor de string

335
00:14:10,180 --> 00:14:12,520
pasándole el parámetro

336
00:14:12,520 --> 00:14:13,600
para iniciar la propiedad

337
00:14:13,600 --> 00:14:16,639
o sea, uno podría instanciar

338
00:14:16,639 --> 00:14:19,259
un objeto string con la forma ortodoxa

339
00:14:19,259 --> 00:14:20,080
new string

340
00:14:20,080 --> 00:14:22,180
el constructor de la clase string

341
00:14:22,180 --> 00:14:23,200
al que podríamos entrar

342
00:14:23,200 --> 00:14:24,180
porque está en la máquina virtual

343
00:14:24,180 --> 00:14:26,659
vemos que recibe una cadena

344
00:14:26,659 --> 00:14:28,580
y la usa para inicializar

345
00:14:28,580 --> 00:14:30,120
la propiedad interna del string

346
00:14:30,120 --> 00:14:31,379
que se sea raíz de chat

347
00:14:31,379 --> 00:14:35,060
podría usar el método ortodoxo

348
00:14:35,060 --> 00:14:37,320
para instanciar un objeto string

349
00:14:37,320 --> 00:14:39,320
pero claro, como los objetos string

350
00:14:39,320 --> 00:14:40,460
se usan continuamente

351
00:14:40,460 --> 00:14:42,980
pues la clase string está hecha

352
00:14:42,980 --> 00:14:43,580
para que nos permita

353
00:14:43,600 --> 00:14:44,420
este atajo

354
00:14:44,420 --> 00:14:46,019
nos permite este atajo

355
00:14:46,019 --> 00:14:47,540
que nada, yo pongo directamente la cadena

356
00:14:47,540 --> 00:14:49,920
y la máquina virtual

357
00:14:49,920 --> 00:14:51,639
pues cuando llame a la clase string

358
00:14:51,639 --> 00:14:53,519
ya ve, entra en el atajo y ya está

359
00:14:53,519 --> 00:14:55,920
entonces, primera cosa

360
00:14:55,920 --> 00:14:58,259
que ya era rara

361
00:14:58,259 --> 00:14:59,899
pero ya hemos aclarado

362
00:14:59,899 --> 00:15:01,540
string es un objeto, hay que instanciarlo

363
00:15:01,540 --> 00:15:02,800
es que no hay otra, hay que instanciarlo

364
00:15:02,800 --> 00:15:06,080
pero la clase nos permite este atajo

365
00:15:06,080 --> 00:15:08,240
que es, le digo directamente esto

366
00:15:08,240 --> 00:15:09,600
y esto es como hacer new string

367
00:15:09,600 --> 00:15:11,060
¿vale? eso por un lado

368
00:15:13,600 --> 00:15:18,139
vale, siguiente cosa

369
00:15:18,139 --> 00:15:19,779
cuando comparábamos dos string

370
00:15:19,779 --> 00:15:21,600
yo os decía

371
00:15:21,600 --> 00:15:24,620
no comparéis nunca el string

372
00:15:24,620 --> 00:15:25,560
con doble o igual

373
00:15:25,560 --> 00:15:26,920
¿verdad?

374
00:15:28,920 --> 00:15:30,060
compararlo con equal

375
00:15:30,060 --> 00:15:31,860
precisamente por eso, porque esto

376
00:15:31,860 --> 00:15:33,480
con lo que yo he dicho

377
00:15:33,480 --> 00:15:36,240
S1 y S2

378
00:15:36,240 --> 00:15:37,779
¿vale?

379
00:15:37,899 --> 00:15:39,620
son dos objetos distintos

380
00:15:39,620 --> 00:15:41,220
son dos objetos distintos

381
00:15:41,220 --> 00:15:42,920
son dos direcciones de memoria distintas

382
00:15:43,600 --> 00:15:45,639
entonces, según esto, no lo probéis

383
00:15:45,639 --> 00:15:46,500
no lo hagáis

384
00:15:46,500 --> 00:15:49,159
porque ahora os explico luego lo que pasa

385
00:15:49,159 --> 00:15:50,639
¿vale? no lo hagáis

386
00:15:50,639 --> 00:15:52,580
entonces

387
00:15:52,580 --> 00:15:55,340
cuando yo tengo un string S1

388
00:15:55,340 --> 00:15:56,620
que tiene hola

389
00:15:56,620 --> 00:15:58,740
un string S2 que tiene hola

390
00:15:58,740 --> 00:16:02,019
el sentido real de mi aplicación

391
00:16:02,019 --> 00:16:03,399
es que si yo quiero ver

392
00:16:03,399 --> 00:16:05,540
si S1 y S2 son iguales es que me diga true

393
00:16:05,540 --> 00:16:07,300
es el sentido real

394
00:16:07,300 --> 00:16:09,519
como cuando quiero ver dos cuidadores

395
00:16:09,519 --> 00:16:11,779
son iguales, el sentido real es que si los códigos

396
00:16:11,779 --> 00:16:13,100
sean iguales me diga true

397
00:16:13,600 --> 00:16:15,580
pues aquí a mí me da igual que S1

398
00:16:15,580 --> 00:16:17,500
sea una dirección de memoria que apunte a hola

399
00:16:17,500 --> 00:16:20,480
y que S2 sea otra que apunte a otro hola distinto

400
00:16:20,480 --> 00:16:23,139
son dos objetos distintos

401
00:16:23,139 --> 00:16:24,759
está claro, apuntados por dos direcciones

402
00:16:24,759 --> 00:16:25,700
la S1 y la S2

403
00:16:25,700 --> 00:16:27,800
pero lo que tiene sentido

404
00:16:27,800 --> 00:16:29,159
es

405
00:16:29,159 --> 00:16:31,940
que me dijeran que son iguales

406
00:16:31,940 --> 00:16:33,820
la condición de igualdad

407
00:16:33,820 --> 00:16:36,159
tiene que ser por el contenido

408
00:16:36,159 --> 00:16:38,100
de la cadena, no por las direcciones de memoria

409
00:16:38,100 --> 00:16:39,000
¿vale?

410
00:16:39,420 --> 00:16:41,540
por eso es por lo que os insistíamos

411
00:16:41,540 --> 00:16:43,560
cuidado, si quieres ver si dos cadenas son iguales

412
00:16:43,600 --> 00:16:46,740
no las compares así

413
00:16:46,740 --> 00:16:48,420
así no

414
00:16:48,420 --> 00:16:50,320
porque si las comparas así

415
00:16:50,320 --> 00:16:51,840
lo que te compara es

416
00:16:51,840 --> 00:16:53,860
la dirección de memoria S1

417
00:16:53,860 --> 00:16:54,960
con la dirección de memoria S2

418
00:16:54,960 --> 00:16:57,080
y ese no es el sentido real de las cosas

419
00:16:57,080 --> 00:16:59,080
el sentido real de las cosas es

420
00:16:59,080 --> 00:17:01,620
yo quiero ver si esta cadena y esta cadena

421
00:17:01,620 --> 00:17:02,820
tienen el mismo texto

422
00:17:02,820 --> 00:17:05,240
entonces decíamos

423
00:17:05,240 --> 00:17:06,360
no la comparéis así

424
00:17:06,360 --> 00:17:08,460
comparadla

425
00:17:08,460 --> 00:17:10,960
así

426
00:17:13,599 --> 00:17:15,039
y esto ya es otra cosa

427
00:17:15,039 --> 00:17:18,039
¿vale?

428
00:17:19,099 --> 00:17:20,819
porque esto ahora como ya sabemos

429
00:17:20,819 --> 00:17:23,319
equals está sobrescrito

430
00:17:23,319 --> 00:17:24,299
en la clase string

431
00:17:24,299 --> 00:17:25,619
no usa el equals de object

432
00:17:25,619 --> 00:17:29,019
usa el equals que está sobrescrito en la clase string

433
00:17:29,019 --> 00:17:30,759
que ahora ya se mete en las cadenas

434
00:17:30,759 --> 00:17:32,039
a ver si son iguales

435
00:17:32,039 --> 00:17:33,000
¿vale?

436
00:17:33,939 --> 00:17:34,419
entonces

437
00:17:43,599 --> 00:17:50,859
, nosotros si ejecutamos esto

438
00:17:50,859 --> 00:17:51,919
pues nos saldrá

439
00:17:51,919 --> 00:17:53,240
iguales

440
00:17:53,240 --> 00:17:53,539
¿verdad?

441
00:18:00,539 --> 00:18:01,539
ay, perdón

442
00:18:01,539 --> 00:18:02,839
es que no lo he puesto en el else

443
00:18:02,839 --> 00:18:04,319
ahí

444
00:18:04,319 --> 00:18:06,519
ahí, vale

445
00:18:06,519 --> 00:18:08,319
¿vale?

446
00:18:08,399 --> 00:18:09,539
si ejecutamos esto

447
00:18:09,539 --> 00:18:10,219
nos sale

448
00:18:13,600 --> 00:18:15,560
obviamente que son iguales

449
00:18:15,560 --> 00:18:17,700
son dos objetos distintos

450
00:18:17,700 --> 00:18:19,460
pero son iguales

451
00:18:19,460 --> 00:18:20,760
y sin embargo

452
00:18:20,760 --> 00:18:22,520
si hago esto

453
00:18:22,520 --> 00:18:23,500
pues me saldrá

454
00:18:23,500 --> 00:18:25,040
obviamente que son distintas

455
00:18:25,040 --> 00:18:25,600
las cadenas

456
00:18:25,600 --> 00:18:26,500
¿está claro, no?

457
00:18:26,900 --> 00:18:28,360
porque el equals que está usando

458
00:18:28,360 --> 00:18:30,220
es el sobrescrito de la clase string

459
00:18:30,220 --> 00:18:32,380
si entramos en

460
00:18:32,380 --> 00:18:35,600
aquí

461
00:18:35,600 --> 00:18:37,420
este es

462
00:18:37,420 --> 00:18:38,460
el método

463
00:18:38,460 --> 00:18:41,040
equals que está en la clase string

464
00:18:41,040 --> 00:18:43,580
en esta clase

465
00:18:43,600 --> 00:18:48,720
la clase string

466
00:18:48,720 --> 00:18:51,180
y la clase string tiene

467
00:18:51,180 --> 00:18:52,380
su método

468
00:18:52,380 --> 00:18:53,400
equals

469
00:18:53,400 --> 00:18:56,580
este

470
00:18:56,580 --> 00:18:59,580
que sobrescribe

471
00:18:59,580 --> 00:19:00,260
¿vale?

472
00:19:00,340 --> 00:19:02,220
que sobrescribe el método equals de object

473
00:19:02,220 --> 00:19:04,240
y mirad que lo sobrescribe

474
00:19:04,240 --> 00:19:05,660
haciendo aquí

475
00:19:05,660 --> 00:19:07,440
un montón de basurilla

476
00:19:07,440 --> 00:19:08,540
¿vale?

477
00:19:08,620 --> 00:19:09,960
hace aquí un montón de cosas raras

478
00:19:09,960 --> 00:19:11,620
y lo que hace es meterse

479
00:19:11,620 --> 00:19:13,260
en la propiedad que tiene el onSharp

480
00:19:13,260 --> 00:19:13,580
a eso ni me interesa

481
00:19:13,600 --> 00:19:14,360
que sea igual, etcétera

482
00:19:14,360 --> 00:19:15,060
lo sobrescribe

483
00:19:15,060 --> 00:19:16,880
porque si no lo sobrescribiera

484
00:19:16,880 --> 00:19:18,780
estaría comprando las direcciones de memoria

485
00:19:18,780 --> 00:19:19,740
¿vale?

486
00:19:21,960 --> 00:19:23,860
bueno, pues aquí hemos estado usando

487
00:19:23,860 --> 00:19:25,100
el equals

488
00:19:25,100 --> 00:19:27,120
todo el rato

489
00:19:27,120 --> 00:19:28,520
¿vale?

490
00:19:29,300 --> 00:19:30,420
ahora ya entendemos

491
00:19:30,420 --> 00:19:31,540
que el equals es un método

492
00:19:31,540 --> 00:19:32,920
que puede usar cualquier objeto

493
00:19:32,920 --> 00:19:33,940
porque lo hereda de object

494
00:19:33,940 --> 00:19:36,660
pero si usamos la versión heredada

495
00:19:36,660 --> 00:19:38,760
dos objetos son iguales

496
00:19:38,760 --> 00:19:39,240
solos

497
00:19:39,240 --> 00:19:40,720
y las direcciones de memoria son iguales

498
00:19:40,720 --> 00:19:43,260
y si queremos añadir otro criterio de igualdad

499
00:19:43,259 --> 00:19:45,240
lo tendremos que sobrescribir en la clase

500
00:19:45,240 --> 00:19:50,440
¿vale?

501
00:19:52,660 --> 00:19:54,700
bueno, entendido, entendido

502
00:19:54,700 --> 00:19:56,379
todo lo de equals

503
00:19:56,379 --> 00:19:58,299
vale, pues no se puede olvidar

504
00:19:58,299 --> 00:20:00,460
porque afecta de forma directa

505
00:20:00,460 --> 00:20:01,519
a cualquier aplicación

506
00:20:01,519 --> 00:20:03,039
sobre todo si se manejan colecciones

507
00:20:03,039 --> 00:20:05,200
se manejan una serie de historias

508
00:20:05,200 --> 00:20:06,440
que vamos a tener que manejar

509
00:20:06,440 --> 00:20:07,059
claro

510
00:20:07,059 --> 00:20:12,480
¿vale?

511
00:20:13,259 --> 00:20:14,539
entonces, según eso

512
00:20:14,539 --> 00:20:17,480
con lo que yo he dicho

513
00:20:17,480 --> 00:20:20,220
ahora ya con todo eso entendido

514
00:20:20,220 --> 00:20:21,299
si yo ejecuto esto

515
00:20:21,299 --> 00:20:22,819
¿qué me saldría?

516
00:20:23,140 --> 00:20:25,140
si he cambiado el equals por doble igual

517
00:20:25,140 --> 00:20:29,220
¿iguales o distintas?

518
00:20:30,839 --> 00:20:31,960
porque está sin miedo

519
00:20:31,960 --> 00:20:33,519
distintas

520
00:20:43,259 --> 00:20:46,480
pues no

521
00:20:46,480 --> 00:20:53,200
estas son las maravillas

522
00:20:53,200 --> 00:20:54,339
de la programación que me encanta

523
00:20:54,339 --> 00:20:56,839
claro

524
00:20:56,839 --> 00:20:58,740
pero por otro pequeñito matiz

525
00:20:58,740 --> 00:21:00,640
que ya es el último que me falta por incorporar

526
00:21:00,640 --> 00:21:02,160
¿vale?

527
00:21:02,420 --> 00:21:05,059
esto prácticamente no lo sabe nadie

528
00:21:05,059 --> 00:21:07,119
porque nadie se encuentra

529
00:21:07,119 --> 00:21:08,980
con esta situación porque todo el mundo pone

530
00:21:08,980 --> 00:21:09,519
equals

531
00:21:09,519 --> 00:21:10,599
¿vale?

532
00:21:11,140 --> 00:21:13,119
pero es que desde cierta

533
00:21:13,120 --> 00:21:15,400
versión de Java hay una pequeña particularidad

534
00:21:15,400 --> 00:21:17,060
que hace

535
00:21:17,060 --> 00:21:19,260
que pase esto

536
00:21:19,260 --> 00:21:21,320
y podemos obviarla

537
00:21:21,320 --> 00:21:22,800
y hacer como que no existe

538
00:21:22,800 --> 00:21:24,820
usamos equals siempre

539
00:21:24,820 --> 00:21:26,320
y eso sería lo correcto

540
00:21:26,320 --> 00:21:27,980
cuando yo comparo objetos

541
00:21:27,980 --> 00:21:30,000
en concreto string, equals siempre

542
00:21:30,000 --> 00:21:31,200
¿vale?

543
00:21:31,480 --> 00:21:33,500
pero hay una pequeñita particularidad que os añado

544
00:21:33,500 --> 00:21:36,720
para que la sepáis, vosotros si vais a ser de los más listos

545
00:21:36,720 --> 00:21:37,640
y es

546
00:21:37,640 --> 00:21:39,540
que Java para ahorrarse

547
00:21:39,540 --> 00:21:40,880
espacio y memoria

548
00:21:40,880 --> 00:21:42,800
hasta cierta cantidad

549
00:21:43,120 --> 00:21:44,000
de cadenas

550
00:21:44,000 --> 00:21:46,300
que no sé si son hasta 1048

551
00:21:46,300 --> 00:21:47,380
o las que sean

552
00:21:47,380 --> 00:21:47,980
esta cantidad

553
00:21:47,980 --> 00:21:51,300
si detecta que dos objetos cadena

554
00:21:51,300 --> 00:21:53,480
tienen el mismo texto

555
00:21:53,480 --> 00:21:54,600
¿vale?

556
00:21:54,680 --> 00:21:55,440
si detecta

557
00:21:55,440 --> 00:21:57,820
entonces los lleva al mismo sitio

558
00:21:57,820 --> 00:21:59,880
y los hace apuntar por la misma dirección

559
00:21:59,880 --> 00:22:01,280
para no duplicar

560
00:22:01,280 --> 00:22:03,460
lo hace internamente él

561
00:22:03,460 --> 00:22:05,220
entonces ¿qué ha pasado?

562
00:22:05,320 --> 00:22:06,540
ahora nosotros solo tenemos dos cadenas

563
00:22:06,540 --> 00:22:07,800
nosotros, ese uno y ese dos

564
00:22:07,800 --> 00:22:09,560
entonces su manejo interno

565
00:22:09,560 --> 00:22:10,980
dice ah lo llevo al mismo sitio

566
00:22:10,980 --> 00:22:12,060
lo llevo al mismo lado

567
00:22:12,060 --> 00:22:13,100
entonces ¿qué pasa?

568
00:22:13,100 --> 00:22:14,260
pues al llevarlo al mismo lado

569
00:22:14,260 --> 00:22:17,040
el efecto es que esto también se cumple

570
00:22:17,040 --> 00:22:18,580
pero ojo con eso

571
00:22:18,580 --> 00:22:21,340
porque eso es a partir de cierta cantidad de cadenas

572
00:22:21,340 --> 00:22:22,420
entonces

573
00:22:22,420 --> 00:22:25,420
lo mejor es que nos olvidemos de que eso ocurre

574
00:22:25,420 --> 00:22:26,880
y de que Java hace eso

575
00:22:26,880 --> 00:22:27,820
por ahorrar

576
00:22:27,820 --> 00:22:30,140
cosas suyas

577
00:22:30,140 --> 00:22:31,820
que nos olvidemos

578
00:22:31,820 --> 00:22:35,460
lo mejor es que usemos siempre equals para comparar cadenas

579
00:22:35,460 --> 00:22:36,540
y así jamás

580
00:22:36,540 --> 00:22:38,260
nos equivocaremos, jamás

581
00:22:38,260 --> 00:22:40,540
¿tú utilizas ahora mismo el método 3-5

582
00:22:40,540 --> 00:22:42,340
para cada uno de los otros objetos?

583
00:22:43,100 --> 00:22:45,800
bueno el método toString de String

584
00:22:45,800 --> 00:22:47,000
te da directamente la cadena

585
00:22:47,000 --> 00:22:54,120
es que no puedo porque está sobrescrito

586
00:22:54,120 --> 00:22:58,160
al estar sobrescrito

587
00:22:58,160 --> 00:23:00,040
en cuanto yo haga ese uno toString

588
00:23:00,040 --> 00:23:01,100
el de object ya no vale

589
00:23:01,100 --> 00:23:03,200
me va a mostrar siempre

590
00:23:03,200 --> 00:23:05,140
el de String

591
00:23:05,140 --> 00:23:07,840
pero a ver

592
00:23:07,840 --> 00:23:09,320
el tema es que

593
00:23:09,320 --> 00:23:10,880
Java hace internamente estas cosas

594
00:23:10,880 --> 00:23:12,760
por un tema de eficiencia de uso suyo

595
00:23:13,100 --> 00:23:14,780
pero la idea es

596
00:23:14,780 --> 00:23:17,200
que no las tengamos en cuenta a la hora de programar

597
00:23:17,200 --> 00:23:18,360
porque si las tenemos en cuenta

598
00:23:18,360 --> 00:23:20,900
nos puede inducir a error

599
00:23:20,900 --> 00:23:22,620
porque a ver, yo sé

600
00:23:22,620 --> 00:23:25,420
que hasta cierto número de cadenas va a funcionar así

601
00:23:25,420 --> 00:23:26,780
entonces me da igual

602
00:23:26,780 --> 00:23:28,740
usar el equals que el doble igual

603
00:23:28,740 --> 00:23:30,780
pero para qué arriesgarme

604
00:23:30,780 --> 00:23:32,480
que más me da, pongo el equals y ya está

605
00:23:32,480 --> 00:23:34,160
y sé que así no me voy a equivocar jamás

606
00:23:34,160 --> 00:23:36,660
os lo ponía solo como anécdota

607
00:23:36,660 --> 00:23:38,360
porque hay veces que les sale una cosa

608
00:23:38,360 --> 00:23:40,260
y decís, ¿y esto por qué?

609
00:23:40,260 --> 00:23:42,780
pues bueno, son pequeños detalles de funcionamiento interno

610
00:23:43,100 --> 00:23:44,120
que podemos obviar

611
00:23:44,120 --> 00:23:47,240
y trabajar con lo ortodoxo

612
00:23:47,240 --> 00:23:49,440
que es, dos cadenas se comparan con el equals

613
00:23:49,440 --> 00:23:51,060
y así jamás, jamás

614
00:23:51,060 --> 00:23:53,500
va a salir un resultado erróneo

615
00:23:53,500 --> 00:23:55,220
nunca, porque el equals está hecho

616
00:23:55,220 --> 00:23:57,100
para comparar que los dos textos sean iguales

617
00:23:57,740 --> 00:23:58,440
¿vale?

618
00:23:59,360 --> 00:24:01,340
entonces esto como si no lo hubiera escrito

619
00:24:01,340 --> 00:24:03,120
dos cadenas

620
00:24:03,120 --> 00:24:04,660
oe

621
00:24:04,660 --> 00:24:05,780
¿por qué me sale este?

622
00:24:07,640 --> 00:24:08,780
dos cadenas

623
00:24:08,780 --> 00:24:11,060
se comparan siempre

624
00:24:11,060 --> 00:24:12,020
con el equals

625
00:24:13,100 --> 00:24:14,100
y listo

626
00:24:14,100 --> 00:24:16,920
porque son objetos

627
00:24:16,920 --> 00:24:18,880
esto es con lo que nos queremos quedar

628
00:24:18,880 --> 00:24:21,100
¿vale?

629
00:24:25,440 --> 00:24:26,040
¿vale?

630
00:24:29,280 --> 00:24:30,620
bueno, pues por ahora

631
00:24:30,620 --> 00:24:33,540
verencia, nos quedamos con todo esto

632
00:24:33,540 --> 00:24:34,580
que en realidad ya es mucho

633
00:24:34,580 --> 00:24:36,440
entre los días que llevamos ya es bastante

634
00:24:36,440 --> 00:24:39,660
bueno, pues vamos a

635
00:24:39,660 --> 00:24:41,420
poner aquí algún ejercicio

636
00:24:41,420 --> 00:24:42,540
o algo para que

637
00:24:42,540 --> 00:24:43,080
ya se vea bien

638
00:24:43,079 --> 00:24:44,379
ya vosotros con vuestra cabeza

639
00:24:44,379 --> 00:24:46,000
lo hagáis un poco ya organizadamente