1
00:00:00,500 --> 00:00:21,420
Vale, pues esta aplicación ya era una aplicación un poquitín más real en cuanto a que gestionaba una situación que se correspondía con un modelo de datos, en nuestro caso clientes y pedidos.

2
00:00:21,420 --> 00:00:27,519
los clientes podían tener uno, muchos pedidos teniendo un NIF y un nombre

3
00:00:27,519 --> 00:00:32,820
y cada pedido podía tener un código, una descripción y un precio

4
00:00:32,820 --> 00:00:37,119
y luego además como había un dato general para toda la aplicación

5
00:00:37,119 --> 00:00:39,060
que es este, pero también variable

6
00:00:39,060 --> 00:00:43,880
pues en una variable estática donde creemos que más pegaba

7
00:00:43,880 --> 00:00:47,700
que como el IVA afecta el precio de los pedidos

8
00:00:47,700 --> 00:00:49,140
pues pega mejor ponerlo ahí

9
00:00:49,140 --> 00:01:17,239
¿Vale? Es lo más parecido a una variable global, pero no es global porque está dentro del contexto de una aplicación, siempre, no hay variables fuera de una clase, perdón, no hay variables fuera de las clases, todo está metido dentro en clases, lo más que podemos decidir es si es particular de cada instancia o común para todas, es lo más que podemos decidir, pero todos los datos están siempre dentro del ámbito de una clase.

10
00:01:17,239 --> 00:01:20,120
que hay muchas posibilidades de diseño

11
00:01:20,120 --> 00:01:21,980
y podemos colocar las cosas de muchas maneras

12
00:01:21,980 --> 00:01:23,359
sí, pero bueno

13
00:01:23,359 --> 00:01:26,019
siempre tenemos que intentar que se corresponda

14
00:01:26,019 --> 00:01:28,340
lo más posible con su significado

15
00:01:28,340 --> 00:01:28,700
real

16
00:01:28,700 --> 00:01:32,260
vale, pues esta es nuestra clase pedido que se caracterizaba

17
00:01:32,260 --> 00:01:33,920
por todo esto, con sus métodos

18
00:01:33,920 --> 00:01:36,060
get y set, que entendemos y sabemos

19
00:01:36,060 --> 00:01:37,859
por qué

20
00:01:37,859 --> 00:01:39,840
os lo pregunté el otro día

21
00:01:39,840 --> 00:01:41,659
además, para

22
00:01:41,659 --> 00:01:43,900
que los hacemos, etc

23
00:01:43,900 --> 00:01:46,319
y luego esta aplicación

24
00:01:46,319 --> 00:01:49,599
tenía unas funcionalidades

25
00:01:49,599 --> 00:01:52,760
que metimos aquí en el main

26
00:01:52,760 --> 00:01:53,500
¿vale?

27
00:01:55,540 --> 00:01:56,180
entonces

28
00:01:56,180 --> 00:01:58,840
en esta aplicación ya empezamos a

29
00:01:58,840 --> 00:01:59,859
usar

30
00:01:59,859 --> 00:02:02,500
la posibilidad de los métodos estáticos

31
00:02:02,500 --> 00:02:04,680
para que no nos quedaran métodos tan horriblemente

32
00:02:04,680 --> 00:02:06,260
largos ¿vale?

33
00:02:06,819 --> 00:02:08,939
porque hay muchos principios

34
00:02:08,939 --> 00:02:10,080
generales

35
00:02:10,080 --> 00:02:12,520
muchos de esos se

36
00:02:12,520 --> 00:02:14,960
concretan en una cosa que se llama patrones de diseño

37
00:02:14,960 --> 00:02:16,240
que son formas de programar

38
00:02:16,240 --> 00:02:18,960
las aplicaciones del año que viene, pues ya sí que tenemos

39
00:02:18,960 --> 00:02:21,039
que respetar un poco más los patrones de diseño

40
00:02:21,039 --> 00:02:22,860
porque si no se convierten en algo inmanejable

41
00:02:22,860 --> 00:02:24,860
pero ahora mismo como son aplicaciones

42
00:02:24,860 --> 00:02:26,580
de un ámbito pequeñito

43
00:02:26,580 --> 00:02:28,500
los patrones de diseño no nos importan tanto

44
00:02:28,500 --> 00:02:30,439
cuando hablo de patrones de diseño

45
00:02:30,439 --> 00:02:32,379
hablo de reglas concretas

46
00:02:32,379 --> 00:02:33,080
¿vale?

47
00:02:35,159 --> 00:02:36,759
pero aparte de esos patrones

48
00:02:36,759 --> 00:02:38,719
de diseño hay unos principios generales

49
00:02:38,719 --> 00:02:41,039
básicos a los que uno se tiene que ir adaptando

50
00:02:41,039 --> 00:02:42,620
muchos de ellos muy sencillos

51
00:02:42,620 --> 00:02:45,020
los hemos mencionado, nombres de variables

52
00:02:45,020 --> 00:02:47,520
lo más explicativos posibles

53
00:02:47,520 --> 00:02:48,900
¿vale?

54
00:02:49,180 --> 00:02:50,659
por muy largos que sean

55
00:02:50,659 --> 00:02:53,580
cuando las variables son datos

56
00:02:53,580 --> 00:02:55,840
estáticos, perdón, son propiedades

57
00:02:55,840 --> 00:02:56,639
estáticas

58
00:02:56,639 --> 00:02:59,889
es buena idea

59
00:02:59,889 --> 00:03:02,930
que su nombre esté

60
00:03:02,930 --> 00:03:04,610
en mayúscula, ¿vale?

61
00:03:04,650 --> 00:03:06,949
no son cosas obligatorias pero son como ciertas

62
00:03:06,949 --> 00:03:09,069
reglas de diseño que luego van a facilitar

63
00:03:09,069 --> 00:03:11,050
entender los códigos

64
00:03:11,050 --> 00:03:11,770
de otros

65
00:03:11,770 --> 00:03:13,030
¿vale?

66
00:03:13,030 --> 00:03:16,689
¿Lo de mayúsculas solo para la variable?

67
00:03:16,889 --> 00:03:18,550
¿O también si un método es estático también?

68
00:03:18,550 --> 00:03:20,729
No, no, no, no, no, no, para las propiedades estáticas

69
00:03:20,729 --> 00:03:21,389
¿Vale?

70
00:03:22,009 --> 00:03:25,110
Nombres de métodos lo más largo y explicativo

71
00:03:25,110 --> 00:03:25,750
posible

72
00:03:25,750 --> 00:03:28,889
¿Vale? Cosas que más o menos hemos ido mencionando

73
00:03:28,889 --> 00:03:30,949
siempre. Bueno, pues otro principio

74
00:03:30,949 --> 00:03:32,849
básico, nada de métodos

75
00:03:32,849 --> 00:03:34,889
así, de bordos con mil líneas

76
00:03:34,889 --> 00:03:37,189
No, eso es muy difícil

77
00:03:37,189 --> 00:03:38,430
luego de mantener

78
00:03:38,430 --> 00:03:40,490
porque si tenemos que hacer cualquier cambio

79
00:03:40,490 --> 00:03:42,729
¿Cómo lo encuentra uno en un

80
00:03:42,729 --> 00:03:43,949
método de 100 líneas

81
00:03:43,949 --> 00:03:46,669
¿vale? se trata de la medida

82
00:03:46,669 --> 00:03:48,969
de lo posible refactorizar

83
00:03:48,969 --> 00:03:50,789
¿qué significa la

84
00:03:50,789 --> 00:03:52,250
palabra refactorizar?

85
00:03:53,229 --> 00:03:54,689
que si el entorno de

86
00:03:54,689 --> 00:03:56,810
desarrollo está a tiempo, pues bueno, refactorizar

87
00:03:56,810 --> 00:03:58,669
en realidad no es más que

88
00:03:58,669 --> 00:04:00,509
yo ya tengo un código que funciona

89
00:04:00,509 --> 00:04:03,050
perfectamente, hace lo que tiene que hacer, mi aplicación

90
00:04:03,050 --> 00:04:04,710
está estupenda, ha pasado toda

91
00:04:04,710 --> 00:04:06,949
la batería de test, todos los casos de prueba

92
00:04:06,949 --> 00:04:08,490
pero

93
00:04:08,490 --> 00:04:10,810
este código está muy

94
00:04:10,810 --> 00:04:12,569
feo, no quiero

95
00:04:12,569 --> 00:04:14,909
cambiar la funcionalidad de la aplicación

96
00:04:14,909 --> 00:04:16,829
está perfecta, no quiero corregir

97
00:04:16,829 --> 00:04:18,629
errores, no quiero corregir errores

