1
00:00:00,000 --> 00:00:05,540
Vale, entonces voy a grabar este ejemplo, ¿vale? A ver qué tal sale.

2
00:00:05,740 --> 00:00:07,799
Pues me voy a crear una clase.

3
00:00:10,240 --> 00:00:16,399
Mi clase se llamará utilidades, ¿vale?

4
00:00:17,719 --> 00:00:21,160
Que es una clase genérica que hace cosas, ¿vale?

5
00:00:22,160 --> 00:00:27,620
No quiero que esto sea utilidades para una clase en concreto,

6
00:00:27,620 --> 00:00:31,239
para, oye, me hago un método para la clase gato, para la clase no sé qué.

7
00:00:31,800 --> 00:00:35,119
Quiero que esta aquí sea una cosa más genérica, ¿vale?

8
00:00:35,119 --> 00:00:44,100
Por ejemplo, yo quiero poder utilizar estas utilidades para que tú me digas una rey

9
00:00:44,100 --> 00:00:48,159
y yo te ordene esta rey, por ejemplo, ¿vale?

10
00:00:48,299 --> 00:00:53,899
O, no lo sé, empezamos desde algo más fácil.

11
00:00:53,899 --> 00:01:11,739
Digamos, que antes me digas si una cosa es mayor o menor que... es ordenada, digamos, o que me pille dos objetos y me los ordene, me ponga antes el primero y luego el segundo, ¿vale? Una cosa de ese estilo, ¿vale?

12
00:01:11,739 --> 00:01:32,750
Entonces, empiezo desde algo muy fácil. Entonces, public void escribe ordenados object a, object b.

13
00:01:34,329 --> 00:01:41,590
¿Sí? Si yo hago una cosa de ese estilo, el objetivo es lo siguiente. Tú me das dos objetos.

14
00:01:41,590 --> 00:01:48,989
y yo te pongo, esto viene antes que este otro, o este viene antes que este otro, ¿sí?

15
00:01:49,909 --> 00:01:53,870
La pregunta es, ¿puedo hacer algo así?

16
00:01:56,150 --> 00:01:58,969
Imaginamos que estos sean enteros, ¿sí?

17
00:01:59,170 --> 00:02:02,629
Si yo te doy 3 y 7, pues tú sabes que 3 viene antes de 7,

18
00:02:02,730 --> 00:02:05,890
si yo te doy 7 y 3, tú sabes que tienes que invertirlos, ¿sí?

19
00:02:06,090 --> 00:02:11,689
Pero si yo aquí pillo objetos, ¿cómo hago a comparar este objeto con este objeto?

20
00:02:13,900 --> 00:02:14,300
Pregunto.

21
00:02:16,590 --> 00:02:19,090
No lo sé, porque no sé cómo se compara un objeto.

22
00:02:19,210 --> 00:02:21,370
Hay objetos que no se pueden comparar.

23
00:02:22,930 --> 00:02:23,069
¿Sí?

24
00:02:23,389 --> 00:02:27,990
Entonces este object sería demasiado genérico para utilizarlo aquí.

25
00:02:27,990 --> 00:02:32,909
¿Cómo podría hacer algo un poquito más interesante?

26
00:02:40,539 --> 00:02:47,159
Por ejemplo, yo podría decir, oye, mira, los objetos que uso aquí no quiero que sean objetos cualquiera.

27
00:02:47,939 --> 00:02:50,599
Quiero que sean objetos comparables.

28
00:02:51,060 --> 00:02:58,979
no sé si tengo que importarlo

29
00:02:58,979 --> 00:03:05,120
un objeto comparable hace referencia

30
00:03:05,120 --> 00:03:08,360
al señor comparable

31
00:03:08,360 --> 00:03:18,599
el señor comparable es una interfaz

32
00:03:18,599 --> 00:03:24,360
definida, que lo que hace

33
00:03:24,360 --> 00:03:27,840
es decir, oye mira, para

34
00:03:27,840 --> 00:03:30,979
para poder hacer un objeto comparable

35
00:03:30,979 --> 00:03:40,340
o sea, para que tú implementes esta interfaz, necesitas necesariamente haber creado un método compare to, ¿vale?

36
00:03:40,639 --> 00:03:52,280
Entonces, si yo aquí utilizo comparables, sé que estos objetos tendrán dentro un compare to, ¿sí?

37
00:03:52,360 --> 00:03:53,219
Y lo puedo utilizar.

38
00:03:53,900 --> 00:03:59,740
Ahora, yo lo que debería hacer es leerme bien qué hace el compare to, para qué sirve, ¿vale?

39
00:03:59,740 --> 00:04:06,560
Entonces, aquí me dice, compara los objetos con otro objeto, ¿vale?

40
00:04:06,560 --> 00:04:07,539
Para ordenarlo

41
00:04:07,539 --> 00:04:12,300
Y dice que, sustancialmente, puede devolver, compare tú, devuelve

42
00:04:12,300 --> 00:04:15,280
O un número negativo, o un número cero, o un número positivo

43
00:04:15,280 --> 00:04:19,459
Dependiendo de si el objeto es menor, igual o mayor

44
00:04:19,459 --> 00:04:21,540
Con respecto al objeto que se compara

45
00:04:21,540 --> 00:04:23,120
¿Sí? Vale

46
00:04:23,120 --> 00:04:27,379
Luego explica cosas aquí, dice otra cosa, bla bla bla bla bla

47
00:04:27,379 --> 00:04:36,300
Ahora, una cosa interesante es que hay que ver qué pasa cuando yo hago comparebol entre objetos que no son el mismo objeto.

48
00:04:37,620 --> 00:04:40,800
Yo tengo gatos, y los gatos se comparan entre ellos.

49
00:04:40,959 --> 00:04:43,220
Tengo string, y los string se comparan entre ellos.

50
00:04:43,300 --> 00:04:45,800
Pero si comparo un gato y un string, ¿qué pasa?

51
00:04:48,639 --> 00:04:50,399
Entonces, vamos a ver qué pasa.

52
00:04:50,399 --> 00:04:52,500
Entonces

53
00:04:52,500 --> 00:04:55,139
Este objeto, esta cosa aquí

54
00:04:55,139 --> 00:04:56,220
Que será estático

55
00:04:56,220 --> 00:05:00,639
Me pilla dos objetos

56
00:05:00,639 --> 00:05:03,199
Y hemos dicho que me los tiene que escribir ordenados

57
00:05:03,199 --> 00:05:05,279
Entonces aquí se preguntará

58
00:05:05,279 --> 00:05:06,300
Si

59
00:05:06,300 --> 00:05:08,860
A

60
00:05:08,860 --> 00:05:11,160
Que es este primer objeto

61
00:05:11,160 --> 00:05:13,199
Punto

62
00:05:13,199 --> 00:05:17,060
Fijaos que aquí son todas cosas de objetos

63
00:05:17,060 --> 00:05:19,120
Pero también me aparece el

64
00:05:19,120 --> 00:05:20,360
Comperto de comparable

65
00:05:20,360 --> 00:05:23,339
Comperto B

66
00:05:23,339 --> 00:05:24,639
¿Qué hago ahora?

67
00:05:24,720 --> 00:05:28,449
¿Qué es esto? Un int

68
00:05:28,449 --> 00:05:30,670
Estamos de acuerdo que es un int

69
00:05:30,670 --> 00:05:32,670
Y tengo tres opciones

70
00:05:32,670 --> 00:05:35,170
O es menor que cero

71
00:05:35,170 --> 00:05:36,170
O es cero

72
00:05:36,170 --> 00:05:37,310
O es mayor que cero

73
00:05:37,310 --> 00:05:40,550
Si es menor que cero

