1
00:00:00,240 --> 00:00:03,140
registrar cliente era una funcionalidad básica

2
00:00:03,140 --> 00:00:03,919
que ya hemos hecho

3
00:00:03,919 --> 00:00:06,940
vamos a hacer una, que menos

4
00:00:06,940 --> 00:00:11,539
puedo

5
00:00:11,539 --> 00:00:20,780
vale

6
00:00:20,780 --> 00:00:25,179
pues que menos que ponerle una funcionalidad

7
00:00:25,179 --> 00:00:26,379
que sea

8
00:00:26,379 --> 00:00:28,160
ver el listado de clientes

9
00:00:28,160 --> 00:00:28,940
para así

10
00:00:28,940 --> 00:00:32,479
poder comprobar si se ha registrado correctamente

11
00:00:32,479 --> 00:00:32,799
o no

12
00:00:32,799 --> 00:00:37,039
que menos, poder tener un listado de clientes

13
00:00:37,039 --> 00:00:41,240
pues venga, vamos a hacer la opción 2, listado de clientes

14
00:00:41,240 --> 00:00:45,320
la opción 2 no hay que pedirle nada al usuario

15
00:00:45,320 --> 00:00:50,039
simplemente hay que recorrer este array para mostrarlo

16
00:00:50,039 --> 00:00:52,619
entonces en principio uno podría hacer esto, verdad

17
00:00:52,619 --> 00:01:05,079
y ahora, parte buena y bonita y estupenda

18
00:01:05,079 --> 00:01:09,120
de haber hecho el toStream, yo quiero mostrar el cliente

19
00:01:09,120 --> 00:01:12,920
con lo que nosotros hemos dicho hasta ahora,

20
00:01:14,060 --> 00:01:17,280
cliente tiene tres cosas dentro.

21
00:01:17,500 --> 00:01:19,920
NIF, nombre, pedidos.

22
00:01:20,700 --> 00:01:22,980
Entonces, realmente mostrarle al cliente sería

23
00:01:22,980 --> 00:01:24,140
que meto en el system out.

24
00:01:24,680 --> 00:01:27,420
Meto NIF, meto nombre, recorro el array

25
00:01:27,420 --> 00:01:28,799
y meto los pedidos.

26
00:01:31,439 --> 00:01:32,439
¿Qué meto?

27
00:01:34,219 --> 00:01:36,500
¿Tendría que hacerte system out?

28
00:01:36,500 --> 00:01:38,980
Pero claro

29
00:01:38,980 --> 00:01:40,519
¿Qué ocurre?

30
00:01:41,420 --> 00:01:42,200
¿Qué pasa?

31
00:01:42,840 --> 00:01:44,920
¿Qué pasa si yo le paso

32
00:01:44,920 --> 00:01:45,739
El

33
00:01:45,739 --> 00:01:47,579
¿Eh?

34
00:01:49,939 --> 00:01:50,959
Sí, pero

35
00:01:50,959 --> 00:01:53,480
¿Por qué te has dado cuenta

36
00:01:53,480 --> 00:01:54,079
Tan rápido?

37
00:01:54,879 --> 00:01:56,420
Quería que se vea en la ejecución

38
00:01:56,420 --> 00:01:58,480
¿Vale? Efectivamente, efectivamente

39
00:01:58,480 --> 00:02:00,840
Lo he puesto así a propósito porque así no lo haríamos

40
00:02:00,840 --> 00:02:03,319
¿Vale? Pero bueno, olvidaos de esta línea por ahora

41
00:02:03,319 --> 00:02:05,439
Olvidaos de esta línea

42
00:02:05,439 --> 00:02:05,980
Por ahora

43
00:02:05,980 --> 00:02:07,799
Vamos a esta

44
00:02:07,799 --> 00:02:09,879
¿Vale? Olvidaos de esta línea por ahora

45
00:02:09,879 --> 00:02:11,479
Vamos a esta

46
00:02:11,479 --> 00:02:12,759
Ahora mismo

47
00:02:12,759 --> 00:02:14,780
Ahora vámonos al system out por ahora

48
00:02:14,780 --> 00:02:17,439
La opción 2

49
00:02:17,439 --> 00:02:19,099
Mostrar el listado de clientes

50
00:02:19,099 --> 00:02:21,259
Que se supone que está en el array

51
00:02:21,259 --> 00:02:22,599
Vale

52
00:02:22,599 --> 00:02:27,639
Vámonos a mostrar el cliente

53
00:02:27,639 --> 00:02:29,599
Cliente es una caja

54
00:02:29,599 --> 00:02:31,280
Con varias cosas dentro

55
00:02:31,280 --> 00:02:33,680
Entonces al system out

56
00:02:33,680 --> 00:02:35,699
Yo no le paso

57
00:02:35,699 --> 00:02:37,039
la caja, ¿qué le pasas?

58
00:02:37,479 --> 00:02:39,439
le pasas el nombre, le pasas, pero claro

59
00:02:39,439 --> 00:02:41,379
ahora es donde sabemos

60
00:02:41,379 --> 00:02:43,319
oye, ¿qué pasa? que C

61
00:02:43,319 --> 00:02:45,000
tenía un método maravilloso

62
00:02:45,000 --> 00:02:46,919
cliente, que era tu string

63
00:02:46,919 --> 00:02:49,180
que me lo convierte a una cadena

64
00:02:49,180 --> 00:02:51,419
pues, magnífico

65
00:02:51,419 --> 00:02:53,599
llamo a tu string y le paso esa cadena

66
00:02:53,599 --> 00:02:55,319
pero es que todavía

67
00:02:55,319 --> 00:02:56,259
más apañado

68
00:02:56,259 --> 00:02:58,520
si yo le paso un objeto

69
00:02:58,520 --> 00:03:01,039
al system out, le paso un objeto

70
00:03:01,039 --> 00:03:03,319
sin más, sin este tu string

71
00:03:03,319 --> 00:03:04,120
le paso el objeto

72
00:03:04,120 --> 00:03:06,379
el system out este

73
00:03:06,379 --> 00:03:07,860
al ver que no es stream

74
00:03:07,860 --> 00:03:10,500
él ya automáticamente llama a tu stream

75
00:03:10,500 --> 00:03:12,919
porque asume que tú tienes ese método

76
00:03:12,919 --> 00:03:15,039
de ahí la importancia

77
00:03:15,039 --> 00:03:16,219
de hacer el método tu stream

78
00:03:16,219 --> 00:03:18,599
porque quienes nos usen, sean los que sean

79
00:03:18,599 --> 00:03:20,520
por ejemplo el SISO este

80
00:03:20,520 --> 00:03:22,680
quienes nos usen, van a asumir

81
00:03:22,680 --> 00:03:25,060
que lo tenemos y si lo necesitan

82
00:03:25,060 --> 00:03:26,159
lo van a llamar

83
00:03:26,159 --> 00:03:28,560
pues el SISO lo necesita

84
00:03:28,560 --> 00:03:30,960
porque el SISO solo es capaz de mostrar cadenas

85
00:03:30,960 --> 00:03:32,840
solo, entonces si yo le paso

86
00:03:32,840 --> 00:03:33,979
algo que no sea una cadena

87
00:03:33,979 --> 00:03:36,900
él, ah, no pasa nada, te llamo al toString

88
00:03:36,900 --> 00:03:38,860
y da por asumido

89
00:03:38,860 --> 00:03:40,639
que lo tenemos

90
00:03:40,639 --> 00:03:41,939
entonces

91
00:03:41,939 --> 00:03:45,020
hace falta que le pase el toString

92
00:03:45,020 --> 00:03:45,699
no hace falta

93
00:03:45,699 --> 00:03:49,719
que se lo pase

94
00:03:49,719 --> 00:03:52,759
porque el System.out.println cuando ve

95
00:03:52,759 --> 00:03:54,599
que le pasó algo que no es cadena

96
00:03:54,599 --> 00:03:56,879
él ya llama al toString

97
00:03:56,879 --> 00:03:58,800
solito, da por sentado que lo tenemos

98
00:03:58,800 --> 00:04:00,159
¿vale?

99
00:04:00,780 --> 00:04:02,520
con lo cual, esa es la importancia

100
00:04:02,520 --> 00:04:03,259
de tener ese método

101
00:04:03,259 --> 00:04:05,460
y no solamente el System.out

102
00:04:05,460 --> 00:04:08,060
va a llamar alto stream, cualquier otro método

103
00:04:08,060 --> 00:04:09,599
que haya por ahí, que nos use

104
00:04:09,599 --> 00:04:11,300
y necesite que seamos cadena

105
00:04:11,300 --> 00:04:13,840
lo va a llamar, va a dar por hecho

106
00:04:13,840 --> 00:04:15,379
que lo tenemos

107
00:04:15,379 --> 00:04:18,000
vale, lo vamos a poner

108
00:04:18,000 --> 00:04:18,959
aquí como comentario

109
00:04:18,959 --> 00:04:36,060
entonces me podríais decir

