1
00:00:00,000 --> 00:00:22,559
Bueno, pues venga. Este ejercicio 2, que podría ser también un ejercicio de examen. ¿Quién nos dice a vosotros que el examen próximo no son 3 horas y media? Por ejemplo, porque entonces lo que buscamos en este examen es evaluar otras destrezas. ¿Quién sabe?

2
00:00:22,559 --> 00:00:25,739
bueno pues en un ejercicio como este

3
00:00:25,739 --> 00:00:27,559
aquí ya rápidamente vemos

4
00:00:27,559 --> 00:00:29,539
como primer vistazo que hay clientes

5
00:00:29,539 --> 00:00:31,179
que hay pedidos, que hay rollos, bueno lo de siempre

6
00:00:31,179 --> 00:00:33,340
entonces ahora

7
00:00:33,340 --> 00:00:34,979
antes de hacer cualquier cosa

8
00:00:34,979 --> 00:00:37,460
tenemos que pensar en que

9
00:00:37,460 --> 00:00:39,840
modelo de entidades reproduce la situación

10
00:00:39,840 --> 00:00:41,719
aquí

11
00:00:41,719 --> 00:00:43,240
lógicamente vamos a hacer

12
00:00:43,240 --> 00:00:45,299
un modelo un poquito pintado por encima

13
00:00:45,299 --> 00:00:47,179
como se nos ocurra pero siempre había

14
00:00:47,179 --> 00:00:49,259
siempre habría la mejor manera de hacerlo

15
00:00:49,259 --> 00:00:51,700
y para eso

16
00:00:51,700 --> 00:00:53,359
tendríamos que entender primero

17
00:00:53,359 --> 00:00:54,700
de principio a fin

18
00:00:54,700 --> 00:00:57,619
cuáles son las funcionalidades que quiere el cliente

19
00:00:57,619 --> 00:00:58,719
para ir apuntando

20
00:00:58,719 --> 00:01:01,179
qué propiedades son importantes

21
00:01:01,179 --> 00:01:02,479
de qué propiedades vamos a tirar

22
00:01:02,479 --> 00:01:05,239
para en función de eso, qué entidad meter dentro de la otra

23
00:01:05,239 --> 00:01:06,019
etcétera

24
00:01:06,019 --> 00:01:08,760
bueno, en este caso, ¿qué tenemos?

25
00:01:09,180 --> 00:01:10,819
tenemos gestión de pedidos

26
00:01:10,819 --> 00:01:13,420
ya automáticamente vemos que una entidad de pedidos va a tener que haber

27
00:01:13,420 --> 00:01:13,980
casi seguro

28
00:01:13,980 --> 00:01:16,959
porque de hecho los pedidos tienen varias cosas dentro

29
00:01:16,959 --> 00:01:19,519
código, nombre de cliente

30
00:01:19,519 --> 00:01:20,980
y lista de productos

31
00:01:20,980 --> 00:01:24,340
cada producto a su vez tiene nombre y precio

32
00:01:24,340 --> 00:01:26,280
con lo cual una entidad producto tiene que haber

33
00:01:26,280 --> 00:01:29,540
¿del cliente qué importa?

34
00:01:30,480 --> 00:01:32,980
del cliente parece que solo importa el nombre

35
00:01:32,980 --> 00:01:35,519
porque aquí solo hablan

36
00:01:35,519 --> 00:01:38,599
de que los pedidos tendrán un nombre de cliente

37
00:01:38,599 --> 00:01:41,439
y el resto de funcionalidades son

38
00:01:41,439 --> 00:01:44,060
dado un cliente, un nombre de cliente

39
00:01:44,060 --> 00:01:45,500
los pedidos que ha hecho

40
00:01:45,500 --> 00:01:50,299
no hay ninguna funcionalidad que trabaje con nada del cliente

41
00:01:50,299 --> 00:01:51,260
que no sea su nombre

42
00:01:51,260 --> 00:01:53,959
por supuesto

43
00:01:53,959 --> 00:01:56,099
es un diseño horrible

44
00:01:56,099 --> 00:01:57,819
y el cliente que te pide esto

45
00:01:57,819 --> 00:01:59,079
tú le dirías, mire

46
00:01:59,079 --> 00:02:01,219
claro

47
00:02:01,219 --> 00:02:03,799
tú efectivamente como eres

48
00:02:03,799 --> 00:02:06,000
un buen trabajador le dirías

49
00:02:06,000 --> 00:02:07,379
al cliente tuyo

50
00:02:07,379 --> 00:02:10,099
oiga usted, vamos a replantear

51
00:02:10,099 --> 00:02:12,139
esto, mejor si trabajamos

52
00:02:12,139 --> 00:02:13,599
con DNIs de clientes

53
00:02:13,599 --> 00:02:16,219
o con clientes con más datos

54
00:02:16,219 --> 00:02:18,120
con una agenda de clientes que tenga

55
00:02:18,120 --> 00:02:20,120
su nombre, su DNI por si necesita

56
00:02:20,120 --> 00:02:22,180
usted en un futuro cambiar

57
00:02:22,180 --> 00:02:24,120
a lo mejor alguna de las características

58
00:02:24,120 --> 00:02:25,840
del cliente, ampliar su aplicación

59
00:02:25,840 --> 00:02:27,020
efectivamente

60
00:02:27,020 --> 00:02:30,319
sería el momento de que dejemos de plantearse

61
00:02:30,319 --> 00:02:30,780
las cosas

62
00:02:30,780 --> 00:02:33,460
claro, pero bueno

63
00:02:33,460 --> 00:02:36,360
vamos a hacerla así porque esto es un examen

64
00:02:36,360 --> 00:02:38,080
y tampoco vamos a complicarla

65
00:02:38,080 --> 00:02:39,860
pues ya está

66
00:02:39,860 --> 00:02:42,060
dos clases, pedido y

67
00:02:42,060 --> 00:02:44,560
producto, nos hemos ahorrado la clase cliente