74
00:05:40,550 --> 00:05:42,970
Quiere decir que A

75
00:05:42,970 --> 00:05:44,970
Es más pequeño que B

76
00:05:44,970 --> 00:05:48,290
Entonces si yo escribiré

77
00:05:48,290 --> 00:05:50,829
Si hizo A, B

78
00:05:50,829 --> 00:05:55,250
Si hizo A, B

79
00:05:55,250 --> 00:06:02,250
else if

80
00:06:02,250 --> 00:06:04,110
o else

81
00:06:04,110 --> 00:06:09,180
vamos así, porque también si son iguales

82
00:06:09,180 --> 00:06:10,740
me da igual escribirlo al orden

83
00:06:10,740 --> 00:06:12,240
entonces digo así, or

84
00:06:12,240 --> 00:06:15,639
si esta cosa

85
00:06:15,639 --> 00:06:18,500
es igual a cero

86
00:06:18,500 --> 00:06:22,819
escribilos así

87
00:06:22,819 --> 00:06:24,740
si no, y aquí

88
00:06:24,740 --> 00:06:26,839
es el único caso en el que en vez

89
00:06:26,839 --> 00:06:28,220
el número es mayor que cero

90
00:06:28,220 --> 00:06:30,740
estrictamente mayor que cero, entonces quiere decir que

91
00:06:30,740 --> 00:06:32,259
b es antes que a

92
00:06:32,259 --> 00:06:34,680
pues entonces lo que tengo que escribir aquí es

93
00:06:34,680 --> 00:06:37,519
siso B

94
00:06:37,519 --> 00:06:39,660
y luego

95
00:06:39,660 --> 00:06:43,720
siso A. ¿Qué no entiendes?

96
00:06:48,569 --> 00:06:49,990
Este señor devuelve un entero.

97
00:06:50,709 --> 00:06:51,670
El entero puede ser

98
00:06:51,670 --> 00:06:53,529
menor que 0

99
00:06:53,529 --> 00:06:55,610
si A es más pequeño que B.

100
00:06:57,829 --> 00:06:59,410
Sea lo que quiera decir

101
00:06:59,410 --> 00:07:00,370
que A es menor que B.

102
00:07:01,509 --> 00:07:03,209
En caso de números es claro.

103
00:07:03,670 --> 00:07:05,470
En caso de string

104
00:07:05,470 --> 00:07:07,310
¿qué quiera decir?

105
00:07:10,980 --> 00:07:12,100
Tenemos que saberlo.

106
00:07:12,220 --> 00:07:13,980
Probablemente los ordenará de forma

107
00:07:13,980 --> 00:07:16,040
lexicográfica. O sea que

108
00:07:16,040 --> 00:07:18,439
abuelo es más pequeño

109
00:07:18,439 --> 00:07:20,000
que zorro.

110
00:07:20,800 --> 00:07:22,220
Porque la A es más pequeña que la Z.

111
00:07:23,319 --> 00:07:23,759
¿Sí?

112
00:07:24,920 --> 00:07:26,399
Probablemente. Me espero eso.

113
00:07:26,680 --> 00:07:27,720
Si no lo sé, me lo voy a leer.

114
00:07:28,160 --> 00:07:29,399
Ahora lo vamos a leer.

115
00:07:30,019 --> 00:07:31,779
Asumiendo que string sea comparable.

116
00:07:34,079 --> 00:07:34,879
Vamos a verlo después.

117
00:07:36,220 --> 00:07:37,879
Ahora, por ejemplo, yo me hago

118
00:07:37,879 --> 00:07:39,759
personas. Y decido que

119
00:07:39,759 --> 00:07:41,420
las personas se ordenan

120
00:07:41,420 --> 00:07:42,279
por edad.

121
00:07:43,519 --> 00:07:45,579
Entonces, si A

122
00:07:45,579 --> 00:07:47,240
es más joven que B,

123
00:07:47,420 --> 00:07:49,579
tendré que devolver un número negativo.

124
00:07:50,920 --> 00:07:52,759
Si B es más...

125
00:07:52,759 --> 00:07:55,160
Si A es mayor que B,

126
00:07:55,740 --> 00:07:56,740
o sea, más viejo,

127
00:07:57,120 --> 00:07:58,300
pues entonces es un número positivo.

128
00:07:58,600 --> 00:08:00,439
Y si tiene la misma edad, cero.

129
00:08:02,019 --> 00:08:02,180
¿Sí?

130
00:08:02,519 --> 00:08:05,120
Ahora, yo no lo sé cómo se comparan dos objetos,

131
00:08:05,620 --> 00:08:06,879
pero sé que esto,

132
00:08:07,399 --> 00:08:09,199
sea como sea que tú has decidido

133
00:08:09,199 --> 00:08:10,439
que se comparan dos objetos,

134
00:08:10,439 --> 00:08:13,720
me los dará con un número menor de cero,

135
00:08:13,839 --> 00:08:15,040
igual o cero.

136
00:08:15,139 --> 00:08:17,300
Entonces, si he dicho que si A es menor que B,

137
00:08:17,420 --> 00:08:18,959
Antes me escribes A y luego B.

138
00:08:19,360 --> 00:08:22,319
Y también si son iguales, me da igual escribir uno o el otro.

139
00:08:23,060 --> 00:08:29,220
En el caso, en vez de que A sea mayor que B, entonces para ordenarlos, antes el menor, luego el mayor,

140
00:08:29,379 --> 00:08:31,540
quiere decir que antes escribo el menor y luego el mayor.

141
00:08:34,830 --> 00:08:39,190
Y fijaos, esto yo lo he hecho asumiendo que hay dos comparables.

142
00:08:39,409 --> 00:08:42,789
No sé cómo se comparan y no sé qué objetos voy a utilizar.

143
00:08:43,610 --> 00:08:46,950
Pero ahora tengo un método que le doy dos objetos cualquiera

144
00:08:46,950 --> 00:08:50,789
y él decide cuál es menor y cuál es menor y me lo escribe ordenado.

145
00:08:52,090 --> 00:08:53,529
Vamos a utilizar esto.

146
00:09:02,350 --> 00:09:07,669
Clase principal, hago un main.

147
00:09:11,850 --> 00:09:13,750
Y por ejemplo, dos objetos.

148
00:09:17,750 --> 00:09:21,649
Integer x es igual a 5.

149
00:09:23,309 --> 00:09:26,750
Integer y es igual a...

150
00:09:28,409 --> 00:10:00,100
Es igual a 9. Cuidado. Esto debería ser new integer. Pero es que no le gusta. O sea, Java hoy en día hace una conversión automática entre tipos primitivos y tipos que representan ese tipo primitivo como objeto.

151
00:10:00,100 --> 00:10:01,620
Esto es un objeto

152
00:10:01,620 --> 00:10:03,759
Un objeto de la clase integer

153
00:10:03,759 --> 00:10:07,919
Pero cuando lo escribo así, él en automático lo que hace es que me pilla 5 como entero

154
00:10:07,919 --> 00:10:12,120
Y me lo guarda dentro de un objeto que representa el número 5 como entero

155
00:10:12,120 --> 00:10:16,269
No

156
00:10:16,269 --> 00:10:22,210
Porque yo int s es igual a 5, a 4

157
00:10:22,210 --> 00:10:24,009
Y yo no puedo hacer ese punto

158
00:10:24,009 --> 00:10:31,590
Porque no puedo hacer métodos o variables sobre el entero como tipo primitivo

159
00:10:31,590 --> 00:10:36,250
Sin embargo, sí que puede hacer x punto, porque es un objeto y tendrá sus métodos.

160
00:10:36,549 --> 00:10:43,230
Tiene métodos que me pueden dar valor, tiene métodos que me puede saber cuánto es largo, muchas cosas,