98
00:04:18,629 --> 00:04:20,250
lo que quiero es

99
00:04:20,250 --> 00:04:22,629
cambiar el estilo del código para que quede

100
00:04:22,629 --> 00:04:25,110
más bonito, eso es lo que se llama refactorizar

101
00:04:25,110 --> 00:04:26,649
vale, pues

102
00:04:26,649 --> 00:04:28,649
cuando nos damos cuenta, cuando vemos una aplicación

103
00:04:28,649 --> 00:04:30,730
aunque funcione, está estupenda, tiene unos métodos así

104
00:04:30,730 --> 00:04:32,689
de gordos, pues deberíamos

105
00:04:32,689 --> 00:04:33,870
refactorizarla

106
00:04:33,870 --> 00:04:37,029
una de las refactorizaciones

107
00:04:37,029 --> 00:04:38,629
consiste en, voy

108
00:04:38,629 --> 00:04:40,769
sacando partes de ese método

109
00:04:40,769 --> 00:04:42,810
las voy sacando a métodos

110
00:04:42,810 --> 00:04:44,990
independientes

111
00:04:44,990 --> 00:04:47,310
y así tengo

112
00:04:47,310 --> 00:04:49,350
cada funcionalidad la tengo recogida

113
00:04:49,350 --> 00:04:50,129
bajo un nombre

114
00:04:50,129 --> 00:04:53,290
esa es la idea, tener cada funcionalidad

115
00:04:53,290 --> 00:04:54,689
recogida bajo un nombre

116
00:04:54,689 --> 00:04:57,149
entonces si tenemos que tocar algo, retocar algo

117
00:04:57,149 --> 00:04:59,209
modificar algo, yo ya me voy

118
00:04:59,209 --> 00:05:01,170
directamente a la parte

119
00:05:01,170 --> 00:05:02,610
donde tengo que hacer esa modificación

120
00:05:02,610 --> 00:05:04,810
que es traer recogidita en un método con un nombre

121
00:05:04,810 --> 00:05:07,029
si el método, si el nombre

122
00:05:07,029 --> 00:05:08,730
es explicativo, mucho mejor, por supuesto

123
00:05:08,730 --> 00:05:10,269
si no me va a costar más encontrarlo

124
00:05:10,269 --> 00:05:29,029
Bueno, pues aquí, por ejemplo, esa regla general la seguíamos, por ejemplo, aquí dijimos en nuestro main, dijimos aquí mostrar menú, jolín, pues mostrar todo el menú, el system out, todos los system out, qué rollo meterlo aquí en este main y que me quede larguísimo.

125
00:05:29,029 --> 00:05:32,649
vale, pues vamos a hacernos un método mostrarMenu

126
00:05:32,649 --> 00:05:36,050
este método por definición es que va a ser estático

127
00:05:36,050 --> 00:05:39,129
vale, porque mostrarMenu te hace un system.out

128
00:05:39,129 --> 00:05:41,389
te lee por teclado y te devuelve un valor

129
00:05:41,389 --> 00:05:43,550
o sea, no depende de que exista ningún objeto

130
00:05:43,550 --> 00:05:46,730
no está asociado a la realidad de ningún objeto, no

131
00:05:46,730 --> 00:05:49,170
te hace una cosa de librería muy básica

132
00:05:49,170 --> 00:05:51,810
bueno, entonces este método mostrarMenu

133
00:05:51,810 --> 00:05:55,430
lo declarábamos en esta misma clase, aquí

134
00:05:55,430 --> 00:05:58,269
con el modificador static

135
00:05:58,269 --> 00:06:01,350
como se iba a usar solo desde esta clase

136
00:06:01,350 --> 00:06:03,370
es un método auxiliar de la clase

137
00:06:03,370 --> 00:06:05,069
¿vale? esto es lo que se llama

138
00:06:05,069 --> 00:06:05,930
un método auxiliar

139
00:06:05,930 --> 00:06:14,699
un método en el que yo he sacado

140
00:06:14,699 --> 00:06:16,399
he sacado esta parte

141
00:06:16,399 --> 00:06:17,480
de aquí que era un rollete

142
00:06:17,480 --> 00:06:23,139
de mostrarme, ¿no? la he sacado ahí fuera

143
00:06:23,139 --> 00:06:24,939
no lo he puesto

144
00:06:24,939 --> 00:06:26,980
en otra clase, ¿por qué? porque eso

145
00:06:26,980 --> 00:06:28,300
no tiene nada que ver con

146
00:06:28,300 --> 00:06:30,740
ni objetos del modelo, ni con clientes

147
00:06:30,740 --> 00:06:32,519
ni con pedidos, no tiene que ver con nada

148
00:06:32,519 --> 00:06:35,300
tiene que ver con una cosa muy concreta

149
00:06:35,300 --> 00:06:37,540
Del main que es mostrar el menú

150
00:06:37,540 --> 00:06:39,660
Pues lo puedo poner aquí mismo como método auxiliar

151
00:06:39,660 --> 00:06:41,720
Y ya está, no hace falta que lo ubique en otra clase

152
00:06:41,720 --> 00:06:42,579
Podría

153
00:06:42,579 --> 00:06:45,680
Podría ponerlo en otra clase

154
00:06:45,680 --> 00:06:47,040
Que

155
00:06:47,040 --> 00:06:49,379
Tenga simplemente métodos static

156
00:06:49,379 --> 00:06:51,360
Pero bueno, aquí lo he puesto aquí

157
00:06:51,360 --> 00:06:53,480
Le puedo poner el modificador privado

158
00:06:53,480 --> 00:06:55,399
En este caso es el que tendría que tener

159
00:06:55,399 --> 00:06:56,860
Porque este método

160
00:06:56,860 --> 00:06:59,319
Solo va a ser llamado por esta clase main

161
00:06:59,319 --> 00:07:00,819
Solo va a ser llamado por esta

162
00:07:00,819 --> 00:07:03,180
Entonces le pongo el modificador privado

163
00:07:03,180 --> 00:07:04,759
Porque solo va a ser llamado por esta

164
00:07:04,759 --> 00:07:09,759
estático porque lógicamente no depende de la existencia

165
00:07:09,759 --> 00:07:13,319
del propio objeto en el que está, de hecho

166
00:07:13,319 --> 00:07:17,600
la clase en la que está es la clase main que ni tiene propiedades ni tiene

167
00:07:17,600 --> 00:07:20,100
nada, vale

168
00:07:20,100 --> 00:07:25,459
entonces pues este era mi método auxiliar que servía solamente

169
00:07:25,459 --> 00:07:29,360
para mostrar el menú, hacer todo este rollo

170
00:07:29,360 --> 00:07:33,620
leer el entero, en este caso

171
00:07:33,620 --> 00:07:37,439
además leerlo con esa clase teclado

172
00:07:37,439 --> 00:07:41,540
de librería que habíamos hecho para olvidarnos del escáner y de todo esto

173
00:07:41,540 --> 00:07:45,699
y gracias a eso pues yo ya me he podido olvidar del escáner y de todo

174
00:07:45,699 --> 00:07:51,149
ya ni había escáner ni había nada y me lo devuelve y ya está

175
00:07:51,149 --> 00:07:55,110
entonces este trocito de código lo he sacado fuera mucho mejor

176
00:07:55,110 --> 00:07:59,649
y ahora aquí ya mi aplicación de clientes pedidos

177
00:07:59,649 --> 00:08:03,569
mostraba el menú, como llamábamos al método

178
00:08:03,569 --> 00:08:06,370
pues como era estático, lo llamábamos con el nombre de la clase

179
00:08:06,370 --> 00:08:10,850
claro, con el nombre de la clase que es main

180
00:08:10,850 --> 00:08:16,529
en este caso, como el método está en esta misma clase

181
00:08:16,529 --> 00:08:19,269
en esta misma, este main es opcional

182
00:08:19,269 --> 00:08:22,310
¿vale? esto lo podría quitar

183
00:08:22,310 --> 00:08:25,720
y no pasa nada

184
00:08:25,720 --> 00:08:29,459
pero porque el método está en esta misma clase

185
00:08:29,459 --> 00:08:31,860
entonces, si un método

186
00:08:31,860 --> 00:08:35,899
no tiene nada delante

187
00:08:35,899 --> 00:08:37,299
que lo llame con un puntito,

188
00:08:37,399 --> 00:08:38,419
no tiene nada delante,

189
00:08:38,860 --> 00:08:41,039
el compilador lo busca en la propia clase.

190
00:08:42,059 --> 00:08:42,700
¿Vale? Lo busca.

191
00:08:43,840 --> 00:08:45,600
Y ahí lo encuentra, ahí debajo está.