68
00:02:44,560 --> 00:02:46,520
que es una mierda ahorrarse la clase cliente

69
00:02:46,520 --> 00:02:47,939
efectivamente, pero nos la vamos a ahorrar

70
00:02:47,939 --> 00:02:48,919
el cliente es un hombre

71
00:02:48,919 --> 00:02:50,680
bueno

72
00:02:50,680 --> 00:02:53,379
pues entonces

73
00:02:53,379 --> 00:02:54,740
¿cómo vais a hacer

74
00:02:54,740 --> 00:02:56,500
esta aplicación entonces?

75
00:02:56,620 --> 00:02:57,680
¿cómo la vais a completar?

76
00:02:57,879 --> 00:02:59,840
claro, de aquí al jueves

77
00:02:59,840 --> 00:03:02,919
pues venga, ejercicio, pedidos

78
00:03:02,919 --> 00:03:10,680
como ya está dentro de un paquete

79
00:03:10,680 --> 00:03:12,139
porque lo he metido en un único proyecto

80
00:03:12,139 --> 00:03:14,240
para su obra virtual, no puedo hacer paquetes

81
00:03:14,240 --> 00:03:16,080
diferentes para modelo, vista

82
00:03:16,080 --> 00:03:18,379
que pena, lo voy a poner todo junto

83
00:03:18,379 --> 00:03:18,900
pero bueno

84
00:03:18,900 --> 00:03:22,479
pues la clase producto, parece la clase más interna

85
00:03:22,500 --> 00:03:41,139
Pues venga, la clase producto, ¿por qué se caracteriza el producto? Pues el producto se caracteriza por nombre y precio.

86
00:03:41,139 --> 00:03:51,139
Aquí también sería el momento de sentarse con el cliente y decirle, a ver, oiga usted, ¿realmente el producto lo quiere caracterizar por su nombre?

87
00:03:51,139 --> 00:03:53,360
y si tiene dos productos que se llaman igual

88
00:03:53,360 --> 00:03:54,939
sería el momento de sentarse con él

89
00:03:54,939 --> 00:03:57,479
pero vamos a dejarle que nos ha pedido esto

90
00:03:57,479 --> 00:03:59,039
pues le hacemos esto

91
00:03:59,039 --> 00:04:10,439
venga, ya está

92
00:04:10,439 --> 00:04:14,710
get y set

93
00:04:14,710 --> 00:04:18,250
hala

94
00:04:18,250 --> 00:04:21,029
silencio

95
00:04:21,029 --> 00:04:23,959
venga

96
00:04:23,959 --> 00:04:26,879
producto

97
00:04:26,879 --> 00:04:29,279
nombre, precio, get y set

98
00:04:29,279 --> 00:04:31,399
si luego me van haciendo falta

99
00:04:31,399 --> 00:04:33,220
constructores, toString,

100
00:04:33,519 --> 00:04:35,060
equals, ya lo voy volviendo después.

101
00:04:36,959 --> 00:04:39,060
Y pedido.

102
00:04:50,810 --> 00:04:52,490
¿Qué va a tener el pedido?

103
00:04:53,250 --> 00:04:54,769
Pues el pedido tiene

104
00:04:54,769 --> 00:04:58,500
el código

105
00:05:08,670 --> 00:05:12,829
el nombre de cliente

106
00:05:12,829 --> 00:05:20,240
vale, aquí realmente

107
00:05:20,240 --> 00:05:22,339
el siguiente paso

108
00:05:22,339 --> 00:05:23,920
de esta aplicación efectivamente

109
00:05:23,920 --> 00:05:26,360
sería quitar este string

110
00:05:26,360 --> 00:05:27,980
y poner esto

111
00:05:27,980 --> 00:05:29,000
sería el siguiente paso

112
00:05:29,000 --> 00:05:31,079
pero bueno, vamos a hacer la versión sencilla

113
00:05:31,079 --> 00:05:33,740
sobre todo queremos ahora trabajar con serializar objetos

114
00:05:33,740 --> 00:05:35,000
y

115
00:05:35,000 --> 00:05:37,839
recordar un poco de colecciones

116
00:05:37,839 --> 00:05:38,620
y ya está

117
00:05:38,620 --> 00:05:41,639
Ah, y la lista de productos

118
00:05:41,639 --> 00:05:43,819
Lista de productos

119
00:05:43,819 --> 00:05:47,199
Vamos a poner una lista

120
00:05:47,199 --> 00:05:48,339
En lugar de una line, ¿te parece?

121
00:05:51,399 --> 00:05:52,779
Ya, eso lo decís todos

122
00:05:52,779 --> 00:05:53,939
Venga

123
00:05:53,939 --> 00:05:57,000
Una lista de productos

124
00:05:57,000 --> 00:06:02,649
Eso no es un reto

125
00:06:02,649 --> 00:06:03,569
Para tu inteligencia, ¿verdad?

126
00:06:03,949 --> 00:06:04,730
Usar listas

127
00:06:04,730 --> 00:06:08,889
New

128
00:06:08,889 --> 00:06:12,649
linked list

129
00:06:12,649 --> 00:06:16,649
ya está

130
00:06:16,649 --> 00:06:22,649
fíjate

131
00:06:22,649 --> 00:06:24,970
vale, es el momento

132
00:06:24,970 --> 00:06:26,329
bueno, hacemos los get y set

133
00:06:26,329 --> 00:06:33,029
pero realmente vas a poner a hacer esto en un blog de notas

134
00:06:33,029 --> 00:06:33,889
alguna vez

135
00:06:33,889 --> 00:06:35,970
Dios no lo quiera

136
00:06:35,970 --> 00:06:40,910
venga, entonces aquí ya sí que es el momento

137
00:06:40,910 --> 00:06:42,829
de pararse a pensar, es decir

138
00:06:42,829 --> 00:06:45,189
cuidado que voy a trabajar con una lista de productos

139
00:06:45,189 --> 00:06:46,670
es muy probable

140
00:06:46,670 --> 00:06:48,050
que quiera yo comprobar