110
00:04:36,060 --> 00:04:38,800
oye, pero y si yo no he hecho

111
00:04:38,800 --> 00:04:40,980
alto stream, porque no es obligatorio

112
00:04:40,980 --> 00:04:41,879
si yo no lo he hecho

113
00:04:41,879 --> 00:04:43,680
¿qué pasa?

114
00:04:44,259 --> 00:04:45,500
si yo no lo he hecho

115
00:04:45,500 --> 00:04:48,699
el compilador sin ningún problema

116
00:04:48,699 --> 00:04:50,899
pero a la hora de ejecutarle

117
00:04:50,899 --> 00:04:52,920
el toString que se va a llamar

118
00:04:52,920 --> 00:04:54,720
es un toString por defecto

119
00:04:54,720 --> 00:04:56,839
que muestra unas cosas muy raras

120
00:04:56,839 --> 00:04:59,120
entonces el toString por defecto

121
00:04:59,120 --> 00:05:00,339
si yo no hago un toString

122
00:05:00,339 --> 00:05:02,100
hay uno por defecto

123
00:05:02,100 --> 00:05:04,579
pero que muestra unas cosas muy raras

124
00:05:04,579 --> 00:05:06,160
entonces el por defecto no lo queremos

125
00:05:06,160 --> 00:05:08,800
por eso hacemos uno específico bonito

126
00:05:08,800 --> 00:05:10,699
¿vale?

127
00:05:10,740 --> 00:05:12,819
hacemos uno específico bonito para no usar

128
00:05:12,819 --> 00:05:14,939
para que no use el por defecto

129
00:05:14,939 --> 00:05:16,360
la clase que sea

130
00:05:16,360 --> 00:05:22,029
Entonces lo ponemos aquí

131
00:05:22,029 --> 00:05:24,470
Si no hubiéramos hecho un toString

132
00:05:24,470 --> 00:05:28,759
Si no hubiéramos

133
00:05:28,759 --> 00:05:32,689
Hecho un toString

134
00:05:32,689 --> 00:05:33,490
Nosotros

135
00:05:33,490 --> 00:05:36,750
Si no lo hubiéramos hecho

136
00:05:36,750 --> 00:05:41,870
Se llamaría a uno por defecto

137
00:05:41,870 --> 00:05:46,199
Pero este por defecto

138
00:05:46,199 --> 00:05:47,720
Muestra unas cosas muy raras

139
00:05:47,720 --> 00:05:48,699
Y no nos interesa

140
00:05:48,699 --> 00:05:52,060
Por eso hacemos uno y listo

141
00:05:52,060 --> 00:05:53,920
Vale, y ahora ya sí

142
00:05:53,920 --> 00:05:56,040
Vamos a lo que habéis apuntado

143
00:05:56,040 --> 00:05:57,259
El forEach

144
00:05:57,259 --> 00:05:58,579
aquí es muy mala elección

145
00:05:58,579 --> 00:06:01,480
porque el for each ya sabemos que te recorre

146
00:06:01,480 --> 00:06:03,019
la raya entero de principio a fin

147
00:06:03,019 --> 00:06:05,759
entero, no puedes parar antes

148
00:06:05,759 --> 00:06:07,779
y nosotros no queremos

149
00:06:07,779 --> 00:06:09,079
recorrer la raya entero

150
00:06:09,079 --> 00:06:11,100
queremos recorrer

151
00:06:11,100 --> 00:06:13,420
solo hasta la posición

152
00:06:13,420 --> 00:06:14,560
que esté rellena

153
00:06:14,560 --> 00:06:17,779
porque la raíz son 100, yo lo he instanciado como 100

154
00:06:17,779 --> 00:06:19,740
con lo cual este for each

155
00:06:19,740 --> 00:06:20,579
de aquí

156
00:06:20,579 --> 00:06:23,420
se va a ejecutar 100 veces

157
00:06:23,420 --> 00:06:25,480
si solo tengo uno, me va a mostrar

158
00:06:25,480 --> 00:06:26,259
99 nul

159
00:06:26,259 --> 00:06:28,060
Entonces yo aquí

160
00:06:28,060 --> 00:06:30,060
El for each es una elección muy mala

161
00:06:30,060 --> 00:06:32,319
Vamos a hacer un for de índice

162
00:06:32,319 --> 00:06:34,259
Y digo yo

163
00:06:34,259 --> 00:06:35,680
¿Dónde me quedo?

164
00:06:38,459 --> 00:06:40,180
Pues empezando por la 0

165
00:06:40,180 --> 00:06:42,240
Mientras

166
00:06:42,240 --> 00:06:44,319
Y sea menor que qué

167
00:06:44,319 --> 00:06:45,480
¿Qué pondríamos?

168
00:06:51,860 --> 00:06:53,639
Esta, que es la que me dice

169
00:06:53,639 --> 00:06:55,879
¿Cuántos realmente tengo rellenos?

170
00:06:58,490 --> 00:06:59,550
Esta variable

171
00:06:59,550 --> 00:07:01,750
es la que me dice cuantos tengo rellenos

172
00:07:01,750 --> 00:07:05,839
cuando la siguiente posición libre es 0

173
00:07:05,839 --> 00:07:06,980
es porque no tengo ninguno

174
00:07:06,980 --> 00:07:09,180
no hay lista de clientes

175
00:07:09,180 --> 00:07:11,800
cuando es 1

176
00:07:11,800 --> 00:07:14,420
cuando la siguiente a rellenar es 1

177
00:07:14,420 --> 00:07:16,160
es porque tengo un cliente

178
00:07:16,160 --> 00:07:16,699
el de la 0

179
00:07:16,699 --> 00:07:19,660
cuando la siguiente posición a rellenar es la 2

180
00:07:19,660 --> 00:07:21,160
es porque tengo dos clientes

181
00:07:21,160 --> 00:07:21,920
el 0 y el 1

182
00:07:21,920 --> 00:07:25,220
luego siguiente posición libre me sirve

183
00:07:25,220 --> 00:07:27,519
como contador de posiciones

184
00:07:27,519 --> 00:07:28,459
que están rellenas

185
00:07:28,459 --> 00:07:35,220
Esta variable nos sirve

186
00:07:35,220 --> 00:07:37,240
Porque lo es, realmente lo es

187
00:07:37,240 --> 00:07:38,879
Como contador

188
00:07:38,879 --> 00:07:42,980
De posiciones que se han rellenado

189
00:07:42,980 --> 00:07:43,579
Realmente

190
00:07:43,579 --> 00:07:56,889
Vale, pues

191
00:07:56,889 --> 00:07:58,629
Por el hecho

192
00:07:58,629 --> 00:08:01,410
De que el array

193
00:08:01,410 --> 00:08:03,430
Necesita fijar una posición al principio

194
00:08:03,430 --> 00:08:05,730
Hemos tenido que usar esta variable

195
00:08:05,730 --> 00:08:07,730
Adicional, no nos queda otra

196
00:08:07,730 --> 00:08:09,610
Vale

197
00:08:09,610 --> 00:08:11,589
Aquí tengo un error de compilación por ahí

198
00:08:11,589 --> 00:08:14,639
Que aquí lógicamente

199
00:08:14,639 --> 00:08:16,759
no es c, sino que es clientes

200
00:08:16,759 --> 00:08:17,560
de id

201
00:08:17,560 --> 00:08:20,360
y este va a llamar alto string

202
00:08:20,360 --> 00:08:26,600
vale, aquí ya podríamos hacer

203
00:08:26,600 --> 00:08:28,160
deberíamos hacer la primera prueba

204
00:08:28,160 --> 00:08:30,459
a ver si al menos la funcionalidad

205
00:08:30,459 --> 00:08:32,679
de registrar clientes la hace correctamente

206
00:08:32,679 --> 00:08:34,720
aunque aquí

207
00:08:34,720 --> 00:08:36,519
voy a tener el problema de que después

208
00:08:36,519 --> 00:08:38,200
del next ir al hacer next line

209
00:08:38,200 --> 00:08:40,279
se va, entonces

210
00:08:40,279 --> 00:08:42,559
necesito aquí esto

211
00:08:42,559 --> 00:08:47,840
porque si no se queda el salto de línea

212
00:08:47,840 --> 00:08:49,759
que va a coger el salto de línea con el nif

213
00:08:49,759 --> 00:08:51,980
No me va a dejar meter el NIF, etc

214
00:08:51,980 --> 00:08:57,379
Vale

215
00:08:57,379 --> 00:08:58,799
Pues probad a hacer la primera

216
00:08:58,799 --> 00:09:00,480
Prueba

217
00:09:00,480 --> 00:09:04,889
Venga, registrar

218
00:09:04,889 --> 00:09:07,149
Vamos a mostrar el listado de clientes

219
00:09:07,149 --> 00:09:10,070
Antes de nada, nada, el listado de clientes no me muestra nada

220
00:09:10,070 --> 00:09:12,129
No me muestra nada, no tengo clientes

221
00:09:12,129 --> 00:09:13,830
Vamos a registrar uno