161
00:10:43,610 --> 00:10:46,909
incluido este de aquí, que a lo mejor lo conocemos de algo.

162
00:10:50,899 --> 00:10:56,659
Entonces, integer implementa comparable.

163
00:10:58,659 --> 00:11:01,019
No lo sé. Vamos a verlo.

164
00:11:01,019 --> 00:11:04,230
que hay un buscador aquí

165
00:11:04,230 --> 00:11:09,759
entonces me voy a buscar integer

166
00:11:09,759 --> 00:11:11,399
api, java

167
00:11:11,399 --> 00:11:13,460
me voy a mirar

168
00:11:13,460 --> 00:11:14,720
integer

169
00:11:14,720 --> 00:11:17,659
y voy a mirar si por ejemplo

170
00:11:17,659 --> 00:11:19,679
implementa

171
00:11:19,679 --> 00:11:21,740
comparable, ahora tiene una

172
00:11:21,740 --> 00:11:23,740
cosa rara aquí, que todavía

173
00:11:23,740 --> 00:11:25,919
no sabemos bien que es, lo veremos

174
00:11:25,919 --> 00:11:27,279
vale, pero

175
00:11:27,279 --> 00:11:29,940
comparable la implementa

176
00:11:29,940 --> 00:11:31,299
y de hecho

177
00:11:31,299 --> 00:11:33,980
si voy a mirar los métodos que puede hacer

178
00:11:33,980 --> 00:11:35,559
está el compare to

179
00:11:35,559 --> 00:12:03,110
¿Sí? Pues, por ejemplo, yo lo que puedo hacer ahora es utilizar mi utilidades, punto, escribe ordenados, x y, y voilà, me lo has escrito ordenado.

180
00:12:03,110 --> 00:12:10,220
Si yo le cambio el valor y lo llamo otra vez, ¡bam!, me lo escribió ordenado.

181
00:12:11,379 --> 00:12:18,080
Es capaz de ordenarme estos objetos porque estos objetos son comparable.

182
00:12:19,980 --> 00:12:20,200
¿Vale?

183
00:12:20,899 --> 00:12:21,820
Cambiamos de objeto.

184
00:12:22,500 --> 00:12:26,200
String a es igual a vuelo.

185
00:12:30,090 --> 00:12:35,649
String b es igual a gato.

186
00:12:35,649 --> 00:12:37,470
Sí, para algo.

187
00:12:37,850 --> 00:12:46,990
Pues sí, ahora puedo utilizar esta cosa de aquí, entre A y B.

188
00:12:51,320 --> 00:12:55,200
Siempre y cuando, si tengo suerte, string,

189
00:12:58,259 --> 00:13:08,240
resulta que implemente, all implement interface, fíjate tú, comparable.

190
00:13:08,940 --> 00:13:13,200
Por lo tanto, tiene un compare to, por algún lado,

191
00:13:13,200 --> 00:13:15,360
y aquí encontraré un compare to.

192
00:13:15,879 --> 00:13:22,700
Y si voy a mirar el compareTo, aquí me dice cómo se ha implementado el compareTo para string.

193
00:13:23,019 --> 00:13:31,980
Y me dice compares two strings lexicográfically, o sea, ordenadas alfabéticamente, ¿vale?

194
00:13:31,980 --> 00:13:37,279
Entonces, me espero que tengo abuelo y gato, me escriba abuelo y gato.

195
00:13:37,279 --> 00:13:40,429
si tengo

196
00:13:40,429 --> 00:13:43,009
zabuelo

197
00:13:43,009 --> 00:13:45,289
y gato

198
00:13:45,289 --> 00:13:47,590
pues me escribirá

199
00:13:47,590 --> 00:13:48,950
gato y zabuelo

200
00:13:48,950 --> 00:13:53,519
y fijaos, yo no he cambiado este método

201
00:13:53,519 --> 00:13:57,120
este método me está valiendo para entero

202
00:13:57,120 --> 00:13:58,980
me está valiendo para string, me está valiendo

203
00:13:58,980 --> 00:14:00,179
para cualquier

204
00:14:00,179 --> 00:14:02,700
objeto que exista

205
00:14:02,700 --> 00:14:05,039
que implemente con parable

206
00:14:05,039 --> 00:14:07,360
me funciona

207
00:14:07,360 --> 00:14:11,320
mi método, ¿me entiendes?

208
00:14:12,500 --> 00:14:12,899
ahora

209
00:14:12,899 --> 00:14:14,840
La pregunta es

210
00:14:14,840 --> 00:14:22,700
¿Qué pasa?

211
00:14:33,899 --> 00:14:34,440
Mi amigo

212
00:14:34,440 --> 00:14:37,500
Cast class exception

213
00:14:37,500 --> 00:14:40,299
Porque claro, ¿qué intenta hacer él?

214
00:14:40,360 --> 00:14:41,879
Él le dice, pongo y pillo un entero

215
00:14:41,879 --> 00:14:44,200
Si os acordáis, hacía esto

216
00:14:44,200 --> 00:14:46,179
Punto compares to esto

217
00:14:46,179 --> 00:14:48,120
Pero claro, este de aquí

218
00:14:48,120 --> 00:14:50,059
No es un tipo compatible

219
00:14:50,059 --> 00:14:51,820
Con integer

220
00:14:51,820 --> 00:14:53,919
Estoy haciendo un integer en string

221
00:14:53,919 --> 00:14:56,720
¿Qué viene antes? ¿Tres o abuelo?

222
00:14:56,720 --> 00:15:00,240
No tengo ni idea, no son comparables

223
00:15:00,240 --> 00:15:03,879
Entonces Java, cuando hace una cosa de ese estilo

224
00:15:03,879 --> 00:15:06,100
Pues explota con una excepción

225
00:15:06,100 --> 00:15:07,340
¿Por qué explota con una excepción?

226
00:15:07,419 --> 00:15:09,399
Porque si yo me voy a mirar aquí

227
00:15:09,399 --> 00:15:12,120
Comparable, ¿vale?

228
00:15:13,399 --> 00:15:16,740
Aquí, además de otras cosas, por algún lado

229
00:15:16,740 --> 00:15:23,000
Me comenta que Compar2 puede lanzar dos cosas

230
00:15:23,000 --> 00:15:25,460
o null pointer exception

231
00:15:25,460 --> 00:15:29,179
si es que tú me has dicho

232
00:15:29,179 --> 00:15:32,440
este punto compare tú

233
00:15:32,440 --> 00:15:35,320
y como parámetro me has dado un null

234
00:15:35,320 --> 00:15:39,179
entonces como no puede él trabajar con este null

235
00:15:39,179 --> 00:15:42,019
pues lo que hace es explota con un null pointer exception

236
00:15:42,019 --> 00:15:45,620
si el objeto especificado es null

237
00:15:45,620 --> 00:15:47,360
lanza un null pointer exception

238
00:15:47,360 --> 00:15:50,500
si el objeto especificado

239
00:15:50,500 --> 00:15:52,399
el tipo del objeto especificado

240
00:15:52,399 --> 00:15:55,340
no puede ser comparado con este

241
00:15:55,340 --> 00:15:56,879
objeto, con this

242
00:15:56,879 --> 00:15:59,399
pues entonces lanza un class

243
00:15:59,399 --> 00:16:01,340
cast exception, o sea te lo dice

244
00:16:01,340 --> 00:16:03,179
aquí como tiene que ser implementado

245
00:16:03,179 --> 00:16:05,259
si tú

246
00:16:05,259 --> 00:16:06,519
haces una implementación

247
00:16:06,519 --> 00:16:08,259
del compares to

248
00:16:08,259 --> 00:16:12,440
y resulta que no son