141
00:06:48,050 --> 00:06:51,310
si está el producto en la lista

142
00:06:51,310 --> 00:06:53,250
etcétera, entonces me interesa

143
00:06:53,250 --> 00:06:54,230
ahora ya sí que sí

144
00:06:54,230 --> 00:06:57,149
definir un criterio de igualdad

145
00:06:57,149 --> 00:06:58,290
entre productos

146
00:06:58,290 --> 00:07:00,870
le tendría que preguntar al señor

147
00:07:00,870 --> 00:07:02,709
hay poco que elegir

148
00:07:02,709 --> 00:07:04,829
en este caso está claro que el criterio de igualdad

149
00:07:04,829 --> 00:07:06,250
en productos va a ser el nombre

150
00:07:06,250 --> 00:07:08,569
bueno, pues entonces

151
00:07:08,569 --> 00:07:10,649
aquí ha llegado el momento de poner un

152
00:07:10,649 --> 00:07:11,550
equals

153
00:07:11,550 --> 00:07:14,110
por el nombre

154
00:07:14,110 --> 00:07:16,949
me deja el jascón

155
00:07:16,949 --> 00:07:18,610
bueno, no pasa nada, lo podríamos dejar

156
00:07:18,610 --> 00:07:20,589
porque es el momento dado, usamos un conjunto

157
00:07:20,589 --> 00:07:23,410
vamos a dejarlo

158
00:07:23,410 --> 00:07:24,529
y se acabó

159
00:07:24,529 --> 00:07:26,790
de hecho

160
00:07:26,790 --> 00:07:28,689
aquí podríamos nosotros

161
00:07:28,689 --> 00:07:29,689
ya como programadores

162
00:07:29,689 --> 00:07:32,529
decir, a ver, no sería, teniendo en cuenta

163
00:07:32,529 --> 00:07:34,009
que un conjunto es más eficiente

164
00:07:34,009 --> 00:07:35,629
computacionalmente

165
00:07:35,629 --> 00:07:38,389
¿realmente es necesario que yo use una lista?

166
00:07:39,170 --> 00:07:40,069
¿voy a necesitar

167
00:07:40,069 --> 00:07:41,069
duplicados?

168
00:07:42,329 --> 00:07:44,129
es decir, un pedido

169
00:07:44,129 --> 00:07:45,769
puede tener

170
00:07:45,769 --> 00:07:47,649
el mismo producto

171
00:07:47,649 --> 00:07:49,410
con el mismo nombre

172
00:07:49,410 --> 00:07:51,889
en diferentes precios

173
00:07:51,889 --> 00:07:53,490
si es así

174
00:07:53,490 --> 00:07:55,389
es que esta aplicación está mal planteada

175
00:07:55,389 --> 00:07:57,569
sería casi mejor cambiar la clase producto

176
00:07:57,569 --> 00:07:58,629
cambiar la clase todo

177
00:07:58,629 --> 00:08:01,209
entonces si hemos puesto

178
00:08:01,209 --> 00:08:03,629
que el producto se caracteriza solo por nombre y precio

179
00:08:03,629 --> 00:08:05,050
será seguramente

180
00:08:05,050 --> 00:08:07,149
porque mi aplicación no admite

181
00:08:07,149 --> 00:08:07,689
que

182
00:08:07,689 --> 00:08:11,569
a ver, podría tener sentido

183
00:08:11,569 --> 00:08:13,529
que si hubiera una tercera

184
00:08:13,529 --> 00:08:14,410
propiedad fecha

185
00:08:14,410 --> 00:08:17,509
que un cliente tuviera

186
00:08:17,509 --> 00:08:18,910
diferentes productos

187
00:08:18,910 --> 00:08:21,069
pero en diferente fecha

188
00:08:21,069 --> 00:08:23,589
a lo mejor, entonces en su lista puede tener el mismo nombre

189
00:08:23,589 --> 00:08:25,129
de producto en diferente fecha

190
00:08:25,129 --> 00:08:27,410
pero el equal no querría seguir

191
00:08:27,410 --> 00:08:28,269
teniendo por nombre

192
00:08:28,269 --> 00:08:32,549
hay las fechas

193
00:08:32,549 --> 00:08:34,809
bueno, entonces

194
00:08:34,809 --> 00:08:36,870
cada situación realmente

195
00:08:36,870 --> 00:08:40,230
cada situación es muy distinta

196
00:08:40,230 --> 00:08:41,990
entonces es importante

197
00:08:41,990 --> 00:08:43,590
no conocer solamente

198
00:08:43,590 --> 00:08:45,409
cómo se programa y se tira código

199
00:08:45,409 --> 00:08:47,830
sino saber entender exactamente

200
00:08:47,830 --> 00:08:48,809
qué necesito

201
00:08:48,809 --> 00:08:52,149
entonces, silencio

202
00:08:52,149 --> 00:08:53,470
repito

203
00:08:53,470 --> 00:08:54,929
imagina esta situación

204
00:08:54,929 --> 00:08:56,850
yo le voy a

205
00:08:56,850 --> 00:08:59,769
le preguntáis al que os ha pedido la aplicación

206
00:08:59,769 --> 00:09:01,429
¿le vas a permitir

207
00:09:01,429 --> 00:09:03,649
al señor, al cliente

208
00:09:03,649 --> 00:09:05,429
que te compre la misma cosa

209
00:09:05,429 --> 00:09:07,549
en diferentes fechas, si él te

210
00:09:07,549 --> 00:09:09,110
dice sí

211
00:09:09,110 --> 00:09:11,529
pues entonces tú meterías

212
00:09:11,529 --> 00:09:12,750
aquí una propiedad fecha

213
00:09:12,750 --> 00:09:15,490
ahora ya te entra, un segundo, te entra

214
00:09:15,490 --> 00:09:17,009
una duda, que es

215
00:09:17,009 --> 00:09:19,470
mi equals seguiría siendo

216
00:09:19,470 --> 00:09:21,669
por nombre o pondría por nombre y fecha

