1
00:00:00,000 --> 00:00:07,000
Bueno, pues este método, efectivamente, es hacer un poquito lo de siempre,

2
00:00:07,000 --> 00:00:09,000
pero ahora ya dentro de un método de una clase.

3
00:00:09,000 --> 00:00:17,000
Nosotros tenemos un array y queremos ver si alguno de los elementos del array

4
00:00:17,000 --> 00:00:21,000
cumple una condición, en particular la de que su código sea este,

5
00:00:21,000 --> 00:00:23,000
pero podría ser cualquier otra, cumple.

6
00:00:23,000 --> 00:00:26,000
Pues eso es lo mismo, es saber si algo pasa o no pasa, es lo de siempre.

7
00:00:26,000 --> 00:00:29,000
De partida, asumimos que no pasa.

8
00:00:29,000 --> 00:00:31,000
Y ahora me pongo a recorrerlos todos.

9
00:00:31,000 --> 00:00:34,000
Con que encuentre uno que cumple la condición,

10
00:00:34,000 --> 00:00:37,000
cambio el resultado final y se acabó.

11
00:00:37,000 --> 00:00:38,000
Es lo de siempre.

12
00:00:38,000 --> 00:00:40,000
Pues aquí yo tendré que recorrer el array,

13
00:00:40,000 --> 00:00:43,000
el array está aquí en las propiedades de la clase.

14
00:00:43,000 --> 00:00:48,000
Luego puede acceder directamente, no tenemos ni que pedirlo ni que nada, lógicamente.

15
00:00:48,000 --> 00:00:51,000
Entonces ahora ya recorremos el array,

16
00:00:51,000 --> 00:00:56,000
y en este caso como es para consultar, un for each o un for de índice,

17
00:00:56,000 --> 00:01:01,000
da igual, si uno no es vago escribiendo, siempre va a ser muchísimo mejor

18
00:01:01,000 --> 00:01:05,000
un for de índice porque no hace copias internas de variables,

19
00:01:05,000 --> 00:01:08,000
no hace copias internas, eso que se ahorra,

20
00:01:08,000 --> 00:01:10,000
y no tiene problemas de sincronización si hay varios hilos.

21
00:01:10,000 --> 00:01:15,000
Ese no es nuestro problema ahora, pero podría serlo en otro momento.

22
00:01:15,000 --> 00:01:19,000
Pero a ver, en un ejemplito, pues normal, que tampoco tiene mayores complicaciones,

23
00:01:19,000 --> 00:01:21,000
pues si uno es vago con un for each y ya está y no pasa nada,

24
00:01:21,000 --> 00:01:24,000
no tiene mayor valedad.

25
00:01:24,000 --> 00:01:33,000
Mientras sí, sea menor que pedidos.length, incrementando i,

26
00:01:33,000 --> 00:01:35,000
pues la historia de siempre.

27
00:01:35,000 --> 00:01:38,000
Vamos a ver, el pedido de i cumple la condición,

28
00:01:38,000 --> 00:01:43,000
¿qué condición? La de que su código sea como el que me han dado.

29
00:01:43,000 --> 00:01:49,000
Entonces, pedidos de i, su código y su código lo tengo que coger con el get,

30
00:01:49,000 --> 00:01:53,000
porque es una propiedad privada, con lo cual no puedo acceder directamente a ella,

31
00:01:53,000 --> 00:01:57,000
y como es un string, o no es un string, sí es un string,

32
00:01:57,000 --> 00:02:00,000
como es un string lo tengo que comparar con equals,

33
00:02:00,000 --> 00:02:03,000
todas las cosas que ya no me puedo olvidar a estas alturas.

34
00:02:03,000 --> 00:02:05,000
¿Es igual que el que me han dado?

35
00:02:05,000 --> 00:02:08,000
Pues ya está, ya hemos encontrado un pedido que cumple la condición.

36
00:02:08,000 --> 00:02:11,000
Pues result igual a true.

37
00:02:11,000 --> 00:02:13,000
Y ya está, y ahí me he quedado.

38
00:02:13,000 --> 00:02:18,000
Y aquí es donde hay que evitar la tentación terrible que os vence a muchos

39
00:02:18,000 --> 00:02:24,000
de decir plantar aquí este else y si no result false.

40
00:02:24,000 --> 00:02:27,000
¿Eh Miguel?

41
00:02:27,000 --> 00:02:33,000
Cuidado con esa tentación tremendo, porque esto entonces ya perdería todo el sentido.

42
00:02:33,000 --> 00:02:36,000
Entonces, ¿qué ocurre? Si es el primero lo hemos cambiado a true,

43
00:02:36,000 --> 00:02:40,000
pero si luego el cuarto no es, me lo pone a false otra vez.

44
00:02:40,000 --> 00:02:42,000
El cuarto ya ha perdido el sentido.

45
00:02:42,000 --> 00:02:46,000
Cuando ya se ha hecho true, ya se ha hecho true para siempre.

46
00:02:46,000 --> 00:02:50,000
Entonces, esto fuera.

47
00:02:56,000 --> 00:02:58,000
¿Cómo en el bucle?

48
00:03:06,000 --> 00:03:08,000
¿Al lado del?

49
00:03:08,000 --> 00:03:10,000
Sí.

50
00:03:10,000 --> 00:03:12,000
Ah, vale, vale, vale.

51
00:03:12,000 --> 00:03:15,000
Claro, o sea, sí.

52
00:03:15,000 --> 00:03:17,000
A ver.

53
00:03:17,000 --> 00:03:20,000
Claro, ¿pero para qué?

54
00:03:20,000 --> 00:03:22,000
Sí, vamos a ver.

55
00:03:22,000 --> 00:03:26,000
Una vez, efectivamente, esta sería la estructura básica.

56
00:03:26,000 --> 00:03:29,000
Una vez que ya he encontrado un pedido que lo cumple, lo pongo a true.

57
00:03:29,000 --> 00:03:33,000
Y ya lo que pase con el resto de pedidos ya me da igual.

58
00:03:33,000 --> 00:03:36,000
Lo que desde luego no puedo hacer es que luego me lleve un pedido

59
00:03:36,000 --> 00:03:38,000
tres posiciones después y lo vuelvo a cambiar a false.

60
00:03:38,000 --> 00:03:40,000
Eso es lo que no me puede ocurrir. Eso está claro, ¿no?

61
00:03:40,000 --> 00:03:42,000
Que era la base de esto.

62
00:03:42,000 --> 00:03:45,000
Ahora ya uno se puede poner a, efectivamente, retocar esto y decir,

63
00:03:45,000 --> 00:03:49,000
hombre, una vez que ya he encontrado un pedido que es true,

64
00:03:49,000 --> 00:03:53,000
voy a dejar de recorrer a array, porque ya no me aporta nada.

65
00:03:53,000 --> 00:03:57,000
Entonces, hombre, imaginaos que este array fuera de, yo qué sé, 4.000.

66
00:03:57,000 --> 00:04:00,000
Y ya encontró en el primero que es true.

67
00:04:00,000 --> 00:04:03,000
¿Vamos a hacer 3.999 iteraciones?

68
00:04:03,000 --> 00:04:05,000
Pues, hombre, ¿para qué?

69
00:04:05,000 --> 00:04:11,000
Entonces, podemos, efectivamente, hacer que una vez que ha entrado aquí,

70
00:04:11,000 --> 00:04:15,000
ya este for no se ejecute más, ¿no?

71
00:04:15,000 --> 00:04:19,000
Por ejemplo, primera forma que se os ocurriría, ¿vale?

72
00:04:19,000 --> 00:04:22,000
Para evitar esas iteraciones que ya no aportan nada.

73
00:04:22,000 --> 00:04:24,000
¿Qué podríamos hacer?

74
00:04:24,000 --> 00:04:26,000
Pues lo que ha dicho él, ¿no?

75
00:04:26,000 --> 00:04:31,000
No nos olvidemos que esto es una condición en la que puedo poner lo que a mí me dé la gana.