249
00:16:12,440 --> 00:16:14,019
compatibles

250
00:16:14,019 --> 00:16:16,940
lo que debería hacer tu programa

251
00:16:16,940 --> 00:16:18,759
compares to es lanzar

252
00:16:18,759 --> 00:16:20,659
un class cast

253
00:16:20,659 --> 00:16:21,100
exception

254
00:16:21,100 --> 00:16:35,269
entonces y hasta aquí utilizando cosas que me han dado ya hecha vale pues vamos a hacer nuestra

255
00:16:35,269 --> 00:16:50,840
propia clase vamos a hacer una clase nueva que es la clase algo que se pueda comparar persona

256
00:16:50,840 --> 00:16:52,000
y comparamos las edad

257
00:16:52,000 --> 00:16:54,480
tenéis otra

258
00:16:54,480 --> 00:16:57,679
persona

259
00:16:57,679 --> 00:17:00,960
la clase persona tiene

260
00:17:00,960 --> 00:17:03,440
string nombre

261
00:17:03,440 --> 00:17:06,839
e int edad

262
00:17:06,839 --> 00:17:09,910
tiene un constructor

263
00:17:09,910 --> 00:17:21,230
que me permite crear una persona

264
00:17:21,230 --> 00:17:25,029
y luego queremos que esta persona

265
00:17:25,029 --> 00:17:26,430
se pueda comparar

266
00:17:26,430 --> 00:17:28,150
fijaos que si ahora voy aquí

267
00:17:28,150 --> 00:17:30,569
y digo vale creamos dos personas

268
00:17:30,569 --> 00:17:32,450
persona p1

269
00:17:32,450 --> 00:17:33,849
p es igual

270
00:17:33,849 --> 00:17:35,809
pers

271
00:17:35,809 --> 00:17:38,589
1 es igual a

272
00:17:38,589 --> 00:17:39,869
new persona

273
00:17:39,869 --> 00:17:43,809
Sara

274
00:17:43,809 --> 00:17:48,019
33

275
00:17:48,019 --> 00:17:51,400
y persona

276
00:17:51,400 --> 00:17:53,599
pers 2

277
00:17:53,599 --> 00:17:56,119
es igual a new persona

278
00:17:56,119 --> 00:18:02,109
paco

279
00:18:02,109 --> 00:18:04,250
coma

280
00:18:04,250 --> 00:18:04,990
44

281
00:18:04,990 --> 00:18:10,599
y ahora le digo

282
00:18:10,599 --> 00:18:12,599
utilidades

283
00:18:12,599 --> 00:18:14,279
punto

284
00:18:14,279 --> 00:18:15,140
escribe

285
00:18:15,140 --> 00:18:15,920
utilidades

286
00:18:15,920 --> 00:18:16,420
de

287
00:18:16,420 --> 00:18:17,940
pers 1

288
00:18:17,940 --> 00:18:20,640
pers 2

289
00:18:20,640 --> 00:18:23,299
se enfada

290
00:18:23,299 --> 00:18:24,339
¿por qué se enfada?

291
00:18:37,660 --> 00:18:38,599
¿por qué me he enfadado?

292
00:18:43,230 --> 00:18:44,529
porque persona

293
00:18:44,529 --> 00:18:46,609
no es de tipo comparable

294
00:18:46,609 --> 00:18:51,099
no es un comparable

295
00:18:51,099 --> 00:18:51,900
¿por qué?

296
00:18:51,980 --> 00:18:53,599
porque todavía no he extendido

297
00:18:53,599 --> 00:18:55,420
no he implementado comparable

298
00:18:55,420 --> 00:18:57,519
y yo he dicho

299
00:18:57,519 --> 00:18:58,220
que utilidades

300
00:18:58,220 --> 00:18:59,779
lo que hace es pillar un comparable

301
00:18:59,779 --> 00:19:02,519
Entonces persona no lo puede hacer

302
00:19:02,519 --> 00:19:03,720
Así como tal

303
00:19:03,720 --> 00:19:05,460
No puedo implementar

304
00:19:05,460 --> 00:19:06,859
Ah, espera, no pasa nada

305
00:19:06,859 --> 00:19:10,250
Public

306
00:19:10,250 --> 00:19:11,970
No, int

307
00:19:11,970 --> 00:19:14,109
Compare to

308
00:19:14,109 --> 00:19:17,250
The object

309
00:19:17,250 --> 00:19:18,829
Object

310
00:19:18,829 --> 00:19:20,609
Ya está

311
00:19:20,609 --> 00:19:22,549
Ya tengo para comparar

312
00:19:22,549 --> 00:19:24,789
Return 1

313
00:19:24,789 --> 00:19:26,869
Ya está, ya lo tengo

314
00:19:26,869 --> 00:19:30,789
¿Por qué se enfada?

315
00:19:40,539 --> 00:19:42,980
Porque el hecho que yo implemente

316
00:19:42,980 --> 00:19:48,279
Este método no quiere decir que esté implementando la interfaz.

317
00:19:49,920 --> 00:19:50,779
¿Se entiende?

318
00:19:51,920 --> 00:19:54,440
O sea, yo no he sobrescrito el contrato.

319
00:19:55,460 --> 00:19:57,599
O sea, no he firmado el contrato.

320
00:19:58,099 --> 00:19:58,299
¿Vale?

321
00:19:58,539 --> 00:20:02,160
La gente desde fuera ve que persona sí tiene un compare to,

322
00:20:02,299 --> 00:20:06,259
pero no es el compare to definido en la interfaz comparable,

323
00:20:06,480 --> 00:20:08,200
porque yo no la implemento esa interfaz.

324
00:20:08,200 --> 00:20:10,359
por lo tanto no puedo

325
00:20:10,359 --> 00:20:11,619
tratar a una persona como

326
00:20:11,619 --> 00:20:14,259
comparable, lo que estoy haciendo

327
00:20:14,259 --> 00:20:16,279
es que tú tienes tu método compare to

328
00:20:16,279 --> 00:20:18,559
tuyo, que lo has usado como te da la gana

329
00:20:18,559 --> 00:20:20,480
para que

330
00:20:20,480 --> 00:20:21,519
yo esté seguro

331
00:20:21,519 --> 00:20:24,099
que esto funcione

332
00:20:24,099 --> 00:20:26,420
pues entonces le tengo que

333
00:20:26,420 --> 00:20:27,539
decir implement

334
00:20:27,539 --> 00:20:30,079
comparable

335
00:20:30,079 --> 00:20:32,200
ahora, este

336
00:20:32,200 --> 00:20:34,220
comparable aquí, ahora yo he

337
00:20:34,220 --> 00:20:36,240
firmado el contrato, que no es un

338
00:20:36,240 --> 00:20:38,220
Compartoo como me da la gana

339
00:20:38,220 --> 00:20:40,599
Es el Compartoo de Comparable

340
00:20:40,599 --> 00:20:42,440
Y yo tendría que

341
00:20:42,440 --> 00:20:43,859
Irme a

342
00:20:43,859 --> 00:20:45,859
La interfaz Comparable

343
00:20:45,859 --> 00:20:48,660
Y leerme bien que quiere

344
00:20:48,660 --> 00:20:51,000
Que haga la interfaz Comparable

345
00:20:51,000 --> 00:20:52,240
Y definir

346
00:20:52,240 --> 00:20:53,339
Esto

347
00:20:53,339 --> 00:20:55,299
¿Está claro?

348
00:20:56,599 --> 00:20:56,920
Vale

349
00:20:56,920 --> 00:21:00,740
Ahora, si yo lo he hecho

350
00:21:00,740 --> 00:21:02,680
Sé que Comparable

351
00:21:02,680 --> 00:21:04,559
Tiene que comparar