222
00:09:13,830 --> 00:09:15,009
Nombre

223
00:09:15,009 --> 00:09:16,889
1111

224
00:09:16,889 --> 00:09:18,529
NIF 1111

225
00:09:18,529 --> 00:09:20,129
Nombre

226
00:09:20,129 --> 00:09:22,350
Nombre 1

227
00:09:22,350 --> 00:09:25,690
Cliente registrado, suponemos

228
00:09:25,690 --> 00:09:27,750
Vamos a ver ahora el listado

229
00:09:27,750 --> 00:09:30,750
Aquí algo hemos hecho mal

230
00:09:30,750 --> 00:09:34,909
Dispedidos is null

231
00:09:34,909 --> 00:09:35,750
Vale

232
00:09:35,750 --> 00:09:50,649
En la clase cliente

233
00:09:50,649 --> 00:09:51,629
He puesto el atributo

234
00:09:51,629 --> 00:09:51,970
¿Cuál?

235
00:09:53,429 --> 00:09:54,070
Sí, a todos

236
00:09:54,070 --> 00:09:56,350
Vale, entonces ahora

237
00:09:56,350 --> 00:09:58,470
Vamos a ver, ahora vamos a

238
00:09:58,470 --> 00:10:00,669
desentrañar una traza de error, que es una

239
00:10:00,669 --> 00:10:02,690
de nuestras tareas más importantes, la que

240
00:10:02,690 --> 00:10:04,750
vamos a hacer, vais a

241
00:10:04,750 --> 00:10:06,210
hacer todo el rato, uy

242
00:10:06,210 --> 00:10:08,570
porque me ha salido error, yo no

243
00:10:08,570 --> 00:10:10,610
tenía en mente que aquí fallara algo, aparentemente

244
00:10:10,610 --> 00:10:13,029
lo hemos hecho todo bien, importantísimo

245
00:10:13,029 --> 00:10:14,590
vamos a ver que nos dice

246
00:10:14,590 --> 00:10:16,590
null pointer exception

247
00:10:16,590 --> 00:10:18,190
error básico

248
00:10:18,190 --> 00:10:20,330
que significa null pointer exception

249
00:10:20,330 --> 00:10:22,429
significa que yo estoy

250
00:10:22,429 --> 00:10:24,809
tratando de entrar en un objeto

251
00:10:24,809 --> 00:10:26,470
que es null, que pasa

252
00:10:26,470 --> 00:10:28,389
continuamente, intentar entrar en un objeto

253
00:10:28,389 --> 00:10:30,330
que es null, vale, hay un objeto

254
00:10:30,330 --> 00:10:32,029
ahí que estoy haciendo, ese objeto

255
00:10:32,029 --> 00:10:34,330
punto algo, ese es el problema, ¿no? del null pointer

256
00:10:34,330 --> 00:10:36,470
exception, yo a un objeto le hago

257
00:10:36,470 --> 00:10:38,210
punto lo que sea

258
00:10:38,210 --> 00:10:39,990
y si ese objeto es null

259
00:10:39,990 --> 00:10:42,149
el punto lo que sea me va a decir null pointer

260
00:10:42,149 --> 00:10:44,070
exception, vale, vamos a ver

261
00:10:44,070 --> 00:10:45,009
que más detalles me da

262
00:10:45,009 --> 00:10:47,909
me dice, no puedo

263
00:10:47,909 --> 00:10:50,370
leer, this pedidos

264
00:10:50,370 --> 00:10:51,330
is null

265
00:10:51,330 --> 00:10:53,730
vale, efectivamente

266
00:10:53,730 --> 00:10:56,129
el cliente tiene

267
00:10:56,129 --> 00:10:57,909
un array de pedidos null

268
00:10:57,909 --> 00:11:00,610
pero yo he accedido a pedidos en algún momento

269
00:11:00,610 --> 00:11:02,330
debe ser que sí

270
00:11:02,330 --> 00:11:03,710
vamos a ver

271
00:11:03,710 --> 00:11:05,870
claro, vamos a ver

272
00:11:05,870 --> 00:11:08,230
en la traza donde me lleva, pues nosotros

273
00:11:08,230 --> 00:11:10,309
bajamos hasta aquí, hasta llegar

274
00:11:10,309 --> 00:11:11,950
a la primera clase que es nuestra

275
00:11:11,950 --> 00:11:13,649
que en este caso es esta, cliente Java

276
00:11:13,649 --> 00:11:16,250
pues justo, cuando

277
00:11:16,250 --> 00:11:18,309
el system out ha llamado al toString

278
00:11:18,309 --> 00:11:20,250
ha intentado hacer un

279
00:11:20,250 --> 00:11:22,210
pedidos.length

280
00:11:22,210 --> 00:11:23,710
y pedidos es null

281
00:11:23,710 --> 00:11:26,190
luego aquí ha salido el error

282
00:11:26,190 --> 00:11:27,269
entonces este toString

283
00:11:27,269 --> 00:11:30,409
no está bien, porque si el objeto

284
00:11:30,409 --> 00:11:31,809
pedidos es null

285
00:11:31,809 --> 00:11:34,450
aquí va a salir null pointer exception

286
00:11:34,450 --> 00:11:36,110
entonces aquí

287
00:11:36,110 --> 00:11:38,070
pues tendríamos que tocarlo

288
00:11:38,070 --> 00:11:40,669
para que el número de pedidos

289
00:11:40,669 --> 00:11:41,750
pues

290
00:11:41,750 --> 00:11:43,850
depende, ¿con qué lo vamos a concatenar?

291
00:11:43,929 --> 00:11:46,129
depende, si es 0 con 0, o sea si pedidos

292
00:11:46,129 --> 00:11:48,269
es null, le vamos a poner aquí

293
00:11:48,269 --> 00:11:49,509
directamente un ternario

294
00:11:49,509 --> 00:11:51,570
si pedidos

295
00:11:51,570 --> 00:11:53,830
es igual a null

296
00:11:53,830 --> 00:11:56,490
entonces concaténamelo

297
00:11:56,490 --> 00:11:57,110
Con cero

298
00:11:57,110 --> 00:12:00,549
Y si no, concatenamelo

299
00:12:00,549 --> 00:12:01,210
Con

300
00:12:01,210 --> 00:12:04,590
Pedidos.length

301
00:12:04,590 --> 00:12:06,129
Vale

302
00:12:06,129 --> 00:12:08,590
No me deja concatenar directamente con el ternario

303
00:12:08,590 --> 00:12:08,889
Ahí

304
00:12:08,889 --> 00:12:12,789
Pero si lo pongo todo en paréntesis

305
00:12:12,789 --> 00:12:13,529
Ya igual sí

306
00:12:13,529 --> 00:12:16,210
A ver, sí, vale

307
00:12:16,210 --> 00:12:18,450
Vale

308
00:12:18,450 --> 00:12:20,590
Pues he cambiado el pedidos.length

309
00:12:20,590 --> 00:12:22,029
Que lo tenía así a capón

310
00:12:22,029 --> 00:12:24,289
Lo he cambiado por esto

311
00:12:24,289 --> 00:12:27,289
que es jugar con el ternario

312
00:12:27,289 --> 00:12:28,070
que sabemos hacerlo

313
00:12:28,070 --> 00:12:30,750
lo he cambiado, hoy es null

314
00:12:30,750 --> 00:12:32,169
entonces plántame 0

315
00:12:32,169 --> 00:12:34,610
si es null no me hagas pedidos.led

316
00:12:34,610 --> 00:12:37,110
número de pedido 0

317
00:12:37,110 --> 00:12:38,809
y si no es null

318
00:12:38,809 --> 00:12:40,950
entonces ya sí que plántame pedidos.led

319
00:12:40,950 --> 00:12:42,970
ahora ya

320
00:12:42,970 --> 00:12:44,929
ese null pointer exception

321
00:12:44,929 --> 00:12:50,799
vale, entonces aquí lo que

322
00:12:50,799 --> 00:12:52,860
concatenamos, con lo que concatenamos

323
00:12:52,860 --> 00:12:54,860
que está entre estos paréntesis

324
00:12:54,860 --> 00:12:56,919
lo que concatenamos, pues depende

325
00:12:56,919 --> 00:12:58,960
concateno con esto o concateno con esto

326
00:12:58,960 --> 00:13:00,879
dependiendo de esa condición

327
00:13:00,879 --> 00:13:02,940
vale, concateno con esto

328
00:13:02,940 --> 00:13:04,879
o con esto, ahí está metidito dentro de la

329
00:13:04,879 --> 00:13:07,100
concatenación, o con esto

330
00:13:07,100 --> 00:13:08,120
o con esto, depende

331
00:13:08,120 --> 00:13:12,919
vale, entonces se usa mucho este

332
00:13:12,919 --> 00:13:15,200
este operador

333
00:13:15,200 --> 00:13:16,980
ternario, porque yo tengo que usar

334
00:13:16,980 --> 00:13:18,259
un valor y a veces ese valor