217
00:09:21,669 --> 00:09:23,190
depende

218
00:09:23,190 --> 00:09:25,309
vamos a ver las funcionalidades de la aplicación

219
00:09:25,309 --> 00:09:26,870
¿hay alguna funcionalidad que sea

220
00:09:26,870 --> 00:09:29,309
mira a ver

221
00:09:29,309 --> 00:09:31,309
qué clientes han pedido el producto

222
00:09:31,309 --> 00:09:33,330
boli, porque si la hay

223
00:09:33,330 --> 00:09:35,269
me interesa que el equals sea solo

224
00:09:35,269 --> 00:09:37,549
por nombre, con lo cual

225
00:09:37,549 --> 00:09:39,269
si el equals es solo por

226
00:09:39,269 --> 00:09:41,509
nombre, pero voy a permitir

227
00:09:41,509 --> 00:09:43,450
que en una misma lista

228
00:09:43,450 --> 00:09:45,529
de pedidos haya el mismo producto

229
00:09:45,529 --> 00:09:47,090
con el mismo nombre en diferentes fechas

230
00:09:47,090 --> 00:09:49,169
ahora ya sí que tengo que usar

231
00:09:49,169 --> 00:09:51,269
obligatoriamente una lista, ya

232
00:09:51,269 --> 00:09:52,649
sí que no podría usar un set

233
00:09:52,649 --> 00:09:55,029
entonces todas estas consideraciones

234
00:09:55,029 --> 00:09:57,350
son las que, con las que tienes

235
00:09:57,350 --> 00:09:58,909
que estar familiarizado y tener claras

236
00:09:58,909 --> 00:10:01,230
vale, ahora te entra a ti un dilema que eso

237
00:10:01,230 --> 00:10:02,169
no me gusta nada

238
00:10:02,169 --> 00:10:04,230
porque vas a poner un aprieto

239
00:10:04,230 --> 00:10:06,409
de hecho estoy por no grabar el dilema

240
00:10:06,409 --> 00:10:08,710
no porque vas a poner apuros

241
00:10:08,710 --> 00:10:10,230
pues venga, no grabamos el dilema

242
00:10:10,230 --> 00:10:11,330
pues seguimos

243
00:10:11,330 --> 00:10:16,070
entonces en nuestro caso

244
00:10:16,070 --> 00:10:17,590
hemos dicho, mira

245
00:10:17,590 --> 00:10:20,570
el cliente me ha dicho que no va a permitir

246
00:10:20,570 --> 00:10:22,610
al usuario hacer

247
00:10:22,610 --> 00:10:25,029
en la misma lista de pedidos

248
00:10:25,029 --> 00:10:26,570
el mismo pedido

249
00:10:26,570 --> 00:10:27,429
varias veces

250
00:10:27,429 --> 00:10:29,850
con lo cual el campo fecha

251
00:10:29,850 --> 00:10:31,210
Aquí no tiene sentido ni nada.

252
00:10:31,789 --> 00:10:33,110
Luego, ¿para qué voy a usar un list?

253
00:10:33,389 --> 00:10:35,269
Si no voy a necesitar duplicados,

254
00:10:35,629 --> 00:10:36,909
no voy a necesitar duplicados,

255
00:10:37,570 --> 00:10:40,429
es decir, dos productos iguales según el criterio de igualdad,

256
00:10:40,490 --> 00:10:42,269
no me van a hacer falta, que coexistan.

257
00:10:43,070 --> 00:10:44,250
¿Para qué usar un list?

258
00:10:44,669 --> 00:10:47,590
Que es mucho más computacionalmente, más complejo,

259
00:10:47,590 --> 00:10:50,250
porque tiene que llevar internamente el registro de las posiciones.

260
00:10:50,909 --> 00:10:52,450
Pues hombre, un set y ya está.

261
00:10:53,509 --> 00:10:54,350
Vale, pues un set.

262
00:10:55,629 --> 00:10:55,850
¿Vale?

263
00:10:56,909 --> 00:10:58,789
Pero insisto, un set, ¿por qué?

264
00:10:58,789 --> 00:11:04,909
Porque la igualdad de producto es solo por nombre y no vamos a admitir productos con el mismo nombre.

265
00:11:06,169 --> 00:11:07,789
¿Qué versión de set instanciamos?

266
00:11:08,929 --> 00:11:11,509
Pues el hash set siempre sería la más cómoda.

267
00:11:12,330 --> 00:11:23,629
El triset también es muy rápida y el triset lo que nos permite es que alguna vez vamos a sacar productos ordenados por el criterio de igualdad,

268
00:11:23,710 --> 00:11:24,590
que en este caso es el nombre.

269
00:11:24,669 --> 00:11:28,149
¿Va a haber algún listado alfabético de productos?

270
00:11:28,789 --> 00:11:36,669
Pues si lo va a ver, me viene genial el triset, porque es que el triset ya por naturaleza te inserta las cosas en el orden del criterio de igualdad.

271
00:11:37,889 --> 00:11:43,269
Entonces, venga, como no suele gustar el triset, vamos a poner el triset, ¿vale?

272
00:11:43,350 --> 00:11:52,029
Y así cuando yo liste los productos del cliente, me los va a listar en orden alfabético, sin tener yo que hacer nada, porque ya el triset trabaja así.

273
00:11:52,029 --> 00:11:54,529
vale, pero si uso

274
00:11:54,529 --> 00:11:55,830
un set y un triset

275
00:11:55,830 --> 00:11:57,870
efectivamente

276
00:11:57,870 --> 00:12:00,629
si uso un triset

277
00:12:00,629 --> 00:12:02,789
ese jasco de equals

278
00:12:02,789 --> 00:12:04,889
que tenía, no lo va a necesitar

279
00:12:04,889 --> 00:12:05,909
tampoco molesta

280
00:12:05,909 --> 00:12:08,090
pero el comparable

281
00:12:08,090 --> 00:12:09,710
si va a hacer falta

282
00:12:09,710 --> 00:12:12,809
ahora me viene la siguiente duda