192
00:08:46,620 --> 00:08:46,799
¿Vale?

193
00:08:50,470 --> 00:08:51,830
Bueno, pues ahora ya sí,

194
00:08:51,929 --> 00:08:54,090
hacíamos el switch case con todas las funcionalidades.

195
00:08:54,889 --> 00:08:56,509
Pues la funcionalidad uno,

196
00:08:56,629 --> 00:08:57,370
que no sé lo que era,

197
00:08:57,509 --> 00:09:01,389
entiendo que insertar cliente nuevo.

198
00:09:02,809 --> 00:09:04,029
Insertábamos un cliente nuevo,

199
00:09:04,029 --> 00:09:08,149
pedíamos los datos, de nuevo todo podríamos sacarlo

200
00:09:08,149 --> 00:09:12,210
a métodos auxiliares, podríamos sacar a un método auxiliar esta parte

201
00:09:12,210 --> 00:09:14,850
de leer cliente, por ejemplo

202
00:09:14,850 --> 00:09:19,590
podríamos sacar esta parte, leer cliente y asignárselo así

203
00:09:19,590 --> 00:09:26,100
asignárselo aquí, entonces vamos a sacar este

204
00:09:26,100 --> 00:09:30,379
trocito de código a un método auxiliar, que me devuelva directamente

205
00:09:30,379 --> 00:09:34,299
un cliente con los datos que se pidan por teclado, leer cliente

206
00:09:34,299 --> 00:09:37,480
Pues entonces podríamos hacernos aquí

207
00:09:37,480 --> 00:09:39,580
Nuestro método

208
00:09:39,580 --> 00:09:45,169
¿Qué me va a devolver este método?

209
00:09:46,470 --> 00:09:48,590
Un objeto cliente

210
00:09:48,590 --> 00:09:51,730
Leer cliente

211
00:09:51,730 --> 00:09:53,309
¿Necesita que le pasemos algo? No

212
00:09:53,309 --> 00:09:54,990
Y ahora

213
00:09:54,990 --> 00:09:56,669
¿Qué metemos aquí?

214
00:09:57,750 --> 00:09:59,450
Pues esta parte

215
00:09:59,450 --> 00:10:03,049
Metemos aquí

216
00:10:03,049 --> 00:10:05,429
Todo esto

217
00:10:05,429 --> 00:10:12,580
Todo esto de leer cliente

218
00:10:12,580 --> 00:10:15,000
Se va aquí a mi método auxiliar

219
00:10:15,000 --> 00:10:21,100
Creo el cliente y lo devuelvo

220
00:10:21,100 --> 00:10:22,720
Retún C

221
00:10:22,720 --> 00:10:28,929
Tengo un método que encapsula

222
00:10:28,929 --> 00:10:33,029
Que oculta la complejidad de pedir los datos

223
00:10:33,029 --> 00:10:36,570
Instanciar un objeto cliente y devolverlo como valor de retorno

224
00:10:36,570 --> 00:10:41,190
Una clase puede tener 200.000 métodos auxiliares

225
00:10:41,190 --> 00:10:41,850
No pasa nada

226
00:10:41,850 --> 00:10:47,129
Una clase con un montonazo, muchos métodos cortitos

227
00:10:47,129 --> 00:10:49,090
No tiene ningún problema

228
00:10:49,090 --> 00:10:52,029
Una clase con dos métodos enormes cada uno

229
00:10:52,029 --> 00:10:52,889
Sí lo va a tener

230
00:10:52,889 --> 00:10:58,820
Hombre, si una clase tiene un montón de métodos cortos

231
00:10:58,820 --> 00:11:03,539
Nos sirve como alerta, semáforo naranja

232
00:11:03,539 --> 00:11:06,320
De que, hombre, a lo mejor el diseño de clases

233
00:11:06,320 --> 00:11:08,039
Igual no está muy bien hecho

234
00:11:08,039 --> 00:11:10,559
Igual nos ha faltado darnos cuenta de alguna otra clase

235
00:11:10,559 --> 00:11:13,320
Porque pocas clases con un montón de métodos

236
00:11:13,320 --> 00:11:15,340
No lo sé, a lo mejor

237
00:11:15,340 --> 00:11:20,080
Pero bueno, eso ya son cuestiones más avanzadas

238
00:11:20,080 --> 00:11:22,600
vale, pues si tengo yo este método auxiliar

239
00:11:22,600 --> 00:11:23,600
ahora ya

240
00:11:23,600 --> 00:11:25,519
fijaos que bien

241
00:11:25,519 --> 00:11:28,279
este switch del main

242
00:11:28,279 --> 00:11:33,259
se queda mucho más bonito

243
00:11:33,259 --> 00:11:35,360
porque se queda

244
00:11:35,360 --> 00:11:35,899
así

245
00:11:35,899 --> 00:11:42,240
y ya está, así se queda

246
00:11:42,240 --> 00:11:45,710
y magnífico, el caso 1

247
00:11:45,710 --> 00:11:46,649
queda mucho más claro

248
00:11:46,649 --> 00:11:49,529
vale, yo antes

249
00:11:49,529 --> 00:11:51,049
cuando yo estoy viendo la aplicación

250
00:11:51,049 --> 00:11:53,649
yo quiero

251
00:11:53,649 --> 00:11:55,509
con un vistazo por encima ver rápidamente

252
00:11:55,509 --> 00:11:57,309
qué hace, por si tengo que hacer alguna

253
00:11:57,309 --> 00:11:59,309
modificación, decidir dónde hacerla, etc.

254
00:11:59,850 --> 00:12:01,389
En este rápido vistazo

255
00:12:01,389 --> 00:12:03,289
veo mucho antes

256
00:12:03,289 --> 00:12:05,250
lo que hace que cuando tenía el otro código,

257
00:12:05,350 --> 00:12:07,350
cuando tenía el otro código, tenía que, hasta que

258
00:12:07,350 --> 00:12:09,389
he entendido qué hacía ese caso,

259
00:12:09,649 --> 00:12:11,309
pues me ha costado más. Si yo hubiera

260
00:12:11,309 --> 00:12:13,370
visto esto, ah, pues está claro lo que hace.

261
00:12:14,029 --> 00:12:15,389
Me lee un cliente y lo guarda

262
00:12:15,389 --> 00:12:17,370
en el array, ya está. Aquí lo veo mucho

263
00:12:17,370 --> 00:12:22,129
mejor. Y así en el resto

264
00:12:22,129 --> 00:12:24,129
de los casos. ¿Qué hacía

265
00:12:24,129 --> 00:12:26,570
el caso 2? El caso 2

266
00:12:26,570 --> 00:12:29,490
mostraba los datos de un cliente

267
00:12:29,490 --> 00:12:30,330
¿verdad?

268
00:12:31,230 --> 00:12:33,149
entonces este caso 2, pues bueno, solo tenía

269
00:12:33,149 --> 00:12:33,970
un for y ya está

270
00:12:33,970 --> 00:12:44,009
recuperaba al cliente

271
00:12:44,009 --> 00:12:46,070
de nuevo, incluso esto

272
00:12:46,070 --> 00:12:48,889
meter aquí

273
00:12:48,889 --> 00:12:51,309
un for directamente en el case

274
00:12:51,309 --> 00:12:53,450
pues incluso esto ya queda feo

275
00:12:53,450 --> 00:12:56,149
podríamos hacer un método

276
00:12:56,149 --> 00:12:57,570
recuperaCliente

277
00:12:57,570 --> 00:12:59,970
recuperaCliente

278
00:12:59,970 --> 00:13:01,149
al que se le pasa

279
00:13:01,149 --> 00:13:03,889
una posición y te lo recupera

280
00:13:03,889 --> 00:13:05,809
¿vale? entonces vamos a hacerlo

281
00:13:05,809 --> 00:13:09,710
aquí nos gustaría

282
00:13:09,710 --> 00:13:11,830
hacer simplemente

283
00:13:11,830 --> 00:13:12,250
esto

284
00:13:12,250 --> 00:13:15,610
un siso que haga

285
00:13:15,610 --> 00:13:17,830
recupera

286
00:13:18,409 --> 00:13:19,830
cliente

287
00:13:20,429 --> 00:13:21,789
ah no, es que

288
00:13:21,789 --> 00:13:23,649
esto lo mostraba a todos, perdón, perdón

289
00:13:23,649 --> 00:13:25,690
esto lo mostraba a todos, no te buscaba

290
00:13:25,690 --> 00:13:27,830
por, vale, bueno pues incluso

291
00:13:27,830 --> 00:13:29,990
así, esto sería mucho más bonito

292
00:13:29,990 --> 00:13:31,370
Si fuera un

