1
00:00:01,459 --> 00:00:15,279
Bueno, pues aquí dejé planteado ayer que hicierais vosotros, por ejemplo, estas dos funcionalidades, la 5 y la 6, que son farragosas, no son especialmente cómodas tampoco.

2
00:00:16,140 --> 00:00:27,100
¿Las habéis hecho? Uno las ha hecho, el empollón de la clase. Es una broma, hombre, que está muy bien.

3
00:00:27,100 --> 00:00:29,120
Vale, has hecho las dos

4
00:00:29,120 --> 00:00:31,359
Vale, fenomenal

5
00:00:31,359 --> 00:00:32,979
¿Nadie más se ha puesto con ellas?

6
00:00:35,240 --> 00:00:37,259
Ay, muy mal, muy mal

7
00:00:37,259 --> 00:00:43,320
Uf, pero tú no eres el que los ibas a hacer en los 10 minutos

8
00:00:43,320 --> 00:00:44,579
Que tenías de cambio de clase

9
00:00:44,579 --> 00:00:49,280
Hombre, pero ¿quién nos saca 3 minutos para hacer esto?

10
00:00:50,979 --> 00:00:51,380
Ay

11
00:00:51,380 --> 00:00:54,259
Bueno

12
00:00:54,259 --> 00:00:55,920
Pues vamos a hacer

13
00:00:55,920 --> 00:00:58,759
Mostrar cliente con más pedidos

14
00:00:58,759 --> 00:00:59,320
5

15
00:00:59,320 --> 00:01:01,520
Recordad que en esta aplicación

16
00:01:01,520 --> 00:01:04,519
Todos los clientes están aquí

17
00:01:04,519 --> 00:01:05,560
En este array

18
00:01:05,560 --> 00:01:08,200
Con lo cual como máximo

19
00:01:08,200 --> 00:01:09,239
Podemos tener 100

20
00:01:09,239 --> 00:01:11,239
Porque el array no tiene espacio para más de 100

21
00:01:11,239 --> 00:01:13,540
Pero no habrá 100

22
00:01:13,540 --> 00:01:15,180
En un momento dado

23
00:01:15,180 --> 00:01:17,579
Habrá tantos como me diga este contador

24
00:01:17,579 --> 00:01:19,099
Inicialmente 0

25
00:01:19,099 --> 00:01:22,620
Pero recordad que cada vez que insertábamos un cliente

26
00:01:22,620 --> 00:01:41,980
Pues el contador se incrementa, ¿vale? Entonces, con esto insertamos cliente, con esto mostramos todos los clientes, con esto agregábamos pedido a un cliente nuevo a través del método correspondiente,

27
00:01:41,980 --> 00:01:49,670
Con este mostrábamos la factura de un cliente con un NIF

28
00:01:49,670 --> 00:01:52,269
Llamando al método correspondiente

29
00:01:52,269 --> 00:01:55,530
Todos estos eran métodos que hacíamos aquí

30
00:01:55,530 --> 00:01:57,109
En la clase Cliente

31
00:01:57,109 --> 00:02:00,590
Hacíamos el método AgregarPedido

32
00:02:00,590 --> 00:02:04,810
Que cogía un pedido nuevo y lo agregaba al array

33
00:02:04,810 --> 00:02:08,849
Hacíamos el método MostrarFactura

34
00:02:08,849 --> 00:02:11,830
Con los datos del cliente que está arriba, etc.

35
00:02:11,830 --> 00:02:36,580
Vale, pues a ver, ¿cómo nos plantearíamos la siguiente funcionalidad que nos queda aquí? Venga, caso 5. El cliente que más pedidos tiene. Sería casi más interesante, ¿tú has hecho el que más pedidos tiene o el que más dinero se ha gastado? El que más pedidos, ¿no?

36
00:02:36,580 --> 00:02:39,199
vale, porque

37
00:02:39,199 --> 00:02:43,340
sería interesante

38
00:02:43,340 --> 00:02:45,139
una vez que hayamos hecho este

39
00:02:45,139 --> 00:02:46,680
pues que hagáis

40
00:02:46,680 --> 00:02:48,639
este otro también

41
00:02:48,639 --> 00:02:51,719
5, 6, 7

42
00:02:51,719 --> 00:02:55,240
el que más se ha gastado, porque uno a lo mejor

43
00:02:55,240 --> 00:02:57,099
ha hecho 20 pedidos de un euro cada uno

44
00:02:57,099 --> 00:02:58,939
y otro ha hecho un pedido de

45
00:02:58,939 --> 00:03:01,199
200.000 euros, entonces casi

46
00:03:01,199 --> 00:03:03,219
que nos gusta más el cliente

47
00:03:03,219 --> 00:03:04,319
que más se ha gastado

48
00:03:04,319 --> 00:03:12,139
pero vamos a hacer el que yo os pedí, el primero

49
00:03:12,139 --> 00:03:13,840
venga, caso 5

50
00:03:13,840 --> 00:03:28,509
vale, pues en el caso 5 se trata

51
00:03:28,509 --> 00:03:30,210
de hacer el máximo

52
00:03:30,210 --> 00:03:32,310
de algo, entonces ya

53
00:03:32,310 --> 00:03:34,389
automáticamente nos ponemos en el chip del algoritmo

54
00:03:34,389 --> 00:03:36,129
del máximo que ya lo tenemos en la cabeza

55
00:03:36,129 --> 00:03:38,449
igual que tenemos el de contar, igual que tenemos

56
00:03:38,449 --> 00:03:40,250
el de sumar o multiplicar

57
00:03:40,250 --> 00:03:42,129
de forma acumulativa o concatenar de forma

58
00:03:42,129 --> 00:03:44,310
acumulativa, pues ya tenemos muchos

59
00:03:44,310 --> 00:03:45,810
algoritmos ya metidos en la cabeza

60
00:03:45,810 --> 00:03:48,469
para resolver tareas concretas

61
00:03:48,469 --> 00:03:50,050
que se hacen todo el rato en programación

62
00:03:50,050 --> 00:03:52,330
como contar, sumar, ver si

63
00:03:52,330 --> 00:03:53,590
algo pasa o no pasa

64
00:03:53,590 --> 00:03:55,789
con el boolean y el contraejemplo

65
00:03:55,789 --> 00:03:57,810
o máximo y mínimo, son las cuatro ideas

66
00:03:57,810 --> 00:03:59,729
básicas, sobre las cuales se monta un poco

67
00:03:59,729 --> 00:04:01,909
todo. Vale, pues el máximo

68
00:04:01,909 --> 00:04:03,689
ya sabemos cómo funciona, el máximo siempre

69
00:04:03,689 --> 00:04:05,050
se hace sobre un conjunto de cosas

70
00:04:05,050 --> 00:04:07,370
entonces cuando hay que hacer el máximo de algo

71
00:04:07,370 --> 00:04:09,069
lo primero que pensamos es

72
00:04:09,069 --> 00:04:11,590
¿el máximo de qué conjunto de cosas?

73
00:04:12,270 --> 00:04:13,810
Pues el cliente que más

74
00:04:13,810 --> 00:04:15,789
pedidos tiene, pues sobre el conjunto

75
00:04:15,789 --> 00:04:17,610
de clientes. ¿Tengo yo alguna

76
00:04:17,610 --> 00:04:19,509
estructura que tenga mis clientes? Sí

77
00:04:19,509 --> 00:04:21,629
¡Qué suerte! Tengo directamente

78
00:04:21,629 --> 00:04:23,750
una estructura con mis clientes que es el array

79
00:04:23,750 --> 00:04:25,990
luego el algoritmo de máximo

80
00:04:25,990 --> 00:04:27,829
lo único

81
00:04:27,829 --> 00:04:29,490
que tiene que hacer es

82
00:04:29,490 --> 00:04:31,389
recorrer este array

83
00:04:31,389 --> 00:04:32,889
para sobre él

84
00:04:32,889 --> 00:04:36,050
ir encontrando que cliente

85
00:04:36,050 --> 00:04:37,329
supera al anterior

86
00:04:37,329 --> 00:04:38,589
en el

87
00:04:38,589 --> 00:04:41,970
criterio por el que

88
00:04:41,970 --> 00:04:43,810
estamos maximizando que en este caso

89
00:04:43,810 --> 00:04:45,509
es el número de pedidos

90
00:04:45,509 --> 00:04:47,410
el algoritmo de máximo siempre es el mismo

91
00:04:47,410 --> 00:04:49,930
yo tengo un conjunto de cosas de la que quiero

92
00:04:49,930 --> 00:04:51,629
encontrar el que más algo

93
00:04:51,629 --> 00:04:52,949
o el que menos algo

94
00:04:52,949 --> 00:04:54,949
pues

95
00:04:54,949 --> 00:04:57,569
asumo, cojo uno de ellos

96
00:04:57,569 --> 00:04:59,370
y asumo que ese

97
00:04:59,370 --> 00:05:01,009
es el que más algo

98
00:05:01,009 --> 00:05:03,089
y ahora empiezo a recorrer los demás

99
00:05:03,089 --> 00:05:04,569
uno por uno

100
00:05:04,569 --> 00:05:08,029
con cada uno de ellos, si ese ha superado

101
00:05:08,029 --> 00:05:10,250
al que hasta ese momento era el que más

102
00:05:10,250 --> 00:05:11,589
pues tengo nuevo

103
00:05:11,589 --> 00:05:14,329
máximo, y ese es el algoritmo que hemos usado siempre

104
00:05:14,329 --> 00:05:15,970
pues vamos a

105
00:05:15,970 --> 00:05:17,029
aplicarlo aquí

106
00:05:17,029 --> 00:05:19,029
entonces aquí tenemos

107
00:05:19,029 --> 00:05:23,970
Tenemos una opción

108
00:05:23,970 --> 00:05:26,990
Que es programarlo aquí todo entero directamente

109
00:05:26,990 --> 00:05:29,790
Entonces el algoritmo de máximo parte

110
00:05:29,790 --> 00:05:32,110
Venga, máximo inicial

111
00:05:32,110 --> 00:05:38,410
El máximo inicial es el primero de los clientes

112
00:05:38,410 --> 00:05:40,870
Clientes de cero

113
00:05:40,870 --> 00:05:44,029
Este es el máximo inicialmente

114
00:05:44,029 --> 00:05:46,769
Ahora voy a recorrer los demás

115
00:05:46,769 --> 00:05:50,029
A ver si alguno supera ese máximo

116
00:05:50,029 --> 00:05:50,750
y actualizo

117
00:05:50,750 --> 00:05:56,009
el que es el máximo

118
00:05:56,009 --> 00:05:57,949
en el criterio que sea, que en este caso es en el

119
00:05:57,949 --> 00:05:59,189
número de pedidos que tiene

120
00:05:59,189 --> 00:06:05,990
Max es un objeto cliente

121
00:06:05,990 --> 00:06:07,269
claro

122
00:06:07,269 --> 00:06:09,790
es un cliente máximo, es un objeto cliente

123
00:06:10,490 --> 00:06:11,730
vale, pues desde

124
00:06:11,730 --> 00:06:13,610
empezando por el segundo