76
00:04:31,000 --> 00:04:34,000
Entonces, en esta condición yo le puedo poner,

77
00:04:34,000 --> 00:04:38,000
oye, tú ve avanzando mientras no hayas llegado a la posición

78
00:04:38,000 --> 00:04:41,000
y no hayas encontrado

79
00:04:46,000 --> 00:04:49,000
y no hayas encontrado un pedido con ese código.

80
00:04:49,000 --> 00:04:51,000
Por ejemplo.

81
00:04:51,000 --> 00:04:55,000
Entonces, simplemente con esa modificación, este bucle va avanzando.

82
00:04:55,000 --> 00:05:01,000
En cuanto encuentra uno que ya lo cumple, se pone a true.

83
00:05:01,000 --> 00:05:04,000
Con lo cual, esto ya se pondría a false.

84
00:05:04,000 --> 00:05:08,000
Luego, en la siguiente iteración, ya no entra.

85
00:05:08,000 --> 00:05:09,000
Y ya está.

86
00:05:09,000 --> 00:05:14,000
Y te ahorras las 20, 30 iteraciones que te faltan, que ya no las necesitas.

87
00:05:14,000 --> 00:05:17,000
Por ejemplo, ¿no?

88
00:05:17,000 --> 00:05:18,000
¿Vale?

89
00:05:18,000 --> 00:05:20,000
Está claro lo que hemos hecho.

90
00:05:20,000 --> 00:05:21,000
Aprovecharnos.

91
00:05:21,000 --> 00:05:23,000
Una vez que esto ya se ha puesto a true,

92
00:05:23,000 --> 00:05:27,000
aprovecharnos para que esta condición ya se convierta en false

93
00:05:27,000 --> 00:05:29,000
y yo ya no entro más.

94
00:05:30,000 --> 00:05:31,000
¿No?

95
00:05:31,000 --> 00:05:34,000
Así una vez que he encontrado el pedido,

96
00:05:34,000 --> 00:05:37,000
lo que pase con los demás es que me da lo mismo.

97
00:05:37,000 --> 00:05:39,000
Lo que pase con los demás ya me da igual.

98
00:05:39,000 --> 00:05:41,000
Esta podría ser una opción.

99
00:05:43,000 --> 00:05:44,000
Claro, otra.

100
00:05:44,000 --> 00:05:48,000
La que pensaba que me ibas a decir la primera,

101
00:05:48,000 --> 00:05:51,000
que es la que me pone muy nerviosa y muy fea.

102
00:05:51,000 --> 00:05:53,000
Plantado un break en el foro.

103
00:05:53,000 --> 00:05:55,000
Claro, pues sí.

104
00:05:55,000 --> 00:05:57,000
Uno planta un break a tomar por culo.

105
00:05:57,000 --> 00:05:58,000
Claro.

106
00:05:58,000 --> 00:06:02,000
Pero los software, los programas que tienen break,

107
00:06:02,000 --> 00:06:05,000
luego son muy confusos.

108
00:06:05,000 --> 00:06:08,000
Aunque ahora no nos hagamos idea.

109
00:06:08,000 --> 00:06:10,000
Porque los códigos que hacemos son cortitos.

110
00:06:10,000 --> 00:06:13,000
Son muy confusos porque el break es párate.

111
00:06:13,000 --> 00:06:17,000
Y a lo mejor el break está en un foro que dentro tiene

112
00:06:17,000 --> 00:06:20,000
un montón de llamadas a métodos y cosas muy largas.

113
00:06:20,000 --> 00:06:23,000
Entonces tú, cuando haces un vistazo al foro,

114
00:06:23,000 --> 00:06:26,000
desde aquí quieres entender lo que pasa.

115
00:06:26,000 --> 00:06:30,000
Y si tú pones en la condición todo lo relacionado

116
00:06:30,000 --> 00:06:32,000
con cuándo entra y cuándo sale,

117
00:06:32,000 --> 00:06:34,000
va a saber rápidamente lo que hace.

118
00:06:34,000 --> 00:06:36,000
Pero si tú en un break que está ahí oculto

119
00:06:36,000 --> 00:06:38,000
lo obligas a salir,

120
00:06:38,000 --> 00:06:41,000
eso tú no lo ves cuando miras aquí arriba.

121
00:06:41,000 --> 00:06:43,000
No te haces a la idea de que puede ocurrir algo

122
00:06:43,000 --> 00:06:44,000
que lo haga salir.

123
00:06:44,000 --> 00:06:45,000
No te haces a la idea.

124
00:06:45,000 --> 00:06:47,000
Tendrías que empezar a ir a todas las llamadas

125
00:06:47,000 --> 00:06:49,000
que hay dentro hasta que llegues al break.

126
00:06:49,000 --> 00:06:53,000
Entonces, hombre, no es un código muy legible.

127
00:06:53,000 --> 00:06:55,000
Lo ideal es que tú, mirando esta línea,

128
00:06:55,000 --> 00:06:57,000
te puedas hacer una idea de cuándo ese bucle

129
00:06:57,000 --> 00:06:59,000
se ejecuta o no se ejecuta.

130
00:06:59,000 --> 00:07:01,000
Entonces, que esta condición se hace más larga.

131
00:07:01,000 --> 00:07:03,000
No pasa nada, se hace más larga.

132
00:07:03,000 --> 00:07:05,000
Pero tú ya más o menos estarás a la idea de lo que hace.

133
00:07:05,000 --> 00:07:07,000
Porque el break ahí escondido

134
00:07:07,000 --> 00:07:09,000
tiene una acción muy radical

135
00:07:09,000 --> 00:07:11,000
que es romper el bucle

136
00:07:11,000 --> 00:07:13,000
y tú aquí arriba no la estás viendo.

137
00:07:13,000 --> 00:07:15,000
No la estás viendo, que puede ocurrir algo

138
00:07:15,000 --> 00:07:17,000
que no está aquí, puede ocurrir algo

139
00:07:17,000 --> 00:07:19,000
y que se por desaparece.

140
00:07:19,000 --> 00:07:22,000
Entonces, salvo en códigos muy manejables y cortitos,

141
00:07:22,000 --> 00:07:26,000
pues por eso los break están tan mal vistos y con razón.

142
00:07:28,000 --> 00:07:31,000
Pero vamos, que si uno está haciendo

143
00:07:31,000 --> 00:07:34,000
sus propios códigos así patateros

144
00:07:34,000 --> 00:07:36,000
y dice, hombre, pues a mí no me importa.

145
00:07:36,000 --> 00:07:38,000
Jolín, yo pongo aquí un break si me da la gana

146
00:07:38,000 --> 00:07:40,000
por lo tal, por la chorrada que estoy haciendo,

147
00:07:40,000 --> 00:07:43,000
pues hombre, pues lo pone y ya está.

148
00:07:43,000 --> 00:07:46,000
Y esto significa, cuando ya he llegado

149
00:07:46,000 --> 00:07:48,000
a que esto sea true, fue razón.

150
00:07:48,000 --> 00:07:50,000
Se acabó.

151
00:07:50,000 --> 00:07:52,000
Y es lo que significa la sentencia break.

152
00:07:52,000 --> 00:07:54,000
Sale del bucle en el que esté.

153
00:07:54,000 --> 00:07:56,000
Ya no se ejecuta más.

154
00:07:56,000 --> 00:07:58,000
Pero esto es muy feo, no me gusta.

155
00:07:58,000 --> 00:08:00,000
Otra cosa que podríamos hacer,

156
00:08:00,000 --> 00:08:02,000
aparte de poner ahí la variable,

157
00:08:02,000 --> 00:08:04,000
que eso estaría mejor, más bonito,

158
00:08:04,000 --> 00:08:06,000
o el break,

159
00:08:06,000 --> 00:08:10,000
para que este bucle saliera

160
00:08:10,000 --> 00:08:12,000
en el momento en el cual

161
00:08:12,000 --> 00:08:14,000
hemos encontrado ya

162
00:08:14,000 --> 00:08:16,000
un pedido que cumple la condición.