293
00:13:31,370 --> 00:13:33,289
Mostrar clientes

294
00:13:33,289 --> 00:13:34,610
Muchísimo mejor

295
00:13:34,610 --> 00:13:39,230
Si fuera un mostrar clientes

296
00:13:39,230 --> 00:13:40,690
¿Vale?

297
00:13:43,990 --> 00:13:44,629
Exacto

298
00:13:44,629 --> 00:13:47,090
Representa mucho mejor la lógica

299
00:13:47,090 --> 00:13:48,809
Y aparte nos va a permitir

300
00:13:48,809 --> 00:13:51,370
Ahora hacer un pequeño cambio de diseño

301
00:13:51,370 --> 00:13:53,210
Que es mucho más aproximado

302
00:13:53,210 --> 00:13:54,009
A cuando ya

303
00:13:54,009 --> 00:13:57,289
Tengamos una estructura en la que hay una base de datos

304
00:13:57,289 --> 00:13:58,850
Todo eso, o sea, esto mucho mejor

305
00:13:58,850 --> 00:14:00,509
Caso 2, mostrar clientes

306
00:14:00,509 --> 00:14:18,070
Tú ves aquí de golpe y porrazo. Vale, entonces todo esto te lo ahorras. Pero claro, hay que hacer el mostrar clientes aquí abajo. Bueno, me vais siguiendo, ¿no? No se va perdiendo nadie con las subidas y bajadas porque esto, sobre todo, estamos haciendo cuestiones de diseño que son mucho más importantes en realidad.

307
00:14:18,070 --> 00:14:20,590
Entonces no quiero que nadie se pierda

308
00:14:20,590 --> 00:14:21,690
Con las subidas y bajadas

309
00:14:21,690 --> 00:14:23,169
Vale, aquí

310
00:14:23,169 --> 00:14:26,789
Lo ideal sería hacer un mostrar clientes y punto pelota

311
00:14:26,789 --> 00:14:30,450
Eso haría que tuviéramos que sacar

312
00:14:30,450 --> 00:14:31,970
Esto a otro método

313
00:14:31,970 --> 00:14:33,730
¿Vale? Vamos a sacarlo a otro método

314
00:14:33,730 --> 00:14:49,009
Mostrar clientes

315
00:14:49,009 --> 00:14:51,450
Vale, y aquí querría

316
00:14:51,450 --> 00:14:52,730
Uy, private void

317
00:14:52,730 --> 00:14:54,110
Porque este

318
00:14:54,110 --> 00:14:57,509
Me lo muestra por consola y ya está

319
00:14:57,509 --> 00:15:00,850
y aquí ya nos encontramos el problema

320
00:15:00,850 --> 00:15:01,909
este

321
00:15:01,909 --> 00:15:09,210
en el propio main

322
00:15:09,210 --> 00:15:10,509
cuando ya ha acabado

323
00:15:10,509 --> 00:15:13,029
aquí acaba el main, son métodos auxiliares

324
00:15:13,029 --> 00:15:14,690
ahora esto lo voy a cambiar

325
00:15:14,690 --> 00:15:18,669
claro, claro, claro

326
00:15:18,669 --> 00:15:19,929
este corchete será el método main

327
00:15:19,929 --> 00:15:22,590
y a partir del método main

328
00:15:22,590 --> 00:15:24,289
vienen más métodos

329
00:15:24,289 --> 00:15:26,769
que son auxiliares que a su vez son llamados

330
00:15:26,769 --> 00:15:27,909
Desde dentro del main

331
00:15:27,909 --> 00:15:29,409
¿Vale?

332
00:15:35,779 --> 00:15:36,259
Sí

333
00:15:36,259 --> 00:15:38,299
Lo estoy haciendo fuera del

334
00:15:38,299 --> 00:15:39,639
Este es un método

335
00:15:39,639 --> 00:15:41,080
Esto es una clase main

336
00:15:41,080 --> 00:15:42,100
Normal y corriente

337
00:15:42,100 --> 00:15:44,519
Lo que pasa es que esta clase main

338
00:15:44,519 --> 00:15:47,480
Tiene un método main

339
00:15:47,480 --> 00:15:49,620
Que es el que la máquina virtual va a ejecutar

340
00:15:49,620 --> 00:15:51,639
Vale, entonces uno se pone a hacer el método main

341
00:15:51,639 --> 00:15:54,059
Entonces, ¿aquí en qué situación estamos?

342
00:15:54,440 --> 00:15:55,580
En la situación de que

343
00:15:55,580 --> 00:15:57,240
Este método main hace un montón de cosas

344
00:15:57,240 --> 00:15:59,700
Un montón de líneas de código y queda muy feo

345
00:15:59,700 --> 00:16:01,899
Entonces yo parte de ese código

346
00:16:01,899 --> 00:16:03,700
Lo quiero meter en otro sitio

347
00:16:03,700 --> 00:16:05,379
Mediante un método para llamarlo

348
00:16:05,379 --> 00:16:07,639
Bueno, pues ¿dónde lo estoy metiendo?

349
00:16:07,759 --> 00:16:09,460
Pues en esta misma clase main

350
00:16:09,460 --> 00:16:11,519
Me estoy haciendo más métodos

351
00:16:11,519 --> 00:16:13,740
¿Vale? Además de este main

352
00:16:13,740 --> 00:16:14,779
Que se abre aquí

353
00:16:14,779 --> 00:16:17,200
Y se cierra aquí

354
00:16:17,200 --> 00:16:20,639
Aquí se ha cerrado

355
00:16:20,639 --> 00:16:23,580
Pues además de este método main voy a hacer más

356
00:16:23,580 --> 00:16:26,080
Todos dentro de la clase

357
00:16:26,080 --> 00:16:28,159
Lo que no puedo hacer

358
00:16:28,159 --> 00:16:30,100
es un método dentro de otro, eso no

359
00:16:30,100 --> 00:16:31,980
existe, eso no tiene sentido, un método

360
00:16:31,980 --> 00:16:33,399
dentro de otro no tiene sentido

361
00:16:33,399 --> 00:16:35,879
¿vale? entonces son

362
00:16:35,879 --> 00:16:38,039
métodos dentro de la clase, bueno, pues este

363
00:16:38,039 --> 00:16:40,139
método, mostrar menú, es

364
00:16:40,139 --> 00:16:41,259
un método estático

365
00:16:41,259 --> 00:16:44,100
está claro que es estático porque

366
00:16:44,100 --> 00:16:46,159
es que no utiliza ninguna propiedad

367
00:16:46,159 --> 00:16:48,259
de la clase, absolutamente

368
00:16:48,259 --> 00:16:49,440
ninguna utiliza

369
00:16:49,440 --> 00:16:52,320
porque de hecho la clase no tiene propiedades

370
00:16:52,320 --> 00:16:56,019
no tiene ninguna, esto está

371
00:16:56,019 --> 00:16:57,919
comentado, que era de pruebas que hicimos

372
00:16:57,919 --> 00:16:59,779
entonces este método es estático

373
00:16:59,779 --> 00:17:00,980
con lo cual

374
00:17:00,980 --> 00:17:03,700
este método lo puedo llamar

375
00:17:03,700 --> 00:17:04,960
desde donde me dé la gana

376
00:17:04,960 --> 00:17:06,859
con nombre de la clase

377
00:17:06,859 --> 00:17:08,599
que es main.mostrarMenu

378
00:17:08,599 --> 00:17:09,400
desde donde me dé la gana

379
00:17:09,400 --> 00:17:12,079
desde cualquier sitio, desde cualquier parte

380
00:17:12,079 --> 00:17:13,579
desde cualquier otra clase que haya por ahí

381
00:17:13,579 --> 00:17:15,920
lo puedo llamar con main.mostrarMenu

382
00:17:15,920 --> 00:17:18,740
vale, en particular desde donde me interesa

383
00:17:18,740 --> 00:17:20,140
llamarlo, hombre pues lo he hecho

384
00:17:20,140 --> 00:17:21,319
para llamarlo desde aquí

385
00:17:21,319 --> 00:17:24,380
lo he hecho justo para llamarlo desde aquí

386
00:17:24,380 --> 00:17:25,920
desde el main

387
00:17:25,920 --> 00:17:27,680
desde otro método de esa clase

388
00:17:27,680 --> 00:17:29,980
bueno pues desde aquí lo llamo

389
00:17:29,980 --> 00:17:32,140
y ya está, como podría llamarlo

390
00:17:32,140 --> 00:17:33,880
desde cualquier sitio, pero me interesa

391
00:17:33,880 --> 00:17:35,579
llamarlo desde ahí, vale

392
00:17:35,579 --> 00:17:38,200
lo que pasa es