283
00:12:12,809 --> 00:12:14,789
a lo mejor producto

284
00:12:14,789 --> 00:12:15,769
yo no tengo

285
00:12:15,769 --> 00:12:17,970
la posibilidad de tocarla

286
00:12:17,970 --> 00:12:20,669
porque producto no lo he hecho yo, es una clase

287
00:12:20,669 --> 00:12:22,690
a la que yo no tengo permisos para editar

288
00:12:22,690 --> 00:12:24,210
he importado el jar y puedo

289
00:12:24,210 --> 00:12:26,529
instanciar objetos producto y todo eso

290
00:12:26,529 --> 00:12:29,250
puedo instanciarlos, pero no puedo editar el código fuente

291
00:12:29,250 --> 00:12:32,269
si yo no puedo editar el código fuente

292
00:12:32,269 --> 00:12:34,909
no puedo entonces

293
00:12:34,909 --> 00:12:35,769
usar un triset

294
00:12:35,769 --> 00:12:40,830
si puedo

295
00:12:40,830 --> 00:12:42,250
porque había un plan C

296
00:12:42,250 --> 00:12:44,429
¿alguien se acuerda?

297
00:12:46,330 --> 00:12:48,370
el terminator, comparator

298
00:12:48,370 --> 00:12:51,610
hacer un criterio de igualdad

299
00:12:51,610 --> 00:12:53,629
específico para la aplicación

300
00:12:53,629 --> 00:12:55,230
aparte y dárselo al triset

301
00:12:55,230 --> 00:12:57,309
decirle, oye triset, como el criterio

302
00:12:57,309 --> 00:12:59,250
de igualdad no lo vas a sacar de producto

303
00:12:59,250 --> 00:13:00,649
porque no te lo puedo poner ahí

304
00:13:00,649 --> 00:13:03,149
te voy a hacer yo uno aparte

305
00:13:03,149 --> 00:13:04,690
y te lo paso aquí por constructor

306
00:13:04,690 --> 00:13:05,669
¿vale?

307
00:13:06,809 --> 00:13:07,789
vamos a hacerlo así

308
00:13:07,789 --> 00:13:11,450
vamos a pensar que en producto yo no puedo implementar

309
00:13:11,450 --> 00:13:13,330
comparable, si pudiera está

310
00:13:13,330 --> 00:13:15,009
claro, implement comparable

311
00:13:15,009 --> 00:13:16,870
y ahora hacemos aquí

312
00:13:16,870 --> 00:13:18,610
vamos a ponerlo aunque luego lo comentemos

313
00:13:18,610 --> 00:13:20,929
implements

314
00:13:20,929 --> 00:13:22,049
comparable

315
00:13:22,049 --> 00:13:24,330
de producto

316
00:13:24,330 --> 00:13:27,129
todo esto si que recupera

317
00:13:27,129 --> 00:13:27,830
colecciones

318
00:13:27,830 --> 00:13:30,450
también llamada RA6

319
00:13:30,450 --> 00:13:34,909
si implementamos comparable

320
00:13:34,909 --> 00:13:36,929
tenemos que implementar

321
00:13:36,929 --> 00:13:38,929
este método, ahora este método

322
00:13:38,929 --> 00:13:41,169
es que tengo que apañarmelas yo para que me devuelva

323
00:13:41,169 --> 00:13:42,850
positivo si el objeto que llama

324
00:13:42,850 --> 00:13:44,909
el método va antes, cero

325
00:13:44,909 --> 00:13:47,529
bueno, pues nos tenemos que preguntar

326
00:13:47,529 --> 00:13:49,830
¿cuál va a ser mi propiedad

327
00:13:49,830 --> 00:13:51,289
para comparar uno con otro?

328
00:13:51,769 --> 00:13:52,450
el nombre

329
00:13:52,450 --> 00:13:54,389
el nombre es un string

330
00:13:54,389 --> 00:13:57,090
el string, la clase string

331
00:13:57,090 --> 00:13:58,789
ya tiene un método compareTo

332
00:13:58,789 --> 00:14:00,970
que me permite comparar un string con otro

333
00:14:00,970 --> 00:14:03,330
pues directamente lo usamos

334
00:14:03,330 --> 00:14:04,009
return

335
00:14:04,009 --> 00:14:07,110
dis.nombre

336
00:14:07,110 --> 00:14:09,250
que es la propiedad nombre del que llama el método

337
00:14:09,250 --> 00:14:10,889
compareTo

338
00:14:10,889 --> 00:14:12,570
o.nombre

339
00:14:12,570 --> 00:14:14,429
o es este tan feo de aquí

340
00:14:14,429 --> 00:14:18,370
ala, ya tengo el

341
00:14:18,370 --> 00:14:20,370
si el que llama

342
00:14:20,370 --> 00:14:22,090
al método está antes

343
00:14:22,090 --> 00:14:24,029
alfabéticamente me devolverá positivo

344
00:14:24,029 --> 00:14:26,190
si el que llama al método es

345
00:14:26,190 --> 00:14:28,490
el mismo nombre que el que le paso

346
00:14:28,490 --> 00:14:30,470
me devolverá cero, y si el que llama al método

347
00:14:30,470 --> 00:14:32,210
es alfabéticamente

348
00:14:32,210 --> 00:14:34,029
posterior al parámetro

349
00:14:34,029 --> 00:14:36,289
me devolverá negativo, justo lo que yo quería

350
00:14:36,289 --> 00:14:38,549
porque el compare to the string funciona así

351
00:14:38,549 --> 00:14:40,649
vale, pero resulta que yo no puedo

352
00:14:40,649 --> 00:14:42,210
trabajar con producto

353
00:14:42,210 --> 00:14:45,309
esto que yo he hecho, que ahora dejo aquí comentado

354
00:14:45,309 --> 00:14:47,289
no puedo hacerlo

355
00:14:47,289 --> 00:14:51,149
que pena, más grande

356
00:14:51,149 --> 00:14:58,769
esto no lo puedo hacer