163
00:08:16,000 --> 00:08:18,000
Bueno, pues podemos aprovecharnos

164
00:08:18,000 --> 00:08:20,000
de que es un método

165
00:08:20,000 --> 00:08:24,000
y usar el retorno.

166
00:08:24,000 --> 00:08:26,000
Y hacer esto.

167
00:08:26,000 --> 00:08:28,000
Y fijaos, ala, qué bonito y qué fácil.

168
00:08:32,000 --> 00:08:34,000
Ala.

169
00:08:34,000 --> 00:08:36,000
Esto es un poco radical también,

170
00:08:36,000 --> 00:08:38,000
pero bueno, esto sí que...

171
00:08:38,000 --> 00:08:40,000
Cuando encuentro el pedido

172
00:08:40,000 --> 00:08:42,000
cuyo código coincide,

173
00:08:42,000 --> 00:08:44,000
ya salgo del método directamente.

174
00:08:44,000 --> 00:08:46,000
Ya salgo, porque ya no quiero hacer más.

175
00:08:46,000 --> 00:08:48,000
Ya acabo el método.

176
00:08:48,000 --> 00:08:50,000
Entonces, si salgo del método,

177
00:08:50,000 --> 00:08:52,000
lógicamente salgo del for y salgo de todo.

178
00:08:52,000 --> 00:08:54,000
Y además salgo devolviendo true.

179
00:08:54,000 --> 00:08:56,000
Y entonces, aquí abajo,

180
00:08:56,000 --> 00:08:58,000
pondríamos return false.

181
00:09:00,000 --> 00:09:02,000
Porque si yo llego aquí abajo,

182
00:09:02,000 --> 00:09:04,000
es porque no salí por el return true.

183
00:09:04,000 --> 00:09:06,000
Entonces esta línea me sobraría ya.

184
00:09:06,000 --> 00:09:08,000
Esta línea me sobraría.

185
00:09:08,000 --> 00:09:10,000
O sea, si llego a un pedido

186
00:09:10,000 --> 00:09:12,000
cuyo código es igual,

187
00:09:12,000 --> 00:09:14,000
fuera ya método, me voy de ahí,

188
00:09:14,000 --> 00:09:16,000
return true.

189
00:09:16,000 --> 00:09:18,000
Que no he salido por aquí nunca.

190
00:09:18,000 --> 00:09:20,000
Entonces es que el for ha terminado y llego aquí.

191
00:09:20,000 --> 00:09:22,000
Pues en ese caso return false,

192
00:09:22,000 --> 00:09:24,000
porque no he encontrado ningún pedido.

193
00:09:24,000 --> 00:09:26,000
Sería otra forma de plantearlo.

194
00:09:26,000 --> 00:09:28,000
Pero claro, en métodos en los cuales

195
00:09:28,000 --> 00:09:30,000
lo único que queremos hacer es esto.

196
00:09:30,000 --> 00:09:32,000
No queremos que se hagan más cosas.

197
00:09:32,000 --> 00:09:34,000
Porque el return es que ya sale del método

198
00:09:34,000 --> 00:09:36,000
y sale de todo.

199
00:09:38,000 --> 00:09:40,000
Pero bueno, lo más bonito, en realidad,

200
00:09:40,000 --> 00:09:42,000
lo más...

201
00:09:42,000 --> 00:09:44,000
sería

202
00:09:44,000 --> 00:09:46,000
una variable que yo la voy cambiando

203
00:09:46,000 --> 00:09:48,000
de valor

204
00:09:52,000 --> 00:09:54,000
y luego aquí la devuelvo.

205
00:09:56,000 --> 00:09:58,000
Esto sería, de alguna manera,

206
00:09:58,000 --> 00:10:00,000
lo más ortodoxo,

207
00:10:00,000 --> 00:10:02,000
lo más purista.

208
00:10:02,000 --> 00:10:04,000
Porque aquí, cualquier otro

209
00:10:04,000 --> 00:10:06,000
cambio que yo quiera incorporar,

210
00:10:06,000 --> 00:10:08,000
seguramente sea más fácilmente

211
00:10:08,000 --> 00:10:10,000
incorporable.

212
00:10:10,000 --> 00:10:12,000
Si quiero que este método además haga otras cosas,

213
00:10:12,000 --> 00:10:14,000
pues las puedo poner aquí abajo.

214
00:10:14,000 --> 00:10:16,000
Si tengo el return aquí arriba, pues ya tengo que cambiar el return.

215
00:10:16,000 --> 00:10:18,000
Porque si tenía el return aquí arriba ya,

216
00:10:18,000 --> 00:10:20,000
pues he puesto dos puntos y coma.

217
00:10:20,000 --> 00:10:22,000
Esto sería lo más

218
00:10:22,000 --> 00:10:24,000
purista y ortodoxo.

219
00:10:24,000 --> 00:10:26,000
Y a la hora de incorporar cosas nuevas,

220
00:10:26,000 --> 00:10:28,000
menos cambios voy a tener que hacer.

221
00:10:28,000 --> 00:10:30,000
Pero lo que tenemos que entenderlo todo.

222
00:10:30,000 --> 00:10:32,000
Lógicamente.

223
00:10:32,000 --> 00:10:34,000
Y saber la potencialidad

224
00:10:34,000 --> 00:10:36,000
que tiene cualquier sentencia

225
00:10:36,000 --> 00:10:38,000
y entender todas las construcciones posibles.

226
00:10:38,000 --> 00:10:40,000
Entenderlas.

227
00:10:40,000 --> 00:10:42,000
¿Vale?

228
00:10:44,000 --> 00:10:46,000
Bueno, pues este método ya estaría.

229
00:10:46,000 --> 00:10:48,000
Para que se nos vaya...

230
00:10:48,000 --> 00:10:50,000
Bueno.

231
00:10:50,000 --> 00:10:52,000
Vamos a incorporar ahora ya

232
00:10:52,000 --> 00:10:54,000
en el software, pues que la aplicación

233
00:10:54,000 --> 00:10:56,000
haga esta funcionalidad.

234
00:10:56,000 --> 00:10:58,000
Porque esto no deja de ser la clase.

235
00:10:58,000 --> 00:11:00,000
Aquí todavía tenemos que ponernos en el chip

236
00:11:00,000 --> 00:11:02,000
de que no hay nada ejecutándose.

237
00:11:02,000 --> 00:11:04,000
Esto es la clase que te dice

238
00:11:04,000 --> 00:11:06,000
si algún cliente alguna vez

239
00:11:06,000 --> 00:11:08,000
quiere ver si ha pedido un pedido,

240
00:11:08,000 --> 00:11:10,000
llamará a esto. Pero todavía no hay

241
00:11:10,000 --> 00:11:12,000
ningún cliente pidiendo nada,

242
00:11:12,000 --> 00:11:14,000
ni hay ningún pedido, ni hay nada.

243
00:11:14,000 --> 00:11:16,000
Estamos ahora haciendo la clase solo.

244
00:11:16,000 --> 00:11:18,000
Luego ya se hará

245
00:11:18,000 --> 00:11:20,000
el software que es el que llama

246
00:11:20,000 --> 00:11:22,000
a estas clases, llama a los objetos

247
00:11:22,000 --> 00:11:24,000
y ya hace las cosas.

248
00:11:24,000 --> 00:11:26,000
Y ese es el main, en nuestro caso el main famoso.

249
00:11:26,000 --> 00:11:28,000
Podría ser una interfaz gráfica

250
00:11:28,000 --> 00:11:30,000
también, la que llama a estas cosas

251
00:11:30,000 --> 00:11:32,000
pero como no sabemos hacer

252
00:11:32,000 --> 00:11:34,000
interfaces gráficas, pues haremos un main.

253
00:11:34,000 --> 00:11:36,000
Un main con un menú.

254
00:11:36,000 --> 00:11:38,000
Bueno, pues ese software que estábamos haciendo

255
00:11:38,000 --> 00:11:40,000
era algo como esto.

256
00:11:42,000 --> 00:11:44,000
Habíamos hecho estas

257
00:11:44,000 --> 00:11:46,000
funcionalidades.