352
00:21:04,559 --> 00:21:06,599
this con este

353
00:21:06,599 --> 00:21:07,420
objeto de aquí

354
00:21:07,420 --> 00:21:09,799
¿vale? y

355
00:21:09,799 --> 00:21:10,980
ver

356
00:21:10,980 --> 00:21:13,460
si son compatibles o no

357
00:21:13,460 --> 00:21:15,880
¿sí? entonces

358
00:21:15,880 --> 00:21:18,240
lo voy a hacer de una forma un poquito rara

359
00:21:18,240 --> 00:21:20,460
pero ve, la primera cosa

360
00:21:20,460 --> 00:21:22,119
es que este objeto de aquí

361
00:21:22,119 --> 00:21:23,940
tiene que ser

362
00:21:23,940 --> 00:21:29,099
una persona, si no

363
00:21:29,099 --> 00:21:32,859
mal vamos, yo estoy en

364
00:21:32,859 --> 00:21:35,099
persona, estoy comparando

365
00:21:35,099 --> 00:21:36,539
this que es una persona

366
00:21:36,539 --> 00:21:38,799
y no lo quiero comparar con un gato

367
00:21:38,799 --> 00:21:57,140
Porque no puedo comparar gato. Si yo te digo, ¿qué viene antes? ¿Esta persona aquí que he creado? ¿Esta persona aquí? ¿Esta? ¿O la palabra abuelo? No lo sé, no son comparables.

368
00:21:57,980 --> 00:22:06,099
Entonces, si yo estoy definiendo una forma de comparar entre ellos dos señores, dos personas, ¿vale?

369
00:22:06,380 --> 00:22:12,359
Entonces, lo que necesito es que esto también sea una persona. Necesito dos personas para poderlas comparar.

370
00:22:13,140 --> 00:22:21,500
Una es... ¿Cuáles son las dos personas que estoy comparando?

371
00:22:23,240 --> 00:22:31,650
No. Aquí no está ni persona 1 ni persona 2. ¿Quién son?

372
00:22:31,650 --> 00:22:36,470
Porque aquí yo lo he llamado así

373
00:22:36,470 --> 00:22:39,589
Pero si ahora le pongo persona 3, persona 4

374
00:22:39,589 --> 00:22:40,690
Es una cosa distinta

375
00:22:40,690 --> 00:22:42,390
No lo sé, no sé qué voy a...

376
00:22:42,390 --> 00:22:44,269
Aquí estoy en general

377
00:22:44,269 --> 00:22:47,470
Pero aquí yo tengo dos objetos con los que puedo trabajar

378
00:22:47,470 --> 00:22:48,509
¿Cuáles son estos objetos?

379
00:22:55,789 --> 00:22:56,670
Uno es esto

380
00:22:56,670 --> 00:23:00,660
Este es un objeto

381
00:23:00,660 --> 00:23:03,180
¿Sí? ¿Y cuál es el otro?

382
00:23:12,150 --> 00:23:14,390
¿Y cómo se llama la referencia de ese mismo objeto?

383
00:23:15,470 --> 00:23:15,750
This

384
00:23:15,750 --> 00:23:18,730
Estos son los dos objetos que estoy comparando

385
00:23:18,730 --> 00:23:19,589
This

386
00:23:19,589 --> 00:23:22,269
Y el objeto que me han pasado por parámetro

387
00:23:22,269 --> 00:23:23,589
¿Sí?

388
00:23:23,990 --> 00:23:25,809
Ahora, this es una persona

389
00:23:25,809 --> 00:23:27,730
¿Por qué? Porque estoy en la clase persona

390
00:23:27,730 --> 00:23:29,750
This es una persona, ningún problema

391
00:23:29,750 --> 00:23:31,529
Pero object

392
00:23:31,529 --> 00:23:33,410
¿Qué es?

393
00:23:33,950 --> 00:23:43,569
Por eso, entonces necesito

394
00:23:43,569 --> 00:23:45,549
Cerciorarme que esto sea

395
00:23:45,549 --> 00:23:47,509
Una persona, ¿cómo lo hago?

396
00:24:06,609 --> 00:24:07,650
¿Qué puede pasar aquí?

397
00:24:08,710 --> 00:24:09,390
Dos cosas

398
00:24:09,390 --> 00:24:11,250
Uno

399
00:24:11,250 --> 00:24:16,720
Que object

400
00:24:16,720 --> 00:24:19,799
sea una instancia de persona

401
00:24:19,799 --> 00:24:21,700
o sea que si hiciera

402
00:24:21,700 --> 00:24:23,740
obj instance of persona

403
00:24:23,740 --> 00:24:24,559
me diera true

404
00:24:24,559 --> 00:24:28,000
y entonces esta cosa funciona perfectamente

405
00:24:28,000 --> 00:24:29,799
¿verdad?

406
00:24:31,119 --> 00:24:32,660
o la segunda opción

407
00:24:32,660 --> 00:24:33,920
que si yo hiciera

408
00:24:33,920 --> 00:24:35,759
persona

409
00:24:35,759 --> 00:24:38,500
p instance of persona

410
00:24:38,500 --> 00:24:39,859
me devolviera un

411
00:24:39,859 --> 00:24:41,059
hola

412
00:24:41,059 --> 00:24:44,140
me devolviera un

413
00:24:44,140 --> 00:24:47,440
un class cast exception

414
00:24:47,440 --> 00:24:49,480
que si os acordáis

415
00:24:49,480 --> 00:24:51,480
el compare to puede lanzar

416
00:24:51,480 --> 00:24:53,299
un class exception

417
00:24:53,299 --> 00:24:55,480
si está mal, por lo tanto esto me viene perfecto

418
00:24:56,240 --> 00:24:57,400
yo lo hago

419
00:24:57,400 --> 00:24:59,579
que son

420
00:24:59,579 --> 00:25:01,519
tipos compatibles, ya lo he transformado

421
00:25:01,519 --> 00:25:03,160
a una persona y ahora tengo dos personas

422
00:25:03,160 --> 00:25:05,259
que no son tipos compatibles

423
00:25:05,259 --> 00:25:06,720
pues lanzará un class exception

424
00:25:06,720 --> 00:25:09,599
que es lo que se espera en la gente

425
00:25:09,599 --> 00:25:10,359
del método

426
00:25:10,359 --> 00:25:13,400
compare to, la gente

427
00:25:13,400 --> 00:25:15,460
según el contrato, este es mi

428
00:25:15,460 --> 00:25:17,299
contrato, se espera que

429
00:25:17,299 --> 00:25:19,559
si el tipo del objeto

430
00:25:19,559 --> 00:25:21,440
que te ha dado no es compatible,

431
00:25:21,720 --> 00:25:23,539
tú lances un class case exception.

432
00:25:24,720 --> 00:25:25,119
Pues ya está.

433
00:25:26,000 --> 00:25:26,500
Ya lo tengo.

434
00:25:29,059 --> 00:25:36,059
¿Se entiende? Pero yo quiero que me salte.

435
00:25:37,960 --> 00:25:39,559
El contrato del

436
00:25:39,559 --> 00:25:41,819
compertú me dice que si tú aquí

437
00:25:41,819 --> 00:25:43,819
me pasas un objeto que no es

438
00:25:43,819 --> 00:25:45,799
persona, tú tienes que hacer

439
00:25:45,799 --> 00:25:47,859
saltar un error. Lo dice aquí.

440
00:25:49,400 --> 00:25:50,019
Lo dice aquí.

441
00:25:51,019 --> 00:25:55,579
Si el tipo del objeto especificado, o sea, el que pasa los parámetros,

442
00:25:56,339 --> 00:26:01,019
no puede ser comparado con este objeto, o sea, porque son tipos distintos,