335
00:13:18,259 --> 00:13:20,820
o uso una versión o uso otra en función

336
00:13:20,820 --> 00:13:23,059
de una condición, no pasa nada

337
00:13:23,059 --> 00:13:25,019
lo pongo así, vale, vamos a

338
00:13:25,019 --> 00:13:26,580
volver a ejecutar el main

339
00:13:26,580 --> 00:13:33,360
este. Registramos

340
00:13:33,360 --> 00:13:34,179
cliente.

341
00:13:36,279 --> 00:13:37,059
Nombre 1.

342
00:13:37,360 --> 00:13:39,779
Vale, registrado. Listado de clientes.

343
00:13:40,440 --> 00:13:41,120
Ahora ya sí.

344
00:13:42,139 --> 00:13:43,399
Cliente, nombre 1,

345
00:13:43,539 --> 00:13:44,659
número de pedidos 0.

346
00:13:45,379 --> 00:13:47,240
El tuestrín ha quedado un poco feo porque se ha quedado muy

347
00:13:47,240 --> 00:13:49,340
concatenado el nombre con número de pedidos.

348
00:13:50,399 --> 00:13:51,519
Luego le vamos a poner aquí

349
00:13:51,519 --> 00:13:53,019
el espacio.

350
00:13:53,559 --> 00:13:54,299
Número pedidos.

351
00:13:57,960 --> 00:14:00,039
Antes de cerrar esta versión, vamos a

352
00:14:00,039 --> 00:14:02,000
insertar otro para hacer una prueba un poco más

353
00:14:02,000 --> 00:14:03,980
completa. Vamos a registrar otro cliente más.

354
00:14:04,139 --> 00:14:06,940
Dos con nombre

355
00:14:06,940 --> 00:14:07,480
Dos

356
00:14:07,480 --> 00:14:12,419
Listado de clientes, pues aquí están los dos

357
00:14:12,419 --> 00:14:14,820
Ambos con número de pedidos

358
00:14:14,820 --> 00:14:15,259
Cero

359
00:14:15,259 --> 00:14:17,559
Salir

360
00:14:17,559 --> 00:14:26,100
Bueno, pues vale

361
00:14:26,100 --> 00:14:31,139
La primera parte, lo que hemos hecho funciona

362
00:14:31,139 --> 00:14:32,460
Como veis está bien

363
00:14:32,460 --> 00:14:33,419
Haciendo pruebas

364
00:14:33,419 --> 00:14:36,960
De forma progresiva

365
00:14:36,960 --> 00:14:39,480
Para no acumular errores

366
00:14:39,480 --> 00:14:41,179
Aquí ya hemos depurado un primer error

367
00:14:41,179 --> 00:14:42,240
Que se nos había escapado

368
00:14:42,240 --> 00:14:43,159
el del toString

369
00:14:43,159 --> 00:14:46,200
entonces si vamos incorporando, hacemos un programa así

370
00:14:46,200 --> 00:14:48,259
y pasamos las pruebas cuando ya lo tenemos

371
00:14:48,259 --> 00:14:50,080
todo, pues salen ahí

372
00:14:50,080 --> 00:14:52,120
un montón de errores que va a ser mucho más complicado

373
00:14:52,120 --> 00:14:54,320
de depurar, vale, esta parte ya está

374
00:14:54,320 --> 00:14:56,100
venga, vamos a hacer

375
00:14:56,100 --> 00:14:58,200
siguiente funcionalidad

376
00:14:58,200 --> 00:15:00,259
que sería evidente que va a necesitar

377
00:15:00,259 --> 00:15:01,860
esta persona, que es

378
00:15:01,860 --> 00:15:04,240
agregar un pedido a un cliente

379
00:15:05,000 --> 00:15:14,870
pues vamos a la opción

380
00:15:14,870 --> 00:15:15,549
3

381
00:15:18,730 --> 00:15:30,549
Pedido a un cliente, él ha venido a la tienda o lo ha hecho por internet o por lo que sea

382
00:15:30,549 --> 00:15:35,389
Y a mí me toca a ese cliente meterle el pedido en su lista de pedidos

383
00:15:35,389 --> 00:15:38,649
Me toca eso, agregar pedido a cliente

384
00:15:38,649 --> 00:15:40,990
Pues venga, caso 3

385
00:15:40,990 --> 00:15:50,870
A ver, ¿qué datos va a necesitar?

386
00:15:51,990 --> 00:15:53,389
Los datos del pedido

387
00:15:53,389 --> 00:16:02,730
Los datos del pedido que son la descripción y el precio

388
00:16:02,730 --> 00:16:05,370
¿por qué? porque el código

389
00:16:05,370 --> 00:16:07,649
no lo da el que compra

390
00:16:07,649 --> 00:16:09,190
cuando vos compráis algo

391
00:16:09,190 --> 00:16:11,509
quiero esto y no sé qué

392
00:16:11,509 --> 00:16:13,789
vale, y voy a pagar esto, esos datos son

393
00:16:13,789 --> 00:16:16,029
vuestros, pero el código

394
00:16:16,029 --> 00:16:17,809
se supone que

395
00:16:17,809 --> 00:16:19,950
es un dato interno que le genera la aplicación

396
00:16:19,950 --> 00:16:21,590
para luego tener ubicados los pedidos

397
00:16:21,590 --> 00:16:22,230
o lo que sea

398
00:16:22,230 --> 00:16:24,870
entonces pues vamos a hacerlo así

399
00:16:24,870 --> 00:16:26,389
entonces

400
00:16:26,389 --> 00:16:29,830
vamos a generar códigos

401
00:16:29,830 --> 00:16:31,370
únicos para los pedidos

402
00:16:31,370 --> 00:16:35,250
Una variable interna de la aplicación

403
00:16:35,250 --> 00:16:36,610
Que genera códigos únicos

404
00:16:36,610 --> 00:16:38,990
Los datos que vienen de fuera realmente

405
00:16:38,990 --> 00:16:40,789
Son la descripción y el precio

406
00:16:40,789 --> 00:16:41,710
Son los que vienen de fuera

407
00:16:41,710 --> 00:16:44,330
El código no debería venir de fuera

408
00:16:44,330 --> 00:16:45,730
Porque el que lo mete

409
00:16:45,730 --> 00:16:48,090
No sabe si ese código ya existió o no

410
00:16:48,090 --> 00:16:50,309
A lo mejor mete uno que ya está usado

411
00:16:50,309 --> 00:16:52,990
Y los códigos deberían ser únicos por definición

412
00:16:52,990 --> 00:16:55,110
Como las claves primarias de las tablas

413
00:16:55,110 --> 00:16:57,330
Entonces vamos a hacerlo bien

414
00:16:57,330 --> 00:16:59,450
Que la información de fuera

415
00:16:59,450 --> 00:17:01,610
Sea solo, descripción y precio

416
00:17:01,610 --> 00:17:04,210
Pues vamos a pedir la información de fuera

417
00:17:04,210 --> 00:17:08,589
Venga

418
00:17:08,589 --> 00:17:10,690
Descripción de lo que quieres

419
00:17:10,690 --> 00:17:12,910
Descripción del pedido

420
00:17:12,910 --> 00:17:21,369
Descripción

421
00:17:21,369 --> 00:17:28,109
Next line

422
00:17:28,109 --> 00:17:32,859
Y

423
00:17:32,859 --> 00:17:33,980
El precio

424
00:17:33,980 --> 00:17:51,119
Vale, el precio

425
00:17:51,119 --> 00:17:51,920
Pues bueno

426
00:17:51,920 --> 00:18:04,000
Vale, ya tenemos

427
00:18:04,000 --> 00:18:05,980
Dos datos para instanciar el pedido

428
00:18:05,980 --> 00:18:08,359
Pero al pedido hay que ponerle

429
00:18:08,359 --> 00:18:08,839
Un código

430
00:18:08,839 --> 00:18:13,940
Pues vamos a generar el código internamente para que sea único

431
00:18:13,940 --> 00:18:30,599
Bueno, pues esto se nos ocurriría hacerlo de mil maneras

432
00:18:30,599 --> 00:18:33,359
Vamos a usar una variable que empieza siendo cero

433
00:18:33,359 --> 00:18:37,759
Usamos esa variable como código y la dejamos incrementada, por ejemplo, y ya está

434
00:18:37,759 --> 00:18:42,700
Y así la aplicación se asegura de que los códigos de los pedidos son únicos

435
00:18:42,700 --> 00:18:45,880
Pues venga, vamos a usar una variable cualquiera

436
00:18:45,880 --> 00:18:47,200
Por aquí

437
00:18:47,200 --> 00:18:54,880
0

438
00:18:54,880 --> 00:18:59,980
Inicialmente es 0

439
00:18:59,980 --> 00:19:01,279
Y ahora

440
00:19:01,279 --> 00:19:03,039
Ahora ya me voy a crear el pedido

441
00:19:03,039 --> 00:19:05,759
Pues mi pedido va a ser