393
00:17:38,200 --> 00:17:39,980
un segundito, para completar

394
00:17:39,980 --> 00:17:42,019
la revisión, lo que pasa

395
00:17:42,019 --> 00:17:43,799
es que como en este caso en particular

396
00:17:43,799 --> 00:17:45,799
el método mostrar menú está dentro

397
00:17:45,799 --> 00:17:47,900
de esta misma clase, no está

398
00:17:47,900 --> 00:17:48,359
en otra

399
00:17:48,359 --> 00:17:51,819
pues este main es opcional

400
00:17:51,819 --> 00:17:52,799
lo puedo quitar

401
00:17:52,799 --> 00:17:55,880
lo puedo quitar, vale, esto es como

402
00:17:55,880 --> 00:17:57,619
lo del disk que también vimos en su momento

403
00:17:57,619 --> 00:17:59,279
si yo lo quito

404
00:17:59,279 --> 00:18:01,640
cuando el compilador vea

405
00:18:01,640 --> 00:18:03,720
un mostrar menú sin nadie

406
00:18:03,720 --> 00:18:05,519
que lo llame, que eso no puede ser

407
00:18:05,519 --> 00:18:07,640
a los métodos siempre los tiene que llamar algo

408
00:18:07,640 --> 00:18:09,700
o alguien, pues cuando vea

409
00:18:09,700 --> 00:18:11,640
que nadie lo llama, dirá, ah pues debe ser

410
00:18:11,640 --> 00:18:13,640
la opción por defecto, y la opción

411
00:18:13,640 --> 00:18:15,519
por defecto es debe ser que te está llamando

412
00:18:15,519 --> 00:18:17,640
la propia clase en la que estoy

413
00:18:17,640 --> 00:18:19,599
voy a ver si hay algún

414
00:18:19,599 --> 00:18:21,440
método que se llame así en esta clase

415
00:18:21,440 --> 00:18:23,079
entonces va bajando, va bajando

416
00:18:23,079 --> 00:18:24,980
dice, uy, sí

417
00:18:24,980 --> 00:18:27,140
sí que lo hay

418
00:18:27,140 --> 00:18:36,230
Si no hubiera un método mostrar menú en esta clase, aquí tendríamos un error porque nos diría, pero ¿esto qué es?

419
00:18:38,369 --> 00:18:47,130
Bueno, entonces el main lo podéis poner si os hacéis lío en el caso de no ponerlo, que es método estático mostrar menú de la clase main.

420
00:18:47,329 --> 00:18:50,750
¿De dónde quiero llamarlo? Desde aquí, como podéis llamarlo desde cualquier sitio.

421
00:18:53,269 --> 00:18:54,410
Jimmy, tu pregunta.

422
00:18:54,410 --> 00:19:01,970
Porque estaba, exacto

423
00:19:01,970 --> 00:19:03,309
Porque lo teníamos aquí dentro

424
00:19:03,309 --> 00:19:06,900
¿Cómo que lo volvías a crear? ¿Dónde?

425
00:19:07,339 --> 00:19:09,000
Dentro del otro, del método filial

426
00:19:09,000 --> 00:19:11,660
Entonces como local

427
00:19:11,660 --> 00:19:13,240
Entonces sí, como no te va a funcionar

428
00:19:13,240 --> 00:19:14,799
O sea, tú pones aquí un escáner, dices

429
00:19:14,799 --> 00:19:17,799
Pero no te va, ¿a qué te refieres?

430
00:19:20,609 --> 00:19:21,470
Escáner canovirus

431
00:19:21,470 --> 00:19:27,670
¿Pero lo has puesto en el import?

432
00:19:28,230 --> 00:19:28,970
Sí, lo he puesto en el import

433
00:19:28,970 --> 00:19:32,569
Ah, vale

434
00:19:32,569 --> 00:19:34,170
Cierto, cierto

435
00:19:34,170 --> 00:19:34,670
Vale

436
00:19:34,670 --> 00:19:37,910
Vale, pues entonces

437
00:19:37,910 --> 00:19:40,029
Perdón, perdón, perdón

438
00:19:40,029 --> 00:19:41,450
Te perdonamos

439
00:19:41,450 --> 00:19:43,789
Pero que sea la última

440
00:19:43,789 --> 00:19:46,950
Vale, entonces seguíamos

441
00:19:46,950 --> 00:19:49,509
Con esta misma idea

442
00:19:49,509 --> 00:19:50,549
Con esta misma idea

443
00:19:50,549 --> 00:19:53,009
Estábamos arreglando o refactorizando

444
00:19:53,009 --> 00:19:54,690
El resto del código de esta aplicación

445
00:19:54,690 --> 00:19:56,410
Que nos había quedado bien, funcionaba

446
00:19:56,410 --> 00:19:58,009
La habíamos probado, funcionaba perfecta

447
00:19:58,009 --> 00:20:02,170
nos había quedado muy feo, muy horrible, pues con esta misma idea estábamos refactorizando el resto

448
00:20:02,170 --> 00:20:05,849
que es, caso 1, leer datos de cliente

449
00:20:05,849 --> 00:20:09,529
pues hombre, me voy a hacer yo, vamos a poner aquí esto si queremos para no

450
00:20:09,529 --> 00:20:13,930
hasta que cojamos altura, pues me voy a hacer un método

451
00:20:13,930 --> 00:20:17,869
estático dentro de esta misma clase, que es el que tenemos hecho ahí abajo

452
00:20:17,869 --> 00:20:22,009
que me pida los datos, me devuelva como

453
00:20:22,009 --> 00:20:26,009
valor de retorno un objeto, y ese objeto lo guardo yo

454
00:20:26,009 --> 00:20:27,930
aquí, en la posición

455
00:20:27,930 --> 00:20:29,490
del array que queda libre

456
00:20:29,490 --> 00:20:32,390
y la dejo incrementada

457
00:20:32,390 --> 00:20:33,930
para

458
00:20:33,930 --> 00:20:35,950
que se quede apuntando a la

459
00:20:35,950 --> 00:20:38,190
siguiente libre, y aviso

460
00:20:38,190 --> 00:20:39,509
vale, pues así

461
00:20:39,509 --> 00:20:41,809
muchísimo mejor el case así

462
00:20:41,809 --> 00:20:43,910
vale, cuando ya se hacen

463
00:20:43,910 --> 00:20:45,829
un montón de llamadas, por si no

464
00:20:45,829 --> 00:20:47,210
sabéis este truco

465
00:20:47,210 --> 00:20:49,829
si uno quiere irse directamente al código

466
00:20:49,829 --> 00:20:51,529
de un método para ver que es lo que hace

467
00:20:51,529 --> 00:20:53,950
pues si pulsáis control

468
00:20:53,950 --> 00:20:55,289
y ponéis el cursor

469
00:20:55,289 --> 00:20:58,009
Pues te dice, a ver, ¿dónde te quieres ir?

470
00:20:58,089 --> 00:21:00,650
Quiero irme a la implementación de leer cliente

471
00:21:00,650 --> 00:21:02,329
Y pum

472
00:21:02,329 --> 00:21:04,410
Pulsas y se va a la implementación

473
00:21:04,410 --> 00:21:06,049
Y así puedes navegar

474
00:21:06,049 --> 00:21:07,930
En tu editor más rápido

475
00:21:07,930 --> 00:21:09,970
Lo que no sé es volver atrás

476
00:21:09,970 --> 00:21:11,329
No sé si hay atajo

477
00:21:11,329 --> 00:21:24,180
Control y luego acercas el cursor

478
00:21:24,180 --> 00:21:25,920
Lo depositas

479
00:21:25,920 --> 00:21:27,460
Y se te habla este

480
00:21:27,460 --> 00:21:29,920
Pulsas control sin más

481
00:21:29,920 --> 00:21:32,099
Vale, pues el caso 1

482
00:21:32,099 --> 00:21:33,559
Ahora ahí vamos con el caso 2

483
00:21:33,559 --> 00:21:36,119
que nos permite hacer un siguiente salto un poco

484
00:21:36,119 --> 00:21:38,220
vale, el caso 2

485
00:21:38,220 --> 00:21:39,339
mostraba clientes

486
00:21:39,339 --> 00:21:42,220
pues entonces, voy a quitar

487
00:21:42,220 --> 00:21:44,160
yo todo esto que lo tenía antes

488
00:21:44,160 --> 00:21:46,200
aquí puesto, voy a quitar yo todo esto

489
00:21:46,200 --> 00:21:48,140
y voy a hacerme un método mostrar

490
00:21:48,140 --> 00:21:50,039
clientes y ya está, me va a quedar

491
00:21:50,039 --> 00:21:51,960
mucho más claro el switch case, un método