443
00:26:01,579 --> 00:26:03,259
me lanzas un class cast exception.

444
00:26:04,599 --> 00:26:08,279
Entonces, si yo voy a, como no sé todavía cómo lanzar excepciones,

445
00:26:10,000 --> 00:26:12,140
pues lo que voy a hacer es aprovecharme de esto.

446
00:26:12,140 --> 00:26:17,380
Yo sé que esta cosa de aquí, si la hago mal, si este de aquí no es una persona,

447
00:26:17,380 --> 00:26:20,279
Cuando lo hace, lanza un classCastException

448
00:26:20,279 --> 00:26:22,119
Por lo tanto, con esta frase aquí

449
00:26:22,119 --> 00:26:25,180
Yo puedo tener dos resultados posibles

450
00:26:25,180 --> 00:26:28,200
O el objeto que me has pasado es una persona

451
00:26:28,200 --> 00:26:30,720
Y por lo tanto ahora lo tengo referenciado como persona

452
00:26:30,720 --> 00:26:32,579
Y puedo usar los métodos de persona

453
00:26:32,579 --> 00:26:34,220
Perfecto

454
00:26:34,220 --> 00:26:36,960
O el objeto que me has pasado no es una persona

455
00:26:36,960 --> 00:26:39,640
Y cuando intento castearlo a algo que es persona

456
00:26:39,640 --> 00:26:41,599
Me va a lanzar un classCastException

457
00:26:41,599 --> 00:26:43,539
Te mueves aquí, por favor

458
00:26:43,539 --> 00:26:47,359
Te mueves aquí

459
00:26:47,359 --> 00:26:53,150
¿Me entendéis?

460
00:26:53,150 --> 00:26:56,069
¿Vale? Entonces, aquí yo estoy aprovechando

461
00:26:56,069 --> 00:26:57,450
La funcionalidad de otra cosa

462
00:26:57,450 --> 00:26:59,369
Que es el cast, que a veces lanza

463
00:26:59,369 --> 00:27:01,710
Un classCastException para poder

464
00:27:01,710 --> 00:27:03,309
Completar mi

465
00:27:03,309 --> 00:27:05,109
Trabajo

466
00:27:05,109 --> 00:27:07,049
Con este de aquí

467
00:27:07,049 --> 00:27:09,750
¿Vale? Entonces, ahora yo tengo

468
00:27:09,750 --> 00:27:11,390
Dos personas, aquí, aquí delante

469
00:27:11,390 --> 00:27:15,490
Ahora tengo dos personas, ¿qué hago?

470
00:27:16,750 --> 00:27:17,589
Tengo dis

471
00:27:17,589 --> 00:27:18,650
Y tengo p

472
00:27:18,650 --> 00:27:21,230
¿Vale? Lo que quiero hacer yo

473
00:27:21,230 --> 00:27:42,900
es, para hacerlo básico, interresultado es igual a cero, por ejemplo, si this.edad, hemos dicho que comparamos por edad, es menor que p.edad,

474
00:27:42,900 --> 00:27:45,099
Entonces, ¿qué hago?

475
00:27:59,950 --> 00:28:03,490
Si this es más pequeño que p

476
00:28:03,490 --> 00:28:04,950
Devuelvo

477
00:28:04,950 --> 00:28:12,940
No estoy en escribir ordenado

478
00:28:12,940 --> 00:28:14,059
Estoy en comparando

479
00:28:14,059 --> 00:28:16,779
Yo tengo que decir si este es más grande o más pequeño

480
00:28:16,779 --> 00:28:20,420
Y para decir que es pequeño mando un número negativo

481
00:28:20,420 --> 00:28:22,279
Para decir que son iguales un cero

482
00:28:22,279 --> 00:28:26,279
Para decir que es mayor un número positivo

483
00:28:26,279 --> 00:28:28,140
Por lo tanto, menos uno

484
00:28:28,140 --> 00:28:38,009
Si this es más joven que p, entonces te daré menos uno.

485
00:28:40,359 --> 00:28:43,940
Else o if otra vez.

486
00:28:44,160 --> 00:28:46,619
Lo hago feo porque luego vemos que hay otro.

487
00:28:47,059 --> 00:28:51,559
This.edad es mayor que p.edad.

488
00:28:54,059 --> 00:28:56,859
Resultado, uno.

489
00:28:59,609 --> 00:29:00,069
Y ya está.

490
00:29:00,950 --> 00:29:02,349
Return, resultado.

491
00:29:02,349 --> 00:29:06,680
Si son iguales

492
00:29:06,680 --> 00:29:07,700
Ya la he metido a cero

493
00:29:07,700 --> 00:29:09,880
Entonces no entrará ni aquí ni aquí

494
00:29:09,880 --> 00:29:11,059
Y me lo dejará en cero

495
00:29:11,059 --> 00:29:14,720
Pues ya está, he definido

496
00:29:14,720 --> 00:29:17,440
Cómo se comparan estas dos personas

497
00:29:17,440 --> 00:29:19,859
Vamos a ver

498
00:29:19,859 --> 00:29:23,670
En principal

499
00:29:23,670 --> 00:29:25,769
Ahora tengo mis dos personas

500
00:29:25,769 --> 00:29:27,710
Que ahora son comparable

501
00:29:27,710 --> 00:29:29,910
Y por lo tanto sí que los puedo poner aquí

502
00:29:29,910 --> 00:29:32,230
En este caso me debería dar

503
00:29:32,230 --> 00:29:34,009
Antes Sara y luego Paco

504
00:29:34,009 --> 00:29:35,150
Y me da

505
00:29:35,150 --> 00:29:41,240
¿Por qué?

506
00:29:43,319 --> 00:29:46,480
Porque no he definido cómo se escriben las personas.

507
00:29:47,779 --> 00:29:52,259
Entonces, public string toString.

508
00:29:54,869 --> 00:30:01,650
Cuando quieres dar una representación en formato string de estos objetos, es el toString.

509
00:30:01,650 --> 00:30:15,039
Lo que haces es, por ejemplo, return this.nombre más una paréntesis,

510
00:30:15,039 --> 00:30:17,759
más this.edad

511
00:30:17,759 --> 00:30:19,920
más cierro paréntesis

512
00:30:19,920 --> 00:30:23,779
entonces la representación de un objeto persona

513
00:30:23,779 --> 00:30:26,019
será su nombre seguido de entre paréntesis

514
00:30:26,019 --> 00:30:27,019
su edad

515
00:30:27,019 --> 00:30:30,180
ahora cuando lo lanzo aquí

516
00:30:30,180 --> 00:30:33,640
veo que me lo ha ordenado como Sara

517
00:30:33,640 --> 00:30:36,079
que tiene 33 años y luego pago de 44

518
00:30:36,079 --> 00:30:37,920
si pago lo pongo

519
00:30:37,920 --> 00:30:39,039
de 14 años

520
00:30:39,039 --> 00:30:43,440
pago y Sara

521
00:30:43,440 --> 00:30:47,319
o sea que yo he definido

522
00:30:47,319 --> 00:30:51,980
Cómo se comparan entre ellos dos personas

523
00:30:51,980 --> 00:30:54,859
Y a partir de allí

524
00:30:54,859 --> 00:30:58,319
Él me los ordena correctamente

525
00:30:58,319 --> 00:31:01,079
¿Se entiende?

526
00:31:02,380 --> 00:31:04,119
Fijaos que yo me espero también

527
00:31:04,119 --> 00:31:05,700
Que este método de aquí

528
00:31:05,700 --> 00:31:06,839
Bueno, el método compare to

529
00:31:06,839 --> 00:31:09,859
Si por si acaso y aquí le pongo