125
00:06:13,610 --> 00:06:14,430
cliente ya

126
00:06:14,430 --> 00:06:16,910
mientras si sea menor que

127
00:06:16,910 --> 00:06:21,149
este de aquí, lógicamente, que son todos

128
00:06:21,149 --> 00:06:22,209
los clientes que tenemos

129
00:06:22,209 --> 00:06:24,670
Recordad que esta variable

130
00:06:24,670 --> 00:06:26,889
Es la que me está contabilizando

131
00:06:26,889 --> 00:06:28,490
En toda la aplicación

132
00:06:28,490 --> 00:06:29,629
Los clientes que tengo

133
00:06:29,629 --> 00:06:32,170
Esta variable es la que me lo está contabilizando

134
00:06:32,170 --> 00:06:35,389
¿Vale? No puedo poner clientes.length

135
00:06:35,389 --> 00:06:36,610
Porque si pongo

136
00:06:36,610 --> 00:06:38,029
Clientes.length

137
00:06:38,029 --> 00:06:40,209
Me iría a 100

138
00:06:40,209 --> 00:06:42,069
Y hay un montón que son null

139
00:06:42,069 --> 00:06:44,189
Entonces

140
00:06:44,189 --> 00:06:45,829
Como todos los recorridos

141
00:06:45,829 --> 00:06:47,029
Al igual que hicimos ayer

142
00:06:47,029 --> 00:06:49,589
Esos recorridos llegarán

143
00:06:49,589 --> 00:06:53,889
Hasta el último

144
00:06:53,889 --> 00:07:07,560
cliente libre, ¿vale? Pues, ¿qué tenemos que hacer dentro del algoritmo de máximo? Pues, ver si cliente de i supera al que es máximo

145
00:07:07,560 --> 00:07:20,819
hasta ese momento, ¿vale? Si queréis, a lo mejor es más fácil de entender si a esta variable la llamamos cliente max, por ejemplo, ¿vale?

146
00:07:20,819 --> 00:07:25,620
Pues si cliente sí supera a cliente max, actualizamos cliente sí.

147
00:07:28,220 --> 00:07:31,100
Esta es la idea general del algoritmo, la idea general.

148
00:07:31,680 --> 00:07:33,879
Ahora hay que aplicarla para nuestro caso concreto,

149
00:07:34,379 --> 00:07:39,600
porque para cada caso, superar el actual al máximo,

150
00:07:39,839 --> 00:07:41,420
en cada caso implicará una cosa.

151
00:07:42,060 --> 00:07:45,000
Que el tamaño de su nombre sea mayor, que no sé qué,

152
00:07:45,100 --> 00:07:46,899
en cada caso implicará una cosa u otra.

153
00:07:47,399 --> 00:07:51,279
¿Aquí qué implica superar este objeto cliente a este otro?

154
00:07:51,279 --> 00:07:56,040
Pues que la longitud de su array de pedidos sea mayor

155
00:07:56,040 --> 00:07:58,259
Eso implica superar

156
00:07:58,259 --> 00:08:02,639
Porque el criterio de ser mayor que, menor que

157
00:08:02,639 --> 00:08:05,139
Es en la longitud del array de pedidos

158
00:08:05,139 --> 00:08:07,160
¿Vale? Pues vamos a hacer eso

159
00:08:07,160 --> 00:08:12,839
Si clientes de i

160
00:08:12,839 --> 00:08:15,639
Cogemos sus pedidos

161
00:08:15,639 --> 00:08:16,980
Clientes de i

162
00:08:16,980 --> 00:08:22,569
Cogemos sus pedidos

163
00:08:22,569 --> 00:08:25,310
Este es el array de pedidos

164
00:08:25,310 --> 00:08:55,220
Pues su longitud, que la puedo sacar con length, resulta que es mayor que el número de pedidos del que es máximo hasta ese momento, que es este, get, ay, es que lo he llamado así, clientemax.getpedidos.length,

165
00:08:55,220 --> 00:08:57,620
Pues si es mayor

166
00:08:57,620 --> 00:08:59,700
Tengo un nuevo máximo

167
00:08:59,700 --> 00:09:00,960
Que es clientes de i

168
00:09:00,960 --> 00:09:12,659
Sí, lo que pasa es que entonces

169
00:09:12,659 --> 00:09:14,200
Solamente te quedarías

170
00:09:14,200 --> 00:09:15,720
Si actualizas esa variable

171
00:09:15,720 --> 00:09:17,980
Con el número de pedidos máximo

172
00:09:17,980 --> 00:09:20,500
Pero la información de que cliente lo ha tenido

173
00:09:20,500 --> 00:09:21,860
Tendrías que llevarla en paralelo

174
00:09:21,860 --> 00:09:23,960
En una variable en paralelo

175
00:09:23,960 --> 00:09:25,779
Si llevamos el objeto entero

176
00:09:25,779 --> 00:09:28,080
Mejor, ahora lo vamos a hacer abajo

177
00:09:28,080 --> 00:09:28,580
¿Vale?

178
00:09:29,759 --> 00:09:30,320
Entonces

179
00:09:30,320 --> 00:09:34,419
si el cliente

180
00:09:34,419 --> 00:09:36,480
actual y supera

181
00:09:36,480 --> 00:09:38,120
al máximo en ese momento

182
00:09:38,120 --> 00:09:40,299
el número de pedidos

183
00:09:40,299 --> 00:09:41,440
pues actualizo

184
00:09:41,440 --> 00:09:50,750
y ya está, ya he acabado el algoritmo

185
00:09:50,750 --> 00:09:54,779
cuando este for ha terminado

186
00:09:54,779 --> 00:09:56,299
que ha terminado aquí

187
00:09:56,299 --> 00:09:58,039
tengo la seguridad

188
00:09:58,039 --> 00:10:00,240
de que en cliente max

189
00:10:00,240 --> 00:10:02,399
va a estar el cliente dentro

190
00:10:02,399 --> 00:10:03,000
del array

191
00:10:03,000 --> 00:10:06,320
cuyo tamaño del array de pedidos sea el más grande

192
00:10:06,320 --> 00:10:08,600
es el algoritmo de máximo de toda la vida

193
00:10:08,600 --> 00:10:13,480
lo que decía ella

194
00:10:13,480 --> 00:10:16,059
por ejemplo, vamos a quedarnos en lugar de

195
00:10:16,059 --> 00:10:17,559
maximizar

196
00:10:17,559 --> 00:10:22,320
voy a suponer que comentamos esto un momentín

197
00:10:22,320 --> 00:10:24,960
vamos a poner

198
00:10:24,960 --> 00:10:30,299
una variable máximo, que el máximo inicial

199
00:10:30,299 --> 00:10:32,240
sea 0

200
00:10:32,240 --> 00:10:35,240
y ahora voy cliente por cliente

201
00:10:35,240 --> 00:10:39,559
el que supere a la variable máximo

202
00:10:39,559 --> 00:10:41,080
Actualiza el máximo

203
00:10:41,080 --> 00:10:42,820
Vale, pues entonces

204
00:10:42,820 --> 00:10:46,639
Esto de igual a 0

205
00:10:46,639 --> 00:10:48,200
Mientras i sea menor que

206
00:10:48,200 --> 00:10:51,159
Siguiente

207
00:10:51,159 --> 00:10:52,840
Posición libre

208
00:10:52,840 --> 00:10:55,080
Incrementando i

209
00:10:55,080 --> 00:10:55,779
Cada vez

210
00:10:55,779 --> 00:10:57,299
Pues sí

211
00:10:57,299 --> 00:11:01,179
Este cliente es de i

212
00:11:01,179 --> 00:11:05,539
Su array pedidos

213
00:11:05,539 --> 00:11:08,440
Pues el tamaño de su array pedidos

214
00:11:08,440 --> 00:11:09,279
Uy, perdón

215
00:11:09,279 --> 00:11:16,480
El tamaño de su array pedidos

216
00:11:16,480 --> 00:11:18,120
Resulta que es mayor

217
00:11:18,120 --> 00:11:21,120
que es mayor

218
00:11:21,120 --> 00:11:22,860
que el máximo hasta ese momento

219
00:11:22,860 --> 00:11:25,240
tengo nueva

220
00:11:25,240 --> 00:11:27,039
variable máxima

221
00:11:27,039 --> 00:11:28,480
que sería esta

222
00:11:28,480 --> 00:11:33,830
tengo nueva variable máxima

223
00:11:33,830 --> 00:11:36,309
que sería esta, vale, pero con esto

224
00:11:36,309 --> 00:11:38,230
cuando el bucle termina

225
00:11:38,230 --> 00:11:40,110
lo único que tenemos es

226
00:11:40,110 --> 00:11:42,190
el número de pedidos máximo

227
00:11:42,190 --> 00:11:44,169
que se ha hecho, pero no sabemos que cliente

228
00:11:44,169 --> 00:11:44,610
lo ha hecho

229
00:11:44,610 --> 00:11:46,809
y si tuvieras max igual a i

230
00:11:46,809 --> 00:11:48,710
podrías tener la posición

231
00:11:48,710 --> 00:12:01,730
Claro. Bueno, max igual a i, no, otra variable que guardará la posición, porque esta ya tiene un uso, que es el número máximo de pedidos. No puedes sustituirla por la posición en la que está. Esta ya tiene un uso que no puedes tocar.

232
00:12:02,409 --> 00:12:11,649
Entonces, como cuando acabe este form no queremos solo el número máximo de pedidos que se ha pedido, sino también qué cliente lo ha hecho, pues tenemos que llevar en paralelo esa información.

233
00:12:11,649 --> 00:12:38,110
La podemos llevar por la posición, por ejemplo, también o llevar una instancia y pues tú puedes hacer cliente c igual a null, vacío, para que se actualice con el primero que supere a cero.

234
00:12:38,110 --> 00:12:40,570
con el primero que supere a cero

235
00:12:40,570 --> 00:12:43,509
inicialmente cliente está sin inicializar

236
00:12:43,509 --> 00:12:44,389
como es un objeto

237
00:12:44,389 --> 00:12:46,389
hay que inicializarlo

238
00:12:46,389 --> 00:12:48,250
a null, vale

239
00:12:48,250 --> 00:12:56,450
vale, lo que pasa es que luego

240
00:12:56,450 --> 00:12:58,409
se va a quedar pisado por otra cosa, pero te es

241
00:12:58,409 --> 00:13:00,549
más cómodo ponerlo a null directamente

242
00:13:00,549 --> 00:13:02,370
que inicializarlo a un valor ficticio

243
00:13:02,370 --> 00:13:03,490
que luego se va a ver pisado

244
00:13:03,490 --> 00:13:06,450
vale, entonces aquí pues tendríamos que

245
00:13:06,450 --> 00:13:07,809
hacer c igual a

246
00:13:07,809 --> 00:13:09,429
clientes de i

247
00:13:09,429 --> 00:13:12,429
o hacer lo que dices tú, me llevo

248
00:13:12,429 --> 00:13:13,870
una variable con la posición

249
00:13:13,870 --> 00:13:16,190
inicialmente cualquiera, me da igual