492
00:21:51,960 --> 00:21:54,279
mostrar clientes, lo voy a llamar

493
00:21:54,279 --> 00:21:55,420
también así con main

494
00:21:55,420 --> 00:21:56,660
vale

495
00:21:56,660 --> 00:22:01,420
no hace falta

496
00:22:01,420 --> 00:22:03,000
pero lo digo bueno para si

497
00:22:03,000 --> 00:22:06,380
quien se sienta más cómodo

498
00:22:06,380 --> 00:22:08,059
todavía porque vea más claro

499
00:22:08,059 --> 00:22:09,420
que es un método estático

500
00:22:09,420 --> 00:22:10,940
de esta misma clase main

501
00:22:10,940 --> 00:22:13,420
vale, pues mostrar clientes

502
00:22:13,420 --> 00:22:15,059
pues vamos a hacer mostrar clientes

503
00:22:15,059 --> 00:22:16,319
entonces mostrar clientes

504
00:22:16,319 --> 00:22:17,480
habíamos empezado a hacerlo

505
00:22:17,480 --> 00:22:19,059
por aquí abajo

506
00:22:19,059 --> 00:22:21,680
public static

507
00:22:21,680 --> 00:22:25,480
y ahora aquí es donde tenemos un problema

508
00:22:25,480 --> 00:22:28,140
y es que este método

509
00:22:28,140 --> 00:22:32,000
necesita acceder a la raíz de clientes

510
00:22:32,000 --> 00:22:33,240
Para mostrarlos todos

511
00:22:33,240 --> 00:22:35,460
Y te accede al array de clientes

512
00:22:35,460 --> 00:22:38,420
Vale, ¿dónde está mi array de clientes?

513
00:22:38,500 --> 00:22:39,720
Pues aquí viene el problema

514
00:22:39,720 --> 00:22:41,960
Que mi array de clientes

515
00:22:41,960 --> 00:22:44,420
Es local al método main

516
00:22:44,420 --> 00:22:47,160
Entonces como mi array de clientes

517
00:22:47,160 --> 00:22:49,339
Que está aquí es local al método main

518
00:22:49,339 --> 00:22:54,200
Pues este no tiene acceso a él

519
00:22:54,200 --> 00:22:55,279
No tiene acceso

520
00:22:55,279 --> 00:22:57,240
Para recorrerlo y mostrarlo

521
00:22:57,240 --> 00:22:59,759
Luego, soluciones que se os ocurren

522
00:22:59,759 --> 00:23:00,819
Venga, solución una

523
00:23:00,819 --> 00:23:03,819
Perfecto, una

524
00:23:03,819 --> 00:23:05,519
Se lo paso por parámetro

525
00:23:05,519 --> 00:23:08,059
¿Vale? Es una solución

526
00:23:08,059 --> 00:23:10,460
¿Alguna otra solución

527
00:23:10,460 --> 00:23:11,180
Que se os ocurra?

528
00:23:14,059 --> 00:23:15,099
O en la misma

529
00:23:15,099 --> 00:23:16,700
Sacarlo

530
00:23:16,700 --> 00:23:20,119
Sacarlo aquí fuera

531
00:23:20,119 --> 00:23:23,930
¿Vale?

532
00:23:25,150 --> 00:23:27,130
Y si lo saco aquí fuera

533
00:23:27,130 --> 00:23:31,339
Ya lo ven todos los métodos

534
00:23:31,339 --> 00:23:33,319
Ya lo ven todos los métodos

535
00:23:33,319 --> 00:23:47,700
Pero claro, ahora tenemos que, claro, lo ven todos los métodos, pero es que todos mis métodos tienen que ser estáticos, porque están hechos todos para ser llamados desde el main, y el main es static, luego solamente puede llamar a cosas static.

536
00:23:48,119 --> 00:24:01,900
Entonces, para que realmente mi método este de mostrar datos pueda acceder a ese array de clientes que acabo de sacar, que acabo de sacar y he quitado de ahí, tiene que ser static.

537
00:24:01,900 --> 00:24:03,980
y la pregunta es

538
00:24:03,980 --> 00:24:05,779
¿es grave que sea static?

539
00:24:08,279 --> 00:24:09,900
poniendo static para arreglar

540
00:24:09,900 --> 00:24:11,900
errores de compilación la estoy liando

541
00:24:11,900 --> 00:24:13,880
par de generando un problema enorme porque hay veces

542
00:24:13,880 --> 00:24:16,180
que ponemos un static para arreglar un error de compilación

543
00:24:16,180 --> 00:24:18,240
y hemos cambiado el sentido

544
00:24:18,240 --> 00:24:19,460
de la aplicación completamente

545
00:24:19,460 --> 00:24:21,279
aquí ese

546
00:24:21,279 --> 00:24:24,099
eso es un problema, haberlo puesto static

547
00:24:24,099 --> 00:24:24,779
es un problema

548
00:24:24,779 --> 00:24:28,200
no es un problema porque

549
00:24:28,200 --> 00:24:29,579
claro

550
00:24:29,579 --> 00:24:32,000
mi aplicación trabaja con un

551
00:24:32,000 --> 00:24:33,599
único array de clientes, ya está

552
00:24:33,599 --> 00:24:35,220
no necesito

553
00:24:35,220 --> 00:24:37,519
esta clase, de esta no va a haber

554
00:24:37,519 --> 00:24:39,519
muchas instancias, cada una con su array

555
00:24:39,519 --> 00:24:41,740
de clientes, no, esta es mi clase

556
00:24:41,740 --> 00:24:43,720
main, que es la que va a instanciar

557
00:24:43,720 --> 00:24:45,380
la máquina virtual para arrancar el main

558
00:24:45,380 --> 00:24:47,799
solo va a haber una instancia, solo va a haber

559
00:24:47,799 --> 00:24:49,619
un array de clientes para mi

560
00:24:49,619 --> 00:24:51,660
aplicación, no hay muchos arrays de clientes

561
00:24:51,660 --> 00:24:53,720
luego por aquí el static, no solo

562
00:24:53,720 --> 00:24:55,880
no lo estropea, sino que

563
00:24:55,880 --> 00:24:57,380
describe

564
00:24:57,380 --> 00:24:59,720
mucho mejor la situación, que es que

565
00:24:59,720 --> 00:25:02,079
solo tengo un array de clientes en toda la aplicación

566
00:25:02,079 --> 00:25:04,279
entonces mucho mejor

567
00:25:04,279 --> 00:25:09,829
meterlo aquí, vale

568
00:25:09,829 --> 00:25:11,710
bueno, pues ahora ya sí

569
00:25:11,710 --> 00:25:15,960
mi método mostrar clientes

570
00:25:15,960 --> 00:25:17,319
pues lo tiene muy fácil

571
00:25:17,319 --> 00:25:19,880
porque ya sí que puede hacer eso

572
00:25:19,880 --> 00:25:21,660
para

573
00:25:21,660 --> 00:25:23,460
cada cliente

574
00:25:23,460 --> 00:25:25,660
C en clientes

575
00:25:26,440 --> 00:25:29,619
muéstrame

576
00:25:30,180 --> 00:25:30,859
C

577
00:25:30,859 --> 00:25:33,279
y ya está

578
00:25:33,279 --> 00:25:39,759
vale

579
00:25:39,759 --> 00:25:42,980
y claro dirás tú

580
00:25:42,980 --> 00:25:44,900
y dirías tú y decías tú

581
00:25:44,900 --> 00:25:47,599
jolín, por dos líneas

582
00:25:47,599 --> 00:25:48,859
sacar un método

583
00:25:48,859 --> 00:25:51,000
por dos líneas y aquí

584
00:25:51,000 --> 00:25:52,420
solamente estoy poniendo una

585
00:25:52,420 --> 00:25:54,940
claro, pero es que esta es mi versión de ahora

586
00:25:54,940 --> 00:25:56,960
pero ahora esta versión, a lo mejor

587
00:25:56,960 --> 00:25:59,039
hay que cambiarla y me dicen, no, que ya no vas

588
00:25:59,039 --> 00:26:01,039
por consola, que ahora vas por

589
00:26:01,039 --> 00:26:03,279
una interfaz gráfica o mandas a base de datos

590
00:26:03,279 --> 00:26:04,759
pues hombre

591
00:26:04,759 --> 00:26:07,240
ah, vale, es mostrar clientes

592
00:26:07,240 --> 00:26:08,980
lo que ha cambiado, pues tú te vas

593
00:26:08,980 --> 00:26:09,660
a este método

594
00:26:09,660 --> 00:26:12,380
y aquí haces el cambio