442
00:19:05,759 --> 00:19:10,559
Pedido va a ser igual

443
00:19:10,559 --> 00:19:11,200
A new

444
00:19:11,200 --> 00:19:13,859
Pedido con los tres datos

445
00:19:13,859 --> 00:19:15,619
Descripción

446
00:19:15,619 --> 00:19:17,279
No sé en qué orden iban en el constructor

447
00:19:17,279 --> 00:19:20,440
En el constructor iban en orden

448
00:19:20,440 --> 00:19:22,359
Código, descripción y precio

449
00:19:22,359 --> 00:19:24,980
Pues vamos a pasarlo en ese orden

450
00:19:24,980 --> 00:19:25,700
Lógicamente

451
00:19:25,700 --> 00:19:27,099
Código

452
00:19:27,099 --> 00:19:34,160
Código, como lo he llamado, código pet directamente

453
00:19:34,160 --> 00:19:36,079
Código

454
00:19:36,079 --> 00:19:37,380
Descripción

455
00:19:37,380 --> 00:19:39,460
Y precio

456
00:19:39,460 --> 00:19:44,660
Tengo que importar pedido o usar

457
00:19:44,660 --> 00:19:47,259
Su nombre completo, ejer22.model

458
00:19:47,259 --> 00:19:48,859
Hombre, usar el nombre

459
00:19:48,859 --> 00:19:49,880
Completo, un rollo

460
00:19:49,880 --> 00:19:52,799
Casi mejor

461
00:19:52,799 --> 00:19:54,880
Hago el import

462
00:19:54,880 --> 00:19:57,240
Arriba, deger22modelpedido

463
00:19:57,240 --> 00:20:01,329
Vale, tengo el pedido creado

464
00:20:01,329 --> 00:20:03,710
Pero ojo, código de pedido

465
00:20:03,710 --> 00:20:05,509
Se tiene que quedar incrementado

466
00:20:05,509 --> 00:20:07,309
Para que el siguiente pedido que hagamos

467
00:20:07,309 --> 00:20:08,369
Tenga código único

468
00:20:08,369 --> 00:20:11,670
Bueno, pues incrementémoslo aquí mismo

469
00:20:11,670 --> 00:20:13,529
Y ya está, y así no usamos una línea adicional

470
00:20:13,529 --> 00:20:17,170
¿Vale? Código de pedido

471
00:20:17,170 --> 00:20:18,369
Se queda incrementado

472
00:20:18,369 --> 00:20:20,890
Para que el siguiente código

473
00:20:20,890 --> 00:20:21,990
Sea distinto

474
00:20:21,990 --> 00:20:25,690
Y ahora, ¿qué nos toca?

475
00:20:26,569 --> 00:20:27,430
Pues nos toca

476
00:20:27,430 --> 00:20:33,470
a qué cliente es el que tiene este pedido.

477
00:20:33,589 --> 00:20:34,990
Porque habrá que meter este pedido

478
00:20:34,990 --> 00:20:36,930
en el array de pedidos del cliente.

479
00:20:38,170 --> 00:20:40,150
Luego, la siguiente información que necesitamos.

480
00:20:40,950 --> 00:20:41,730
¿Qué cliente es?

481
00:20:43,430 --> 00:20:46,369
¿Qué identificaría de forma única al cliente?

482
00:20:47,029 --> 00:20:47,769
El NIF.

483
00:20:48,509 --> 00:20:49,849
Entonces, eso es lo que tenemos que pedir.

484
00:20:49,910 --> 00:20:50,450
¿Cuál es el NIF?

485
00:20:51,309 --> 00:20:52,829
Si la aplicación...

486
00:20:52,829 --> 00:20:53,869
No estamos verificando,

487
00:20:53,970 --> 00:20:55,910
cada vez que se registra un cliente,

488
00:20:55,910 --> 00:20:58,410
No estamos verificando que el NIF no esté repetido,

489
00:20:58,609 --> 00:21:00,069
pues para no complicar la aplicación.

490
00:21:00,809 --> 00:21:02,250
Pero, hombre, se debería verificar.

491
00:21:03,069 --> 00:21:04,289
Cuando vendimos un NIF,

492
00:21:04,410 --> 00:21:05,789
deberíamos hacer una búsqueda en el array

493
00:21:05,789 --> 00:21:06,690
para ver si ya existe.

494
00:21:07,430 --> 00:21:09,549
Y si ya existe, decir el NIF ya está registrado.

495
00:21:10,230 --> 00:21:11,390
Por ahora, emitimos esa parte.

496
00:21:11,650 --> 00:21:13,109
Asumimos que el NIF es único,

497
00:21:13,349 --> 00:21:15,390
que debería ser único en el array de clientes.

498
00:21:15,990 --> 00:21:17,309
Luego, es lo único que tenemos que pedir.

499
00:21:18,029 --> 00:21:20,190
El NIF, para identificar al cliente.

500
00:21:25,579 --> 00:21:26,960
NIF del cliente.

501
00:21:27,480 --> 00:21:28,599
Pues venga.

502
00:21:28,599 --> 00:21:33,569
NIF del cliente

503
00:21:33,569 --> 00:21:43,460
Y ahora

504
00:21:43,460 --> 00:21:45,619
Pues que tenemos que hacer

505
00:21:45,619 --> 00:21:48,059
Recorrer el array de clientes

506
00:21:48,059 --> 00:21:50,559
Cuando encontremos el cliente

507
00:21:50,559 --> 00:21:51,759
Con este NIF

508
00:21:51,759 --> 00:21:54,220
Agregarle a su array

509
00:21:54,220 --> 00:21:54,960
Este pedido

510
00:22:17,220 --> 00:22:31,119
En el caso 3, tenemos el pedido y el precio.

511
00:22:32,119 --> 00:22:35,779
¿Qué caso 3? ¿En la T?

512
00:22:35,980 --> 00:22:36,599
Sí, en el caso 3.

513
00:22:37,599 --> 00:22:42,200
¿Mostrar clientes con más pedidos a dónde han llegado por el producto o por las descompras pedidas?

514
00:22:42,200 --> 00:22:43,200
Gracias.

515
00:23:12,200 --> 00:23:27,720
Seguimos

516
00:23:27,720 --> 00:23:31,059
Si yo lo tengo aquí también

517
00:23:31,059 --> 00:23:34,339
Y para algunas cosas de sprint

518
00:23:34,339 --> 00:23:37,180
Pues a veces lo uso porque lo integra muy rápido

519
00:23:37,180 --> 00:23:37,579
Pero

520
00:23:37,579 --> 00:23:44,299
Venga, a ver, vamos a completarlo

521
00:23:44,299 --> 00:23:46,420
Vale

522
00:23:46,420 --> 00:23:47,920
¿Dónde estamos?

523
00:23:48,599 --> 00:23:50,660
Lo de los escáneres, ahora revisamos

524
00:23:50,660 --> 00:23:52,599
Porque efectivamente algún escáner

525
00:23:52,599 --> 00:23:54,779
Ahí nos va a dar la murga

526
00:23:54,779 --> 00:23:57,039
Ahora, vamos a recorrer

527
00:23:57,039 --> 00:23:58,740
El array de clientes hasta encontrar

528
00:23:58,740 --> 00:23:59,319
El bueno

529
00:23:59,319 --> 00:24:04,059
Un for each, de nuevo no

530
00:24:04,059 --> 00:24:06,960
Un for de índice porque tenemos que quedarnos

531
00:24:06,960 --> 00:24:07,720
En el

532
00:24:07,720 --> 00:24:09,700
Siguiente

533
00:24:09,700 --> 00:24:12,200
Posición libre

534
00:24:12,200 --> 00:24:18,069
¿Vale? Ahora ya

535
00:24:18,069 --> 00:24:18,630
Si

536
00:24:18,630 --> 00:24:22,349
clientes

537
00:24:22,349 --> 00:24:24,089
de i

538
00:24:24,089 --> 00:24:26,569
punto get

539
00:24:26,569 --> 00:24:28,250
nif

540
00:24:28,250 --> 00:24:30,849
es igual, con un equals

541
00:24:30,849 --> 00:24:32,029
no con doble igual

542
00:24:32,029 --> 00:24:34,450
porque estamos hablando de string

543
00:24:34,450 --> 00:24:37,210
es igual a mi nif de búsqueda

544
00:24:37,210 --> 00:24:38,670
a mi nif de búsqueda

545
00:24:38,670 --> 00:24:41,410
aquí es donde tengo que agregar

546
00:24:41,410 --> 00:24:44,589
pedido

547
00:24:44,589 --> 00:24:48,680
p a client

548
00:24:48,680 --> 00:24:54,369
claro, aquí podría hacer

549
00:24:54,369 --> 00:24:55,890
todo el código correspondiente

550
00:24:55,890 --> 00:24:59,009
pero esto ya empezaría a hacerse un caso 3

551
00:24:59,009 --> 00:25:01,390
un poco largo y feo

552
00:25:01,390 --> 00:25:02,910
ya de hecho bastante largo es