250
00:13:16,190 --> 00:13:18,009
cero o la que sea

251
00:13:18,009 --> 00:13:20,710
y aquí actualizo

252
00:13:20,710 --> 00:13:21,970
la posición ahí

253
00:13:21,970 --> 00:13:24,570
¿vale? me llevo una variable

254
00:13:24,570 --> 00:13:26,690
posición con cualquier

255
00:13:26,690 --> 00:13:30,070
valor y

256
00:13:30,070 --> 00:13:32,309
si el cliente supera

257
00:13:32,309 --> 00:13:34,129
pues la posición donde está

258
00:13:34,129 --> 00:13:34,950
igual ahí

259
00:13:34,950 --> 00:13:38,450
¿vale? me da igual llevar en paralelo esta variable

260
00:13:38,450 --> 00:13:40,210
que llevar esta ¿vale?

261
00:13:40,269 --> 00:13:42,330
y aquí ya tendría toda la información, pero

262
00:13:42,330 --> 00:13:45,070
nos ahorramos

263
00:13:45,070 --> 00:13:45,889
variables

264
00:13:45,889 --> 00:13:48,210
si lo hacemos como arriba

265
00:13:48,210 --> 00:13:51,210
si lo hacemos como arriba, arrastramos ya el cliente entero

266
00:13:51,210 --> 00:13:53,070
entonces voy a dejar

267
00:13:53,070 --> 00:13:54,809
esto es lo que voy a dejar comentado

268
00:13:54,809 --> 00:13:57,049
y voy a dejar

269
00:13:57,049 --> 00:13:57,590
el de arriba

270
00:13:57,590 --> 00:14:04,940
¿vale? entonces

271
00:14:04,940 --> 00:14:06,840
hombre, el de arriba mejor, yo estoy

272
00:14:06,840 --> 00:14:08,899
maximizando, siempre que podamos hacerlo así

273
00:14:08,899 --> 00:14:10,720
yo estoy maximizando

274
00:14:10,720 --> 00:14:12,519
un conjunto de clientes

275
00:14:12,519 --> 00:14:15,019
un conjunto de pedidos, un conjunto de ordenadores

276
00:14:15,019 --> 00:14:16,620
un conjunto de lo que sea, de objetos

277
00:14:16,620 --> 00:14:18,820
pues trabajo con el objeto directamente

278
00:14:18,820 --> 00:14:20,919
este es el objeto máximo

279
00:14:20,919 --> 00:14:22,059
hasta ese momento, el cero

280
00:14:22,059 --> 00:14:25,019
voy por los demás, si supera el máximo

281
00:14:25,019 --> 00:14:26,940
tengo nuevo máximo y ya está

282
00:14:26,940 --> 00:14:29,159
¿vale?

283
00:14:29,559 --> 00:14:30,879
si cliente es de i

284
00:14:30,879 --> 00:14:32,820
su número de pedidos es mayor

285
00:14:32,820 --> 00:14:35,080
que el que tenía más hasta ese momento

286
00:14:35,080 --> 00:14:37,059
iniciándolo con el primero

287
00:14:37,059 --> 00:14:39,259
tengo nuevo cliente máximo y ya está

288
00:14:39,259 --> 00:14:41,360
cuando el bucle ha terminado

289
00:14:41,360 --> 00:14:42,980
ya tenemos en el objeto

290
00:14:42,980 --> 00:14:44,940
cliente máximo todos los datos

291
00:14:44,940 --> 00:14:46,220
del cliente

292
00:14:46,220 --> 00:14:51,549
y ahora podríamos

293
00:14:51,549 --> 00:14:55,100
poner el cliente

294
00:14:55,879 --> 00:14:57,120
con

295
00:14:57,120 --> 00:14:59,480
más pedidos

296
00:14:59,480 --> 00:15:00,100
es

297
00:15:00,100 --> 00:15:02,779
y lo podemos concatenar sin miedo

298
00:15:02,779 --> 00:15:04,899
con cliente max

299
00:15:04,899 --> 00:15:07,259
porque la clase cliente

300
00:15:07,259 --> 00:15:08,379
tiene un toString

301
00:15:08,379 --> 00:15:11,470
tiene un toString

302
00:15:11,470 --> 00:15:17,470
entonces al tener un toString

303
00:15:17,470 --> 00:15:19,590
el método system.out

304
00:15:19,590 --> 00:15:21,990
a la hora de concatenar

305
00:15:21,990 --> 00:15:23,830
no le queda más remedio que convertirlo a stream

306
00:15:23,830 --> 00:15:25,210
el método system.out tiene que

307
00:15:25,210 --> 00:15:27,409
convertirlo a stream para concatenar

308
00:15:27,409 --> 00:15:29,009
¿cómo convierte a stream?

309
00:15:29,509 --> 00:15:31,669
llamando al toStream, que no tenemos

310
00:15:31,669 --> 00:15:34,090
toStream hecho, hace una patata

311
00:15:34,090 --> 00:15:35,769
como tenemos hecho un

312
00:15:35,769 --> 00:15:37,730
toStream, pues mostrará aquí lo que

313
00:15:37,730 --> 00:15:51,990
hayamos hecho nosotros, vale

314
00:15:51,990 --> 00:15:57,950
¿tienes el poder de verificar

315
00:15:57,950 --> 00:15:58,669
el poder de luz?

316
00:16:00,309 --> 00:16:01,629
ah, tienes toda la razón

317
00:16:01,629 --> 00:16:02,490
claro, porque

318
00:16:02,490 --> 00:16:05,429
si no verificamos, porque el cliente puede no

319
00:16:05,429 --> 00:16:06,889
tener pedido, entonces si no los tiene

320
00:16:06,889 --> 00:16:08,990
en ese caso no quiero considerarlo

321
00:16:08,990 --> 00:16:11,230
quiero que la condición sea falsa, efectivamente

322
00:16:11,230 --> 00:16:13,029
puede haber clientes sin pedidos

323
00:16:13,029 --> 00:16:15,250
entonces me saldría un pedazo null pointer

324
00:16:15,250 --> 00:16:16,850
exception, de hecho

325
00:16:16,850 --> 00:16:18,690
si uno no se da cuenta

326
00:16:18,690 --> 00:16:21,129
según lo ve, se va a dar cuenta en cuanto

327
00:16:21,129 --> 00:16:23,269
haga un par de pruebas, en cuanto le salga un null

328
00:16:23,269 --> 00:16:25,210
pointer exception va a decir, ah claro

329
00:16:25,210 --> 00:16:27,169
yo estoy recorriendo todos los

330
00:16:27,169 --> 00:16:29,289
clientes, puede que haya clientes

331
00:16:29,289 --> 00:16:31,370
que no tengan pedidos, cuidado

332
00:16:31,370 --> 00:16:33,210
porque en esta condición entonces tengo que

333
00:16:33,210 --> 00:16:35,450
añadir, si clientes

334
00:16:35,450 --> 00:16:36,350
.get

335
00:16:36,350 --> 00:16:40,029
clientes de i

336
00:16:40,029 --> 00:16:42,769
si clientes de i

337
00:16:42,769 --> 00:16:45,470
.get

338
00:16:45,470 --> 00:16:46,269
pedidos

339
00:16:46,269 --> 00:16:48,850
es diferente de null

340
00:16:48,850 --> 00:16:53,299
y si además de ser

341
00:16:53,299 --> 00:16:54,500
diferente de null

342
00:16:54,500 --> 00:16:57,340
y si además de ser diferente de null

343
00:16:57,340 --> 00:16:59,179
clientes de i

344
00:16:59,179 --> 00:17:00,059
.get pedidos

345
00:17:00,059 --> 00:17:02,539
.len supera

346
00:17:02,539 --> 00:17:05,119
entonces esta condición if tiene que ser más compleja

347
00:17:05,119 --> 00:17:06,900
tiene que tener, si es diferente de null

348
00:17:06,900 --> 00:17:09,440
y además de ser diferente de null

349
00:17:09,440 --> 00:17:11,559
supera su tamaño, la del máximo

350
00:17:11,559 --> 00:17:12,440
hasta ese momento

351
00:17:12,440 --> 00:17:15,660
vale, efectivamente, si no ponemos esto

352
00:17:15,660 --> 00:17:17,759
pues nos va a salir un null pointer exception

353
00:17:17,759 --> 00:17:19,099
seguro, en algún momento

354
00:17:19,099 --> 00:17:24,079
este es otro ejemplo

355
00:17:24,079 --> 00:17:26,940
de la diferencia grande entre

356
00:17:26,940 --> 00:17:28,599
poner un solo ampersand o dos

357
00:17:28,599 --> 00:17:30,119
vale

358
00:17:30,119 --> 00:17:33,980
si ponemos dos ampersand

359
00:17:33,980 --> 00:17:36,500
acordaos, de que en cuanto

360
00:17:36,500 --> 00:17:37,799
esta sea falsa

361
00:17:37,799 --> 00:17:39,819
la de abajo ya ni la mira

362
00:17:39,819 --> 00:17:42,859
entonces, si entramos a un cliente

363
00:17:42,859 --> 00:17:43,759
con pedidos null

364
00:17:43,759 --> 00:17:46,799
esta ya ni la mira, el and es falso y se acabó

365
00:17:46,799 --> 00:17:49,240
pero si ponemos solo una ampersand

366
00:17:49,240 --> 00:17:51,039
cuando lleguemos

367
00:17:51,039 --> 00:17:52,700
a un cliente con pedidos null

368
00:17:52,700 --> 00:17:55,119
esta va a dar false, pero aún así

369
00:17:55,119 --> 00:17:57,099
va a entrar aquí, con lo cual nos va a seguir

370
00:17:57,099 --> 00:17:58,539
saltando el null pointer exception

371
00:17:58,539 --> 00:18:00,920
entonces hay un montón de casos

372
00:18:00,920 --> 00:18:02,940
en que lógicamente, aunque la tabla

373
00:18:02,940 --> 00:18:04,920
de verdad sea la misma

374
00:18:04,920 --> 00:18:06,640
el false, false, true, true, sea la misma

375
00:18:06,640 --> 00:18:07,720
con un ampersand que dos

376
00:18:07,720 --> 00:18:10,839
la diferencia entre que se ejecute lo segundo

377
00:18:10,839 --> 00:18:11,559
no es enorme

378
00:18:11,559 --> 00:18:14,119
¿Vale? Aquí con un solo ampersand

379
00:18:14,119 --> 00:18:16,119
Nos va a salir un null pointer de excepción

380
00:18:16,119 --> 00:18:16,640
Todo el rato

381
00:18:16,640 --> 00:18:19,579
Y solamente podemos arreglarlo

382
00:18:19,579 --> 00:18:20,720
Con el doble ampersand

383
00:18:20,720 --> 00:18:29,329
¿Vale? Pues este máximo

384
00:18:29,329 --> 00:18:30,289
Estaría entendido

385
00:18:30,289 --> 00:18:32,990
Entonces, si hiciéramos el otro

386
00:18:32,990 --> 00:18:34,430
Maximizar ahora