530
00:31:09,859 --> 00:31:10,819
X

531
00:31:10,819 --> 00:31:12,599
Que es un entero

532
00:31:12,599 --> 00:31:15,400
Pues esto debería explotar con un

533
00:31:15,400 --> 00:31:19,819
ClassCastException

534
00:31:19,819 --> 00:31:22,660
perfecto, classCastException

535
00:31:22,660 --> 00:31:25,420
¿por qué? porque cuando llegará aquí

536
00:31:25,420 --> 00:31:27,740
e intenta hacer del integer

537
00:31:27,740 --> 00:31:30,480
una conversión a persona

538
00:31:30,480 --> 00:31:32,640
pues esto no es correcto

539
00:31:32,640 --> 00:31:34,799
y por lo tanto lanzará un classCastException

540
00:31:34,799 --> 00:31:36,680
me vale

541
00:31:36,680 --> 00:31:39,460
y por otro lado

542
00:31:39,460 --> 00:31:42,779
si yo aquí le paso un null

543
00:31:42,779 --> 00:31:49,690
me debería dar un null pointer exception

544
00:31:49,690 --> 00:31:55,609
¿Por qué? Porque cuando dentro de persona intentará hacer P.edad

545
00:31:55,609 --> 00:31:57,950
P es null

546
00:31:57,950 --> 00:32:02,569
Y por lo tanto null.edad me dará un null pointer exception

547
00:32:02,569 --> 00:32:04,849
¿Dudas hasta aquí?

548
00:32:07,319 --> 00:32:08,000
Vale, ahora

549
00:32:08,000 --> 00:32:10,339
Si os fijáis

550
00:32:10,339 --> 00:32:14,819
Esto compara dos personas

551
00:32:14,819 --> 00:32:18,279
Y me dice si es menor o igual o mayor de edad

552
00:32:18,279 --> 00:32:19,039
¿Sí?

553
00:32:19,500 --> 00:32:20,819
Pero no me dice cuánto

554
00:32:21,319 --> 00:32:30,930
O sea, independientemente de que uno sea de una edad y uno sea de otra, me dará menos uno. Uno o cero.

555
00:32:31,589 --> 00:32:37,289
Y funciona. Está definido. ¿Vale? Por cómo está definido compertú, me vale.

556
00:32:38,190 --> 00:32:51,890
Pero compertú podría ser más fino, hilar más fino, y decirme en este int cuánto es menor o cuánto es mayor con respecto al otro objeto.

557
00:32:53,210 --> 00:33:04,750
O sea, que en vez de devolverme menos 1, 0 y 1, me podría, si los dos están cerquita, devolverme menos 1, por ejemplo, pero si los dos son muy lejos, pues devolverme menos 100.

558
00:33:05,390 --> 00:33:07,710
Y si los dos son muy, muy lejos, menos 1000.

559
00:33:10,859 --> 00:33:32,250
Por ejemplo, aquí podría hacer dis.p menos, dis.edad, perdón, menos p.edad.

560
00:33:32,250 --> 00:33:40,700
porque si esto tiene 10 y esto tiene 20

561
00:33:40,700 --> 00:33:42,700
me dará un número negativo

562
00:33:42,700 --> 00:33:45,380
y es como tiene que ser

563
00:33:45,380 --> 00:33:47,440
si esto tiene 20 y esto tiene 10

564
00:33:47,440 --> 00:33:48,859
me dará un número positivo

565
00:33:48,859 --> 00:33:51,380
y si esto tiene la misma edad me dará 0

566
00:33:51,380 --> 00:33:53,920
perfecto

567
00:33:53,920 --> 00:33:56,140
¿si o no?

568
00:33:57,460 --> 00:33:58,079
por lo tanto

569
00:33:58,079 --> 00:33:59,660
esta podría ser una solución

570
00:33:59,660 --> 00:34:00,319
es más

571
00:34:00,319 --> 00:34:03,559
si esto tiene 10 años y esto tiene 40

572
00:34:03,559 --> 00:34:06,240
me dará menos 30

573
00:34:06,240 --> 00:34:08,219
y me está dando

574
00:34:08,219 --> 00:34:10,679
más distancia con respecto a

575
00:34:10,679 --> 00:34:12,460
si esto tiene 10 y esto tiene 12

576
00:34:12,460 --> 00:34:13,780
que me dará menos 2

577
00:34:13,780 --> 00:34:16,559
entonces el número que me da, no solo me dice

578
00:34:16,559 --> 00:34:18,400
positivo o negativo, que es lo que

579
00:34:18,400 --> 00:34:20,360
para que sirve Compertur

580
00:34:20,360 --> 00:34:22,039
sino que también lo puedo utilizar

581
00:34:22,039 --> 00:34:24,900
para saber cuánta distancia hay entre ellos

582
00:34:24,900 --> 00:34:26,739
que a lo mejor para otros

583
00:34:26,739 --> 00:34:28,460
otros trabajos

584
00:34:28,460 --> 00:34:29,460
pues puede venir bien

585
00:34:29,460 --> 00:34:32,199
¿sí? y fijaos que

586
00:34:32,199 --> 00:34:34,800
esta implementación, aparte que es más elegante

587
00:34:34,800 --> 00:34:36,019
que todo este iffeo

588
00:34:36,019 --> 00:34:39,519
pues sigue funcionándome

589
00:34:39,519 --> 00:34:46,239
sigue funcionando

590
00:34:46,239 --> 00:34:47,679
aquí

591
00:34:47,679 --> 00:34:54,840
si, fijaos el método es siempre

592
00:34:54,840 --> 00:34:56,800
el mismo, da igual

593
00:34:56,800 --> 00:34:58,920
que objetos le estoy pasando

594
00:34:58,920 --> 00:35:00,980
con que implementen

595
00:35:00,980 --> 00:35:02,880
comparable tendrán

596
00:35:02,880 --> 00:35:04,260
dentro el método compareTo

597
00:35:04,260 --> 00:35:06,760
por lo tanto independientemente

598
00:35:06,760 --> 00:35:08,760
de lo que sea comparable tendrá

599
00:35:08,760 --> 00:35:10,440
el compareTo y lo podré utilizar

600
00:35:10,440 --> 00:35:12,800
sobre estos objetos y por lo tanto

601
00:35:12,800 --> 00:35:14,380
podré definir

602
00:35:14,380 --> 00:35:16,960
este método y podré utilizar

603
00:35:16,960 --> 00:35:19,340
este método, ahora esto extendiéndolo

604
00:35:19,340 --> 00:35:21,219
en vez de escribir ordenados

605
00:35:21,219 --> 00:35:22,679
yo lo que podría hacer aquí es

606
00:35:22,679 --> 00:35:24,960
pillar un array

607
00:35:24,960 --> 00:35:26,460
de comparable

608
00:35:26,460 --> 00:35:28,280
y ordenarlo

609
00:35:28,280 --> 00:35:30,960
independientemente de lo que esté

610
00:35:30,960 --> 00:35:32,159
a lo que estoy ordenando

611
00:35:32,159 --> 00:35:33,559
vale

612
00:35:33,559 --> 00:35:35,820
si yo me voy

613
00:35:35,820 --> 00:35:39,289
a Arrays

614
00:35:39,289 --> 00:35:46,719
en Arrays, si no me equivoco

615
00:35:46,719 --> 00:35:52,840
estará

616
00:35:52,840 --> 00:35:54,059
este señor de aquí

617
00:35:54,059 --> 00:35:57,789
en sus varias funciones

618
00:35:57,789 --> 00:36:00,250
este de aquí es un array sort

619
00:36:00,250 --> 00:36:01,449
¿vale?

620
00:36:02,610 --> 00:36:04,090
por algún lado