553
00:25:02,910 --> 00:25:06,329
hombre, ya que tengo la clase cliente

554
00:25:06,329 --> 00:25:08,670
y agregar pedido a cliente

555
00:25:08,670 --> 00:25:12,430
es algo que se hace en el cliente para el cliente

556
00:25:12,430 --> 00:25:15,309
es algo que sufre la acción de agregar pedido

557
00:25:15,309 --> 00:25:18,549
la recibe el cliente, como él es el que recibe la acción

558
00:25:18,549 --> 00:25:21,769
que menos que hacerle un método en la clase cliente

559
00:25:21,769 --> 00:25:22,829
que sea agregar pedido

560
00:25:22,829 --> 00:25:25,109
entonces todas las funcionalidades

561
00:25:25,109 --> 00:25:27,349
que modifiquen

562
00:25:27,349 --> 00:25:29,230
actúen, tengan su efecto

563
00:25:29,230 --> 00:25:31,509
sobre objetos de una clase

564
00:25:31,509 --> 00:25:33,329
pues metámoslas en

565
00:25:33,329 --> 00:25:34,390
métodos de esa clase

566
00:25:34,390 --> 00:25:37,369
de su sitio, porque si nos ponemos a hacerlo

567
00:25:37,369 --> 00:25:39,130
aquí todo, al final esta

568
00:25:39,130 --> 00:25:41,069
pronunciación de cada objeto se ha quedado muy descafeinada

569
00:25:41,069 --> 00:25:43,529
descafeinada, ¿vale? pues repito

570
00:25:43,529 --> 00:25:45,490
agregar un pedido

571
00:25:45,490 --> 00:25:47,029
P a un cliente

572
00:25:47,029 --> 00:25:49,430
es algo que afecta al objeto cliente

573
00:25:49,430 --> 00:25:50,730
es algo que le va a modificar

574
00:25:50,730 --> 00:25:52,809
va a modificar su array de pedidos

575
00:25:52,809 --> 00:25:56,869
pues hombre, hagamos un método en la clase cliente que lo haga

576
00:25:56,869 --> 00:25:58,529
y desde aquí llamamos al método

577
00:25:58,529 --> 00:26:02,410
es decir, si tuviéramos

578
00:26:02,410 --> 00:26:05,009
un método maravilloso

579
00:26:05,009 --> 00:26:07,869
que si lo llama un objeto cliente

580
00:26:07,869 --> 00:26:12,460
pasándole yo mi pedido

581
00:26:12,460 --> 00:26:16,180
se lo agregara, si yo tuviera este método estupendo

582
00:26:16,180 --> 00:26:18,559
fijaos que fácil

583
00:26:18,559 --> 00:26:22,319
ojalá yo tuviera un método al que puede llamar

584
00:26:22,319 --> 00:26:24,119
un objeto cliente, en este caso

585
00:26:24,119 --> 00:26:26,279
clientes de i, porque clientes

586
00:26:26,279 --> 00:26:27,559
de i es un objeto cliente,

587
00:26:28,420 --> 00:26:30,160
a este método le pasara

588
00:26:30,160 --> 00:26:31,640
yo el pedido nuevo

589
00:26:31,640 --> 00:26:34,440
y este método ya, cogiera el pedido,

590
00:26:34,539 --> 00:26:35,339
lo metía en el array,

591
00:26:36,220 --> 00:26:37,900
estaría estupendo, ¿verdad?

592
00:26:38,019 --> 00:26:39,539
Ojalá lo tuviera.

593
00:26:40,299 --> 00:26:42,519
Porque entonces ya mi código estaría terminado.

594
00:26:44,279 --> 00:26:44,759
Pondría,

595
00:26:45,079 --> 00:26:46,259
¿vale?

596
00:26:48,099 --> 00:26:49,819
Vale, pues vamos a hacer este método.

597
00:26:50,059 --> 00:26:51,839
Vamos a hacer este método que me sería tan útil.

598
00:26:52,319 --> 00:27:14,880
¿Este método dónde va? A la clase cliente, porque lo va a llamar un objeto cliente, a la clase cliente, pues vámonos a hacer en la clase cliente un método public para poder ser llamado desde fuera, no hace falta que me devuelva nada, porque el efecto lo sufre ya el array de arriba, este array es el que sufre el efecto,

599
00:27:14,880 --> 00:27:20,940
el método se llama agregar

600
00:27:20,940 --> 00:27:23,299
pedido y que va a recibir

601
00:27:23,299 --> 00:27:25,299
un objeto pedido

602
00:27:25,299 --> 00:27:27,079
eso es lo que va a recibir

603
00:27:27,079 --> 00:27:28,619
un objeto pedido

604
00:27:28,619 --> 00:27:29,680
este p de aquí

605
00:27:29,680 --> 00:27:31,799
pues entonces

606
00:27:31,799 --> 00:27:34,720
aquí tendré que poner

607
00:27:34,720 --> 00:27:35,480
esto

608
00:27:35,480 --> 00:27:37,359
dime

609
00:27:37,359 --> 00:27:39,859
en la opción 1

610
00:27:39,859 --> 00:27:43,099
si pero por eso

611
00:27:43,099 --> 00:27:44,779
he dicho que vamos a hacer una aplicación

612
00:27:44,779 --> 00:27:46,539
la vamos a hacer entera a nuestra manera

613
00:27:46,539 --> 00:27:48,319
saliéndonos del ejercicio, ¿vale?

614
00:27:49,980 --> 00:27:50,980
Olvídate de denunciado.

615
00:27:51,019 --> 00:27:52,759
Porque así le vamos a dar un poco más de sentido.

616
00:27:52,859 --> 00:27:55,099
Vamos a ir metiendo cosas. Vamos a hacer una aplicación de clientes

617
00:27:55,099 --> 00:27:56,660
pedido como más general con más cosas.

618
00:27:57,660 --> 00:27:58,960
Y así la podemos usar

619
00:27:58,960 --> 00:28:00,599
para aprender más cositas.

620
00:28:03,690 --> 00:28:04,890
Vale, pues estupendo

621
00:28:04,890 --> 00:28:06,750
que tengamos este método. Bueno, hay que

622
00:28:06,750 --> 00:28:08,289
hacer el código. No se lo hemos hecho, claro.

623
00:28:08,869 --> 00:28:10,569
Que yo le paso un objeto pedido

624
00:28:10,569 --> 00:28:12,930
y me lo mete en el array de este objeto.

625
00:28:14,230 --> 00:28:14,609
Estupendo.

626
00:28:16,130 --> 00:28:16,849
Ese método

627
00:28:16,849 --> 00:28:17,910
estará aquí colocado.

628
00:28:18,430 --> 00:28:19,950
Estará ahí

629
00:28:19,950 --> 00:28:20,890
¿Vale?

630
00:28:23,390 --> 00:28:23,950
Ahí

631
00:28:23,950 --> 00:28:25,990
¿Vale? Pues que tiene que hacer este

632
00:28:25,990 --> 00:28:27,730
Este no es tan sencillo

633
00:28:27,730 --> 00:28:30,289
Porque este array

634
00:28:30,289 --> 00:28:32,890
¿Qué tendré que hacer?

635
00:28:34,230 --> 00:28:34,789
Romperlo

636
00:28:34,789 --> 00:28:36,829
Y hacer un auxiliar con una posición más

637
00:28:36,829 --> 00:28:38,490
Meter el pedido

638
00:28:38,490 --> 00:28:39,470
Y sustituir uno por otro

639
00:28:39,470 --> 00:28:40,849
Lo que hicimos en el pasado

640
00:28:40,849 --> 00:28:43,849
Cuando queríamos simular un array que se hiciera grande

641
00:28:43,849 --> 00:28:45,349
Para coger un valor nuevo

642
00:28:45,349 --> 00:28:47,410
Lo que hicimos en el pasado

643
00:28:47,410 --> 00:28:49,109
Pues eso lo metemos aquí en este método

644
00:28:49,109 --> 00:28:51,950
Que bien que va a ir aquí escondido

645
00:28:51,950 --> 00:28:54,369
Y el main le va a dar igual

646
00:28:54,369 --> 00:28:56,289
El main va a hacer agregar pedido

647
00:28:56,289 --> 00:28:56,990
Y le va a dar igual

648
00:28:56,990 --> 00:28:58,890
Que bien que va a ir escondido aquí

649
00:28:58,890 --> 00:29:00,769
Pues venga

650
00:29:00,769 --> 00:29:02,650
Vamos a hacer una array auxiliar

651
00:29:02,650 --> 00:29:09,579
De pedidos

652
00:29:09,579 --> 00:29:13,450
Una array auxiliar de pedidos

653
00:29:13,450 --> 00:29:14,930
Esto ya lo hicimos cuando hicimos arrays

654
00:29:14,930 --> 00:29:17,390
Que sea un nuevo array

655
00:29:17,390 --> 00:29:18,329
De pedido

656
00:29:18,329 --> 00:29:22,140
Con una posición más