387
00:18:34,430 --> 00:18:36,369
Pero por el que más se ha gastado

388
00:18:36,369 --> 00:18:38,710
Pues sería prácticamente lo mismo

389
00:18:38,710 --> 00:18:41,289
Pero cambiando solo la condición de máximo

390
00:18:41,289 --> 00:18:45,859
Este sería

391
00:18:45,859 --> 00:18:47,359
A ver si, porque

392
00:18:47,359 --> 00:18:49,740
No sé si tengo cerrado

393
00:18:49,740 --> 00:18:51,200
sí, este es el del case

394
00:18:51,200 --> 00:18:56,170
caso

395
00:18:56,170 --> 00:18:59,210
6, ¿verdad?

396
00:19:01,869 --> 00:19:03,349
caso 6, este era

397
00:19:03,349 --> 00:19:04,549
maximizar

398
00:19:04,549 --> 00:19:06,130
pero ahora

399
00:19:06,130 --> 00:19:09,349
por el cliente que más

400
00:19:09,349 --> 00:19:10,210
se ha gastado

401
00:19:10,210 --> 00:19:12,650
luego el criterio no es

402
00:19:12,650 --> 00:19:14,710
el tamaño del array

403
00:19:14,710 --> 00:19:17,109
sino la suma de todos los elementos

404
00:19:17,109 --> 00:19:19,450
vale, pues

405
00:19:19,450 --> 00:19:21,369
gran parte

406
00:19:21,369 --> 00:19:22,930
del código lo vamos a reutilizar

407
00:19:22,930 --> 00:19:24,569
pues nos hacemos un copia y pega

408
00:19:24,569 --> 00:19:27,130
Aquí tengo un

409
00:19:27,130 --> 00:19:29,009
Un

410
00:19:29,009 --> 00:19:34,460
Un error en el punto y coma

411
00:19:34,460 --> 00:19:36,700
Porque algo no he debido cerrar

412
00:19:36,700 --> 00:19:37,539
O yo que sé qué

413
00:19:37,539 --> 00:19:39,599
Sí, me falta

414
00:19:39,599 --> 00:19:42,400
Alguna llave en algún sitio

415
00:19:42,400 --> 00:19:47,349
A ver

416
00:19:47,349 --> 00:19:49,650
Este cierra ahí

417
00:19:49,650 --> 00:19:58,779
Y este, ¿qué le pasa?

418
00:20:07,410 --> 00:20:08,630
No sé qué le pasa a este

419
00:20:08,630 --> 00:20:15,930
Este es este

420
00:20:15,930 --> 00:20:19,519
Hay alguna llave que tengo

421
00:20:19,519 --> 00:20:23,359
¿Cómo es hacer el máximo?

422
00:20:23,359 --> 00:20:25,759
vamos a copiar y pegar este código

423
00:20:25,759 --> 00:20:26,980
el único que cambiamos

424
00:20:26,980 --> 00:20:29,339
es el criterio por el que

425
00:20:29,339 --> 00:20:31,440
supera un cliente al máximo

426
00:20:31,440 --> 00:20:33,380
pues todo esto

427
00:20:33,380 --> 00:20:35,279
lo podemos

428
00:20:35,279 --> 00:20:36,140
copiar y pegar

429
00:20:36,140 --> 00:20:44,920
porque arrancamos

430
00:20:44,920 --> 00:20:46,859
igual, el cliente

431
00:20:46,859 --> 00:20:47,980
que más se ha gastado

432
00:20:47,980 --> 00:20:50,779
clientes de 0, recorremos

433
00:20:50,779 --> 00:20:53,059
los demás, si clientes

434
00:20:53,059 --> 00:20:54,640
de i supera cliente máximo

435
00:20:54,640 --> 00:20:56,779
vale, aquí lo que

436
00:20:56,779 --> 00:20:58,859
pasa es que esta

437
00:20:58,859 --> 00:21:00,180
condición es la que cambia

438
00:21:00,180 --> 00:21:02,779
¿vale? lo único que cambia

439
00:21:02,779 --> 00:21:04,720
del código de arriba es que esta

440
00:21:04,720 --> 00:21:07,019
condición de aquí que tengo marcada es la que cambia

441
00:21:07,019 --> 00:21:08,980
antes, el cliente

442
00:21:08,980 --> 00:21:10,920
actual cliente sí, superaba

443
00:21:10,920 --> 00:21:12,720
al máximo si el tamaño de su

444
00:21:12,720 --> 00:21:14,640
array era mayor que el tamaño del array

445
00:21:14,640 --> 00:21:16,440
de este, pero ahora no

446
00:21:16,440 --> 00:21:18,619
ahora este cliente va a superar al máximo

447
00:21:18,619 --> 00:21:20,779
si la suma de precios

448
00:21:20,779 --> 00:21:22,259
de todos los pedidos que tiene

449
00:21:22,259 --> 00:21:24,839
es mayor que la suma de precios

450
00:21:24,839 --> 00:21:26,319
de todos los pedidos que tiene este otro

451
00:21:26,319 --> 00:21:28,880
con lo cual, aquí ya se complica

452
00:21:28,880 --> 00:21:30,579
porque esa suma

453
00:21:30,579 --> 00:21:33,039
no la podemos hacer aquí en la condición a la vez

454
00:21:33,039 --> 00:21:35,119
tendríamos que hacerla

455
00:21:35,119 --> 00:21:35,940
antes

456
00:21:35,940 --> 00:21:39,059
pero claro, este case empieza ya a hacerse

457
00:21:39,059 --> 00:21:41,359
muy grato, ahora en cuando pensamos

458
00:21:41,359 --> 00:21:43,220
oye, que bien me vendría

459
00:21:43,220 --> 00:21:45,720
que bien me vendría

460
00:21:45,720 --> 00:21:47,259
tener un método

461
00:21:47,259 --> 00:21:48,980
que si lo llamo un cliente

462
00:21:48,980 --> 00:21:50,980
me devolviera por ejemplo

463
00:21:50,980 --> 00:21:53,000
gasto total

464
00:21:53,000 --> 00:21:56,819
porque si yo tuviera un método

465
00:21:56,819 --> 00:21:58,400
que me devolviera gasto total

466
00:21:58,400 --> 00:21:59,700
lo llamo

467
00:21:59,700 --> 00:22:03,789
y ya tengo esto hecho

468
00:22:03,789 --> 00:22:09,319
repito, si yo tengo

469
00:22:09,319 --> 00:22:11,099
un método en la clase cliente

470
00:22:11,099 --> 00:22:13,420
que para el objeto que lo llame

471
00:22:13,420 --> 00:22:15,559
me devuelve lo que se ha gastado

472
00:22:15,559 --> 00:22:17,460
en pedidos, maravilloso

473
00:22:17,460 --> 00:22:18,720
mi máximo ya estaría

474
00:22:18,720 --> 00:22:21,420
máximo inicial el primero

475
00:22:21,420 --> 00:22:22,519
recorro los demás

476
00:22:22,519 --> 00:22:25,359
si él tiene pedidos

477
00:22:25,359 --> 00:22:26,940
nul y el gasto total

478
00:22:26,940 --> 00:22:29,200
de ese cliente es mayor que el gasto

479
00:22:29,200 --> 00:22:31,099
total del cliente máximo, hasta ese momento

480
00:22:31,099 --> 00:22:33,319
tengo un nuevo cliente máximo, y ya está

481
00:22:33,319 --> 00:22:34,940
y aquí ya diría

482
00:22:34,940 --> 00:22:37,000
el cliente que más ha gastado

483
00:22:37,000 --> 00:22:39,500
es

484
00:22:39,500 --> 00:22:40,880
quien sea

485
00:22:40,880 --> 00:22:47,799
vale, pero claro, me vendría muy bien

486
00:22:47,799 --> 00:22:48,279
ese método

487
00:22:48,279 --> 00:22:52,019
si no, tengo que hacer la suma acumulativa

488
00:22:52,019 --> 00:22:53,500
aquí en este mismo código

489
00:22:53,500 --> 00:22:54,859
antes de la comparación

490
00:22:54,859 --> 00:22:57,339
la suma acumulativa para clientes de ahí

491
00:22:57,339 --> 00:22:59,299
la suma acumulativa para cliente max

492
00:22:59,299 --> 00:23:00,339
un rollo

493
00:23:00,339 --> 00:23:03,640
entonces, si tengo este método, fenomenal

494
00:23:03,640 --> 00:23:07,450
vale, pues entonces

495
00:23:07,450 --> 00:23:09,490
mi código parte de que ese método

496
00:23:09,490 --> 00:23:11,549
existe, yo ya al que esté haciendo cliente

497
00:23:11,549 --> 00:23:12,809
le digo, incorpora este método

498
00:23:12,809 --> 00:23:15,589
y ese es un problema del que hace la clase

499
00:23:15,589 --> 00:23:17,670
cliente, el que hace la clase

500
00:23:17,670 --> 00:23:19,509
cliente, ahora incorporará

501
00:23:19,509 --> 00:23:21,809
un método que para un cliente

502
00:23:21,809 --> 00:23:23,829
en particular, te devuelve

503
00:23:23,829 --> 00:23:25,789
la suma de todo

504
00:23:25,789 --> 00:23:31,680
lo que se ha gastado, vale

505
00:23:31,680 --> 00:23:33,460
pues hemos derivado

506
00:23:33,460 --> 00:23:35,900
el problema desde el main, lo hemos derivado

507
00:23:35,900 --> 00:23:46,039
la clase cliente. ¿Puedo abrir

508
00:23:46,039 --> 00:23:51,880
la clase cliente? Pues venga,

509
00:23:51,960 --> 00:23:53,880
vamos a hacer el método en la clase cliente.

510
00:23:57,549 --> 00:23:58,730
¡Hala! Otro método

511
00:23:58,730 --> 00:24:00,829
más. Pues un método

512
00:24:00,829 --> 00:24:02,589
public, porque lo estoy usando desde otro

513
00:24:02,589 --> 00:24:04,789
paquete. ¿Qué me va

514
00:24:04,789 --> 00:24:06,650
a devolver? Una suma de precios.

515
00:24:06,970 --> 00:24:08,470
Luego este método me devuelve double.

516
00:24:09,430 --> 00:24:10,569
¿Cómo hemos dicho que

517
00:24:10,569 --> 00:24:12,750
se tiene que llamar? Gasto total.

518
00:24:14,029 --> 00:24:14,710
¿Recibe algún

519
00:24:14,710 --> 00:24:16,930
parámetro? No. Este método solamente

520
00:24:16,930 --> 00:24:18,390
trabaja con la lista de pedidos.

521
00:24:18,609 --> 00:24:20,569
No recibe nada. Pues ¡hala!

522
00:24:20,589 --> 00:24:24,069
ahora ya a este método le toca

523
00:24:24,069 --> 00:24:26,109
trabajar con este

524
00:24:26,109 --> 00:24:27,730
array de pedidos de aquí arriba

525
00:24:27,730 --> 00:24:29,769
para

526
00:24:29,769 --> 00:24:32,210
hacer una suma acumulativa