357
00:14:58,769 --> 00:15:02,059
tengo que renunciar

358
00:15:02,059 --> 00:15:04,059
al triset, no, no tengo que renunciar

359
00:15:04,059 --> 00:15:06,019
al triset, vamos a hacer un criterio de comparación

360
00:15:06,019 --> 00:15:08,039
aparte, los criterios

361
00:15:08,039 --> 00:15:08,820
de comparación

362
00:15:08,820 --> 00:15:12,080
son implementaciones de la interfaz

363
00:15:12,080 --> 00:15:13,279
comparator

364
00:15:13,279 --> 00:15:16,080
pues vamos a hacer un criterio de comparación

365
00:15:16,080 --> 00:15:16,500
aquí

366
00:15:16,500 --> 00:15:23,190
compara nombres

367
00:15:23,190 --> 00:15:23,929
por ejemplo

368
00:15:23,929 --> 00:15:27,690
este es un criterio de comparación

369
00:15:27,690 --> 00:15:29,009
¿no puedes crear la

370
00:15:29,009 --> 00:15:29,649
conglomeración interna?

371
00:15:30,370 --> 00:15:33,450
sí, podría, pero no lo voy a hacer

372
00:15:33,450 --> 00:15:35,309
para no liar, pero sí, si solo lo voy a usar ahí

373
00:15:35,309 --> 00:15:37,730
claro, efectivamente

374
00:15:37,730 --> 00:15:41,779
comparator

375
00:15:41,779 --> 00:15:43,100
¿de qué? de producto

376
00:15:43,100 --> 00:15:45,480
porque este va a ser para comparar

377
00:15:45,480 --> 00:15:46,240
productos

378
00:15:46,240 --> 00:15:52,700
luego esto es

379
00:15:52,700 --> 00:15:54,899
no es una entidad, no es un objeto

380
00:15:54,899 --> 00:15:57,200
no es una entidad, no representa ninguna realidad

381
00:15:57,200 --> 00:15:58,779
representa un criterio

382
00:15:58,779 --> 00:16:00,700
para comparar, bueno pues

383
00:16:00,700 --> 00:16:02,720
si es un criterio para comparar, tiene que

384
00:16:02,720 --> 00:16:03,559
implementar

385
00:16:03,559 --> 00:16:05,379
el compare

386
00:16:05,379 --> 00:16:08,919
y este compare me tiene que comparar

387
00:16:08,919 --> 00:16:10,159
el O1 con el O2

388
00:16:10,159 --> 00:16:12,620
el O1 con el O2 se comparan de nuevo

389
00:16:12,620 --> 00:16:13,700
en función del nombre

390
00:16:13,700 --> 00:16:16,940
pues el compare tú del nombre

391
00:16:16,940 --> 00:16:18,500
pues ya está, O1

392
00:16:18,500 --> 00:16:20,200
punto nombre

393
00:16:20,200 --> 00:16:23,279
get nombre

394
00:16:23,279 --> 00:16:24,320
porque no vale

395
00:16:24,320 --> 00:16:26,100
compare tú

396
00:16:26,100 --> 00:16:27,700
o dos

397
00:16:27,700 --> 00:16:29,799
punto getNombre

398
00:16:29,799 --> 00:16:33,899
ya está

399
00:16:33,899 --> 00:16:40,340
a ver

400
00:16:40,340 --> 00:16:42,500
este es un método

401
00:16:42,500 --> 00:16:44,480
que simplemente está diseñado

402
00:16:44,480 --> 00:16:46,019
para que te permita

403
00:16:46,019 --> 00:16:48,100
dos objetos, el que llama y el otro

404
00:16:48,100 --> 00:16:50,360
mediante la obtención

405
00:16:50,360 --> 00:16:52,320
de un número entero que puede ser positivo

406
00:16:52,320 --> 00:16:54,139
cero, negativo, decirte

407
00:16:54,139 --> 00:16:56,320
si uno está delante, si otro está detrás

408
00:16:56,320 --> 00:16:57,519
o si son el mismo

409
00:16:57,519 --> 00:16:59,080
0 si son el mismo

410
00:16:59,080 --> 00:17:01,679
positivo si este está detrás

411
00:17:01,679 --> 00:17:03,120
y negativo si este está delante

412
00:17:03,120 --> 00:17:04,599
y eso

413
00:17:04,599 --> 00:17:07,420
esa forma de comparar la usan muchas clases

414
00:17:07,420 --> 00:17:09,859
entre ella y el triset, por eso lo necesitamos

415
00:17:09,859 --> 00:17:12,920
entonces

416
00:17:12,920 --> 00:17:15,019
ahora ya hemos hecho

417
00:17:15,019 --> 00:17:17,960
un criterio de comparación

418
00:17:17,960 --> 00:17:19,859
ahora ya

419
00:17:19,859 --> 00:17:21,259
al triset le decimos

420
00:17:21,259 --> 00:17:22,180
oye triset

421
00:17:22,180 --> 00:17:24,059
úsame

422
00:17:24,059 --> 00:17:26,079
un objeto

423
00:17:26,079 --> 00:17:28,460
criterio de comparación

424
00:17:28,460 --> 00:17:29,220
que sea este.

425
00:17:30,799 --> 00:17:31,940
Compara nombres.

426
00:17:36,190 --> 00:17:36,609
Ya está.

427
00:17:39,900 --> 00:17:40,099
¡Hala!

428
00:17:41,940 --> 00:17:43,279
Pues ahora ya podremos

429
00:17:43,279 --> 00:17:45,539
hacer triset

430
00:17:45,539 --> 00:17:47,759
de productos, porque el triset

431
00:17:47,759 --> 00:17:49,640
ya va a saber a qué criterio recurrir

432
00:17:49,640 --> 00:17:51,440
a la hora de meterlos en el árbol.

433
00:17:52,539 --> 00:17:53,839
Ya va a saber a qué criterio

434
00:17:53,839 --> 00:17:55,779
recurrir. Aquí lo único es que