595
00:26:12,380 --> 00:26:30,160
Y a lo mejor ese cambio implica añadir 20 líneas más, porque ahora ya no mandas la salida con un siso, sino que la mandas con una interfaz gráfica. Pues bueno, amplías este método, pero eso se mantiene completamente independiente del main, completamente.

596
00:26:30,160 --> 00:26:31,420
que es lo que importa

597
00:26:31,420 --> 00:26:33,880
lo importante es separar

598
00:26:33,880 --> 00:26:35,740
lo más posible, lo que se llama

599
00:26:35,740 --> 00:26:38,359
desacoplar, vamos a desacoplarlo

600
00:26:38,359 --> 00:26:39,839
todo, entonces

601
00:26:39,839 --> 00:26:41,960
esto está separado del main

602
00:26:41,960 --> 00:26:44,079
que yo tengo que tocar la forma

603
00:26:44,079 --> 00:26:45,960
de mostrar los clientes, me vengo

604
00:26:45,960 --> 00:26:47,539
aquí a mostrar cliente y la toco

605
00:26:47,539 --> 00:26:50,119
y al main le da igual, el main ya va a mostrar

606
00:26:50,119 --> 00:26:51,180
al cliente y se acabó

607
00:26:51,180 --> 00:26:53,779
¿vale? esa es la diferencia entre una

608
00:26:53,779 --> 00:26:55,799
aplicación que esté bien hecha

609
00:26:55,799 --> 00:26:58,099
y pueda tener un buen recorrido y que esté mal hecha

610
00:26:58,099 --> 00:26:59,519
porque si yo he metido aquí

611
00:26:59,519 --> 00:27:02,079
toda la complejidad de mostrar clientes

612
00:27:02,079 --> 00:27:04,099
y ahora me dicen, oye, que he cambiado

613
00:27:04,099 --> 00:27:05,759
y ahora voy por inteligencia gráfica

614
00:27:05,759 --> 00:27:07,220
pues me tengo que ir a mi main

615
00:27:07,220 --> 00:27:09,900
ir buscando en todas las partes donde accedo

616
00:27:09,900 --> 00:27:11,720
a los clientes

617
00:27:11,720 --> 00:27:13,680
ir retocando en todos lados, pues no

618
00:27:13,680 --> 00:27:16,140
si lo tengo agrupadito en métodos

619
00:27:16,140 --> 00:27:17,680
no voy al método que toque y el main

620
00:27:17,680 --> 00:27:22,599
no tengo ni que tocarlo

621
00:27:22,599 --> 00:27:26,940
bueno, con el main

622
00:27:26,940 --> 00:27:27,660
al método main

623
00:27:27,660 --> 00:27:29,359
vale

624
00:27:29,359 --> 00:27:32,119
Vale, y con el resto

625
00:27:32,119 --> 00:27:33,900
Pues podríamos ir haciendo un poco lo mismo

626
00:27:33,900 --> 00:27:35,880
Vale, vamos a

627
00:27:35,880 --> 00:27:37,740
Antes de meternos con el resto

628
00:27:37,740 --> 00:27:38,960
Bueno, de mirarlo por encima

629
00:27:38,960 --> 00:27:42,000
Vamos a recordar lo del toString, si os acordáis

630
00:27:42,000 --> 00:27:44,160
Vale, acordaos

631
00:27:44,160 --> 00:27:45,559
De que

632
00:27:45,559 --> 00:27:48,119
Al system.out este de aquí

633
00:27:48,119 --> 00:27:50,180
Le estábamos pasando

634
00:27:50,180 --> 00:27:52,180
Directamente un objeto

635
00:27:52,180 --> 00:27:53,440
Entero

636
00:27:53,440 --> 00:27:55,940
Al system.out normalmente

637
00:27:55,940 --> 00:27:57,839
Le pasábamos variables

638
00:27:57,839 --> 00:27:58,700
Primitivas

639
00:27:58,700 --> 00:28:00,500
o cadenas de texto

640
00:28:00,500 --> 00:28:02,599
directamente, cuando le pasábamos variables

641
00:28:02,599 --> 00:28:04,519
primitivas pues él las convertía

642
00:28:04,519 --> 00:28:07,119
a la representación

643
00:28:07,119 --> 00:28:08,839
ASCII, si le pasábamos

644
00:28:08,839 --> 00:28:10,240
la variable entera 17

645
00:28:10,240 --> 00:28:12,779
pues él la transformaba al 1 7

646
00:28:12,779 --> 00:28:13,940
y no había ningún problema

647
00:28:13,940 --> 00:28:16,940
pero que pasaba cuando le pasábamos un objeto

648
00:28:16,940 --> 00:28:18,640
pues un objeto es una

649
00:28:18,640 --> 00:28:20,180
dirección de memoria en realidad

650
00:28:20,180 --> 00:28:22,440
entonces si yo

651
00:28:22,440 --> 00:28:24,599
sin haber hecho nada en la clase clientea

652
00:28:24,599 --> 00:28:25,940
hacía esto

653
00:28:25,940 --> 00:28:28,440
este sistema me mostraba una cosa muy rara

654
00:28:28,440 --> 00:28:29,819
¿Vale?

655
00:28:30,039 --> 00:28:31,779
Que con la herencia entenderemos un poco mejor

656
00:28:31,779 --> 00:28:33,099
Por qué me mostraba esa clase tan rara

657
00:28:33,099 --> 00:28:36,279
Entonces, lo que yo os decía

658
00:28:36,279 --> 00:28:38,380
O avanzaba de herencia

659
00:28:38,380 --> 00:28:40,319
Es, vale, lo que realmente

660
00:28:40,319 --> 00:28:41,799
El system out está haciendo

661
00:28:41,799 --> 00:28:42,960
Cuando tú le pasas un objeto

662
00:28:42,960 --> 00:28:45,700
Es, como el objeto no lo entiende

663
00:28:45,700 --> 00:28:48,460
Llama a un método de esa clase

664
00:28:48,460 --> 00:28:50,240
Que se llama toString para convertir

665
00:28:50,240 --> 00:28:51,240
Para que se lo den string

666
00:28:51,240 --> 00:28:54,339
Eso es lo que decía, oye, pues voy a llamar a un toString para que te lo den string

667
00:28:54,339 --> 00:28:55,680
Entonces

668
00:28:55,680 --> 00:28:58,039
Nosotros nos íbamos a cliente

669
00:28:58,039 --> 00:28:59,720
y hacíamos ese toString

670
00:28:59,720 --> 00:29:02,279
que sabemos que es

671
00:29:02,279 --> 00:29:04,339
el método al que

672
00:29:04,339 --> 00:29:06,279
el System.out va a llamar cuando le pasamos

673
00:29:06,279 --> 00:29:08,259
el objeto. Es decir, oye, me das

674
00:29:08,259 --> 00:29:10,119
un objeto que esto es una disminución de memoria, es una mierda,

675
00:29:10,180 --> 00:29:12,180
esto yo no lo quiero. Voy a llamar a un toString

676
00:29:12,180 --> 00:29:13,480
para que me lo cambie a string.

677
00:29:14,420 --> 00:29:15,920
Pues nosotros lo hacíamos

678
00:29:15,920 --> 00:29:18,440
para que lo convirtiera exactamente

679
00:29:18,440 --> 00:29:19,500
como nosotros queríamos.

680
00:29:21,119 --> 00:29:22,539
Porque podíamos no hacerlo,

681
00:29:23,019 --> 00:29:23,859
pero si no lo hacemos,

682
00:29:24,279 --> 00:29:26,059
entonces aparece un toString

683
00:29:26,059 --> 00:29:27,720
por defecto, así de la nada.

684
00:29:28,039 --> 00:29:29,539
aunque no lo veamos físicamente.

685
00:29:30,480 --> 00:29:32,900
Y ese toString por defecto que aparece de la nada

686
00:29:32,900 --> 00:29:34,619
hacía una cosa muy fea.

687
00:29:35,960 --> 00:29:36,160
¿Vale?

688
00:29:38,710 --> 00:29:41,289
De hecho, si dejamos comentado este método,

689
00:29:42,529 --> 00:29:44,109
lo dejamos comentado así

690
00:29:44,109 --> 00:29:48,930
y ejecutábamos esta aplicación

691
00:29:48,930 --> 00:29:52,730
que es esta.

692
00:29:59,779 --> 00:30:01,539
Bueno, primero nos pedía, pues eso,

693
00:30:01,680 --> 00:30:03,319
él iba para configurar

694
00:30:03,319 --> 00:30:04,720
y ahora vamos a hacer un cliente,

695
00:30:04,720 --> 00:30:06,000
Al menos para que me lo muestre

696
00:30:06,000 --> 00:30:13,109
Vale, ya teníamos un primer cliente