527
00:24:32,210 --> 00:24:34,210
la suma acumulativa

528
00:24:34,210 --> 00:24:36,109
sabemos hacerlo, estamos usando todo el

529
00:24:36,109 --> 00:24:37,809
rato los patrones básicos

530
00:24:37,809 --> 00:24:40,450
algorítmicos que conocemos

531
00:24:40,450 --> 00:24:42,150
entonces bueno, antes que nada

532
00:24:42,150 --> 00:24:43,309
si pedidos fuera null

533
00:24:43,309 --> 00:24:45,930
ni entro en el array

534
00:24:45,930 --> 00:24:47,769
porque es que me va a salir un pedazo null point

535
00:24:47,769 --> 00:24:49,849
de excepción, entonces si los

536
00:24:49,849 --> 00:24:51,890
pedidos del usuario es null, pues se ha

537
00:24:51,890 --> 00:24:53,990
gastado cero, return cero

538
00:24:53,990 --> 00:24:56,759
¿vale?

539
00:24:59,170 --> 00:25:01,150
entonces cuando el método alcanza

540
00:25:01,150 --> 00:25:02,849
return, ahí ya ha terminado

541
00:25:02,849 --> 00:25:05,569
¿vale? o sea el return

542
00:25:05,569 --> 00:25:07,309
no solo manda el

543
00:25:07,309 --> 00:25:09,509
valor hacia afuera, sino que también

544
00:25:09,509 --> 00:25:10,490
para el método

545
00:25:10,490 --> 00:25:14,500
aquí el método termina

546
00:25:14,500 --> 00:25:21,279
claro, claro

547
00:25:21,279 --> 00:25:23,839
lo de abajo sería

548
00:25:23,839 --> 00:25:25,799
si no se ha dado

549
00:25:25,799 --> 00:25:26,539
la condición de lift

550
00:25:26,539 --> 00:25:29,640
vale, entonces el return implica

551
00:25:29,640 --> 00:25:30,900
devuelve valor

552
00:25:30,900 --> 00:25:33,599
y además método se acabó, sales de ahí

553
00:25:33,599 --> 00:25:34,700
y te vas al programa principal

554
00:25:34,700 --> 00:25:37,660
vale, pero que ocurre si pedidos es diferente

555
00:25:37,660 --> 00:25:39,480
de null, si pedidos es diferente

556
00:25:39,480 --> 00:25:41,720
de null, como no alcanzamos el return

557
00:25:41,720 --> 00:25:43,380
el método sigue hacia abajo

558
00:25:43,380 --> 00:25:45,359
porque no ha entrado en el return, el método sigue

559
00:25:45,359 --> 00:25:47,500
vale, pues en este caso ahora ya si que

560
00:25:47,500 --> 00:25:48,660
queremos hacer la suma

561
00:25:48,660 --> 00:25:54,079
y ahora la suma, pues esto ya es

562
00:25:54,079 --> 00:25:55,279
muy fácil para nosotros

563
00:25:55,279 --> 00:25:58,119
esto si que lo podemos hacer con un

564
00:25:58,119 --> 00:26:00,279
for each, porque el array de pedidos

565
00:26:00,279 --> 00:26:01,359
tiene tantos

566
00:26:01,359 --> 00:26:03,799
el tamaño es exactamente

567
00:26:03,799 --> 00:26:05,900
el de los pedidos, porque el agregar pedido

568
00:26:05,900 --> 00:26:07,960
lo hemos hecho agrandando el array, etc

569
00:26:07,960 --> 00:26:11,980
y ahora aquí ya suma

570
00:26:11,980 --> 00:26:13,380
más igual

571
00:26:13,380 --> 00:26:15,700
p.getPrecio

572
00:26:15,700 --> 00:26:17,200
ala

573
00:26:17,200 --> 00:26:19,039
ya tengo la suma acumulativa

574
00:26:19,039 --> 00:26:21,839
una vez que la tengo, para afuera

575
00:26:21,839 --> 00:26:25,109
y se acabó este método

576
00:26:25,109 --> 00:26:38,809
vale, si pedidos es null

577
00:26:38,809 --> 00:26:41,170
cero, te has gastado cero y se acabó

578
00:26:41,170 --> 00:26:45,069
que no es null, no entra aquí

579
00:26:45,069 --> 00:26:47,009
luego sigue, suma acumulativa

580
00:26:47,009 --> 00:26:48,390
recorre los pedidos

581
00:26:48,390 --> 00:26:51,009
del usuario y va

582
00:26:51,009 --> 00:26:52,789
sumando el precio

583
00:26:52,789 --> 00:26:53,650
de ese pedido

584
00:26:53,650 --> 00:26:57,109
a la variable suma acumulativa, cuando el for

585
00:26:57,109 --> 00:26:58,990
ha terminado, devolvemos

586
00:26:58,990 --> 00:26:59,890
la suma hacia afuera

587
00:26:59,890 --> 00:27:09,970
vale, pues ese método ya lo ha hecho alguien en cliente

588
00:27:09,970 --> 00:27:11,250
y yo lo uso desde mi mail

589
00:27:11,250 --> 00:27:12,930
ya me despreocupo de

590
00:27:12,930 --> 00:27:14,710
dime

591
00:27:14,710 --> 00:27:19,970
claro

592
00:27:19,970 --> 00:27:22,190
lo que pasa es que en este caso

593
00:27:22,190 --> 00:27:24,490
porque tal y como hemos hecho agregar pedido

594
00:27:24,490 --> 00:27:26,630
lo hemos hecho de tal manera que el array

595
00:27:26,630 --> 00:27:27,630
pedidos de arriba

596
00:27:27,630 --> 00:27:30,250
tiene siempre exactamente

597
00:27:30,250 --> 00:27:31,869
tantas posiciones como pedidos

598
00:27:31,869 --> 00:27:33,990
porque agregar pedido lo hemos hecho que

599
00:27:33,990 --> 00:27:35,410
va agrandando una posición

600
00:27:35,410 --> 00:27:38,289
entonces en este caso el for

601
00:27:38,289 --> 00:27:39,970
queremos que lo recorra entero de principio a fin

602
00:27:39,970 --> 00:27:42,430
con lo cual puedo usar el for each

603
00:27:42,430 --> 00:27:44,450
solo porque es más rápido de escribir

604
00:27:44,450 --> 00:27:45,910
no porque aporte ninguna otra ventaja

605
00:27:45,910 --> 00:27:47,769
porque es más rápido de escribir

606
00:27:47,769 --> 00:27:50,170
porque el único problema

607
00:27:50,170 --> 00:27:52,130
que tiene el for es que va de principio

608
00:27:52,130 --> 00:27:54,009
a fin obligatoriamente, no es como el de índice

609
00:27:54,009 --> 00:27:56,029
que yo lo paro cuando quiera, pues como en este

610
00:27:56,029 --> 00:27:57,970
caso quiero ir de principio a fin, porque

611
00:27:57,970 --> 00:27:59,990
es más fácil y cómodo de escribir, pues lo

612
00:27:59,990 --> 00:28:01,930
he hecho así, pero claro, lo puedes hacer con un for

613
00:28:01,930 --> 00:28:03,910
con i, por índice igual a cero

614
00:28:03,910 --> 00:28:11,819
¿vale? como si lo haces con

615
00:28:11,819 --> 00:28:13,720
un for normal, es exactamente igual, unido

616
00:28:13,720 --> 00:28:15,579
y cambias esto, igual a cero

617
00:28:15,579 --> 00:28:17,480
mientras i sea menor que

618
00:28:17,480 --> 00:28:19,339
pedidos.length

619
00:28:19,339 --> 00:28:21,420
incrementando i

620
00:28:21,420 --> 00:28:26,220
Claro, pedidos

621
00:28:26,220 --> 00:28:28,539
Cuando se llegue a este método

622
00:28:28,539 --> 00:28:29,539
Pedidos ya existirá

623
00:28:29,539 --> 00:28:30,900
Porque ya hay un objeto creado

624
00:28:30,900 --> 00:28:32,140
¿Vale?

625
00:28:34,430 --> 00:28:35,750
Suma más igual

626
00:28:35,750 --> 00:28:38,569
Pedidos de i

627
00:28:38,569 --> 00:28:39,609
Punto

628
00:28:39,609 --> 00:28:42,089
El de arriba y el de abajo

629
00:28:42,089 --> 00:28:43,869
Pues hacen lo mismo

630
00:28:43,869 --> 00:28:46,069
El for de arriba y el for de abajo

631
00:28:46,069 --> 00:28:47,730
Hacen exactamente igual

632
00:28:47,730 --> 00:28:50,549
Este lo hace con una variable

633
00:28:50,549 --> 00:28:52,910
Temporal que se queda con la

634
00:28:52,910 --> 00:28:53,690
copia

635
00:28:53,690 --> 00:28:56,390
pero el resultado es el mismo

636
00:28:56,390 --> 00:28:57,630
vale

637
00:28:57,630 --> 00:29:02,319
vale

638
00:29:02,319 --> 00:29:04,599
pues entonces gracias a que está este método

639
00:29:04,599 --> 00:29:06,279
ahora ya el main

640
00:29:06,279 --> 00:29:07,400
tira de él

641
00:29:07,400 --> 00:29:09,319
para el máximo

642
00:29:09,319 --> 00:29:35,420
vale pues vamos a aprovechar

643
00:29:35,420 --> 00:29:37,420
el

644
00:29:37,420 --> 00:29:39,319
método este que calcula

645
00:29:39,319 --> 00:29:40,220
el gasto total

646
00:29:40,220 --> 00:29:43,220
este método que tenemos aquí

647
00:29:43,220 --> 00:29:45,400
por ejemplo este

648
00:29:45,400 --> 00:29:48,680
para incorporar otro concepto

649
00:29:48,680 --> 00:29:50,460
que es el concepto

650
00:29:50,460 --> 00:29:51,799
de variables

651
00:29:51,799 --> 00:29:57,960
y métodos estáticos

652
00:29:57,960 --> 00:30:00,039
¿vale? es sencillo

653
00:30:00,039 --> 00:30:00,880
no hay que estresarse

654
00:30:00,880 --> 00:30:07,130
¿cuál? el main

655
00:30:07,130 --> 00:30:10,309
el main es el mismo

656
00:30:10,309 --> 00:30:11,269
de arriba

657
00:30:11,269 --> 00:30:13,910
pero lo único que hace es

658
00:30:13,910 --> 00:30:16,089
comparar si el gasto total del cliente

659
00:30:16,089 --> 00:30:17,990
en posición i es mayor

660
00:30:17,990 --> 00:30:20,190
que el gasto total del máximo

661
00:30:20,190 --> 00:30:20,950
hasta ese momento

662
00:30:20,950 --> 00:30:26,720
ahora el criterio para hacer el máximo

663
00:30:26,720 --> 00:30:28,460
es el gasto del cliente

664
00:30:28,460 --> 00:30:30,299
no el tamaño de su array

665
00:30:30,299 --> 00:30:33,990
vale, o sea son

666
00:30:33,990 --> 00:30:36,369
el caso 5 y 6 son iguales