258
00:11:46,000 --> 00:11:48,000
Yo aquí en mi ejemplito

259
00:11:48,000 --> 00:11:50,000
no las tengo todas incorporadas

260
00:11:50,000 --> 00:11:52,000
todavía porque esta es la versión de aquí,

261
00:11:52,000 --> 00:11:54,000
no es la de mi portátil, que se me había traído.

262
00:11:54,000 --> 00:11:56,000
Pero bueno, estas las teníamos

263
00:11:58,000 --> 00:12:00,000
todas hechas, yo creo.

264
00:12:00,000 --> 00:12:02,000
Nos faltaba eliminar simplemente.

265
00:12:02,000 --> 00:12:04,000
La llamada al método.

266
00:12:04,000 --> 00:12:06,000
Pero vamos.

267
00:12:06,000 --> 00:12:08,000
Teníamos estas funcionalidades hechas.

268
00:12:08,000 --> 00:12:10,000
Vale, pues ahora esta es nuestro software

269
00:12:10,000 --> 00:12:12,000
cuando solamente

270
00:12:12,000 --> 00:12:14,000
trabajaba con pedidos.

271
00:12:14,000 --> 00:12:16,000
Solamente trabajaba con pedidos.

272
00:12:16,000 --> 00:12:18,000
Ahora nuestro software se ha hecho más grande

273
00:12:18,000 --> 00:12:20,000
y ahora puede

274
00:12:20,000 --> 00:12:22,000
trabajar también con clientes.

275
00:12:24,000 --> 00:12:26,000
Bueno, pues entonces.

276
00:12:26,000 --> 00:12:28,000
La primera pregunta

277
00:12:28,000 --> 00:12:30,000
en relación a un

278
00:12:30,000 --> 00:12:32,000
diseño de software siempre es

279
00:12:32,000 --> 00:12:34,000
¿Cómo vas a trabajar con datos?

280
00:12:34,000 --> 00:12:36,000
¿Los datos dónde están?

281
00:12:36,000 --> 00:12:38,000
¿Dónde están los datos? ¿Cuáles son tus datos y dónde están?

282
00:12:38,000 --> 00:12:40,000
Vale, pues ahora tenemos también

283
00:12:40,000 --> 00:12:42,000
un volumen de datos que van a ser los clientes.

284
00:12:42,000 --> 00:12:44,000
Y eso es lo primero

285
00:12:44,000 --> 00:12:46,000
que hay que resolver.

286
00:12:46,000 --> 00:12:48,000
Vale, si vas a trabajar con clientes,

287
00:12:48,000 --> 00:12:50,000
¿esos clientes dónde están?

288
00:12:50,000 --> 00:12:52,000
Para que yo haga cosas con ellos.

289
00:12:52,000 --> 00:12:54,000
Cuando yo inserte uno nuevo, ¿dónde va a ir a parar?

290
00:12:54,000 --> 00:12:56,000
¿Dónde están?

291
00:12:56,000 --> 00:12:58,000
Esa es la primera pregunta.

292
00:12:58,000 --> 00:13:00,000
Hay que empezar a preguntarse

293
00:13:00,000 --> 00:13:02,000
¿Qué vas a hacer con esos clientes?

294
00:13:02,000 --> 00:13:04,000
Hay que preguntarse dónde van a estar.

295
00:13:04,000 --> 00:13:06,000
La respuesta habitual es

296
00:13:06,000 --> 00:13:08,000
obviamente en una base de datos.

297
00:13:08,000 --> 00:13:10,000
Y entonces la aplicación se conectará

298
00:13:10,000 --> 00:13:12,000
con esa base de datos

299
00:13:12,000 --> 00:13:14,000
para bien meter clientes nuevos

300
00:13:14,000 --> 00:13:16,000
o bien para recoger clientes

301
00:13:16,000 --> 00:13:18,000
y trabajar con ellos.

302
00:13:18,000 --> 00:13:20,000
Pero claro, nosotros no sabemos conectarnos

303
00:13:20,000 --> 00:13:22,000
a una base de datos

304
00:13:22,000 --> 00:13:24,000
para meterle un objeto cliente o recuperarlo.

305
00:13:24,000 --> 00:13:26,000
No sabemos hacer eso.

306
00:13:26,000 --> 00:13:28,000
Nuestros clientes tienen que estar en otro sitio.

307
00:13:28,000 --> 00:13:30,000
Pues por eso los metemos directamente

308
00:13:30,000 --> 00:13:32,000
en una variable de la aplicación.

309
00:13:32,000 --> 00:13:34,000
¿Vale?

310
00:13:34,000 --> 00:13:36,000
En condiciones normales, esa variable se habrá

311
00:13:36,000 --> 00:13:38,000
rellenado con lo que hay en una base de datos.

312
00:13:38,000 --> 00:13:40,000
En nuestro caso,

313
00:13:40,000 --> 00:13:42,000
la rellenamos directamente por consola

314
00:13:42,000 --> 00:13:44,000
porque no sabemos rellenarla en una base de datos.

315
00:13:44,000 --> 00:13:46,000
Y esa variable

316
00:13:46,000 --> 00:13:48,000
para guardar muchos clientes,

317
00:13:48,000 --> 00:13:50,000
pues ahora mismo

318
00:13:50,000 --> 00:13:52,000
es un array.

319
00:13:52,000 --> 00:13:54,000
Pero bueno, podría ser un conjunto, una lista,

320
00:13:54,000 --> 00:13:56,000
un mapa, un diccionario, bueno, millones de cosas.

321
00:13:56,000 --> 00:13:58,000
Podría ser.

322
00:13:58,000 --> 00:14:00,000
¿Vale? Pues

323
00:14:00,000 --> 00:14:02,000
en esta aplicación vamos a

324
00:14:02,000 --> 00:14:04,000
poner

325
00:14:08,000 --> 00:14:10,000
nuestro almacén

326
00:14:10,000 --> 00:14:12,000
de clientes.

327
00:14:12,000 --> 00:14:14,000
Nuestro almacén de clientes.

328
00:14:14,000 --> 00:14:16,000
Entonces claro, el array

329
00:14:16,000 --> 00:14:18,000
es tremendamente

330
00:14:18,000 --> 00:14:20,000
eficiente computacionalmente y es una

331
00:14:20,000 --> 00:14:22,000
estructura básica sobre la que se apoya todo.

332
00:14:22,000 --> 00:14:24,000
Pero

333
00:14:24,000 --> 00:14:26,000
ya sabemos,

334
00:14:26,000 --> 00:14:28,000
por enésima vez hemos dicho,

335
00:14:28,000 --> 00:14:30,000
que su única pega

336
00:14:30,000 --> 00:14:32,000
es que es una estructura

337
00:14:32,000 --> 00:14:34,000
estática, o lo que es lo mismo,

338
00:14:34,000 --> 00:14:36,000
cuando se crea,

339
00:14:36,000 --> 00:14:38,000
se crea con un tamaño determinado

340
00:14:38,000 --> 00:14:40,000
y ese no se mueve.

341
00:14:40,000 --> 00:14:42,000
Esa es la única pega que tiene el array.

342
00:14:42,000 --> 00:14:44,000
Y por esa única pega

343
00:14:44,000 --> 00:14:46,000
es por la que se han hecho clases

344
00:14:46,000 --> 00:14:48,000
por encima que usan

345
00:14:48,000 --> 00:14:50,000
los arrays debajo trucándolos.

346
00:14:50,000 --> 00:14:52,000
Trucándolos como los hemos

347
00:14:52,000 --> 00:14:54,000
trucado nosotros, pues haciendo uno nuevo

348
00:14:54,000 --> 00:14:56,000
con una posición más, sustituyéndolo.

349
00:14:56,000 --> 00:14:58,000
Pues son clases que tienen como propiedad

350
00:14:58,000 --> 00:15:00,000
interna un array suyo y lo trucan.

351
00:15:00,000 --> 00:15:02,000
¿Vale? Bueno,

352
00:15:02,000 --> 00:15:04,000
esas son las colecciones.