621
00:36:04,090 --> 00:36:06,429
no, no, hay un sort

622
00:36:06,429 --> 00:36:08,110
de comparable, no

623
00:36:08,110 --> 00:36:11,380
hay un sort de object

624
00:36:11,380 --> 00:36:15,530
pero bueno, a ver como lo hace

625
00:36:15,530 --> 00:36:18,050
yo podría hacerme, pensaba de encontrarlo

626
00:36:18,050 --> 00:36:19,670
aquí, pero podría hacerme un

627
00:36:19,670 --> 00:36:21,250
ordena

628
00:36:21,250 --> 00:36:23,070
de objetos comparable

629
00:36:23,070 --> 00:36:26,130
y luego allí dentro ir comparándolo

630
00:36:26,130 --> 00:36:28,210
entre ellos y si están desordenados

631
00:36:28,210 --> 00:36:30,070
ordenarlos hasta que tenga

632
00:36:30,070 --> 00:36:32,349
un array ordenado y lo devuelva

633
00:36:32,349 --> 00:36:34,269
¿vale? y esto es un ejercicio parecido

634
00:36:34,269 --> 00:36:36,630
a lo que hacíamos en octubre

635
00:36:36,630 --> 00:36:38,409
de dado un array desordenado

636
00:36:38,409 --> 00:36:40,190
ordenalos, solo que en vez

637
00:36:40,190 --> 00:36:42,130
de ordenarlos según los

638
00:36:42,130 --> 00:36:44,150
números, lo ordeno según lo que me

639
00:36:44,150 --> 00:36:45,269
dice el

640
00:36:45,269 --> 00:36:47,869
el Compertú

641
00:36:47,869 --> 00:36:49,550
¿sí?

642
00:36:49,969 --> 00:36:51,570
o sea que esto lo podéis hacer

643
00:36:51,570 --> 00:36:54,210
¿sí?

644
00:36:55,489 --> 00:36:57,530
y más cosas que yo

645
00:36:57,530 --> 00:36:59,130
quería hacer con esto

646
00:36:59,130 --> 00:37:14,019
vale, entonces

647
00:37:14,019 --> 00:37:19,460
Si todo esto está bien, ahora yo puedo hacer lo siguiente, ¿vale?

648
00:37:19,880 --> 00:37:37,079
Yo podría hacer siso persona.perts1.compareto.perts2, ¿sí?

649
00:37:37,079 --> 00:37:44,860
Y también puedo hacer siso persona.equals.perts2.

650
00:37:46,420 --> 00:37:52,599
¿Sí? Entonces, si eso es que persona 1 y persona 2 son distintos, ¡voilá!

651
00:37:54,119 --> 00:37:58,619
Me está diciendo que hay una diferencia de edad de 19 años y que no son lo mismo.

652
00:37:59,980 --> 00:38:00,420
¡Fenomenal!

653
00:38:01,280 --> 00:38:13,980
Pero cuidado. Y si yo le digo que los dos tienen 14 años, con pertú me dicen que son iguales.

654
00:38:14,980 --> 00:38:17,380
Sin embargo, ¿eh? ¿Cuál se me dice que son distintos?

655
00:38:17,380 --> 00:38:38,380
Y esto no puede ser. Es mi responsabilidad cuando implemento la clase Persona, que implementa Comparable, y entonces hago esta cosa de aquí, yo tengo que estar seguro que ahora cuando me da cero, los dos son iguales.

656
00:38:38,380 --> 00:39:00,369
¿Se entiende? Pues ¿cómo hago eso? Tendré que redefinir equals porque según mi concepto de comparación, para mí dos personas son iguales cuando dos personas son mayores o menores según la edad.

657
00:39:00,369 --> 00:39:17,789
Entonces, tendré que definir de alguna forma que cuando estas dos personas, mejor, cuando estas dos personas sean iguales, no puedan ser distintos esta cosa aquí, el compertú.

658
00:39:17,789 --> 00:39:34,429
O sea que aquí hay que razonarlo un poquito mejor. Porque esto me podría valer asumiendo que mi concepto de equals, de igualdad, tenga en consideración también el nombre.

659
00:39:34,429 --> 00:39:42,869
O sea, estos señores no son la misma persona, porque uno es sara y uno es pajo, tienen la misma edad.

660
00:39:43,170 --> 00:39:48,929
Entonces, si los comparo son iguales, pero es justo que no sean la misma persona.

661
00:39:49,969 --> 00:39:53,110
A menos que para mí dos personas de la misma edad sean la misma persona.

662
00:39:53,590 --> 00:40:03,019
Pero si yo ahora hago esto, y yo considero que estos dos sean la misma persona, deberían ser equivalentes,

663
00:40:04,039 --> 00:40:06,900
pues entonces esto ahora me debería dar true.

664
00:40:07,880 --> 00:40:25,659
No sé si me explico lo que quiero decir, ¿vale? O sea, que yo cuando toco el compare to, tengo que pensar también a cómo identifico el equals. Las dos cosas van juntas y tienen que ser consistentes, ¿vale?

665
00:40:25,659 --> 00:40:45,360
Si para mí dos personas son iguales cuando tienen nombre y edad iguales, que es una definición de igualdad un poco blanda, porque nosotros sabemos que dos personas se pueden llamar Sara y dos personas pueden tener 14 años, pero por cómo lo estoy haciendo yo, dos objetos Sara 14 deberían ser el mismo.

666
00:40:45,360 --> 00:40:55,380
Si yo quiero poderlo separar, a lo mejor le pongo un identificador, a lo mejor le pongo el DNI, entonces sí que sé cuándo son iguales, cuándo no, ¿vale?

667
00:40:55,659 --> 00:41:12,420
Pero COMPARE TO e EQUALS deberían estar consistentes entre ellos, sobre todo si dos personas son la misma persona, el resultado de COMPARE TO tiene que ser cero, sí o sí.

668
00:41:12,420 --> 00:41:21,460
Y que si compareTo da un valor que no es cero, pues probablemente los objetos no deberían ser el mismo objeto.

669
00:41:25,110 --> 00:41:27,030
Estas dos cosas hay que comprobar.

670
00:41:28,130 --> 00:41:34,929
Entonces, en este caso aquí, pues debería yo pensar también en cuando hago, como norma general,

671
00:41:35,090 --> 00:41:39,809
cuando hago la implementación de comparable o entonces compareTo,

672
00:41:39,809 --> 00:41:42,730
pues va en pareja también sobre escribir el equals

673
00:41:42,730 --> 00:41:46,030
para que sean consistentes los resultados de comparable

674
00:41:46,030 --> 00:41:48,769
y de equals, y esto por algún lado dice

675
00:41:48,769 --> 00:41:55,070
esto, yo creo que aquí no

676
00:41:55,070 --> 00:42:08,960
mira

677
00:42:08,960 --> 00:42:15,119
he recomendado muchísimo

678
00:42:15,119 --> 00:42:18,300
pero no requerido

679
00:42:18,300 --> 00:42:21,019
estrictamente, que si

680
00:42:21,019 --> 00:42:23,840
x convertido de y da 0

681
00:42:23,840 --> 00:42:25,639
entonces

682
00:42:25,639 --> 00:42:28,460
x.equals de y

683
00:42:28,460 --> 00:42:30,739
te de true

684
00:42:30,739 --> 00:42:31,539
constantemente

685
00:42:31,539 --> 00:42:35,869
luego

686
00:42:35,869 --> 00:42:37,889
habrá casos en que tú dices

687
00:42:37,889 --> 00:42:39,869
no, no puede ser y quiero que no

688
00:42:39,869 --> 00:42:41,530
pero por lo general

689
00:42:41,530 --> 00:42:43,570
esto debería ser una cosa que funcione