667
00:30:36,369 --> 00:30:37,529
solo cambia esta condición

668
00:30:37,529 --> 00:30:40,250
tamaño del array o gasto total

669
00:30:40,250 --> 00:30:45,200
vale, pues vamos a

670
00:30:45,200 --> 00:30:46,140
aprovechar

671
00:30:46,140 --> 00:30:48,759
este método por ejemplo de aquí

672
00:30:48,759 --> 00:30:50,759
gasto total para

673
00:30:50,759 --> 00:30:53,319
incorporar otro concepto

674
00:30:53,319 --> 00:30:54,579
como hemos dicho, el de las

675
00:30:54,579 --> 00:30:56,980
variables y los métodos estáticos

676
00:30:56,980 --> 00:31:06,910
que silencio

677
00:31:06,910 --> 00:31:10,009
Que creo que esta última semana de Navidad

678
00:31:10,009 --> 00:31:12,430
Normalmente solo estamos aquí en el instituto

679
00:31:12,430 --> 00:31:13,309
Los de informática

680
00:31:13,309 --> 00:31:18,880
Que sois los únicos pringados

681
00:31:18,880 --> 00:31:20,579
Que trabajáis a todas horas

682
00:31:20,579 --> 00:31:22,319
Hasta el último minuto

683
00:31:22,319 --> 00:31:25,240
Cosa que está fenomenal

684
00:31:25,240 --> 00:31:26,619
Que la vida os devolverá

685
00:31:26,619 --> 00:31:31,059
Y yo que quería

686
00:31:31,059 --> 00:31:32,799
Yo quería esto

687
00:31:32,799 --> 00:31:44,910
Vale

688
00:31:44,910 --> 00:31:49,519
Vale, pues a ver

689
00:31:49,519 --> 00:31:51,640
Sabemos ya como funciona este tema

690
00:31:51,640 --> 00:31:52,299
De los objetos

691
00:31:52,299 --> 00:31:54,119
tenemos

692
00:31:54,119 --> 00:32:00,569
yo aquí tengo

693
00:32:00,569 --> 00:32:03,289
por ejemplo mi clase cliente

694
00:32:03,289 --> 00:32:05,130
mi clase cliente que dice

695
00:32:05,130 --> 00:32:07,109
que tiene nif y nombre

696
00:32:07,109 --> 00:32:09,269
por ejemplo, nif nombre

697
00:32:09,269 --> 00:32:09,910
o lo que sea

698
00:32:09,910 --> 00:32:12,970
voy a ponerle dos propiedades solo

699
00:32:12,970 --> 00:32:15,250
mi clase cliente que tiene nif y

700
00:32:15,250 --> 00:32:16,710
nombre, entonces yo a partir de aquí

701
00:32:16,710 --> 00:32:19,150
puedo ya instanciar

702
00:32:19,150 --> 00:32:20,009
¿vale?

703
00:32:20,750 --> 00:32:23,069
puedo ya instanciar

704
00:32:23,069 --> 00:32:23,589
un

705
00:32:23,589 --> 00:32:30,680
todos los objetos que quiera

706
00:32:30,680 --> 00:32:31,319
¿vale?

707
00:32:32,099 --> 00:32:33,940
ya sabemos cómo funciona esto

708
00:32:33,940 --> 00:32:35,839
C1, C2, C3

709
00:32:35,839 --> 00:32:38,480
y ya sabemos que cada objeto

710
00:32:38,480 --> 00:32:40,539
tiene su propio NIF

711
00:32:40,539 --> 00:32:41,319
su propio nombre

712
00:32:41,319 --> 00:32:42,839
su propio NIF, su propio nombre

713
00:32:42,839 --> 00:32:44,339
su propio NIF, su propio nombre

714
00:32:44,339 --> 00:32:46,880
¿vale? porque NIF y nombre son propiedades

715
00:32:46,880 --> 00:32:47,539
de la clase

716
00:32:47,539 --> 00:32:51,119
lo cual significa que cada objeto

717
00:32:51,119 --> 00:32:53,079
que se instancie de esta clase

718
00:32:53,079 --> 00:32:54,720
que puede ser uno, pueden ser

719
00:32:54,720 --> 00:32:56,819
200.000 millones, cada uno

720
00:32:56,819 --> 00:32:58,940
de ellos tiene un valor concreto

721
00:32:58,940 --> 00:33:00,880
para sus propiedades, porque es un ejemplo

722
00:33:00,880 --> 00:33:02,980
concreto. Cada objeto

723
00:33:02,980 --> 00:33:05,279
es un ejemplo concreto de cliente,

724
00:33:05,759 --> 00:33:07,180
siendo esta, pues, la plantilla.

725
00:33:07,940 --> 00:33:08,019
¿Vale?

726
00:33:09,200 --> 00:33:10,759
Vale, entonces, esto representa

727
00:33:10,759 --> 00:33:12,660
bastante la realidad. En la realidad,

728
00:33:12,980 --> 00:33:14,740
pues, tenemos objetos

729
00:33:14,740 --> 00:33:17,000
concretos de las ideas

730
00:33:17,000 --> 00:33:18,279
platónicas, ¿verdad?

731
00:33:18,579 --> 00:33:20,660
Si habéis estudiado filosofía de Kuhn, pues, tenemos

732
00:33:20,660 --> 00:33:22,619
instancias concretas. Vale,

733
00:33:22,859 --> 00:33:24,980
pero hay cosas

734
00:33:24,980 --> 00:33:26,000
de la realidad

735
00:33:26,000 --> 00:33:28,759
que nos gustaría también recoger

736
00:33:28,759 --> 00:33:30,539
y representar aquí de alguna manera

737
00:33:30,539 --> 00:33:32,859
en nuestro modelo de datos, en nuestra aplicación.

738
00:33:33,920 --> 00:33:34,640
Y es la idea

739
00:33:34,640 --> 00:33:36,480
de que puede haber información

740
00:33:36,480 --> 00:33:38,480
que es común

741
00:33:38,480 --> 00:33:41,119
para todos los objetos de una clase.

742
00:33:41,700 --> 00:33:42,900
La misma, compartida.

743
00:33:43,660 --> 00:33:44,920
Y que si cambia para uno,

744
00:33:45,359 --> 00:33:47,339
cambia para otro, porque todos la comparten.

745
00:33:48,319 --> 00:33:48,940
Entonces, esa idea

746
00:33:48,940 --> 00:33:51,059
también se da en la realidad, ¿no?

747
00:33:51,059 --> 00:33:53,119
Por ejemplo, vosotros sois todos

748
00:33:53,119 --> 00:33:55,160
ejemplos concretos de la clase

749
00:33:55,160 --> 00:33:57,039
alumno, os podéis

750
00:33:57,039 --> 00:33:58,960
caracterizar por vuestro NIF

751
00:33:58,960 --> 00:34:01,079
por vuestro nombre, pero

752
00:34:01,079 --> 00:34:02,859
también os podéis caracterizar por el aula

753
00:34:02,859 --> 00:34:04,920
por la que dais clase, porque ese dato

754
00:34:04,920 --> 00:34:06,900
por lo que sea le interesa a la aplicación, el aula

755
00:34:06,900 --> 00:34:09,079
donde dais clase, pero ¿qué ocurre?

756
00:34:09,179 --> 00:34:10,980
que como sois todos alumnos de Damu

757
00:34:10,980 --> 00:34:13,019
no vais todos juntitos, pues

758
00:34:13,019 --> 00:34:15,019
la clase es la misma para todos, entonces

759
00:34:15,019 --> 00:34:17,219
yo puedo tener mil instancias

760
00:34:17,219 --> 00:34:19,099
de cada uno de vosotros, cada uno con el

761
00:34:19,099 --> 00:34:20,119
carterito aquí de

762
00:34:20,119 --> 00:34:23,039
Pepito, NIF1, en

763
00:34:23,039 --> 00:34:24,900
aula de alguno, pero el apartado

764
00:34:24,900 --> 00:34:26,800
aula es que es el mismo para todos

765
00:34:26,800 --> 00:34:29,079
porque vais todos a la misma

766
00:34:29,079 --> 00:34:30,599
clase, entonces

767
00:34:30,599 --> 00:34:32,539
si uno de vosotros cambia su nombre

768
00:34:32,539 --> 00:34:34,659
lo cambia solo en su tarjetita

769
00:34:34,659 --> 00:34:36,860
estupendo, pero si de repente cambia

770
00:34:36,860 --> 00:34:38,920
el aula, hay que ir a la tarjetita

771
00:34:38,920 --> 00:34:40,280
de todos y de cada uno de ellos

772
00:34:40,280 --> 00:34:43,039
es un rollo, que la información que compartís

773
00:34:43,039 --> 00:34:44,920
todos, esté duplicada

774
00:34:44,920 --> 00:34:46,639
es un rollo, entonces

775
00:34:46,639 --> 00:34:48,960
podríamos decir, saquemos

776
00:34:48,960 --> 00:34:50,380
la de propiedades de la clase

777
00:34:50,380 --> 00:34:52,059
que esa esté en otro sitio

778
00:34:52,059 --> 00:34:54,860
¿pero qué otro sitio? es que no hay otro sitio

779
00:34:54,860 --> 00:34:57,139
en Java todo está en clases

780
00:34:57,139 --> 00:34:58,739
todo tiene que estar ubicado en una clase

781
00:34:58,739 --> 00:35:00,920
¿en qué otro sitio? el concepto de

782
00:35:00,920 --> 00:35:03,219
variable global suelta con un dato global

783
00:35:03,219 --> 00:35:04,980
ese afortunadamente no existe

784
00:35:04,980 --> 00:35:06,940
en Java, porque las variables globales son

785
00:35:06,940 --> 00:35:08,480
unos generadores enormes

786
00:35:08,480 --> 00:35:11,119
de errores y efectos secundarios extraños

787
00:35:11,119 --> 00:35:13,099
entonces en algún sitio tiene que estar

788
00:35:13,099 --> 00:35:13,619
ese dato

789
00:35:13,619 --> 00:35:16,900
vale, pues para eso se han

790
00:35:16,900 --> 00:35:18,880
inventado las variables

791
00:35:18,880 --> 00:35:21,059
o propiedades static

792
00:35:21,059 --> 00:35:24,340
¿vale? entonces, imaginaos

793
00:35:24,340 --> 00:35:26,440
que yo ahora, al dato

794
00:35:26,440 --> 00:35:27,980
aula a la que voy

795
00:35:27,980 --> 00:35:29,300
aula a la que voy

796
00:35:29,300 --> 00:35:31,840
¿como el aula? bueno, en este caso

797
00:35:31,840 --> 00:35:34,500
he puesto un cliente

798
00:35:34,500 --> 00:35:35,880
pero bueno, podría ser un alumno

799
00:35:35,880 --> 00:35:38,340
así seguimos el ejemplo

800
00:35:38,340 --> 00:35:39,539
¿vale?

801
00:35:40,039 --> 00:35:40,599
entonces

802
00:35:40,599 --> 00:35:43,780
si esto es un alumno

803
00:35:43,780 --> 00:35:47,599
vale