657
00:29:22,140 --> 00:29:24,220
Que el que tiene el actual

658
00:29:24,220 --> 00:29:26,720
Pedidos.length

659
00:29:26,720 --> 00:29:27,940
Más 1

660
00:29:27,940 --> 00:29:32,950
Pedido

661
00:29:32,950 --> 00:29:35,029
Esto, vale

662
00:29:35,029 --> 00:29:36,529
En la radio auxiliar

663
00:29:36,529 --> 00:29:38,789
Copiamos el viejo

664
00:29:38,789 --> 00:29:41,210
Que es el de aquí arriba

665
00:29:41,210 --> 00:29:42,230
En el nuevo

666
00:29:42,230 --> 00:29:43,650
Y sustituimos

667
00:29:43,650 --> 00:29:46,289
Pues venga, vamos a copiar

668
00:29:46,289 --> 00:30:00,099
Pues copiamos

669
00:30:00,099 --> 00:30:01,900
aux de i

670
00:30:01,900 --> 00:30:04,460
Igual a

671
00:30:04,460 --> 00:30:06,400
Pedidos de i

672
00:30:06,400 --> 00:30:08,119
vale

673
00:30:08,119 --> 00:30:10,539
y ahora

674
00:30:10,539 --> 00:30:12,359
la posición extra

675
00:30:12,359 --> 00:30:14,660
es la que se ha quedado libre

676
00:30:14,660 --> 00:30:16,480
pues en la posición extra va P

677
00:30:16,480 --> 00:30:18,960
pues la posición esta

678
00:30:18,960 --> 00:30:20,359
es la última del aus

679
00:30:20,359 --> 00:30:21,059
que es esta

680
00:30:21,059 --> 00:30:25,750
esta es la posición extra

681
00:30:25,750 --> 00:30:26,690
que es la última

682
00:30:26,690 --> 00:30:30,009
pues en la posición extra va el P

683
00:30:30,009 --> 00:30:30,710
el nuevo

684
00:30:30,710 --> 00:30:36,039
y ahora ya sustituimos

685
00:30:36,039 --> 00:30:37,279
la propiedad pedidos

686
00:30:37,279 --> 00:30:38,559
la dejamos pisada

687
00:30:38,559 --> 00:30:41,059
por la nueva

688
00:30:41,059 --> 00:30:42,339
Por el nuevo array, por aux

689
00:30:42,339 --> 00:30:43,759
Sí

690
00:30:43,759 --> 00:31:08,289
Dime

691
00:31:08,289 --> 00:31:10,809
Pedidos

692
00:31:10,809 --> 00:31:12,029
¿Qué variable es?

693
00:31:12,730 --> 00:31:14,829
Pedidos, la propiedad pedidos

694
00:31:14,829 --> 00:31:16,430
Del objeto cliente en el que estamos

695
00:31:16,430 --> 00:31:18,450
Sus pedidos actuales

696
00:31:18,450 --> 00:31:21,490
Vale, no me hacéis ningún comentario

697
00:31:21,490 --> 00:31:22,309
Sobre este código

698
00:31:22,309 --> 00:31:24,289
Algo que os suena que pueda fallar

699
00:31:24,289 --> 00:31:29,170
Cuando le metamos

700
00:31:29,170 --> 00:31:30,410
El primero de todos

701
00:31:30,410 --> 00:31:33,910
Porque cuando le metamos el primero

702
00:31:33,910 --> 00:31:35,029
Pedidos es null

703
00:31:35,029 --> 00:31:38,049
Entonces cuando le metamos el primero

704
00:31:38,049 --> 00:31:39,650
En ese momento pedidos es null

705
00:31:39,650 --> 00:31:42,309
Luego al hacer aquí pedidos.led null pointer exception

706
00:31:42,309 --> 00:31:44,609
Vamos a arreglar esto de forma fácil

707
00:31:44,609 --> 00:31:46,490
Si pedidos

708
00:31:46,490 --> 00:31:47,569
Es

709
00:31:47,569 --> 00:31:48,950
Igual a null

710
00:31:48,950 --> 00:31:50,710
Entonces

711
00:31:50,710 --> 00:31:53,089
Si pedidos es igual a null

712
00:31:53,089 --> 00:31:55,430
Habrá que hacer pedidos con una posición

713
00:31:55,430 --> 00:31:58,309
Pedidos

714
00:31:58,309 --> 00:31:59,650
Le creamos el espacio

715
00:31:59,650 --> 00:32:01,809
new pedido

716
00:32:01,809 --> 00:32:04,569
de una posición solo

717
00:32:04,569 --> 00:32:05,890
el nuevo que vamos a meter

718
00:32:05,890 --> 00:32:08,309
y pedidos de 0

719
00:32:08,309 --> 00:32:09,910
igual a p

720
00:32:09,910 --> 00:32:12,589
y si no

721
00:32:12,589 --> 00:32:14,089
ya hacemos todo lo demás

722
00:32:14,089 --> 00:32:16,910
un arreglito rápido para eso

723
00:32:16,910 --> 00:32:18,890
si, si, si, ahora lo dejo

724
00:32:18,890 --> 00:32:20,269
todo puesto

725
00:32:20,269 --> 00:32:22,650
un momentito

726
00:32:22,650 --> 00:32:27,680
¿por qué?

727
00:32:29,680 --> 00:32:30,619
el auxiliar

728
00:32:30,619 --> 00:32:32,420
como tiene uno de más, el pedido si

729
00:32:32,420 --> 00:32:34,440
va a llegar en la última

730
00:32:34,440 --> 00:32:36,200
y te va a dar error en internet

731
00:32:36,200 --> 00:32:38,700
no, porque el for está solo en pedidos.led

732
00:32:38,700 --> 00:32:39,779
no en aux.led

733
00:32:39,779 --> 00:32:41,319
ah, cierto

734
00:32:41,319 --> 00:32:51,009
porque ese array

735
00:32:51,009 --> 00:32:52,369
tiene ya su tamaño fijo

736
00:32:52,369 --> 00:32:53,569
ese array ya no te vale

737
00:32:53,569 --> 00:32:56,329
tienes que hacer uno nuevo

738
00:32:56,329 --> 00:32:59,009
ese no se le puede crear una posición adicional

739
00:32:59,009 --> 00:33:00,849
ese es una caja de 7

740
00:33:00,849 --> 00:33:02,009
y va a tener siempre 7

741
00:33:02,009 --> 00:33:04,990
si tú quieres meter una octava botella

742
00:33:04,990 --> 00:33:06,809
tienes que comprarte

743
00:33:06,809 --> 00:33:07,650
una caja de 8

744
00:33:07,650 --> 00:33:09,849
y tirar la de 7

745
00:33:09,849 --> 00:33:11,809
porque en esa de 7 no puedes poner

746
00:33:11,809 --> 00:33:13,349
una posición más, no se puede

747
00:33:13,349 --> 00:33:19,829
el auxiliar tiene una posición más

748
00:33:19,829 --> 00:33:20,450
que pedidos

749
00:33:20,450 --> 00:33:23,089
a pedidos

750
00:33:23,089 --> 00:33:24,809
recorro hasta donde tiene

751
00:33:24,809 --> 00:33:26,930
aux tiene una más

752
00:33:26,930 --> 00:33:28,809
en la extra pongo p

753
00:33:28,809 --> 00:33:31,930
y ahora a pedidos lo pisoteo por el nuevo array

754
00:33:31,930 --> 00:33:33,930
pero sigue teniendo la misma longitud

755
00:33:33,930 --> 00:33:35,609
no, tiene una más

756
00:33:35,609 --> 00:33:37,250
pedidos contundentes más 1

757
00:33:37,250 --> 00:33:39,710
Ya, pero es que Pedidos ya se ha ido a la basura

758
00:33:39,710 --> 00:33:41,250
Pedidos ya se ha quedado sin referencia

759
00:33:41,250 --> 00:33:42,730
Ya se desaparecerá

760
00:33:42,730 --> 00:33:45,150
Es decir, lo que hemos hecho es lo siguiente

761
00:33:45,150 --> 00:33:46,170
Ah, vale, vale

762
00:33:46,170 --> 00:33:54,359
Claro, lo que hemos hecho es

763
00:33:54,359 --> 00:33:56,500
Por si alguien no lo entiende, esto es lo que vimos con Arrays

764
00:33:56,500 --> 00:33:58,200
Yo tengo mi

765
00:33:58,200 --> 00:34:02,259
Array, por ejemplo

766
00:34:02,259 --> 00:34:03,660
Imaginaos de tres posiciones

767
00:34:03,660 --> 00:34:05,359
Y quiero meter un cuarto

768
00:34:05,359 --> 00:34:07,640
Este cuarto ahí, imposible

769
00:34:07,640 --> 00:34:10,139
Pues entonces, este es Pedidos

770
00:34:10,139 --> 00:34:12,219
me hago aux

771
00:34:12,219 --> 00:34:14,380
que tiene 4

772
00:34:14,380 --> 00:34:16,019
una más