353
00:15:04,000 --> 00:15:06,000
Hay varias variantes, varios rollos, ¿vale?

354
00:15:06,000 --> 00:15:08,000
Eso pues ya lo veremos, el tema de colecciones que le gustan

355
00:15:08,000 --> 00:15:10,000
tanto a Alejandro. Y ya veremos cuando

356
00:15:10,000 --> 00:15:12,000
las veamos por dentro, las hagamos nosotros y te siguen gustando

357
00:15:12,000 --> 00:15:14,000
tanto. Dios quiera que sí.

358
00:15:14,000 --> 00:15:16,000
¿Vale? Porque...

359
00:15:17,000 --> 00:15:19,000
Claro hombre, porque es la forma fácil

360
00:15:19,000 --> 00:15:21,000
de usarlas, pero todavía no las hemos visto.

361
00:15:21,000 --> 00:15:23,000
Tenéis que aprender a programar primero.

362
00:15:24,000 --> 00:15:26,000
Tenéis que aprender primero a programar

363
00:15:26,000 --> 00:15:28,000
y luego ya...

364
00:15:28,000 --> 00:15:30,000
Puedes decir lo que quieras.

365
00:15:30,000 --> 00:15:32,000
¿Eh?

366
00:15:33,000 --> 00:15:35,000
Eso es lo bueno, luego todo se sepa.

367
00:15:35,000 --> 00:15:37,000
Vale, pues entonces.

368
00:15:37,000 --> 00:15:39,000
Todo este rollo venía a cuento de que

369
00:15:39,000 --> 00:15:41,000
la única pega que tiene el array es que es una estructura estática.

370
00:15:41,000 --> 00:15:43,000
Entonces tenemos que decidir el volumen,

371
00:15:43,000 --> 00:15:45,000
la capacidad

372
00:15:45,000 --> 00:15:47,000
previamente.

373
00:15:47,000 --> 00:15:49,000
Bueno, pues para no complicarnos

374
00:15:49,000 --> 00:15:51,000
en la vida, venga, esta aplicación

375
00:15:51,000 --> 00:15:53,000
como mucho va a tener, como muchísimo

376
00:15:53,000 --> 00:15:55,000
yo voy a poder registrar

377
00:15:55,000 --> 00:15:57,000
100 clientes, pues ala, 100.

378
00:15:57,000 --> 00:15:59,000
¿Vale? Repito,

379
00:15:59,000 --> 00:16:01,000
esto lo solucionaremos

380
00:16:01,000 --> 00:16:03,000
lo solucionaremos

381
00:16:03,000 --> 00:16:05,000
a corto plazo usando colecciones.

382
00:16:05,000 --> 00:16:07,000
¿Vale? Pero las colecciones

383
00:16:07,000 --> 00:16:09,000
hay que entender muy bien cómo está hecha

384
00:16:09,000 --> 00:16:11,000
cada una por dentro, porque cada una tiene su peculiaridad.

385
00:16:11,000 --> 00:16:13,000
Porque de entender eso

386
00:16:13,000 --> 00:16:15,000
se deriva

387
00:16:15,000 --> 00:16:17,000
que luego tú puedas hacer una selección

388
00:16:17,000 --> 00:16:19,000
correcta de la colección que vas a usar.

389
00:16:19,000 --> 00:16:21,000
No te vale cualquiera para cualquier

390
00:16:21,000 --> 00:16:23,000
aplicación, no te vale cualquiera para cualquiera.

391
00:16:23,000 --> 00:16:25,000
Tienes que hacer una selección correcta.

392
00:16:25,000 --> 00:16:27,000
Vale, pues nada.

393
00:16:27,000 --> 00:16:29,000
Cliente, importamos la clase cliente

394
00:16:29,000 --> 00:16:31,000
porque no nos apetece ponerle

395
00:16:31,000 --> 00:16:33,000
todo el rollito de com, dan uno

396
00:16:33,000 --> 00:16:35,000
entidades que es muy largo, no nos apetece

397
00:16:35,000 --> 00:16:37,000
pues le ponemos el import.

398
00:16:37,000 --> 00:16:39,000
Ya tenemos la clase cliente.

399
00:16:39,000 --> 00:16:41,000
Bueno, pues eso nos permitiría

400
00:16:41,000 --> 00:16:43,000
ya hacer

401
00:16:43,000 --> 00:16:45,000
funcionalidades añadidas con este software.

402
00:16:45,000 --> 00:16:47,000
Pues por ejemplo,

403
00:16:47,000 --> 00:16:49,000
vamos a

404
00:16:49,000 --> 00:16:51,000
hacer

405
00:16:51,000 --> 00:16:53,000
la funcionalidad

406
00:16:53,000 --> 00:16:55,000
8, con lo cual

407
00:16:55,000 --> 00:16:57,000
cambia la 9 de salir

408
00:16:57,000 --> 00:16:59,000
y por tanto

409
00:16:59,000 --> 00:17:01,000
que no se me olvide esto,

410
00:17:01,000 --> 00:17:03,000
cambiarlo a 9,

411
00:17:03,000 --> 00:17:05,000
la de salir, cambiarlo a 9,

412
00:17:05,000 --> 00:17:07,000
pues la funcionalidad 8

413
00:17:07,000 --> 00:17:09,000
que sea

414
00:17:09,000 --> 00:17:13,000
incorporar

415
00:17:13,000 --> 00:17:15,000
pedido

416
00:17:15,000 --> 00:17:17,000
a cliente.

417
00:17:21,000 --> 00:17:23,000
Vale,

418
00:17:23,000 --> 00:17:25,000
incorporar pedido a cliente.

419
00:17:25,000 --> 00:17:27,000
Vale.

420
00:17:27,000 --> 00:17:29,000
Y luego podemos

421
00:17:29,000 --> 00:17:31,000
hacer también la...

422
00:17:31,000 --> 00:17:33,000
A ver,

423
00:17:33,000 --> 00:17:35,000
para no tener que estar viendo el numerito este todo el rato,

424
00:17:35,000 --> 00:17:37,000
voy a poner que la de salir sea

425
00:17:37,000 --> 00:17:39,000
muy bien.

426
00:17:39,000 --> 00:17:41,000
Iba a poner yo la 100, pero es absurdo

427
00:17:41,000 --> 00:17:43,000
poner tres números y ponerte poner uno.

428
00:17:43,000 --> 00:17:45,000
Tienes toda razón, la de salir es la 0.

429
00:17:45,000 --> 00:17:47,000
Y así yo no la cambio nunca más.

430
00:17:47,000 --> 00:17:49,000
La de salir es la 0.

431
00:17:51,000 --> 00:17:53,000
Vale, bien pensado.

432
00:17:55,000 --> 00:17:57,000
Vale, pues la otra que vamos a hacer

433
00:17:57,000 --> 00:17:59,000
va a ser incorporar un pedido a cliente.

434
00:18:07,000 --> 00:18:09,000
Mostrar dirección,

435
00:18:09,000 --> 00:18:11,000
por ejemplo,

436
00:18:11,000 --> 00:18:13,000
bueno cliente,

437
00:18:13,000 --> 00:18:15,000
para que hemos hecho los datos, el nombre y la dirección

438
00:18:15,000 --> 00:18:17,000
para poder enviar la cartita, una carta,

439
00:18:17,000 --> 00:18:19,000
se lo mandamos a un paquete.

440
00:18:19,000 --> 00:18:21,000
Mostrar datos del cliente que ha hecho un pedido.

441
00:18:29,000 --> 00:18:31,000
Vale, entonces esta opción 9

442
00:18:31,000 --> 00:18:33,000
es la que daremos cuando nos ha llegado un pedido

443
00:18:33,000 --> 00:18:35,000
y decimos, a ver, ¿este para quién es?

444
00:18:35,000 --> 00:18:37,000
Se lo voy a meter en una caja y voy a poner aquí

445
00:18:37,000 --> 00:18:39,000
la pegatina con su nombre y dirección.