804
00:35:47,599 --> 00:35:48,960
pues entonces

805
00:35:48,960 --> 00:35:52,079
Aula a la que va el alumno

806
00:35:52,079 --> 00:35:54,619
El aula tiene que estar recogida en algún sitio

807
00:35:54,619 --> 00:35:56,760
Como está relacionada

808
00:35:56,760 --> 00:35:58,000
Con el concepto de alumno

809
00:35:58,000 --> 00:35:58,820
Está relacionada

810
00:35:58,820 --> 00:36:01,260
Su sitio debería ser la clase alumno

811
00:36:01,260 --> 00:36:03,739
Porque en alguna clase tiene que estar

812
00:36:03,739 --> 00:36:05,940
Es el aula de los alumnos

813
00:36:05,940 --> 00:36:07,820
Pues tendré que ponerla en la clase alumno

814
00:36:07,820 --> 00:36:09,599
No la voy a poner en una clase por ahí

815
00:36:09,599 --> 00:36:10,320
Que no pinta nada

816
00:36:10,320 --> 00:36:12,320
Pues tendré que ponerla aquí, aula

817
00:36:12,320 --> 00:36:15,559
Vale, desde el momento en que yo pongo aquí la propiedad

818
00:36:15,559 --> 00:36:17,679
Ya sabemos que automáticamente

819
00:36:17,679 --> 00:36:21,460
eso implica lo que no queremos, que les aparece a todos

820
00:36:21,460 --> 00:36:24,539
las instancias, les aparece a todos

821
00:36:24,539 --> 00:36:29,639
la casillita para el aula, pero menudo

822
00:36:29,639 --> 00:36:31,579
rollo porque en todas es el mismo

823
00:36:31,579 --> 00:36:37,539
entonces si cambia uno de aula, cambian todos, tengo que ir uno por uno

824
00:36:37,539 --> 00:36:41,599
menudo rollo, entonces, ¿qué ocurre si yo

825
00:36:41,599 --> 00:36:45,579
dándome cuenta de que eso es así y de que esa es la situación que quiero representar

826
00:36:45,579 --> 00:36:47,619
información común para todos, si cambian uno

827
00:36:47,619 --> 00:36:48,380
cambian todos

828
00:36:48,380 --> 00:36:53,289
¿qué pasa si yo pongo

829
00:36:53,289 --> 00:36:55,690
delante de esa propiedad

830
00:36:55,690 --> 00:36:57,650
el modificador static?

831
00:36:58,610 --> 00:36:59,690
otro modificador

832
00:36:59,690 --> 00:37:00,510
más que puedo poner

833
00:37:00,510 --> 00:37:03,670
además del private, entonces ya tendría

834
00:37:03,670 --> 00:37:05,449
pues el private, static, ya tendría

835
00:37:05,449 --> 00:37:06,929
dos uno detrás del otro, que no pasa nada

836
00:37:06,929 --> 00:37:09,090
se pueden poner muchos modificadores

837
00:37:09,090 --> 00:37:12,789
¿qué pasa si yo pongo el static?

838
00:37:13,030 --> 00:37:14,389
delante de una propiedad

839
00:37:14,389 --> 00:37:17,190
pues si pongo el static delante de la propiedad

840
00:37:17,190 --> 00:37:20,130
automáticamente todas estas réplicas

841
00:37:20,130 --> 00:37:21,809
se funden

842
00:37:21,809 --> 00:37:22,530
en una

843
00:37:22,530 --> 00:37:25,190
y ahora ya

844
00:37:25,190 --> 00:37:27,449
tendríamos cada

845
00:37:27,449 --> 00:37:30,010
objeto tiene su conjunto

846
00:37:30,010 --> 00:37:31,510
de propiedades propias

847
00:37:31,510 --> 00:37:33,590
las suyas y luego hay ahí

848
00:37:33,590 --> 00:37:34,969
en memoria una caja

849
00:37:34,969 --> 00:37:37,469
compartida por todos que es

850
00:37:37,469 --> 00:37:38,630
única para todos

851
00:37:38,630 --> 00:37:42,969
¿cómo accedemos a esa caja?

852
00:37:43,849 --> 00:37:45,230
pues perfectamente accedemos

853
00:37:45,230 --> 00:37:47,210
como accedemos a cualquier propiedad

854
00:37:47,210 --> 00:37:49,389
de una clase a través de un objeto

855
00:37:49,389 --> 00:37:51,170
es decir, si yo hago

856
00:37:51,170 --> 00:37:52,989
c1.aula

857
00:37:52,989 --> 00:37:55,250
accedo a este

858
00:37:55,250 --> 00:37:55,829
hueco

859
00:37:55,829 --> 00:37:59,150
pero claro, si hago c2.aula

860
00:37:59,150 --> 00:38:01,210
también, porque es una caja compartida

861
00:38:01,210 --> 00:38:03,329
y si hago c3.aula

862
00:38:03,329 --> 00:38:04,250
también

863
00:38:04,250 --> 00:38:07,230
me da igual cuantos objetos

864
00:38:07,230 --> 00:38:08,869
tenga, si hago

865
00:38:08,869 --> 00:38:11,230
c27.aula accedo aquí

866
00:38:11,230 --> 00:38:13,690
entonces si yo hago c1.aula

867
00:38:13,690 --> 00:38:14,449
igual a 7

868
00:38:14,449 --> 00:38:16,269
pues aquí se pone el 7

869
00:38:16,269 --> 00:38:19,670
y si ahora accedo a c3.aula

870
00:38:19,670 --> 00:38:20,929
pues veré que está el 7

871
00:38:20,929 --> 00:38:22,510
porque es lo mismo

872
00:38:22,510 --> 00:38:24,730
c1.aula es lo mismo que c3.aula

873
00:38:24,730 --> 00:38:26,050
igual que c21.aula

874
00:38:26,050 --> 00:38:27,809
todos me llevan

875
00:38:27,809 --> 00:38:30,250
a la misma cajita

876
00:38:30,250 --> 00:38:34,380
tanto es así

877
00:38:34,380 --> 00:38:36,519
que por comodidad

878
00:38:36,519 --> 00:38:39,400
aunque podemos acceder a las variables

879
00:38:39,400 --> 00:38:40,340
static así

880
00:38:40,340 --> 00:38:42,460
con el nombre de un objeto cualquiera

881
00:38:42,460 --> 00:38:44,659
pues como realmente da igual

882
00:38:44,659 --> 00:38:46,239
el objeto con el que accedas

883
00:38:46,239 --> 00:38:48,480
da exactamente igual, porque accedas

884
00:38:48,480 --> 00:38:50,500
por C1, C2, C3, vas a ir

885
00:38:50,500 --> 00:38:51,280
a la misma caja

886
00:38:51,280 --> 00:38:54,639
a las variables static se les permite

887
00:38:54,639 --> 00:38:56,940
acceder y se suele hacer y es recomendable

888
00:38:56,940 --> 00:38:58,679
con el nombre de la clase

889
00:38:58,679 --> 00:39:00,699
sin más, entonces si yo

890
00:39:00,699 --> 00:39:02,079
pongo alumno

891
00:39:02,079 --> 00:39:04,639
nombre de la clase, que es el nombre

892
00:39:04,639 --> 00:39:06,239
de la clase, no de ningún objeto

893
00:39:06,239 --> 00:39:07,820
el de la clase, este

894
00:39:07,820 --> 00:39:10,659
alumno.aula

895
00:39:10,659 --> 00:39:15,019
con esto estoy accediendo

896
00:39:15,019 --> 00:39:18,000
a este espacio compartido, ¿vale?

897
00:39:18,739 --> 00:39:21,559
No necesito usar ningún objeto.

898
00:39:22,000 --> 00:39:24,179
Con el nombre de la clase punto aula

899
00:39:24,179 --> 00:39:27,260
accedo al objeto compartido, ¿vale?

900
00:39:27,579 --> 00:39:34,710
De hecho, es que ni es necesario

901
00:39:34,710 --> 00:39:37,590
que existan objetos para que exista

902
00:39:37,590 --> 00:39:42,980
este objeto compartido, es que ni hace falta, ¿vale?

903
00:39:43,300 --> 00:39:44,579
Decimos esto y paramos.

904
00:39:45,480 --> 00:39:48,679
Es decir, si una clase tiene una, dos o tres

905
00:39:48,679 --> 00:39:50,420
las que sean variables estáticas

906
00:39:50,420 --> 00:39:52,059
en este caso tiene una

907
00:39:52,059 --> 00:39:54,280
eso es lo que se llama

908
00:39:54,280 --> 00:39:56,219
el contexto estático de la clase

909
00:39:56,219 --> 00:39:58,860
que es la cantidad de variables estáticas que tiene

910
00:39:58,860 --> 00:40:00,239
esta tendría solo una

911
00:40:00,239 --> 00:40:02,619
su contexto estático sería uno

912
00:40:02,619 --> 00:40:03,840
eso

913
00:40:03,840 --> 00:40:06,800
no existe, ese espacio en memoria

914
00:40:06,800 --> 00:40:08,579
no existe, igual que no existe este

915
00:40:08,579 --> 00:40:10,360
ni existe este hasta que no aparece un objeto

916
00:40:10,360 --> 00:40:12,739
vale, pues ¿cuándo es la primera vez

917
00:40:12,739 --> 00:40:14,219
que aparece ese espacio en memoria?

918
00:40:14,739 --> 00:40:16,539
la primera vez que lo llamamos

919
00:40:16,539 --> 00:40:17,679
y hacemos referencia a él

920
00:40:17,679 --> 00:40:20,920
es decir, si yo hago alumno.aula

921
00:40:20,920 --> 00:40:22,760
igual a 7

922
00:40:22,760 --> 00:40:24,380
sin haber creado

923
00:40:24,380 --> 00:40:26,360
ningún objeto antes, sin haber creado ninguno

924
00:40:26,360 --> 00:40:28,219
sin haber hecho ni un new alumno

925
00:40:28,219 --> 00:40:29,400
ni alumno, ni alumno

926
00:40:29,400 --> 00:40:31,719
la primera vez que yo desde mi main

927
00:40:31,719 --> 00:40:34,579
hago referencia a esta variable estática

928
00:40:34,579 --> 00:40:36,519
con el nombre de la clase, la primera vez

929
00:40:36,519 --> 00:40:38,400
paz, ahí aparece

930
00:40:38,400 --> 00:40:40,239
memoria, luego

931
00:40:40,239 --> 00:40:42,239
las variables estáticas pueden estar

932
00:40:42,239 --> 00:40:43,000
ahí en memoria

933
00:40:43,000 --> 00:40:46,179
antes de que aparezcan los objetos

934
00:40:46,179 --> 00:41:06,440
No hay necesidad de que aparezcan los objetos. Aparecen la primera vez que hacemos referencia a ellos. Luego es una forma que tenemos de guardar información al margen de la existencia de objetos, al margen de la existencia.

935
00:41:06,440 --> 00:41:10,719
lo que pasa es que esa información tiene que estar asociada a una clase

936
00:41:10,719 --> 00:41:12,900
porque tiene que estar declarada dentro de una clase