435
00:17:55,779 --> 00:17:57,819
el set lo voy a

436
00:17:57,819 --> 00:17:59,920
tener que cambiar.

437
00:17:59,920 --> 00:18:11,880
vale, pues ya tengo

438
00:18:11,880 --> 00:18:13,519
todas las clases que me hacen falta

439
00:18:13,519 --> 00:18:17,839
¿hay por ahí más entidades en mi aplicación

440
00:18:17,839 --> 00:18:19,460
que tengan propiedades dentro? pues no

441
00:18:19,460 --> 00:18:21,039
porque el cliente es solo el nombre

442
00:18:21,039 --> 00:18:22,519
no hay nada más

443
00:18:22,519 --> 00:18:25,339
entonces si esto

444
00:18:25,339 --> 00:18:27,980
representa todo lo que el usuario

445
00:18:27,980 --> 00:18:30,019
necesita, pues ya está

446
00:18:30,019 --> 00:18:31,740
ahora ya

447
00:18:31,740 --> 00:18:33,299
sí que empezaría a

448
00:18:33,299 --> 00:18:36,539
primero debería yo entender bien

449
00:18:36,539 --> 00:18:38,319
lógicamente lo que va a hacer, nos hemos ahorrado

450
00:18:38,319 --> 00:18:40,259
esa lectura para entender lo que hace cada cosa

451
00:18:40,259 --> 00:18:41,400
pero bueno, suponemos que

452
00:18:41,400 --> 00:18:44,220
eso ve la marcha, ahora ya sí

453
00:18:44,220 --> 00:18:46,380
tendremos que hacer en frame

454
00:18:46,380 --> 00:18:48,440
con las dos pestañas, insertar

455
00:18:48,440 --> 00:18:49,220
y consultar

456
00:18:49,220 --> 00:18:52,440
insertar pues para cada

457
00:18:52,440 --> 00:18:54,299
cliente, insertar todo esto

458
00:18:54,299 --> 00:18:56,299
de aquí, entonces ahora

459
00:18:56,299 --> 00:18:58,539
cuando ya

460
00:18:58,539 --> 00:19:00,240
empezamos la aplicación que funciona

461
00:19:00,240 --> 00:19:02,359
nos viene otro dato que vamos

462
00:19:02,359 --> 00:19:04,180
a fijar ya antes de que lo hagáis,

463
00:19:04,279 --> 00:19:05,920
¿qué es? Pero, ¿mis datos dónde están?

464
00:19:06,000 --> 00:19:06,920
¿Mis datos quiénes son?

465
00:19:08,019 --> 00:19:09,039
¿Mis datos son

466
00:19:09,039 --> 00:19:12,400
clientes, pedidos? ¿Cuáles son mis datos?

467
00:19:12,680 --> 00:19:13,240
Vamos a ver.

468
00:19:16,500 --> 00:19:17,440
Vale, pues a ver.

469
00:19:18,960 --> 00:19:20,160
Esto me va a hacer

470
00:19:20,160 --> 00:19:23,039
a un cliente insertar

471
00:19:23,039 --> 00:19:26,579
productos.

472
00:19:26,920 --> 00:19:28,660
Nombre y precio, que pongamos aquí.

473
00:19:28,660 --> 00:19:30,000
Nombre y precio. Vale.

474
00:19:32,539 --> 00:19:33,180
Entonces,

475
00:19:33,180 --> 00:19:35,960
ese cliente

476
00:19:35,960 --> 00:19:36,940
con ese nombre

477
00:19:36,940 --> 00:19:39,059
tendrá

478
00:19:39,059 --> 00:19:41,339
los pedidos

479
00:19:41,339 --> 00:19:42,319
vale

480
00:19:42,319 --> 00:19:49,089
pues ya está

481
00:19:49,089 --> 00:19:51,809
los datos de mi aplicación van a ser

482
00:19:51,809 --> 00:19:53,950
los conjuntos de los pedidos

483
00:19:53,950 --> 00:19:54,430
que tenga

484
00:19:54,430 --> 00:19:58,009
cada insertar me genera

485
00:19:58,009 --> 00:19:59,670
un pedido de productos

486
00:19:59,670 --> 00:20:00,710
para ese cliente

487
00:20:00,710 --> 00:20:06,170
aquí abajo en esta área de texto

488
00:20:06,170 --> 00:20:08,589
poniendo nombre guión precio

489
00:20:08,589 --> 00:20:10,529
ahí al darle insertar

490
00:20:10,529 --> 00:20:12,650
habrá que sacarlo de ese área de texto

491
00:20:12,650 --> 00:20:14,670
luego los datos de mi aplicación

492
00:20:14,670 --> 00:20:16,130
van a ser la lista de pedidos

493
00:20:16,130 --> 00:20:18,490
luego vamos a hacer eso ya por último

494
00:20:18,490 --> 00:20:20,210
mi aplicación

495
00:20:20,210 --> 00:20:21,309
¿cuáles van a ser sus datos?

496
00:20:22,609 --> 00:20:23,869
pues vamos a meterlos

497
00:20:23,869 --> 00:20:26,789
en una clase datos por ejemplo

498
00:20:26,789 --> 00:20:30,910
y aquí van a estar los datos de mi aplicación

499
00:20:30,910 --> 00:20:35,720
venga

500
00:20:35,720 --> 00:20:37,799
los pedidos ya vamos a poner que sean una lista

501
00:20:37,799 --> 00:20:55,930
bueno, pues aquí están mis datos

502
00:20:55,930 --> 00:20:57,509
en lugar de una base de datos

503
00:20:57,509 --> 00:20:59,450
están ahí, inicialmente siempre vacíos

504
00:20:59,450 --> 00:21:01,390
vale, luego

505
00:21:01,390 --> 00:21:02,670
antes de empezar a hacer nada

506
00:21:02,670 --> 00:21:05,329
primero hay que diseñar bien las clases

507
00:21:05,329 --> 00:21:06,809
con las que va a trabajar mi aplicación