446
00:18:39,000 --> 00:18:41,000
Pues daremos esa opción.

447
00:18:41,000 --> 00:18:43,000
Vale, vamos a hacer primero la 8,

448
00:18:43,000 --> 00:18:45,000
porque para aprobar la 9 los clientes tienen que tener pedidos.

449
00:18:45,000 --> 00:18:47,000
Bueno, claro, tendremos que poder meter clientes.

450
00:18:47,000 --> 00:18:49,000
Si no metemos clientes, pues

451
00:18:49,000 --> 00:18:51,000
chungo.

452
00:18:51,000 --> 00:18:53,000
Vamos a poner la opción 10.

453
00:18:55,000 --> 00:18:57,000
Esto en una consola ya se queda muy largo.

454
00:18:57,000 --> 00:18:59,000
En una aplicación con interfaz gráfica,

455
00:18:59,000 --> 00:19:01,000
pues bueno, uno puede hacer un despliegue

456
00:19:01,000 --> 00:19:03,000
de opciones y es un poquito más

457
00:19:03,000 --> 00:19:05,000
manejable.

458
00:19:05,000 --> 00:19:07,000
La 10 sería

459
00:19:07,000 --> 00:19:09,000
insertar cliente.

460
00:19:11,000 --> 00:19:13,000
Sería, sí, sí, sí.

461
00:19:13,000 --> 00:19:15,000
Lo que pasa es que como la voy poniendo,

462
00:19:15,000 --> 00:19:17,000
vosotros lo queréis dejar más bonito, pues ya lo vais colocando

463
00:19:17,000 --> 00:19:19,000
como queráis.

464
00:19:19,000 --> 00:19:21,000
Yo como voy ahí

465
00:19:21,000 --> 00:19:23,000
sobre la marcha improvisando.

466
00:19:27,000 --> 00:19:29,000
Vale.

467
00:19:29,000 --> 00:19:31,000
Bueno, pues venga.

468
00:19:31,000 --> 00:19:33,000
Vamos a hacer primero lo de insertar

469
00:19:33,000 --> 00:19:35,000
cliente porque

470
00:19:37,000 --> 00:19:39,000
que sería como la de crear pedido.

471
00:19:39,000 --> 00:19:41,000
Pues igual, pero en este caso clientes.

472
00:19:41,000 --> 00:19:43,000
Entonces, en realidad

473
00:19:43,000 --> 00:19:45,000
es como la de pedido,

474
00:19:45,000 --> 00:19:47,000
pero cambiando por cliente

475
00:19:47,000 --> 00:19:49,000
y usando una variable adicional

476
00:19:49,000 --> 00:19:51,000
porque esta pos,

477
00:19:51,000 --> 00:19:53,000
ahora ya esta pos convendría cambiarla

478
00:19:53,000 --> 00:19:55,000
de nombre y llamarla pos de pedidos

479
00:19:55,000 --> 00:19:57,000
porque ahora tendremos una para indicar la

480
00:19:57,000 --> 00:19:59,000
posición de los clientes, son dos arrays en paralelo.

481
00:19:59,000 --> 00:20:01,000
Entonces vamos a aprovecharnos de

482
00:20:01,000 --> 00:20:03,000
ese concepto que os mencioné

483
00:20:03,000 --> 00:20:05,000
de la refactorización

484
00:20:05,000 --> 00:20:07,000
que es, yo quiero cambiar

485
00:20:07,000 --> 00:20:09,000
un elemento de mi

486
00:20:09,000 --> 00:20:11,000
código fuente de nombre,

487
00:20:11,000 --> 00:20:13,000
pues en lugar de hacerlo yo a mano,

488
00:20:13,000 --> 00:20:15,000
que es un rollo, se me puede escapar alguno,

489
00:20:15,000 --> 00:20:17,000
usamos que el entorno de desarrollo

490
00:20:17,000 --> 00:20:19,000
me hace una refactorización, me ayuda a refactorizar.

491
00:20:19,000 --> 00:20:21,000
Recordad que refactorizar

492
00:20:21,000 --> 00:20:23,000
es

493
00:20:23,000 --> 00:20:25,000
cambiar el aspecto de mi código

494
00:20:25,000 --> 00:20:27,000
pero sin cambiar nada de la funcionalidad.

495
00:20:27,000 --> 00:20:29,000
Nada, la funcionalidad es la misma.

496
00:20:29,000 --> 00:20:31,000
A lo mejor yo estoy cambiando nombres

497
00:20:31,000 --> 00:20:33,000
de variables, estoy cambiando,

498
00:20:33,000 --> 00:20:35,000
pero no cambio la funcionalidad. Bueno, en este caso

499
00:20:35,000 --> 00:20:37,000
vamos a cambiar el nombre de la variable pos.

500
00:20:37,000 --> 00:20:39,000
Entonces, botón derecho en la variable

501
00:20:39,000 --> 00:20:41,000
en la que queramos refactorizar, botón derecho

502
00:20:41,000 --> 00:20:43,000
os vais a refactor,

503
00:20:43,000 --> 00:20:45,000
rename, que esta arriba

504
00:20:45,000 --> 00:20:47,000
y ahora queremos

505
00:20:47,000 --> 00:20:49,000
que,

506
00:20:49,000 --> 00:20:51,000
a ver,

507
00:20:51,000 --> 00:20:53,000
porque no me,

508
00:20:53,000 --> 00:20:55,000
vamos a ver,

509
00:20:55,000 --> 00:20:57,000
rename,

510
00:20:57,000 --> 00:20:59,000
vale, y ahora ya escribo aquí

511
00:20:59,000 --> 00:21:01,000
el nuevo nombre, ¿verdad?

512
00:21:01,000 --> 00:21:03,000
Y le doy

513
00:21:03,000 --> 00:21:05,000
al enter y el me lo

514
00:21:05,000 --> 00:21:07,000
actualiza todo.

515
00:21:09,000 --> 00:21:11,000
Pues ala,

516
00:21:11,000 --> 00:21:13,000
refactorizo otra vez.

517
00:21:13,000 --> 00:21:15,000
Si, lo que pasa es que

518
00:21:15,000 --> 00:21:17,000
para no cambiarlo de sitio, como lo tengo aquí en la

519
00:21:17,000 --> 00:21:19,000
funcionalidad de pedidos, tendría que acordarme

520
00:21:19,000 --> 00:21:21,000
de cambiarlo de sitio. Entonces voy a

521
00:21:21,000 --> 00:21:23,000
llamarlo, efectivamente,

522
00:21:23,000 --> 00:21:25,000
eh,

523
00:21:25,000 --> 00:21:27,000
me he perdido,

524
00:21:27,000 --> 00:21:29,000
aquí estoy.

525
00:21:29,000 --> 00:21:31,000
A ver, es que

526
00:21:31,000 --> 00:21:33,000
no estaba,

527
00:21:33,000 --> 00:21:35,000
ahora sí.

528
00:21:35,000 --> 00:21:37,000
Vale, pues

529
00:21:37,000 --> 00:21:39,000
venga, pos

530
00:21:43,000 --> 00:21:45,000
pedidos.

531
00:21:45,000 --> 00:21:47,000
Ala, ya está,

532
00:21:47,000 --> 00:21:49,000
más bonita, esta es la posición de pedidos,

533
00:21:49,000 --> 00:21:51,000
todo lo que tenía que ver con pedidos

534
00:21:51,000 --> 00:21:53,000
ya se ha cambiado de nombre.

535
00:21:53,000 --> 00:21:55,000
Estas yo no las tengo llenas, vos las tendréis llenas

536
00:21:55,000 --> 00:21:57,000
del otro día.

537
00:21:57,000 --> 00:21:59,000
Venga, pues ahora necesitamos otra variable

538
00:21:59,000 --> 00:22:01,000
para como indicadora de las posiciones

539
00:22:01,000 --> 00:22:03,000
de los clientes. Un entero

540
00:22:03,000 --> 00:22:05,000
también,

541
00:22:05,000 --> 00:22:07,000
pos clientes, que empieza valiendo 0.