697
00:30:13,109 --> 00:30:14,789
Y ahora listado de clientes

698
00:30:14,789 --> 00:30:18,410
Ah, vale, vale, perdón

699
00:30:18,410 --> 00:30:19,849
Mi método lo he hecho

700
00:30:19,849 --> 00:30:22,490
Listado de clientes

701
00:30:22,490 --> 00:30:25,029
Aquí no tenía nada en el array, por eso me ha mostrado nul

702
00:30:25,029 --> 00:30:25,990
Eso lo cambiamos ahora

703
00:30:25,990 --> 00:30:27,829
Me mostraba esto

704
00:30:27,829 --> 00:30:30,869
Esto es una información que no me vale para nada

705
00:30:30,869 --> 00:30:32,809
Porque este es

706
00:30:32,809 --> 00:30:34,809
El toStream por defecto

707
00:30:34,809 --> 00:30:36,630
Yo no quiero el toStream por defecto

708
00:30:36,630 --> 00:30:38,710
Por eso hemos hecho uno específico para nosotros

709
00:30:38,710 --> 00:30:42,210
vale, entonces el toString

710
00:30:42,210 --> 00:30:44,990
que habíamos hecho nosotros era este

711
00:30:44,990 --> 00:30:49,269
y ahora voy a cambiar en el cliente

712
00:30:49,269 --> 00:30:51,690
en el main este, he sido yo muy chula aquí

713
00:30:51,690 --> 00:30:52,950
lo he hecho con un for each

714
00:30:52,950 --> 00:30:55,829
y recordáis que el for each que hacía

715
00:30:55,829 --> 00:30:57,549
recorría la raya entero

716
00:30:57,549 --> 00:31:00,049
y no queremos recorrer la raya entero

717
00:31:00,049 --> 00:31:02,670
queremos recorrer solo hasta donde haya clientes

718
00:31:02,670 --> 00:31:05,549
y hasta donde hay clientes

719
00:31:05,549 --> 00:31:07,430
Hasta donde indique la variable

720
00:31:07,430 --> 00:31:08,710
Siguiente posición libre

721
00:31:08,710 --> 00:31:11,150
Por esto esto lo hacíamos con un

722
00:31:11,150 --> 00:31:12,690
For de índice

723
00:31:12,690 --> 00:31:22,940
Que no se debe llamar así

724
00:31:22,940 --> 00:31:27,359
Porque se llama

725
00:31:27,359 --> 00:31:31,049
ST pos libre

726
00:31:31,049 --> 00:31:34,519
Ah, si se llama así

727
00:31:34,519 --> 00:31:37,339
Vale, de posición libre

728
00:31:37,339 --> 00:31:38,519
CDI

729
00:31:38,519 --> 00:31:45,180
Clientes

730
00:31:45,180 --> 00:31:46,339
De I, vale

731
00:31:46,339 --> 00:31:50,210
Vale

732
00:31:50,210 --> 00:31:53,470
Ahora ya si me llegaría solo

733
00:31:53,470 --> 00:31:55,630
Este for hasta el que estuviera

734
00:31:55,630 --> 00:31:58,250
Pero claro, ¿por qué me sale este error de compilación?

735
00:32:00,599 --> 00:32:02,900
Claro, de nuevo por el mismo problema de antes

736
00:32:02,900 --> 00:32:04,880
Porque los datos

737
00:32:04,880 --> 00:32:06,920
Que le interesan al conjunto

738
00:32:06,920 --> 00:32:07,740
De la aplicación

739
00:32:07,740 --> 00:32:09,339
No es solo el array entero

740
00:32:09,339 --> 00:32:11,200
Los datos también son

741
00:32:11,200 --> 00:32:14,019
Oye, ¿cuál es la siguiente posición que tienes?

742
00:32:14,180 --> 00:32:14,859
Entonces esto

743
00:32:14,859 --> 00:32:17,019
También tenemos que sacarlo fuera

744
00:32:17,019 --> 00:32:24,140
Esto nos pasa porque no tenemos colecciones de datos todavía

745
00:32:24,140 --> 00:32:26,960
Y el array tiene este pequeño problemilla

746
00:32:26,960 --> 00:32:35,410
Entonces

747
00:32:35,410 --> 00:32:36,509
Ahora ya sí

748
00:32:36,509 --> 00:32:40,069
la siguiente posición libre es un dato que puede necesitar

749
00:32:40,069 --> 00:32:40,950
cualquier método

750
00:32:40,950 --> 00:32:45,880
y sigue quedando un error

751
00:32:45,880 --> 00:32:46,940
en algún sitio

752
00:32:46,940 --> 00:32:48,420
aquí esto

753
00:32:48,420 --> 00:33:02,470
y en el resto de

754
00:33:02,470 --> 00:33:04,490
métodos podríamos ir haciendo lo mismo

755
00:33:04,490 --> 00:33:06,430
podéis ir haciendo

756
00:33:06,430 --> 00:33:07,349
vosotros lo mismo

757
00:33:07,349 --> 00:33:10,490
o ponerlo en práctica en el resto de aplicaciones

758
00:33:10,490 --> 00:33:12,750
pues el caso 3

759
00:33:12,750 --> 00:33:14,130
es hacer un pedido nuevo

760
00:33:14,130 --> 00:33:16,250
este en particular

761
00:33:16,250 --> 00:33:18,490
si que hay que

762
00:33:18,490 --> 00:33:20,130
Refactorizarlo, porque esto es un rollo

763
00:33:20,130 --> 00:33:21,490
Entonces

764
00:33:21,490 --> 00:33:25,190
Este que es, para leer un pedido

765
00:33:25,190 --> 00:33:28,509
¿Vale? Generando el código

766
00:33:28,509 --> 00:33:30,390
Todo eso se puede sacar a otro método

767
00:33:30,390 --> 00:33:32,529
Todo

768
00:33:32,529 --> 00:33:34,210
¿Vale?

769
00:33:34,529 --> 00:33:35,690
A ese método

770
00:33:35,690 --> 00:33:39,789
Ya está

771
00:33:39,789 --> 00:33:43,460
Se sacaría todo un método que haga esto

772
00:33:43,460 --> 00:33:44,039
Y se acabó

773
00:33:44,039 --> 00:33:49,930
Esto sería, vamos a hacer el copia y pega

774
00:33:49,930 --> 00:34:01,660
Esto sería, agregar pedido

775
00:34:01,660 --> 00:34:10,250
Agregar pedido

776
00:34:10,250 --> 00:34:12,690
Vale, pues este agregar pedido

777
00:34:12,690 --> 00:34:19,300
En este agregar pedido

778
00:34:19,300 --> 00:34:19,840
De aquí

779
00:34:19,840 --> 00:34:23,940
Quiero yo

780
00:34:23,940 --> 00:34:27,059
En principio hacer todo eso

781
00:34:27,059 --> 00:34:29,039
Que es

782
00:34:29,039 --> 00:34:30,559
Dame una descripción

783
00:34:30,559 --> 00:34:32,440
Dame un precio

784
00:34:32,440 --> 00:34:40,989
Generar código de pedido para que sea único

785
00:34:40,989 --> 00:34:43,739
Vale

786
00:34:43,739 --> 00:34:47,900
Todo este rollo que hicimos

787
00:34:47,900 --> 00:34:48,619
De aquí

788
00:34:48,619 --> 00:34:50,900
Nos íbamos

789
00:34:50,900 --> 00:34:53,219
al cliente con ese nif

790
00:34:53,219 --> 00:34:55,320
una vez que

791
00:34:55,320 --> 00:34:57,159
encontrábamos el cliente con ese nif

792
00:34:57,159 --> 00:34:58,639
le agregábamos el pedido

793
00:34:58,639 --> 00:35:02,920
y ya está

794
00:35:02,920 --> 00:35:07,670
con esta refactorización lo único es que

795
00:35:07,670 --> 00:35:09,570
el código de pedido de nuevo

796
00:35:09,570 --> 00:35:11,650
nos damos cuenta de que el código de pedido es una

797
00:35:11,650 --> 00:35:13,889
información común para todos

798
00:35:13,889 --> 00:35:14,949
el código de pedido

799
00:35:14,949 --> 00:35:17,969
¿verdad? pues el código

800
00:35:17,969 --> 00:35:19,769
de pedido aquí también

801
00:35:19,769 --> 00:35:33,289
y el main se va quedando cada vez

802
00:35:33,289 --> 00:35:35,070
más vacío, más claro, más limpio

803
00:35:35,070 --> 00:35:38,340
¿vale?

804
00:35:38,340 --> 00:35:41,940
Bueno, vamos a parar aquí un momento