937
00:41:12,900 --> 00:41:16,980
entonces la solemos meter en la clase cuyo significado tiene relación

938
00:41:16,980 --> 00:41:19,360
claro, no hacemos un diseño metiendo ahí una variable

939
00:41:19,360 --> 00:41:21,880
porque quiero que no pega nada con alumno

940
00:41:21,880 --> 00:41:25,840
hay que meter variables aquí

941
00:41:25,840 --> 00:41:30,460
aunque para existir no necesitan que existan los objetos

942
00:41:30,460 --> 00:41:32,800
pues que su significado tenga que ver

943
00:41:32,800 --> 00:41:34,960
que la foto que yo tengo ahí con mis clases

944
00:41:34,960 --> 00:41:36,820
pues que represente un poco que tenga sentido

945
00:41:36,820 --> 00:41:41,860
¿vale? bueno, ¿entendido?

946
00:41:43,579 --> 00:41:45,199
¿eso solo funcionaría para

947
00:41:45,199 --> 00:41:46,699
si tienes solo el aula de dao?

948
00:41:53,340 --> 00:41:54,219
es que claro

949
00:41:54,219 --> 00:41:56,099
si esa información

950
00:41:56,099 --> 00:41:57,980
no es común para todos los objetos

951
00:41:57,980 --> 00:42:00,159
entonces no puede ser una variable estática

952
00:42:00,159 --> 00:42:01,940
entonces si puede haber alumnos en dao 1

953
00:42:01,940 --> 00:42:03,599
y alumnos en dao 1

954
00:42:03,599 --> 00:42:05,820
ya no puedes poner una variable estática

955
00:42:05,820 --> 00:42:08,400
esto es solo cuando tú has concluido

956
00:42:08,400 --> 00:42:09,920
después de analizar tu problema

957
00:42:09,920 --> 00:42:12,199
que ese dato es común

958
00:42:12,199 --> 00:42:14,000
para todos los objetos

959
00:42:14,000 --> 00:42:16,179
que se creen, da igual cuántos se creen

960
00:42:16,179 --> 00:42:17,320
común para todos ellos

961
00:42:17,320 --> 00:42:20,139
hombre, pues para un montón

962
00:42:20,139 --> 00:42:22,360
de cosas, para, se usa muchísimo

963
00:42:22,360 --> 00:42:23,860
más que las variables

964
00:42:23,860 --> 00:42:25,440
ahora, sus

965
00:42:25,440 --> 00:42:28,079
consecuencias naturales, que son los métodos

966
00:42:28,079 --> 00:42:28,559
estáticos

967
00:42:28,559 --> 00:42:32,260
pues para guardar valores constantes

968
00:42:32,260 --> 00:42:33,460
por ejemplo, pues

969
00:42:33,460 --> 00:42:35,280
si se hace una aplicación, pues pi

970
00:42:35,280 --> 00:42:37,619
se está guardado con una variable estática

971
00:42:37,619 --> 00:42:40,260
es una información común, que está en la clase

972
00:42:40,260 --> 00:42:42,000
más, ahí está

973
00:42:42,000 --> 00:42:44,519
¿vale? entonces por ejemplo

974
00:42:44,519 --> 00:42:45,440
aquí

975
00:42:45,440 --> 00:42:46,840
si

976
00:42:46,840 --> 00:43:00,550
claro, claro

977
00:43:00,550 --> 00:43:02,730
claro, porque las variables estáticas

978
00:43:02,730 --> 00:43:04,030
el constructor

979
00:43:04,030 --> 00:43:06,050
usaría las variables propias

980
00:43:06,050 --> 00:43:07,789
las variables estáticas tienen

981
00:43:07,789 --> 00:43:09,329
otro significado

982
00:43:09,329 --> 00:43:12,510
otro significado que no es caracterizar al objeto

983
00:43:12,510 --> 00:43:14,269
sino caracterizar el

984
00:43:14,269 --> 00:43:15,570
contexto en el que se mueven

985
00:43:15,570 --> 00:43:17,489
no a él propiamente dicho

986
00:43:17,489 --> 00:43:19,550
entonces cuando tú invocas a un constructor

987
00:43:19,550 --> 00:43:22,190
estás construyendo un objeto concreto

988
00:43:22,190 --> 00:43:23,949
y ahí tiene sentido

989
00:43:23,949 --> 00:43:24,989
que le des lo que le

990
00:43:24,989 --> 00:43:27,710
caracteriza a él de forma única

991
00:43:27,710 --> 00:43:29,869
lo que va en las variables estáticas

992
00:43:29,869 --> 00:43:31,269
es como información de contexto

993
00:43:31,269 --> 00:43:34,309
que tú inicializas por libre y con el nombre de la clase

994
00:43:34,309 --> 00:43:35,050
y ya está

995
00:43:35,050 --> 00:43:39,289
harías el constructor con if y nombre

996
00:43:39,289 --> 00:43:41,570
y las variables estáticas no tienen get y set

997
00:43:41,570 --> 00:43:43,949
por ejemplo, se ponen como public

998
00:43:43,949 --> 00:43:44,690
normalmente

999
00:43:44,690 --> 00:43:47,710
y tú accedes con el nombre de la clase sin más

1000
00:43:47,710 --> 00:43:49,989
por ejemplo, y ya paramos

1001
00:43:49,989 --> 00:43:52,150
Hemos usado a veces la clase math

1002
00:43:52,150 --> 00:43:53,789
Que math es una clase, un objeto

1003
00:43:53,789 --> 00:43:55,570
Así alegremente

1004
00:43:55,570 --> 00:43:57,909
¿Por qué? Porque la clase math

1005
00:43:57,909 --> 00:44:00,170
Fijaos todas las cosas

1006
00:44:00,170 --> 00:44:10,090
Que nos...

1007
00:44:10,090 --> 00:44:12,030
Vale, pues hemos usado a veces

1008
00:44:12,030 --> 00:44:13,070
Para hacer cosas

1009
00:44:13,070 --> 00:44:14,670
La clase math, ¿no?

1010
00:44:14,909 --> 00:44:19,280
Que lo he escrito aquí para...

1011
00:44:19,280 --> 00:44:20,860
Bueno, no sé dónde lo he escrito, pero da igual

1012
00:44:20,860 --> 00:44:26,460
Vale, a veces hemos usado

1013
00:44:26,460 --> 00:44:29,239
La clase math para hacer cosas

1014
00:44:29,239 --> 00:44:31,280
Math es una clase, no es un objeto

1015
00:44:31,280 --> 00:44:33,400
Y pese a ser una clase

1016
00:44:33,400 --> 00:44:35,099
si le damos al punto

1017
00:44:35,099 --> 00:44:36,880
me ofrece cosas

1018
00:44:36,880 --> 00:44:38,539
por ejemplo como pi

1019
00:44:38,539 --> 00:44:39,980
¿por qué?

1020
00:44:40,559 --> 00:44:43,019
porque pi es una propiedad

1021
00:44:43,019 --> 00:44:45,320
estática de la clase

1022
00:44:45,320 --> 00:44:47,639
math, con lo cual no necesito

1023
00:44:47,639 --> 00:44:49,119
un objeto de la clase math

1024
00:44:49,119 --> 00:44:49,840
para usarlo

1025
00:44:49,840 --> 00:44:52,800
no necesito instanciar un new math

1026
00:44:52,800 --> 00:44:55,079
no hace falta, con la clase

1027
00:44:55,079 --> 00:44:56,179
como pi es estática

1028
00:44:56,179 --> 00:44:57,380
entonces

1029
00:44:57,380 --> 00:45:00,840
¿veis? esta es mi clase math

1030
00:45:00,840 --> 00:45:02,820
mi clase math

1031
00:45:02,820 --> 00:45:04,920
esta de aquí, ¿vale?

1032
00:45:05,000 --> 00:45:08,860
que está aquí, con todos sus

1033
00:45:08,860 --> 00:45:09,679
esta clase

1034
00:45:09,679 --> 00:45:14,760
la clase math

1035
00:45:14,760 --> 00:45:17,260
es una clase que no se puede instanciar

1036
00:45:17,260 --> 00:45:18,280
no tiene constructor

1037
00:45:18,280 --> 00:45:21,039
nada, no se puede instanciar, por eso tiene el private

1038
00:45:21,039 --> 00:45:23,199
delante, ¿por qué? porque esta clase

1039
00:45:23,199 --> 00:45:24,980
solamente vale para dar

1040
00:45:24,980 --> 00:45:27,079
contenido estático, para cosas útiles

1041
00:45:27,079 --> 00:45:28,599
por ejemplo, e

1042
00:45:28,599 --> 00:45:31,000
¿veis? es una variable static

1043
00:45:31,000 --> 00:45:32,699
y double también

1044
00:45:32,699 --> 00:45:34,860
public para poder

1045
00:45:34,860 --> 00:45:36,500
accederla desde cualquier sitio

1046
00:45:36,500 --> 00:45:41,960
este es un método

1047
00:45:41,960 --> 00:45:45,380
pi

1048
00:45:45,380 --> 00:45:48,119
pues pi es una variable estática

1049
00:45:48,119 --> 00:45:48,940
de la clase math

1050
00:45:48,940 --> 00:45:51,900
entonces yo puedo usar esa variable

1051
00:45:51,900 --> 00:45:54,440
sin que exista ningún objeto de la clase math

1052
00:45:54,440 --> 00:45:57,380
que ya le da este valor

1053
00:45:57,380 --> 00:46:00,119
entonces las variables

1054
00:46:00,119 --> 00:46:02,000
estáticas tienen

1055
00:46:02,000 --> 00:46:03,920
muchos usos a la hora de describir

1056
00:46:03,920 --> 00:46:06,199
una situación pero también

1057
00:46:06,199 --> 00:46:08,039
es para guardar

1058
00:46:08,039 --> 00:46:10,500
dentro de una clase recoger información

1059
00:46:10,500 --> 00:46:12,639
constantes

1060
00:46:12,639 --> 00:46:13,820
que van a usar otras clases

1061
00:46:13,820 --> 00:46:15,780
pues lo recojo, lo dejo ahí recogidito

1062
00:46:15,780 --> 00:46:17,079
por ejemplo, esto es un ejemplo

1063
00:46:17,079 --> 00:46:19,400
¿vale? un ejemplo

1064
00:46:19,400 --> 00:46:21,539
el final ya veremos lo que significa

1065
00:46:21,539 --> 00:46:23,980
pero estos dos modificadores

1066
00:46:23,980 --> 00:46:24,920
pues los entendemos

1067
00:46:24,920 --> 00:46:26,840
¿vale? entonces yo aquí

1068
00:46:26,840 --> 00:46:28,760
puedo usar mathP

1069
00:46:28,760 --> 00:46:31,800
pues para lo que quiera, para multiplicarlo

1070
00:46:31,800 --> 00:46:33,519
por algo, para lo que quiera

1071
00:46:33,519 --> 00:46:35,440
¿vale?

1072
00:46:35,440 --> 00:46:40,949
Bueno, venga, ahora sí que vamos a parar aquí