542
00:22:07,000 --> 00:22:09,000
Vale,

543
00:22:09,000 --> 00:22:11,000
y ahora la funcionalidad

544
00:22:11,000 --> 00:22:13,000
de añadir cliente, que

545
00:22:13,000 --> 00:22:15,000
en mi caso es la 10,

546
00:22:15,000 --> 00:22:17,000
es como la de pedido,

547
00:22:17,000 --> 00:22:19,000
igual, pero pidiendo datos

548
00:22:19,000 --> 00:22:21,000
de cliente y

549
00:22:21,000 --> 00:22:23,000
ya está. Voy a copiar el mismo caso 1

550
00:22:25,000 --> 00:22:27,000
y ahora lo modifico

551
00:22:27,000 --> 00:22:29,000
en el caso 10.

552
00:22:29,000 --> 00:22:31,000
En mi caso en el 10.

553
00:22:31,000 --> 00:22:33,000
A ver.

554
00:22:49,000 --> 00:22:51,000
7, 8, 9 y caso 10.

555
00:23:01,000 --> 00:23:03,000
Vale, pues aquí es

556
00:23:03,000 --> 00:23:05,000
donde lo quería yo hacer

557
00:23:05,000 --> 00:23:07,000
y ahora, ¿qué datos hay que pedir? Los del cliente,

558
00:23:07,000 --> 00:23:09,000
que son 3 strings,

559
00:23:09,000 --> 00:23:11,000
nif, nombre y dirección.

560
00:23:11,000 --> 00:23:13,000
Vale,

561
00:23:13,000 --> 00:23:15,000
pues vosotros que tenéis

562
00:23:15,000 --> 00:23:17,000
ya la clase teclado seguramente lo tenéis muy fácil,

563
00:23:17,000 --> 00:23:19,000
yo lo voy a hacer con el escáner,

564
00:23:19,000 --> 00:23:21,000
porque estoy en la versión antigua de esto.

565
00:23:21,000 --> 00:23:23,000
Entonces,

566
00:23:27,000 --> 00:23:29,000
introduzca

567
00:23:29,000 --> 00:23:31,000
nif.

568
00:23:31,000 --> 00:23:33,000
Pues lo leo.

569
00:23:33,000 --> 00:23:35,000
Introduzca

570
00:23:35,000 --> 00:23:37,000
nombre.

571
00:23:39,000 --> 00:23:41,000
Pues lo leo.

572
00:23:43,000 --> 00:23:45,000
E introduzca

573
00:23:45,000 --> 00:23:47,000
dirección.

574
00:23:53,000 --> 00:23:55,000
Pues la leo.

575
00:23:57,000 --> 00:23:59,000
Y ahora ya, en mi array de clientes,

576
00:23:59,000 --> 00:24:01,000
en la

577
00:24:01,000 --> 00:24:03,000
posición que toque,

578
00:24:03,000 --> 00:24:05,000
en la posición

579
00:24:05,000 --> 00:24:07,000
que toque, dejándola

580
00:24:07,000 --> 00:24:09,000
incrementada, por supuesto,

581
00:24:09,000 --> 00:24:11,000
en la que toque dejándola incrementada,

582
00:24:11,000 --> 00:24:13,000
pues

583
00:24:13,000 --> 00:24:15,000
clientes,

584
00:24:15,000 --> 00:24:17,000
en la que toque, meto

585
00:24:17,000 --> 00:24:19,000
ese nuevo cliente

586
00:24:19,000 --> 00:24:21,000
y

587
00:24:23,000 --> 00:24:25,000
¿qué constructor usamos?

588
00:24:25,000 --> 00:24:27,000
Pues lo ideal sería que en cliente hubiera

589
00:24:27,000 --> 00:24:29,000
un constructor al que yo le doy

590
00:24:29,000 --> 00:24:31,000
los 3 parámetros básicos.

591
00:24:31,000 --> 00:24:33,000
Nombre, dirección y

592
00:24:33,000 --> 00:24:35,000
todavía no lo leo.

593
00:24:35,000 --> 00:24:37,000
Nombre, dirección y nif.

594
00:24:37,000 --> 00:24:39,000
Y el array de clientes, de pedidos,

595
00:24:39,000 --> 00:24:41,000
pasamos de él por ahora porque no hay ningún pedido incorporado.

596
00:24:41,000 --> 00:24:43,000
Entonces,

597
00:24:43,000 --> 00:24:45,000
voy aquí y yo,

598
00:24:45,000 --> 00:24:47,000
que todavía no tengo ni un constructor ni nada,

599
00:24:47,000 --> 00:24:49,000
porque lo acabo de hacer,

600
00:24:51,000 --> 00:24:53,000
pues voy a crear un constructor,

601
00:24:53,000 --> 00:24:55,000
si es que

602
00:24:55,000 --> 00:24:57,000
no lo, igual lo tenéis otros de ayer,

603
00:24:59,000 --> 00:25:01,000
voy a crear un constructor para cliente

604
00:25:01,000 --> 00:25:03,000
con esos 3 datos.

605
00:25:03,000 --> 00:25:05,000
Y entonces cuando cree

606
00:25:05,000 --> 00:25:07,000
mi objeto cliente con este constructor,

607
00:25:07,000 --> 00:25:09,000
pedidos se inicializará a null, que es el valor

608
00:25:09,000 --> 00:25:11,000
por defecto de un array.

609
00:25:11,000 --> 00:25:13,000
Se inicializará a null.

610
00:25:13,000 --> 00:25:15,000
Vale.

611
00:25:15,000 --> 00:25:17,000
Venga, pues nada.

612
00:25:17,000 --> 00:25:19,000
Entonces, llamo yo aquí a cliente

613
00:25:19,000 --> 00:25:21,000
con esos 3 parámetros.

614
00:25:21,000 --> 00:25:23,000
Nif,

615
00:25:23,000 --> 00:25:25,000
nombre

616
00:25:25,000 --> 00:25:27,000
y dirección.

617
00:25:27,000 --> 00:25:29,000
Pues ya está, ya tengo la funcionalidad de

618
00:25:29,000 --> 00:25:31,000
crear, insertar un nuevo cliente

619
00:25:31,000 --> 00:25:33,000
en mi registro de clientes.

620
00:25:33,000 --> 00:25:35,000
Con esos datos básicos y por ahora

621
00:25:35,000 --> 00:25:37,000
sin pedidos.

622
00:25:39,000 --> 00:25:41,000
Bueno,

623
00:25:45,000 --> 00:25:47,000
pues ahora

624
00:25:47,000 --> 00:25:49,000
lo natural sería poder hacerle,

625
00:25:49,000 --> 00:25:51,000
meterle un pedido

626
00:25:51,000 --> 00:25:53,000
a este cliente.

627
00:25:53,000 --> 00:25:55,000
Vale, que sería la funcionalidad

628
00:25:55,000 --> 00:25:57,000
8.

629
00:25:57,000 --> 00:25:59,000
Aquí de nuevo,

630
00:25:59,000 --> 00:26:01,000
como estamos haciendo

631
00:26:01,000 --> 00:26:03,000
el programa escalándolo poco a poco,

632
00:26:03,000 --> 00:26:05,000
primero hicimos la parte de pedidos, luego la de cliente,

633
00:26:05,000 --> 00:26:07,000
se complica un poco

634
00:26:07,000 --> 00:26:09,000
la cosa, claro.

635
00:26:09,000 --> 00:26:11,000
O sea, lo ideal es que cuando uno hace una aplicación,

636
00:26:11,000 --> 00:26:13,000
ya desde el principio,

637
00:26:13,000 --> 00:26:15,000
tenga definidas

638
00:26:15,000 --> 00:26:17,000
todas las necesidades.

639
00:26:17,000 --> 00:26:19,000
Vas a tener clientes, pedidos,

640
00:26:19,000 --> 00:26:21,000
van a tener que hacer esto, para ti, para tal.

641
00:26:21,000 --> 00:26:23,000
Nosotros cuando hicimos esta primera versión de la aplicación,