508
00:21:06,809 --> 00:21:09,630
y luego tengo que preguntarme por los datos

509
00:21:09,630 --> 00:21:10,650
¿mis datos dónde están?

510
00:21:11,930 --> 00:21:13,670
pues mis datos, ¿qué van a ser?

511
00:21:14,049 --> 00:21:15,130
la lista de pedidos

512
00:21:15,130 --> 00:21:17,549
cada pedido tendrá su nombre

513
00:21:17,549 --> 00:21:18,950
de cliente dentro y sus productos

514
00:21:18,950 --> 00:21:19,990
esos van a ser mis datos

515
00:21:19,990 --> 00:21:23,069
los datos podrían haber sido

516
00:21:23,069 --> 00:21:25,529
si hubiéramos tenido la clase cliente

517
00:21:25,529 --> 00:21:27,630
pues la lista de clientes

518
00:21:27,630 --> 00:21:28,730
con los pedidos dentro

519
00:21:28,730 --> 00:21:31,490
depende, en mi caso, tal y como están las clases

520
00:21:31,490 --> 00:21:33,450
diseñadas, los datos

521
00:21:33,450 --> 00:21:35,390
van a ser la lista de pedidos, porque los pedidos

522
00:21:35,390 --> 00:21:37,369
no tienen todo dentro, el pedido tiene

523
00:21:37,369 --> 00:21:38,809
dentro el nombre del cliente y los productos

524
00:21:38,809 --> 00:21:40,890
entonces mis datos tienen que ser

525
00:21:40,890 --> 00:21:43,250
una colección de objetos que tengan

526
00:21:43,250 --> 00:21:45,390
todo lo demás dentro, que tengan todo lo demás

527
00:21:45,390 --> 00:21:47,430
pues el pedido es el que tiene

528
00:21:47,430 --> 00:21:49,430
todo lo demás dentro, porque tiene el nombre

529
00:21:49,430 --> 00:21:51,549
del cliente y los productos, pues mis datos

530
00:21:51,549 --> 00:21:53,190
van a ser la lista de pedidos.

531
00:21:54,990 --> 00:21:58,150
Vale, ahora ya que tengo claro cuáles van a ser mis datos

532
00:21:58,150 --> 00:22:02,190
y dónde van a estar, ahora ya sí que entraríamos

533
00:22:02,849 --> 00:22:07,470
a hacer la interfaz y irnos a los eventos.

534
00:22:08,769 --> 00:22:10,529
Que en este caso, tal y como está,

535
00:22:10,670 --> 00:22:16,430
es el evento del botón insertar y el evento del botón consultar.

536
00:22:16,490 --> 00:22:17,809
Ya está, los eventos.

537
00:22:20,980 --> 00:22:23,339
Venga, pues hacéis la interfaz y completáis los eventos

538
00:22:23,339 --> 00:22:24,680
y el evento de la clase anterior.

539
00:22:27,940 --> 00:22:37,960
Y paramos aquí, pero aquí nos falta lógicamente

540
00:22:37,960 --> 00:22:41,619
que los datos se tienen que guardar en un fichero.

541
00:22:41,880 --> 00:22:42,720
Hay que serializarlo.

542
00:22:42,720 --> 00:22:44,779
O sea, la aplicación cuando arranca

543
00:22:44,779 --> 00:22:49,059
cargará estos pedidos de un fichero.

544
00:22:49,200 --> 00:22:51,759
Luego esta clase de datos tendrá que tener

545
00:22:51,759 --> 00:23:05,950
recupera pedidos.

546
00:23:05,950 --> 00:23:11,099
tendrá que tener este método

547
00:23:11,099 --> 00:23:13,039
que

548
00:23:13,039 --> 00:23:15,420
del objeto fichero

549
00:23:15,420 --> 00:23:17,420
que le pasemos, me recupera

550
00:23:17,420 --> 00:23:19,420
los pedidos que ya hay y los guarde

551
00:23:19,420 --> 00:23:21,400
aquí, y también tendrá

552
00:23:21,400 --> 00:23:22,359
que tener un método

553
00:23:22,359 --> 00:23:33,079
para que cuando la aplicación termine, guarde

554
00:23:33,079 --> 00:23:34,059
los pedidos antes

555
00:23:34,059 --> 00:23:53,019
o la aplicación cuando arranca entonces

556
00:23:53,019 --> 00:23:55,299
solicitará

557
00:23:55,299 --> 00:23:56,859
el nombre del fichero de pedidos

558
00:23:56,859 --> 00:23:58,920
con un jOptionPane

559
00:23:58,920 --> 00:24:00,880
por ejemplo, y tratará de

560
00:24:00,880 --> 00:24:01,900
recuperar los que hay

561
00:24:01,900 --> 00:24:04,839
y los guardará aquí y ya está.

562
00:24:05,299 --> 00:24:06,680
La aplicación luego trabaja

563
00:24:06,680 --> 00:24:08,720
y en el momento de salir,

564
00:24:09,319 --> 00:24:10,880
antes de salir, los volverá a guardar.

565
00:24:12,980 --> 00:24:15,160
Pues nada, ese es el trabajo que falta por hacer.

566
00:24:15,240 --> 00:24:16,779
La interfaz, dos eventos y ya está.

567
00:24:16,880 --> 00:24:18,720
Si es lo mismo que la aplicación de facturas que hicimos

568
00:24:18,720 --> 00:24:20,500
para ver esto de securización,

569
00:24:21,180 --> 00:24:21,839
ya está.

570
00:24:22,700 --> 00:24:25,019
Venga, pues vamos a dejarlo aquí.

571
00:24:26,500 --> 00:24:27,259
Intentad hacerlo,

572
00:24:27,259 --> 00:24:29,039
tratad de hacerlo porque el próximo día

573
00:24:29,039 --> 00:24:29,980
lo vamos a tunear

574
00:24:29,980 --> 00:24:34,859
para que tenga un poquito más de complejidad el acceso a ficheros y todo eso.