773
00:34:16,019 --> 00:34:18,219
vale, con este for de aquí

774
00:34:18,219 --> 00:34:20,400
copio esto en esto, copio esto

775
00:34:20,400 --> 00:34:21,760
en esto, copio esto en esto

776
00:34:21,760 --> 00:34:24,460
¿qué hago con el nuevo? el nuevo aquí

777
00:34:24,460 --> 00:34:26,440
vale, ahora este array

778
00:34:26,440 --> 00:34:29,800
p, este es el array p

779
00:34:29,800 --> 00:34:31,900
y este es el array aux, que apunta aquí

780
00:34:31,900 --> 00:34:34,079
pues ahora ¿qué estoy haciendo con esta sentencia?

781
00:34:34,619 --> 00:34:35,739
estoy haciendo que

782
00:34:35,739 --> 00:34:37,860
pedidos p, deje

783
00:34:37,860 --> 00:34:39,139
de apuntar al viejo

784
00:34:39,139 --> 00:34:42,179
deje de apuntar al viejo y empiece a apuntar a este

785
00:34:42,179 --> 00:34:44,639
es lo que estoy haciendo con esta sentencia

786
00:34:44,639 --> 00:34:47,280
hacer que la referencia pedidos

787
00:34:47,280 --> 00:34:49,960
deje de apuntar a este array que ya no lo quiero

788
00:34:49,960 --> 00:34:51,960
y empiece a apuntar a este

789
00:34:51,960 --> 00:34:56,940
luego ahora pedidos se ha convertido en una referencia al bueno

790
00:34:56,940 --> 00:34:59,139
y ya está, y ya se queda

791
00:34:59,139 --> 00:35:00,860
pedidos con el bueno

792
00:35:00,860 --> 00:35:02,920
y este que le ha pasado

793
00:35:02,920 --> 00:35:06,159
este no es que haya desaparecido, ese sigue ahí en memoria

794
00:35:06,159 --> 00:35:08,579
pero se ha quedado sin nadie que lo apunte

795
00:35:08,579 --> 00:35:10,719
ahí ya no hay nadie que le esté apuntando

796
00:35:10,719 --> 00:35:12,980
porque el único que le apuntaba, que era este

797
00:35:12,980 --> 00:35:14,980
ha pasado a apuntar a este otro

798
00:35:14,980 --> 00:35:17,179
entonces si nadie le mira

799
00:35:17,179 --> 00:35:18,619
desaparece

800
00:35:18,619 --> 00:35:20,679
el recolector de basura, que es un proceso

801
00:35:20,679 --> 00:35:22,559
que aparece cada cierto tiempo en background

802
00:35:22,559 --> 00:35:24,500
va eliminando

803
00:35:24,500 --> 00:35:27,000
todo lo que se ha quedado

804
00:35:27,000 --> 00:35:28,239
sin nadie que le apunte

805
00:35:28,239 --> 00:35:31,019
este, el único

806
00:35:31,019 --> 00:35:32,920
que le apuntaba era este, que empezó

807
00:35:32,920 --> 00:35:33,820
a apuntar a este otro

808
00:35:33,820 --> 00:35:36,880
este se ha quedado ahí sin nadie que le apunta

809
00:35:36,880 --> 00:35:38,559
pues entonces, ala

810
00:35:38,559 --> 00:35:41,420
Ese, el recolector de basura

811
00:35:41,420 --> 00:35:42,300
Lo tira a la basura

812
00:35:42,300 --> 00:35:43,699
Para hacer dos milisegundos

813
00:35:43,699 --> 00:35:45,519
Y ahora ya, ¿qué se me ha quedado?

814
00:35:46,099 --> 00:35:47,840
Se me ha quedado este array ya bueno

815
00:35:47,840 --> 00:35:49,519
Con pedidos apuntándole

816
00:35:49,519 --> 00:35:52,980
Y aux también le está apuntando

817
00:35:52,980 --> 00:35:53,780
Pero no pasa nada

818
00:35:53,780 --> 00:35:55,519
Porque aux, como es una variable local

819
00:35:55,519 --> 00:35:56,820
Va a desaparecer

820
00:35:56,820 --> 00:35:59,059
¿Y dónde le hemos dado el tamaño?

821
00:36:00,889 --> 00:36:01,329
Aquí

822
00:36:01,329 --> 00:36:03,650
Ah, dices al original

823
00:36:03,650 --> 00:36:05,829
Tendrá el que tenga

824
00:36:05,829 --> 00:36:06,929
En el main

825
00:36:06,929 --> 00:36:09,829
La primera vez que insertemos un pedido

826
00:36:09,829 --> 00:36:12,150
la primera vez entrará por aquí porque es nul

827
00:36:12,150 --> 00:36:14,610
pues aquí le daremos su primer tamaño que es 1

828
00:36:14,610 --> 00:36:16,090
¿vale?

829
00:36:16,190 --> 00:36:18,170
o sea, con el primer pedido que insertemos

830
00:36:18,170 --> 00:36:20,409
con el primer pedido entraremos por aquí

831
00:36:20,409 --> 00:36:22,289
por el nul, porque será nul

832
00:36:22,289 --> 00:36:24,510
con el primero, y aquí le daremos

833
00:36:24,510 --> 00:36:25,690
su primer tamaño que es 1

834
00:36:25,690 --> 00:36:28,050
pero ya las siguientes veces

835
00:36:28,050 --> 00:36:30,670
irá creciendo a 2, y luego a 3

836
00:36:30,670 --> 00:36:31,349
y luego a 4

837
00:36:31,349 --> 00:36:38,050
claro, habría

838
00:36:38,050 --> 00:36:40,329
habido otra posibilidad, pero ya sería como

839
00:36:40,329 --> 00:36:42,449
ocupar demasiada memoria, que es

840
00:36:42,449 --> 00:36:44,690
crear para todos los clientes

841
00:36:44,690 --> 00:36:46,449
una array de pedidos de 50

842
00:36:46,449 --> 00:36:48,989
asumiendo que nunca va a tener

843
00:36:48,989 --> 00:36:50,829
más de 50, pero habría sido

844
00:36:50,829 --> 00:36:53,230
muy rollo, porque dentro de la clase cliente

845
00:36:53,230 --> 00:36:55,010
habría que haber puesto una variable

846
00:36:55,010 --> 00:36:57,130
adicional que dijera hasta cuántos

847
00:36:57,130 --> 00:36:59,010
pedidos hay, entonces ya

848
00:36:59,010 --> 00:37:04,929
vale, entonces

849
00:37:04,929 --> 00:37:06,090
ahora ya este método

850
00:37:06,090 --> 00:37:08,690
tiene toda esta complejidad

851
00:37:08,690 --> 00:37:10,670
que es un rollo, pero el main le viene

852
00:37:10,670 --> 00:37:12,650
fenomenal, el main llama a agregar

853
00:37:12,650 --> 00:37:14,349
pedido y se acabó, dime

854
00:37:14,349 --> 00:37:17,750
Y ahora podemos poner

855
00:37:17,750 --> 00:37:21,070
Pues eso, este método tiene aquí

856
00:37:21,070 --> 00:37:22,269
Es un rollo de método

857
00:37:22,269 --> 00:37:24,449
Pero ahí se queda escondido

858
00:37:24,449 --> 00:37:27,250
Ahora el main llama a agregar pedido

859
00:37:27,250 --> 00:37:29,969
Y ya sabe, no sabe cómo lo hace

860
00:37:29,969 --> 00:37:31,050
Y le da igual

861
00:37:31,050 --> 00:37:34,610
Sabe que este pedido se mete a la raíz de clientes

862
00:37:34,610 --> 00:37:37,530
Y ahora ya podemos completar aquí

863
00:37:37,530 --> 00:37:39,190
Pedido agregado

864
00:37:39,190 --> 00:37:55,940
Y listo

865
00:37:55,940 --> 00:37:56,500
¿Vale?

866
00:37:56,500 --> 00:37:59,860
Uy, me he puesto esto

867
00:37:59,860 --> 00:38:03,960
Vale, pedido agregado y ya está

868
00:38:03,960 --> 00:38:09,329
Vale, todo esto tiene miles de mejoras

869
00:38:09,329 --> 00:38:10,510
Aunque nos vamos ya así

870
00:38:10,510 --> 00:38:13,510
Pues que si encuentra el cliente

871
00:38:13,510 --> 00:38:14,750
Yo querría

872
00:38:14,750 --> 00:38:16,889
Dejar, abandonar el array

873
00:38:16,889 --> 00:38:18,269
Y no seguirlo recorriendo

874
00:38:18,269 --> 00:38:19,809
Pues un boolean que se ha encontrado

875
00:38:19,809 --> 00:38:20,849
Y aquí añade el boolean

876
00:38:20,849 --> 00:38:22,110
Luego un montón de arreglos, ¿vale?

877
00:38:22,789 --> 00:38:23,889
Venga, paramos aquí

878
00:38:26,929 --> 00:38:27,429
Vale