642
00:26:23,000 --> 00:26:25,000
solamente teníamos definida

643
00:26:25,000 --> 00:26:27,000
la parte de pedidos y le hemos incorporado

644
00:26:27,000 --> 00:26:29,000
ahora después la de clientes.

645
00:26:29,000 --> 00:26:31,000
Vale, pues entonces,

646
00:26:31,000 --> 00:26:33,000
eso ha implicado que tengamos dos arrays.

647
00:26:33,000 --> 00:26:35,000
El array con los pedidos

648
00:26:35,000 --> 00:26:37,000
que van sueltos, los pedidos que se van haciendo.

649
00:26:37,000 --> 00:26:39,000
Y luego,

650
00:26:39,000 --> 00:26:41,000
y luego,

651
00:26:41,000 --> 00:26:43,000
a un cliente,

652
00:26:43,000 --> 00:26:45,000
le tendremos que incorporar

653
00:26:45,000 --> 00:26:47,000
un pedido concreto que ya esté aquí.

654
00:26:47,000 --> 00:26:49,000
Ese es como va a funcionar nuestro software.

655
00:26:51,000 --> 00:26:53,000
Porque ya tenemos previamente

656
00:26:53,000 --> 00:26:55,000
la parte hecha en la cual hacemos un pedido

657
00:26:55,000 --> 00:26:57,000
por libre y lo metemos aquí.

658
00:26:57,000 --> 00:26:59,000
Bueno, pues entonces,

659
00:26:59,000 --> 00:27:01,000
eso significa, vale,

660
00:27:01,000 --> 00:27:03,000
pues entonces, incorporar pedido a cliente,

661
00:27:03,000 --> 00:27:05,000
¿qué tendré yo que pedir?

662
00:27:05,000 --> 00:27:07,000
Pues como siempre, la clave primaria del pedido.

663
00:27:07,000 --> 00:27:09,000
Los pedidos ya están aquí guardados todos.

664
00:27:09,000 --> 00:27:11,000
Los pedidos que se han hecho están ahí.

665
00:27:11,000 --> 00:27:13,000
Se ha hecho un pedido de boli, tenéis aquí.

666
00:27:13,000 --> 00:27:15,000
Pues voy a asociar este pedido al cliente, voy a asociarlo.

667
00:27:15,000 --> 00:27:17,000
Pues entonces, tendremos que pedir,

668
00:27:17,000 --> 00:27:19,000
oye, vale, ¿qué pedido de todos estos

669
00:27:19,000 --> 00:27:21,000
que tienes tú en tu almacén

670
00:27:21,000 --> 00:27:23,000
de pedidos,

671
00:27:23,000 --> 00:27:25,000
¿qué pedido vas a asociar al cliente?

672
00:27:25,000 --> 00:27:27,000
Pues lo que vas a necesitar para identificarlo

673
00:27:27,000 --> 00:27:29,000
será lo que lo identifique de forma única,

674
00:27:29,000 --> 00:27:31,000
que es su clave.

675
00:27:31,000 --> 00:27:33,000
El código, ¿no?

676
00:27:33,000 --> 00:27:35,000
Pues entonces,

677
00:27:35,000 --> 00:27:37,000
en la funcionalidad de incorporar

678
00:27:37,000 --> 00:27:39,000
pedido a cliente, lo primero que habrá

679
00:27:39,000 --> 00:27:41,000
que preguntar es, oye, ¿cuál es el código

680
00:27:41,000 --> 00:27:43,000
del pedido que le quieres pasar al cliente?

681
00:27:43,000 --> 00:27:45,000
¿Cuál es? Eso es lo primero que habrá

682
00:27:45,000 --> 00:27:47,000
que hacer.

683
00:27:49,000 --> 00:27:51,000
Código del pedido.

684
00:27:51,000 --> 00:27:53,000
Código del pedido,

685
00:27:53,000 --> 00:27:55,000
que es string, ¿verdad?

686
00:27:55,000 --> 00:27:59,000
Sí, es string,

687
00:27:59,000 --> 00:28:01,000
afortunadamente queda menos guerra.

688
00:28:01,000 --> 00:28:03,000
Código del pedido,

689
00:28:03,000 --> 00:28:05,000
como ya tenemos una variable

690
00:28:05,000 --> 00:28:07,000
de declarar arriba, la reutilizo

691
00:28:07,000 --> 00:28:09,000
para leer.

692
00:28:11,000 --> 00:28:13,000
Vamos a acabar

693
00:28:13,000 --> 00:28:15,000
este caso 8

694
00:28:15,000 --> 00:28:17,000
y ahora paramos.

695
00:28:17,000 --> 00:28:19,000
Va, ya tengo el código del pedido.

696
00:28:19,000 --> 00:28:21,000
¿Ahora qué hacemos?

697
00:28:21,000 --> 00:28:23,000
Pues tendremos que

698
00:28:23,000 --> 00:28:25,000
saber

699
00:28:25,000 --> 00:28:27,000
a qué cliente incorporarlo.

700
00:28:29,000 --> 00:28:31,000
Bueno, pedimos lo del cliente y paramos

701
00:28:31,000 --> 00:28:33,000
porque se va a hacer quizá un pelín en largo.

702
00:28:33,000 --> 00:28:35,000
Ya tengo el código del pedido.

703
00:28:35,000 --> 00:28:37,000
Ahora será, vale, ¿a qué cliente?

704
00:28:37,000 --> 00:28:39,000
Porque tenemos muchos, ¿a qué cliente?

705
00:28:39,000 --> 00:28:41,000
Pues de nuevo la pregunta es, ¿qué identifica

706
00:28:41,000 --> 00:28:43,000
de forma única a cada cliente?

707
00:28:43,000 --> 00:28:45,000
El nif, ¿no?

708
00:28:45,000 --> 00:28:47,000
Si he hecho bien el diseño,

709
00:28:47,000 --> 00:28:49,000
si he hecho bien el diseño,

710
00:28:49,000 --> 00:28:51,000
alguna de las propiedades debería ser

711
00:28:51,000 --> 00:28:53,000
que el nif no se identifique de forma única,

712
00:28:53,000 --> 00:28:55,000
si lo he hecho bien.

713
00:28:55,000 --> 00:28:57,000
Se supone que el nif

714
00:28:57,000 --> 00:28:59,000
no se identifica

715
00:28:59,000 --> 00:29:01,000
de forma única, se supone.

716
00:29:01,000 --> 00:29:03,000
Pues sería lo siguiente que hay que pedir.

717
00:29:03,000 --> 00:29:05,000
Venga, ya tengo el pedido

718
00:29:05,000 --> 00:29:07,000
que le voy a enseñar al cliente.

719
00:29:07,000 --> 00:29:09,000
Ahora,

720
00:29:11,000 --> 00:29:13,000
nif del cliente.

721
00:29:15,000 --> 00:29:17,000
Pues nada, lo leemos.

722
00:29:21,000 --> 00:29:23,000
Line.

723
00:29:23,000 --> 00:29:25,000
Y como no tenía ninguna variable

724
00:29:25,000 --> 00:29:27,000
nif declarada arriba,

725
00:29:27,000 --> 00:29:29,000
string nif.

726
00:29:31,000 --> 00:29:33,000
Vale, ya tenemos la concentrada.

727
00:29:33,000 --> 00:29:35,000
Y ahora ya efectivamente habría que

728
00:29:35,000 --> 00:29:37,000
localizar el cliente con ese nif

729
00:29:37,000 --> 00:29:39,000
y a través del método de incorporar pedido

730
00:29:39,000 --> 00:29:41,000
pasarle el pedido con ese código.

731
00:29:41,000 --> 00:29:43,000
¿Vale?

732
00:29:43,000 --> 00:29:45,000
Bueno, pues paramos aquí un momentito

733
00:29:45,000 --> 00:29:47,000
y lo

734
00:29:47,000 --> 00:29:49,000
si os aburrís

735
00:29:49,000 --> 00:29:51,000
lo meditáis en estos minutos.

736
00:29:51,000 --> 00:29:53,000
Vale, pues